Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rtnetlink.c
Go to the documentation of this file.
1 /*
2  * INET An implementation of the TCP/IP protocol suite for the LINUX
3  * operating system. INET is implemented using the BSD Socket
4  * interface as the means of communication with the user level.
5  *
6  * Routing netlink socket interface: protocol independent part.
7  *
8  * Authors: Alexey Kuznetsov, <[email protected]>
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version
13  * 2 of the License, or (at your option) any later version.
14  *
15  * Fixes:
16  * Vitaly E. Lavrov RTA_OK arithmetics was wrong.
17  */
18 
19 #include <linux/errno.h>
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/socket.h>
23 #include <linux/kernel.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <linux/fcntl.h>
29 #include <linux/mm.h>
30 #include <linux/slab.h>
31 #include <linux/interrupt.h>
32 #include <linux/capability.h>
33 #include <linux/skbuff.h>
34 #include <linux/init.h>
35 #include <linux/security.h>
36 #include <linux/mutex.h>
37 #include <linux/if_addr.h>
38 #include <linux/if_bridge.h>
39 #include <linux/pci.h>
40 #include <linux/etherdevice.h>
41 
42 #include <asm/uaccess.h>
43 
44 #include <linux/inet.h>
45 #include <linux/netdevice.h>
46 #include <net/ip.h>
47 #include <net/protocol.h>
48 #include <net/arp.h>
49 #include <net/route.h>
50 #include <net/udp.h>
51 #include <net/sock.h>
52 #include <net/pkt_sched.h>
53 #include <net/fib_rules.h>
54 #include <net/rtnetlink.h>
55 #include <net/net_namespace.h>
56 
57 struct rtnl_link {
58  rtnl_doit_func doit;
59  rtnl_dumpit_func dumpit;
60  rtnl_calcit_func calcit;
61 };
62 
63 static DEFINE_MUTEX(rtnl_mutex);
64 
65 void rtnl_lock(void)
66 {
67  mutex_lock(&rtnl_mutex);
68 }
69 EXPORT_SYMBOL(rtnl_lock);
70 
71 void __rtnl_unlock(void)
72 {
73  mutex_unlock(&rtnl_mutex);
74 }
75 
76 void rtnl_unlock(void)
77 {
78  /* This fellow will unlock it for us. */
79  netdev_run_todo();
80 }
81 EXPORT_SYMBOL(rtnl_unlock);
82 
83 int rtnl_trylock(void)
84 {
85  return mutex_trylock(&rtnl_mutex);
86 }
87 EXPORT_SYMBOL(rtnl_trylock);
88 
89 int rtnl_is_locked(void)
90 {
91  return mutex_is_locked(&rtnl_mutex);
92 }
93 EXPORT_SYMBOL(rtnl_is_locked);
94 
95 #ifdef CONFIG_PROVE_LOCKING
96 int lockdep_rtnl_is_held(void)
97 {
98  return lockdep_is_held(&rtnl_mutex);
99 }
100 EXPORT_SYMBOL(lockdep_rtnl_is_held);
101 #endif /* #ifdef CONFIG_PROVE_LOCKING */
102 
103 static struct rtnl_link *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
104 
105 static inline int rtm_msgindex(int msgtype)
106 {
107  int msgindex = msgtype - RTM_BASE;
108 
109  /*
110  * msgindex < 0 implies someone tried to register a netlink
111  * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
112  * the message type has not been added to linux/rtnetlink.h
113  */
114  BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
115 
116  return msgindex;
117 }
118 
119 static rtnl_doit_func rtnl_get_doit(int protocol, int msgindex)
120 {
121  struct rtnl_link *tab;
122 
123  if (protocol <= RTNL_FAMILY_MAX)
124  tab = rtnl_msg_handlers[protocol];
125  else
126  tab = NULL;
127 
128  if (tab == NULL || tab[msgindex].doit == NULL)
129  tab = rtnl_msg_handlers[PF_UNSPEC];
130 
131  return tab ? tab[msgindex].doit : NULL;
132 }
133 
134 static rtnl_dumpit_func rtnl_get_dumpit(int protocol, int msgindex)
135 {
136  struct rtnl_link *tab;
137 
138  if (protocol <= RTNL_FAMILY_MAX)
139  tab = rtnl_msg_handlers[protocol];
140  else
141  tab = NULL;
142 
143  if (tab == NULL || tab[msgindex].dumpit == NULL)
144  tab = rtnl_msg_handlers[PF_UNSPEC];
145 
146  return tab ? tab[msgindex].dumpit : NULL;
147 }
148 
149 static rtnl_calcit_func rtnl_get_calcit(int protocol, int msgindex)
150 {
151  struct rtnl_link *tab;
152 
153  if (protocol <= RTNL_FAMILY_MAX)
154  tab = rtnl_msg_handlers[protocol];
155  else
156  tab = NULL;
157 
158  if (tab == NULL || tab[msgindex].calcit == NULL)
159  tab = rtnl_msg_handlers[PF_UNSPEC];
160 
161  return tab ? tab[msgindex].calcit : NULL;
162 }
163 
182 int __rtnl_register(int protocol, int msgtype,
183  rtnl_doit_func doit, rtnl_dumpit_func dumpit,
184  rtnl_calcit_func calcit)
185 {
186  struct rtnl_link *tab;
187  int msgindex;
188 
189  BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
190  msgindex = rtm_msgindex(msgtype);
191 
192  tab = rtnl_msg_handlers[protocol];
193  if (tab == NULL) {
194  tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL);
195  if (tab == NULL)
196  return -ENOBUFS;
197 
198  rtnl_msg_handlers[protocol] = tab;
199  }
200 
201  if (doit)
202  tab[msgindex].doit = doit;
203 
204  if (dumpit)
205  tab[msgindex].dumpit = dumpit;
206 
207  if (calcit)
208  tab[msgindex].calcit = calcit;
209 
210  return 0;
211 }
212 EXPORT_SYMBOL_GPL(__rtnl_register);
213 
223 void rtnl_register(int protocol, int msgtype,
224  rtnl_doit_func doit, rtnl_dumpit_func dumpit,
225  rtnl_calcit_func calcit)
226 {
227  if (__rtnl_register(protocol, msgtype, doit, dumpit, calcit) < 0)
228  panic("Unable to register rtnetlink message handler, "
229  "protocol = %d, message type = %d\n",
230  protocol, msgtype);
231 }
232 EXPORT_SYMBOL_GPL(rtnl_register);
233 
241 int rtnl_unregister(int protocol, int msgtype)
242 {
243  int msgindex;
244 
245  BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
246  msgindex = rtm_msgindex(msgtype);
247 
248  if (rtnl_msg_handlers[protocol] == NULL)
249  return -ENOENT;
250 
251  rtnl_msg_handlers[protocol][msgindex].doit = NULL;
252  rtnl_msg_handlers[protocol][msgindex].dumpit = NULL;
253 
254  return 0;
255 }
256 EXPORT_SYMBOL_GPL(rtnl_unregister);
257 
265 void rtnl_unregister_all(int protocol)
266 {
267  BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
268 
269  kfree(rtnl_msg_handlers[protocol]);
270  rtnl_msg_handlers[protocol] = NULL;
271 }
272 EXPORT_SYMBOL_GPL(rtnl_unregister_all);
273 
274 static LIST_HEAD(link_ops);
275 
276 static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
277 {
278  const struct rtnl_link_ops *ops;
279 
280  list_for_each_entry(ops, &link_ops, list) {
281  if (!strcmp(ops->kind, kind))
282  return ops;
283  }
284  return NULL;
285 }
286 
297 int __rtnl_link_register(struct rtnl_link_ops *ops)
298 {
299  if (rtnl_link_ops_get(ops->kind))
300  return -EEXIST;
301 
302  if (!ops->dellink)
303  ops->dellink = unregister_netdevice_queue;
304 
305  list_add_tail(&ops->list, &link_ops);
306  return 0;
307 }
308 EXPORT_SYMBOL_GPL(__rtnl_link_register);
309 
316 int rtnl_link_register(struct rtnl_link_ops *ops)
317 {
318  int err;
319 
320  rtnl_lock();
321  err = __rtnl_link_register(ops);
322  rtnl_unlock();
323  return err;
324 }
325 EXPORT_SYMBOL_GPL(rtnl_link_register);
326 
327 static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
328 {
329  struct net_device *dev;
330  LIST_HEAD(list_kill);
331 
332  for_each_netdev(net, dev) {
333  if (dev->rtnl_link_ops == ops)
334  ops->dellink(dev, &list_kill);
335  }
336  unregister_netdevice_many(&list_kill);
337 }
338 
345 void __rtnl_link_unregister(struct rtnl_link_ops *ops)
346 {
347  struct net *net;
348 
349  for_each_net(net) {
350  __rtnl_kill_links(net, ops);
351  }
352  list_del(&ops->list);
353 }
354 EXPORT_SYMBOL_GPL(__rtnl_link_unregister);
355 
360 void rtnl_link_unregister(struct rtnl_link_ops *ops)
361 {
362  rtnl_lock();
363  __rtnl_link_unregister(ops);
364  rtnl_unlock();
365 }
366 EXPORT_SYMBOL_GPL(rtnl_link_unregister);
367 
368 static size_t rtnl_link_get_size(const struct net_device *dev)
369 {
370  const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
371  size_t size;
372 
373  if (!ops)
374  return 0;
375 
376  size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
377  nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */
378 
379  if (ops->get_size)
380  /* IFLA_INFO_DATA + nested data */
381  size += nla_total_size(sizeof(struct nlattr)) +
382  ops->get_size(dev);
383 
384  if (ops->get_xstats_size)
385  /* IFLA_INFO_XSTATS */
386  size += nla_total_size(ops->get_xstats_size(dev));
387 
388  return size;
389 }
390 
391 static LIST_HEAD(rtnl_af_ops);
392 
393 static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
394 {
395  const struct rtnl_af_ops *ops;
396 
397  list_for_each_entry(ops, &rtnl_af_ops, list) {
398  if (ops->family == family)
399  return ops;
400  }
401 
402  return NULL;
403 }
404 
413 int __rtnl_af_register(struct rtnl_af_ops *ops)
414 {
415  list_add_tail(&ops->list, &rtnl_af_ops);
416  return 0;
417 }
418 EXPORT_SYMBOL_GPL(__rtnl_af_register);
419 
426 int rtnl_af_register(struct rtnl_af_ops *ops)
427 {
428  int err;
429 
430  rtnl_lock();
431  err = __rtnl_af_register(ops);
432  rtnl_unlock();
433  return err;
434 }
435 EXPORT_SYMBOL_GPL(rtnl_af_register);
436 
443 void __rtnl_af_unregister(struct rtnl_af_ops *ops)
444 {
445  list_del(&ops->list);
446 }
447 EXPORT_SYMBOL_GPL(__rtnl_af_unregister);
448 
453 void rtnl_af_unregister(struct rtnl_af_ops *ops)
454 {
455  rtnl_lock();
456  __rtnl_af_unregister(ops);
457  rtnl_unlock();
458 }
459 EXPORT_SYMBOL_GPL(rtnl_af_unregister);
460 
461 static size_t rtnl_link_get_af_size(const struct net_device *dev)
462 {
463  struct rtnl_af_ops *af_ops;
464  size_t size;
465 
466  /* IFLA_AF_SPEC */
467  size = nla_total_size(sizeof(struct nlattr));
468 
469  list_for_each_entry(af_ops, &rtnl_af_ops, list) {
470  if (af_ops->get_link_af_size) {
471  /* AF_* + nested data */
472  size += nla_total_size(sizeof(struct nlattr)) +
473  af_ops->get_link_af_size(dev);
474  }
475  }
476 
477  return size;
478 }
479 
480 static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
481 {
482  const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
483  struct nlattr *linkinfo, *data;
484  int err = -EMSGSIZE;
485 
486  linkinfo = nla_nest_start(skb, IFLA_LINKINFO);
487  if (linkinfo == NULL)
488  goto out;
489 
490  if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
491  goto err_cancel_link;
492  if (ops->fill_xstats) {
493  err = ops->fill_xstats(skb, dev);
494  if (err < 0)
495  goto err_cancel_link;
496  }
497  if (ops->fill_info) {
498  data = nla_nest_start(skb, IFLA_INFO_DATA);
499  if (data == NULL)
500  goto err_cancel_link;
501  err = ops->fill_info(skb, dev);
502  if (err < 0)
503  goto err_cancel_data;
504  nla_nest_end(skb, data);
505  }
506 
507  nla_nest_end(skb, linkinfo);
508  return 0;
509 
510 err_cancel_data:
511  nla_nest_cancel(skb, data);
512 err_cancel_link:
513  nla_nest_cancel(skb, linkinfo);
514 out:
515  return err;
516 }
517 
518 static const int rtm_min[RTM_NR_FAMILIES] =
519 {
520  [RTM_FAM(RTM_NEWLINK)] = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
521  [RTM_FAM(RTM_NEWADDR)] = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
522  [RTM_FAM(RTM_NEWROUTE)] = NLMSG_LENGTH(sizeof(struct rtmsg)),
523  [RTM_FAM(RTM_NEWRULE)] = NLMSG_LENGTH(sizeof(struct fib_rule_hdr)),
524  [RTM_FAM(RTM_NEWQDISC)] = NLMSG_LENGTH(sizeof(struct tcmsg)),
525  [RTM_FAM(RTM_NEWTCLASS)] = NLMSG_LENGTH(sizeof(struct tcmsg)),
526  [RTM_FAM(RTM_NEWTFILTER)] = NLMSG_LENGTH(sizeof(struct tcmsg)),
527  [RTM_FAM(RTM_NEWACTION)] = NLMSG_LENGTH(sizeof(struct tcamsg)),
528  [RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
529  [RTM_FAM(RTM_GETANYCAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
530 };
531 
532 static const int rta_max[RTM_NR_FAMILIES] =
533 {
534  [RTM_FAM(RTM_NEWLINK)] = IFLA_MAX,
535  [RTM_FAM(RTM_NEWADDR)] = IFA_MAX,
536  [RTM_FAM(RTM_NEWROUTE)] = RTA_MAX,
537  [RTM_FAM(RTM_NEWRULE)] = FRA_MAX,
538  [RTM_FAM(RTM_NEWQDISC)] = TCA_MAX,
539  [RTM_FAM(RTM_NEWTCLASS)] = TCA_MAX,
540  [RTM_FAM(RTM_NEWTFILTER)] = TCA_MAX,
541  [RTM_FAM(RTM_NEWACTION)] = TCAA_MAX,
542 };
543 
544 int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
545 {
546  struct sock *rtnl = net->rtnl;
547  int err = 0;
548 
549  NETLINK_CB(skb).dst_group = group;
550  if (echo)
551  atomic_inc(&skb->users);
552  netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
553  if (echo)
554  err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
555  return err;
556 }
557 
558 int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
559 {
560  struct sock *rtnl = net->rtnl;
561 
562  return nlmsg_unicast(rtnl, skb, pid);
563 }
564 EXPORT_SYMBOL(rtnl_unicast);
565 
566 void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
567  struct nlmsghdr *nlh, gfp_t flags)
568 {
569  struct sock *rtnl = net->rtnl;
570  int report = 0;
571 
572  if (nlh)
573  report = nlmsg_report(nlh);
574 
575  nlmsg_notify(rtnl, skb, pid, group, report, flags);
576 }
577 EXPORT_SYMBOL(rtnl_notify);
578 
579 void rtnl_set_sk_err(struct net *net, u32 group, int error)
580 {
581  struct sock *rtnl = net->rtnl;
582 
583  netlink_set_err(rtnl, 0, group, error);
584 }
585 EXPORT_SYMBOL(rtnl_set_sk_err);
586 
587 int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
588 {
589  struct nlattr *mx;
590  int i, valid = 0;
591 
592  mx = nla_nest_start(skb, RTA_METRICS);
593  if (mx == NULL)
594  return -ENOBUFS;
595 
596  for (i = 0; i < RTAX_MAX; i++) {
597  if (metrics[i]) {
598  valid++;
599  if (nla_put_u32(skb, i+1, metrics[i]))
600  goto nla_put_failure;
601  }
602  }
603 
604  if (!valid) {
605  nla_nest_cancel(skb, mx);
606  return 0;
607  }
608 
609  return nla_nest_end(skb, mx);
610 
611 nla_put_failure:
612  nla_nest_cancel(skb, mx);
613  return -EMSGSIZE;
614 }
615 EXPORT_SYMBOL(rtnetlink_put_metrics);
616 
617 int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
618  long expires, u32 error)
619 {
620  struct rta_cacheinfo ci = {
621  .rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse),
622  .rta_used = dst->__use,
623  .rta_clntref = atomic_read(&(dst->__refcnt)),
624  .rta_error = error,
625  .rta_id = id,
626  };
627 
628  if (expires) {
629  unsigned long clock;
630 
631  clock = jiffies_to_clock_t(abs(expires));
632  clock = min_t(unsigned long, clock, INT_MAX);
633  ci.rta_expires = (expires > 0) ? clock : -clock;
634  }
635  return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
636 }
637 EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
638 
639 static void set_operstate(struct net_device *dev, unsigned char transition)
640 {
641  unsigned char operstate = dev->operstate;
642 
643  switch (transition) {
644  case IF_OPER_UP:
645  if ((operstate == IF_OPER_DORMANT ||
646  operstate == IF_OPER_UNKNOWN) &&
647  !netif_dormant(dev))
648  operstate = IF_OPER_UP;
649  break;
650 
651  case IF_OPER_DORMANT:
652  if (operstate == IF_OPER_UP ||
653  operstate == IF_OPER_UNKNOWN)
654  operstate = IF_OPER_DORMANT;
655  break;
656  }
657 
658  if (dev->operstate != operstate) {
659  write_lock_bh(&dev_base_lock);
660  dev->operstate = operstate;
661  write_unlock_bh(&dev_base_lock);
662  netdev_state_change(dev);
663  }
664 }
665 
666 static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
667 {
668  return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
669  (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
670 }
671 
672 static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
673  const struct ifinfomsg *ifm)
674 {
675  unsigned int flags = ifm->ifi_flags;
676 
677  /* bugwards compatibility: ifi_change == 0 is treated as ~0 */
678  if (ifm->ifi_change)
679  flags = (flags & ifm->ifi_change) |
680  (rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
681 
682  return flags;
683 }
684 
685 static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
686  const struct rtnl_link_stats64 *b)
687 {
688  a->rx_packets = b->rx_packets;
689  a->tx_packets = b->tx_packets;
690  a->rx_bytes = b->rx_bytes;
691  a->tx_bytes = b->tx_bytes;
692  a->rx_errors = b->rx_errors;
693  a->tx_errors = b->tx_errors;
694  a->rx_dropped = b->rx_dropped;
695  a->tx_dropped = b->tx_dropped;
696 
697  a->multicast = b->multicast;
698  a->collisions = b->collisions;
699 
700  a->rx_length_errors = b->rx_length_errors;
701  a->rx_over_errors = b->rx_over_errors;
702  a->rx_crc_errors = b->rx_crc_errors;
703  a->rx_frame_errors = b->rx_frame_errors;
704  a->rx_fifo_errors = b->rx_fifo_errors;
705  a->rx_missed_errors = b->rx_missed_errors;
706 
707  a->tx_aborted_errors = b->tx_aborted_errors;
708  a->tx_carrier_errors = b->tx_carrier_errors;
709  a->tx_fifo_errors = b->tx_fifo_errors;
710  a->tx_heartbeat_errors = b->tx_heartbeat_errors;
711  a->tx_window_errors = b->tx_window_errors;
712 
713  a->rx_compressed = b->rx_compressed;
714  a->tx_compressed = b->tx_compressed;
715 }
716 
717 static void copy_rtnl_link_stats64(void *v, const struct rtnl_link_stats64 *b)
718 {
719  memcpy(v, b, sizeof(*b));
720 }
721 
722 /* All VF info */
723 static inline int rtnl_vfinfo_size(const struct net_device *dev,
724  u32 ext_filter_mask)
725 {
726  if (dev->dev.parent && dev_is_pci(dev->dev.parent) &&
727  (ext_filter_mask & RTEXT_FILTER_VF)) {
728  int num_vfs = dev_num_vf(dev->dev.parent);
729  size_t size = nla_total_size(sizeof(struct nlattr));
730  size += nla_total_size(num_vfs * sizeof(struct nlattr));
731  size += num_vfs *
732  (nla_total_size(sizeof(struct ifla_vf_mac)) +
733  nla_total_size(sizeof(struct ifla_vf_vlan)) +
734  nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
735  nla_total_size(sizeof(struct ifla_vf_spoofchk)));
736  return size;
737  } else
738  return 0;
739 }
740 
741 static size_t rtnl_port_size(const struct net_device *dev)
742 {
743  size_t port_size = nla_total_size(4) /* PORT_VF */
744  + nla_total_size(PORT_PROFILE_MAX) /* PORT_PROFILE */
745  + nla_total_size(sizeof(struct ifla_port_vsi))
746  /* PORT_VSI_TYPE */
747  + nla_total_size(PORT_UUID_MAX) /* PORT_INSTANCE_UUID */
748  + nla_total_size(PORT_UUID_MAX) /* PORT_HOST_UUID */
749  + nla_total_size(1) /* PROT_VDP_REQUEST */
750  + nla_total_size(2); /* PORT_VDP_RESPONSE */
751  size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
752  size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
753  + port_size;
754  size_t port_self_size = nla_total_size(sizeof(struct nlattr))
755  + port_size;
756 
757  if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent)
758  return 0;
759  if (dev_num_vf(dev->dev.parent))
760  return port_self_size + vf_ports_size +
761  vf_port_size * dev_num_vf(dev->dev.parent);
762  else
763  return port_self_size;
764 }
765 
766 static noinline size_t if_nlmsg_size(const struct net_device *dev,
767  u32 ext_filter_mask)
768 {
769  return NLMSG_ALIGN(sizeof(struct ifinfomsg))
770  + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
771  + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
772  + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
773  + nla_total_size(sizeof(struct rtnl_link_ifmap))
774  + nla_total_size(sizeof(struct rtnl_link_stats))
775  + nla_total_size(sizeof(struct rtnl_link_stats64))
776  + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
777  + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
778  + nla_total_size(4) /* IFLA_TXQLEN */
779  + nla_total_size(4) /* IFLA_WEIGHT */
780  + nla_total_size(4) /* IFLA_MTU */
781  + nla_total_size(4) /* IFLA_LINK */
782  + nla_total_size(4) /* IFLA_MASTER */
783  + nla_total_size(4) /* IFLA_PROMISCUITY */
784  + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
785  + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
786  + nla_total_size(1) /* IFLA_OPERSTATE */
787  + nla_total_size(1) /* IFLA_LINKMODE */
788  + nla_total_size(ext_filter_mask
789  & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
790  + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
791  + rtnl_port_size(dev) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
792  + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
793  + rtnl_link_get_af_size(dev); /* IFLA_AF_SPEC */
794 }
795 
796 static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
797 {
798  struct nlattr *vf_ports;
799  struct nlattr *vf_port;
800  int vf;
801  int err;
802 
803  vf_ports = nla_nest_start(skb, IFLA_VF_PORTS);
804  if (!vf_ports)
805  return -EMSGSIZE;
806 
807  for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
808  vf_port = nla_nest_start(skb, IFLA_VF_PORT);
809  if (!vf_port)
810  goto nla_put_failure;
811  if (nla_put_u32(skb, IFLA_PORT_VF, vf))
812  goto nla_put_failure;
813  err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
814  if (err == -EMSGSIZE)
815  goto nla_put_failure;
816  if (err) {
817  nla_nest_cancel(skb, vf_port);
818  continue;
819  }
820  nla_nest_end(skb, vf_port);
821  }
822 
823  nla_nest_end(skb, vf_ports);
824 
825  return 0;
826 
827 nla_put_failure:
828  nla_nest_cancel(skb, vf_ports);
829  return -EMSGSIZE;
830 }
831 
832 static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
833 {
834  struct nlattr *port_self;
835  int err;
836 
837  port_self = nla_nest_start(skb, IFLA_PORT_SELF);
838  if (!port_self)
839  return -EMSGSIZE;
840 
841  err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
842  if (err) {
843  nla_nest_cancel(skb, port_self);
844  return (err == -EMSGSIZE) ? err : 0;
845  }
846 
847  nla_nest_end(skb, port_self);
848 
849  return 0;
850 }
851 
852 static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev)
853 {
854  int err;
855 
856  if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent)
857  return 0;
858 
859  err = rtnl_port_self_fill(skb, dev);
860  if (err)
861  return err;
862 
863  if (dev_num_vf(dev->dev.parent)) {
864  err = rtnl_vf_ports_fill(skb, dev);
865  if (err)
866  return err;
867  }
868 
869  return 0;
870 }
871 
872 static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
873  int type, u32 pid, u32 seq, u32 change,
874  unsigned int flags, u32 ext_filter_mask)
875 {
876  struct ifinfomsg *ifm;
877  struct nlmsghdr *nlh;
878  struct rtnl_link_stats64 temp;
879  const struct rtnl_link_stats64 *stats;
880  struct nlattr *attr, *af_spec;
881  struct rtnl_af_ops *af_ops;
882 
883  ASSERT_RTNL();
884  nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
885  if (nlh == NULL)
886  return -EMSGSIZE;
887 
888  ifm = nlmsg_data(nlh);
889  ifm->ifi_family = AF_UNSPEC;
890  ifm->__ifi_pad = 0;
891  ifm->ifi_type = dev->type;
892  ifm->ifi_index = dev->ifindex;
893  ifm->ifi_flags = dev_get_flags(dev);
894  ifm->ifi_change = change;
895 
896  if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
897  nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
898  nla_put_u8(skb, IFLA_OPERSTATE,
899  netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
900  nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
901  nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
902  nla_put_u32(skb, IFLA_GROUP, dev->group) ||
903  nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
904  nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
905 #ifdef CONFIG_RPS
906  nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
907 #endif
908  (dev->ifindex != dev->iflink &&
909  nla_put_u32(skb, IFLA_LINK, dev->iflink)) ||
910  (dev->master &&
911  nla_put_u32(skb, IFLA_MASTER, dev->master->ifindex)) ||
912  (dev->qdisc &&
913  nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
914  (dev->ifalias &&
915  nla_put_string(skb, IFLA_IFALIAS, dev->ifalias)))
916  goto nla_put_failure;
917 
918  if (1) {
919  struct rtnl_link_ifmap map = {
920  .mem_start = dev->mem_start,
921  .mem_end = dev->mem_end,
922  .base_addr = dev->base_addr,
923  .irq = dev->irq,
924  .dma = dev->dma,
925  .port = dev->if_port,
926  };
927  if (nla_put(skb, IFLA_MAP, sizeof(map), &map))
928  goto nla_put_failure;
929  }
930 
931  if (dev->addr_len) {
932  if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
933  nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
934  goto nla_put_failure;
935  }
936 
937  attr = nla_reserve(skb, IFLA_STATS,
938  sizeof(struct rtnl_link_stats));
939  if (attr == NULL)
940  goto nla_put_failure;
941 
942  stats = dev_get_stats(dev, &temp);
943  copy_rtnl_link_stats(nla_data(attr), stats);
944 
945  attr = nla_reserve(skb, IFLA_STATS64,
946  sizeof(struct rtnl_link_stats64));
947  if (attr == NULL)
948  goto nla_put_failure;
949  copy_rtnl_link_stats64(nla_data(attr), stats);
950 
951  if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF) &&
952  nla_put_u32(skb, IFLA_NUM_VF, dev_num_vf(dev->dev.parent)))
953  goto nla_put_failure;
954 
955  if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent
956  && (ext_filter_mask & RTEXT_FILTER_VF)) {
957  int i;
958 
959  struct nlattr *vfinfo, *vf;
960  int num_vfs = dev_num_vf(dev->dev.parent);
961 
962  vfinfo = nla_nest_start(skb, IFLA_VFINFO_LIST);
963  if (!vfinfo)
964  goto nla_put_failure;
965  for (i = 0; i < num_vfs; i++) {
966  struct ifla_vf_info ivi;
967  struct ifla_vf_mac vf_mac;
968  struct ifla_vf_vlan vf_vlan;
969  struct ifla_vf_tx_rate vf_tx_rate;
970  struct ifla_vf_spoofchk vf_spoofchk;
971 
972  /*
973  * Not all SR-IOV capable drivers support the
974  * spoofcheck query. Preset to -1 so the user
975  * space tool can detect that the driver didn't
976  * report anything.
977  */
978  ivi.spoofchk = -1;
979  if (dev->netdev_ops->ndo_get_vf_config(dev, i, &ivi))
980  break;
981  vf_mac.vf =
982  vf_vlan.vf =
983  vf_tx_rate.vf =
984  vf_spoofchk.vf = ivi.vf;
985 
986  memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
987  vf_vlan.vlan = ivi.vlan;
988  vf_vlan.qos = ivi.qos;
989  vf_tx_rate.rate = ivi.tx_rate;
990  vf_spoofchk.setting = ivi.spoofchk;
991  vf = nla_nest_start(skb, IFLA_VF_INFO);
992  if (!vf) {
993  nla_nest_cancel(skb, vfinfo);
994  goto nla_put_failure;
995  }
996  if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
997  nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
998  nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
999  &vf_tx_rate) ||
1000  nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1001  &vf_spoofchk))
1002  goto nla_put_failure;
1003  nla_nest_end(skb, vf);
1004  }
1005  nla_nest_end(skb, vfinfo);
1006  }
1007 
1008  if (rtnl_port_fill(skb, dev))
1009  goto nla_put_failure;
1010 
1011  if (dev->rtnl_link_ops) {
1012  if (rtnl_link_fill(skb, dev) < 0)
1013  goto nla_put_failure;
1014  }
1015 
1016  if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC)))
1017  goto nla_put_failure;
1018 
1019  list_for_each_entry(af_ops, &rtnl_af_ops, list) {
1020  if (af_ops->fill_link_af) {
1021  struct nlattr *af;
1022  int err;
1023 
1024  if (!(af = nla_nest_start(skb, af_ops->family)))
1025  goto nla_put_failure;
1026 
1027  err = af_ops->fill_link_af(skb, dev);
1028 
1029  /*
1030  * Caller may return ENODATA to indicate that there
1031  * was no data to be dumped. This is not an error, it
1032  * means we should trim the attribute header and
1033  * continue.
1034  */
1035  if (err == -ENODATA)
1036  nla_nest_cancel(skb, af);
1037  else if (err < 0)
1038  goto nla_put_failure;
1039 
1040  nla_nest_end(skb, af);
1041  }
1042  }
1043 
1044  nla_nest_end(skb, af_spec);
1045 
1046  return nlmsg_end(skb, nlh);
1047 
1048 nla_put_failure:
1049  nlmsg_cancel(skb, nlh);
1050  return -EMSGSIZE;
1051 }
1052 
1053 static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
1054 {
1055  struct net *net = sock_net(skb->sk);
1056  int h, s_h;
1057  int idx = 0, s_idx;
1058  struct net_device *dev;
1059  struct hlist_head *head;
1060  struct hlist_node *node;
1061  struct nlattr *tb[IFLA_MAX+1];
1062  u32 ext_filter_mask = 0;
1063 
1064  s_h = cb->args[0];
1065  s_idx = cb->args[1];
1066 
1067  rcu_read_lock();
1068  cb->seq = net->dev_base_seq;
1069 
1070  if (nlmsg_parse(cb->nlh, sizeof(struct rtgenmsg), tb, IFLA_MAX,
1071  ifla_policy) >= 0) {
1072 
1073  if (tb[IFLA_EXT_MASK])
1074  ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
1075  }
1076 
1077  for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
1078  idx = 0;
1079  head = &net->dev_index_head[h];
1080  hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
1081  if (idx < s_idx)
1082  goto cont;
1083  if (rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
1084  NETLINK_CB(cb->skb).portid,
1085  cb->nlh->nlmsg_seq, 0,
1086  NLM_F_MULTI,
1087  ext_filter_mask) <= 0)
1088  goto out;
1089 
1090  nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1091 cont:
1092  idx++;
1093  }
1094  }
1095 out:
1096  rcu_read_unlock();
1097  cb->args[1] = idx;
1098  cb->args[0] = h;
1099 
1100  return skb->len;
1101 }
1102 
1103 const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1104  [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 },
1105  [IFLA_ADDRESS] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1106  [IFLA_BROADCAST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1107  [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) },
1108  [IFLA_MTU] = { .type = NLA_U32 },
1109  [IFLA_LINK] = { .type = NLA_U32 },
1110  [IFLA_MASTER] = { .type = NLA_U32 },
1111  [IFLA_TXQLEN] = { .type = NLA_U32 },
1112  [IFLA_WEIGHT] = { .type = NLA_U32 },
1113  [IFLA_OPERSTATE] = { .type = NLA_U8 },
1114  [IFLA_LINKMODE] = { .type = NLA_U8 },
1115  [IFLA_LINKINFO] = { .type = NLA_NESTED },
1116  [IFLA_NET_NS_PID] = { .type = NLA_U32 },
1117  [IFLA_NET_NS_FD] = { .type = NLA_U32 },
1118  [IFLA_IFALIAS] = { .type = NLA_STRING, .len = IFALIASZ-1 },
1119  [IFLA_VFINFO_LIST] = {. type = NLA_NESTED },
1120  [IFLA_VF_PORTS] = { .type = NLA_NESTED },
1121  [IFLA_PORT_SELF] = { .type = NLA_NESTED },
1122  [IFLA_AF_SPEC] = { .type = NLA_NESTED },
1123  [IFLA_EXT_MASK] = { .type = NLA_U32 },
1124  [IFLA_PROMISCUITY] = { .type = NLA_U32 },
1125  [IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 },
1126  [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 },
1127 };
1128 EXPORT_SYMBOL(ifla_policy);
1129 
1130 static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1131  [IFLA_INFO_KIND] = { .type = NLA_STRING },
1132  [IFLA_INFO_DATA] = { .type = NLA_NESTED },
1133 };
1134 
1135 static const struct nla_policy ifla_vfinfo_policy[IFLA_VF_INFO_MAX+1] = {
1136  [IFLA_VF_INFO] = { .type = NLA_NESTED },
1137 };
1138 
1139 static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1140  [IFLA_VF_MAC] = { .type = NLA_BINARY,
1141  .len = sizeof(struct ifla_vf_mac) },
1142  [IFLA_VF_VLAN] = { .type = NLA_BINARY,
1143  .len = sizeof(struct ifla_vf_vlan) },
1144  [IFLA_VF_TX_RATE] = { .type = NLA_BINARY,
1145  .len = sizeof(struct ifla_vf_tx_rate) },
1146  [IFLA_VF_SPOOFCHK] = { .type = NLA_BINARY,
1147  .len = sizeof(struct ifla_vf_spoofchk) },
1148 };
1149 
1150 static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
1151  [IFLA_PORT_VF] = { .type = NLA_U32 },
1152  [IFLA_PORT_PROFILE] = { .type = NLA_STRING,
1153  .len = PORT_PROFILE_MAX },
1154  [IFLA_PORT_VSI_TYPE] = { .type = NLA_BINARY,
1155  .len = sizeof(struct ifla_port_vsi)},
1156  [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
1157  .len = PORT_UUID_MAX },
1158  [IFLA_PORT_HOST_UUID] = { .type = NLA_STRING,
1159  .len = PORT_UUID_MAX },
1160  [IFLA_PORT_REQUEST] = { .type = NLA_U8, },
1161  [IFLA_PORT_RESPONSE] = { .type = NLA_U16, },
1162 };
1163 
1164 struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
1165 {
1166  struct net *net;
1167  /* Examine the link attributes and figure out which
1168  * network namespace we are talking about.
1169  */
1170  if (tb[IFLA_NET_NS_PID])
1171  net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
1172  else if (tb[IFLA_NET_NS_FD])
1173  net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
1174  else
1175  net = get_net(src_net);
1176  return net;
1177 }
1178 EXPORT_SYMBOL(rtnl_link_get_net);
1179 
1180 static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
1181 {
1182  if (dev) {
1183  if (tb[IFLA_ADDRESS] &&
1184  nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
1185  return -EINVAL;
1186 
1187  if (tb[IFLA_BROADCAST] &&
1188  nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
1189  return -EINVAL;
1190  }
1191 
1192  if (tb[IFLA_AF_SPEC]) {
1193  struct nlattr *af;
1194  int rem, err;
1195 
1196  nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
1197  const struct rtnl_af_ops *af_ops;
1198 
1199  if (!(af_ops = rtnl_af_lookup(nla_type(af))))
1200  return -EAFNOSUPPORT;
1201 
1202  if (!af_ops->set_link_af)
1203  return -EOPNOTSUPP;
1204 
1205  if (af_ops->validate_link_af) {
1206  err = af_ops->validate_link_af(dev, af);
1207  if (err < 0)
1208  return err;
1209  }
1210  }
1211  }
1212 
1213  return 0;
1214 }
1215 
1216 static int do_setvfinfo(struct net_device *dev, struct nlattr *attr)
1217 {
1218  int rem, err = -EINVAL;
1219  struct nlattr *vf;
1220  const struct net_device_ops *ops = dev->netdev_ops;
1221 
1222  nla_for_each_nested(vf, attr, rem) {
1223  switch (nla_type(vf)) {
1224  case IFLA_VF_MAC: {
1225  struct ifla_vf_mac *ivm;
1226  ivm = nla_data(vf);
1227  err = -EOPNOTSUPP;
1228  if (ops->ndo_set_vf_mac)
1229  err = ops->ndo_set_vf_mac(dev, ivm->vf,
1230  ivm->mac);
1231  break;
1232  }
1233  case IFLA_VF_VLAN: {
1234  struct ifla_vf_vlan *ivv;
1235  ivv = nla_data(vf);
1236  err = -EOPNOTSUPP;
1237  if (ops->ndo_set_vf_vlan)
1238  err = ops->ndo_set_vf_vlan(dev, ivv->vf,
1239  ivv->vlan,
1240  ivv->qos);
1241  break;
1242  }
1243  case IFLA_VF_TX_RATE: {
1244  struct ifla_vf_tx_rate *ivt;
1245  ivt = nla_data(vf);
1246  err = -EOPNOTSUPP;
1247  if (ops->ndo_set_vf_tx_rate)
1248  err = ops->ndo_set_vf_tx_rate(dev, ivt->vf,
1249  ivt->rate);
1250  break;
1251  }
1252  case IFLA_VF_SPOOFCHK: {
1253  struct ifla_vf_spoofchk *ivs;
1254  ivs = nla_data(vf);
1255  err = -EOPNOTSUPP;
1256  if (ops->ndo_set_vf_spoofchk)
1257  err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
1258  ivs->setting);
1259  break;
1260  }
1261  default:
1262  err = -EINVAL;
1263  break;
1264  }
1265  if (err)
1266  break;
1267  }
1268  return err;
1269 }
1270 
1271 static int do_set_master(struct net_device *dev, int ifindex)
1272 {
1273  struct net_device *master_dev;
1274  const struct net_device_ops *ops;
1275  int err;
1276 
1277  if (dev->master) {
1278  if (dev->master->ifindex == ifindex)
1279  return 0;
1280  ops = dev->master->netdev_ops;
1281  if (ops->ndo_del_slave) {
1282  err = ops->ndo_del_slave(dev->master, dev);
1283  if (err)
1284  return err;
1285  } else {
1286  return -EOPNOTSUPP;
1287  }
1288  }
1289 
1290  if (ifindex) {
1291  master_dev = __dev_get_by_index(dev_net(dev), ifindex);
1292  if (!master_dev)
1293  return -EINVAL;
1294  ops = master_dev->netdev_ops;
1295  if (ops->ndo_add_slave) {
1296  err = ops->ndo_add_slave(master_dev, dev);
1297  if (err)
1298  return err;
1299  } else {
1300  return -EOPNOTSUPP;
1301  }
1302  }
1303  return 0;
1304 }
1305 
1306 static int do_setlink(struct net_device *dev, struct ifinfomsg *ifm,
1307  struct nlattr **tb, char *ifname, int modified)
1308 {
1309  const struct net_device_ops *ops = dev->netdev_ops;
1310  int send_addr_notify = 0;
1311  int err;
1312 
1313  if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) {
1314  struct net *net = rtnl_link_get_net(dev_net(dev), tb);
1315  if (IS_ERR(net)) {
1316  err = PTR_ERR(net);
1317  goto errout;
1318  }
1319  err = dev_change_net_namespace(dev, net, ifname);
1320  put_net(net);
1321  if (err)
1322  goto errout;
1323  modified = 1;
1324  }
1325 
1326  if (tb[IFLA_MAP]) {
1327  struct rtnl_link_ifmap *u_map;
1328  struct ifmap k_map;
1329 
1330  if (!ops->ndo_set_config) {
1331  err = -EOPNOTSUPP;
1332  goto errout;
1333  }
1334 
1335  if (!netif_device_present(dev)) {
1336  err = -ENODEV;
1337  goto errout;
1338  }
1339 
1340  u_map = nla_data(tb[IFLA_MAP]);
1341  k_map.mem_start = (unsigned long) u_map->mem_start;
1342  k_map.mem_end = (unsigned long) u_map->mem_end;
1343  k_map.base_addr = (unsigned short) u_map->base_addr;
1344  k_map.irq = (unsigned char) u_map->irq;
1345  k_map.dma = (unsigned char) u_map->dma;
1346  k_map.port = (unsigned char) u_map->port;
1347 
1348  err = ops->ndo_set_config(dev, &k_map);
1349  if (err < 0)
1350  goto errout;
1351 
1352  modified = 1;
1353  }
1354 
1355  if (tb[IFLA_ADDRESS]) {
1356  struct sockaddr *sa;
1357  int len;
1358 
1359  if (!ops->ndo_set_mac_address) {
1360  err = -EOPNOTSUPP;
1361  goto errout;
1362  }
1363 
1364  if (!netif_device_present(dev)) {
1365  err = -ENODEV;
1366  goto errout;
1367  }
1368 
1369  len = sizeof(sa_family_t) + dev->addr_len;
1370  sa = kmalloc(len, GFP_KERNEL);
1371  if (!sa) {
1372  err = -ENOMEM;
1373  goto errout;
1374  }
1375  sa->sa_family = dev->type;
1376  memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
1377  dev->addr_len);
1378  err = ops->ndo_set_mac_address(dev, sa);
1379  kfree(sa);
1380  if (err)
1381  goto errout;
1382  send_addr_notify = 1;
1383  modified = 1;
1384  add_device_randomness(dev->dev_addr, dev->addr_len);
1385  }
1386 
1387  if (tb[IFLA_MTU]) {
1388  err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
1389  if (err < 0)
1390  goto errout;
1391  modified = 1;
1392  }
1393 
1394  if (tb[IFLA_GROUP]) {
1395  dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
1396  modified = 1;
1397  }
1398 
1399  /*
1400  * Interface selected by interface index but interface
1401  * name provided implies that a name change has been
1402  * requested.
1403  */
1404  if (ifm->ifi_index > 0 && ifname[0]) {
1405  err = dev_change_name(dev, ifname);
1406  if (err < 0)
1407  goto errout;
1408  modified = 1;
1409  }
1410 
1411  if (tb[IFLA_IFALIAS]) {
1412  err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
1413  nla_len(tb[IFLA_IFALIAS]));
1414  if (err < 0)
1415  goto errout;
1416  modified = 1;
1417  }
1418 
1419  if (tb[IFLA_BROADCAST]) {
1420  nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
1421  send_addr_notify = 1;
1422  }
1423 
1424  if (ifm->ifi_flags || ifm->ifi_change) {
1425  err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm));
1426  if (err < 0)
1427  goto errout;
1428  }
1429 
1430  if (tb[IFLA_MASTER]) {
1431  err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]));
1432  if (err)
1433  goto errout;
1434  modified = 1;
1435  }
1436 
1437  if (tb[IFLA_TXQLEN])
1438  dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
1439 
1440  if (tb[IFLA_OPERSTATE])
1441  set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
1442 
1443  if (tb[IFLA_LINKMODE]) {
1444  write_lock_bh(&dev_base_lock);
1445  dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
1446  write_unlock_bh(&dev_base_lock);
1447  }
1448 
1449  if (tb[IFLA_VFINFO_LIST]) {
1450  struct nlattr *attr;
1451  int rem;
1452  nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
1453  if (nla_type(attr) != IFLA_VF_INFO) {
1454  err = -EINVAL;
1455  goto errout;
1456  }
1457  err = do_setvfinfo(dev, attr);
1458  if (err < 0)
1459  goto errout;
1460  modified = 1;
1461  }
1462  }
1463  err = 0;
1464 
1465  if (tb[IFLA_VF_PORTS]) {
1466  struct nlattr *port[IFLA_PORT_MAX+1];
1467  struct nlattr *attr;
1468  int vf;
1469  int rem;
1470 
1471  err = -EOPNOTSUPP;
1472  if (!ops->ndo_set_vf_port)
1473  goto errout;
1474 
1475  nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
1476  if (nla_type(attr) != IFLA_VF_PORT)
1477  continue;
1478  err = nla_parse_nested(port, IFLA_PORT_MAX,
1479  attr, ifla_port_policy);
1480  if (err < 0)
1481  goto errout;
1482  if (!port[IFLA_PORT_VF]) {
1483  err = -EOPNOTSUPP;
1484  goto errout;
1485  }
1486  vf = nla_get_u32(port[IFLA_PORT_VF]);
1487  err = ops->ndo_set_vf_port(dev, vf, port);
1488  if (err < 0)
1489  goto errout;
1490  modified = 1;
1491  }
1492  }
1493  err = 0;
1494 
1495  if (tb[IFLA_PORT_SELF]) {
1496  struct nlattr *port[IFLA_PORT_MAX+1];
1497 
1498  err = nla_parse_nested(port, IFLA_PORT_MAX,
1499  tb[IFLA_PORT_SELF], ifla_port_policy);
1500  if (err < 0)
1501  goto errout;
1502 
1503  err = -EOPNOTSUPP;
1504  if (ops->ndo_set_vf_port)
1505  err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
1506  if (err < 0)
1507  goto errout;
1508  modified = 1;
1509  }
1510 
1511  if (tb[IFLA_AF_SPEC]) {
1512  struct nlattr *af;
1513  int rem;
1514 
1515  nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
1516  const struct rtnl_af_ops *af_ops;
1517 
1518  if (!(af_ops = rtnl_af_lookup(nla_type(af))))
1519  BUG();
1520 
1521  err = af_ops->set_link_af(dev, af);
1522  if (err < 0)
1523  goto errout;
1524 
1525  modified = 1;
1526  }
1527  }
1528  err = 0;
1529 
1530 errout:
1531  if (err < 0 && modified)
1532  net_warn_ratelimited("A link change request failed with some changes committed already. Interface %s may have been left with an inconsistent configuration, please check.\n",
1533  dev->name);
1534 
1535  if (send_addr_notify)
1536  call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
1537 
1538  return err;
1539 }
1540 
1541 static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1542 {
1543  struct net *net = sock_net(skb->sk);
1544  struct ifinfomsg *ifm;
1545  struct net_device *dev;
1546  int err;
1547  struct nlattr *tb[IFLA_MAX+1];
1548  char ifname[IFNAMSIZ];
1549 
1550  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
1551  if (err < 0)
1552  goto errout;
1553 
1554  if (tb[IFLA_IFNAME])
1555  nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
1556  else
1557  ifname[0] = '\0';
1558 
1559  err = -EINVAL;
1560  ifm = nlmsg_data(nlh);
1561  if (ifm->ifi_index > 0)
1562  dev = __dev_get_by_index(net, ifm->ifi_index);
1563  else if (tb[IFLA_IFNAME])
1564  dev = __dev_get_by_name(net, ifname);
1565  else
1566  goto errout;
1567 
1568  if (dev == NULL) {
1569  err = -ENODEV;
1570  goto errout;
1571  }
1572 
1573  err = validate_linkmsg(dev, tb);
1574  if (err < 0)
1575  goto errout;
1576 
1577  err = do_setlink(dev, ifm, tb, ifname, 0);
1578 errout:
1579  return err;
1580 }
1581 
1582 static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1583 {
1584  struct net *net = sock_net(skb->sk);
1585  const struct rtnl_link_ops *ops;
1586  struct net_device *dev;
1587  struct ifinfomsg *ifm;
1588  char ifname[IFNAMSIZ];
1589  struct nlattr *tb[IFLA_MAX+1];
1590  int err;
1591  LIST_HEAD(list_kill);
1592 
1593  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
1594  if (err < 0)
1595  return err;
1596 
1597  if (tb[IFLA_IFNAME])
1598  nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
1599 
1600  ifm = nlmsg_data(nlh);
1601  if (ifm->ifi_index > 0)
1602  dev = __dev_get_by_index(net, ifm->ifi_index);
1603  else if (tb[IFLA_IFNAME])
1604  dev = __dev_get_by_name(net, ifname);
1605  else
1606  return -EINVAL;
1607 
1608  if (!dev)
1609  return -ENODEV;
1610 
1611  ops = dev->rtnl_link_ops;
1612  if (!ops)
1613  return -EOPNOTSUPP;
1614 
1615  ops->dellink(dev, &list_kill);
1616  unregister_netdevice_many(&list_kill);
1617  list_del(&list_kill);
1618  return 0;
1619 }
1620 
1621 int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm)
1622 {
1623  unsigned int old_flags;
1624  int err;
1625 
1626  old_flags = dev->flags;
1627  if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
1628  err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm));
1629  if (err < 0)
1630  return err;
1631  }
1632 
1633  dev->rtnl_link_state = RTNL_LINK_INITIALIZED;
1634  rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U);
1635 
1636  __dev_notify_flags(dev, old_flags);
1637  return 0;
1638 }
1639 EXPORT_SYMBOL(rtnl_configure_link);
1640 
1641 struct net_device *rtnl_create_link(struct net *src_net, struct net *net,
1642  char *ifname, const struct rtnl_link_ops *ops, struct nlattr *tb[])
1643 {
1644  int err;
1645  struct net_device *dev;
1646  unsigned int num_tx_queues = 1;
1647  unsigned int num_rx_queues = 1;
1648 
1649  if (tb[IFLA_NUM_TX_QUEUES])
1650  num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
1651  else if (ops->get_num_tx_queues)
1652  num_tx_queues = ops->get_num_tx_queues();
1653 
1654  if (tb[IFLA_NUM_RX_QUEUES])
1655  num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
1656  else if (ops->get_num_rx_queues)
1657  num_rx_queues = ops->get_num_rx_queues();
1658 
1659  err = -ENOMEM;
1660  dev = alloc_netdev_mqs(ops->priv_size, ifname, ops->setup,
1661  num_tx_queues, num_rx_queues);
1662  if (!dev)
1663  goto err;
1664 
1665  dev_net_set(dev, net);
1666  dev->rtnl_link_ops = ops;
1667  dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
1668 
1669  if (tb[IFLA_MTU])
1670  dev->mtu = nla_get_u32(tb[IFLA_MTU]);
1671  if (tb[IFLA_ADDRESS])
1672  memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]),
1673  nla_len(tb[IFLA_ADDRESS]));
1674  if (tb[IFLA_BROADCAST])
1675  memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
1676  nla_len(tb[IFLA_BROADCAST]));
1677  if (tb[IFLA_TXQLEN])
1678  dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
1679  if (tb[IFLA_OPERSTATE])
1680  set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
1681  if (tb[IFLA_LINKMODE])
1682  dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
1683  if (tb[IFLA_GROUP])
1684  dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
1685 
1686  return dev;
1687 
1688 err:
1689  return ERR_PTR(err);
1690 }
1691 EXPORT_SYMBOL(rtnl_create_link);
1692 
1693 static int rtnl_group_changelink(struct net *net, int group,
1694  struct ifinfomsg *ifm,
1695  struct nlattr **tb)
1696 {
1697  struct net_device *dev;
1698  int err;
1699 
1700  for_each_netdev(net, dev) {
1701  if (dev->group == group) {
1702  err = do_setlink(dev, ifm, tb, NULL, 0);
1703  if (err < 0)
1704  return err;
1705  }
1706  }
1707 
1708  return 0;
1709 }
1710 
1711 static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1712 {
1713  struct net *net = sock_net(skb->sk);
1714  const struct rtnl_link_ops *ops;
1715  struct net_device *dev;
1716  struct ifinfomsg *ifm;
1717  char kind[MODULE_NAME_LEN];
1718  char ifname[IFNAMSIZ];
1719  struct nlattr *tb[IFLA_MAX+1];
1720  struct nlattr *linkinfo[IFLA_INFO_MAX+1];
1721  int err;
1722 
1723 #ifdef CONFIG_MODULES
1724 replay:
1725 #endif
1726  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
1727  if (err < 0)
1728  return err;
1729 
1730  if (tb[IFLA_IFNAME])
1731  nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
1732  else
1733  ifname[0] = '\0';
1734 
1735  ifm = nlmsg_data(nlh);
1736  if (ifm->ifi_index > 0)
1737  dev = __dev_get_by_index(net, ifm->ifi_index);
1738  else {
1739  if (ifname[0])
1740  dev = __dev_get_by_name(net, ifname);
1741  else
1742  dev = NULL;
1743  }
1744 
1745  err = validate_linkmsg(dev, tb);
1746  if (err < 0)
1747  return err;
1748 
1749  if (tb[IFLA_LINKINFO]) {
1750  err = nla_parse_nested(linkinfo, IFLA_INFO_MAX,
1751  tb[IFLA_LINKINFO], ifla_info_policy);
1752  if (err < 0)
1753  return err;
1754  } else
1755  memset(linkinfo, 0, sizeof(linkinfo));
1756 
1757  if (linkinfo[IFLA_INFO_KIND]) {
1758  nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
1759  ops = rtnl_link_ops_get(kind);
1760  } else {
1761  kind[0] = '\0';
1762  ops = NULL;
1763  }
1764 
1765  if (1) {
1766  struct nlattr *attr[ops ? ops->maxtype + 1 : 0], **data = NULL;
1767  struct net *dest_net;
1768 
1769  if (ops) {
1770  if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
1771  err = nla_parse_nested(attr, ops->maxtype,
1772  linkinfo[IFLA_INFO_DATA],
1773  ops->policy);
1774  if (err < 0)
1775  return err;
1776  data = attr;
1777  }
1778  if (ops->validate) {
1779  err = ops->validate(tb, data);
1780  if (err < 0)
1781  return err;
1782  }
1783  }
1784 
1785  if (dev) {
1786  int modified = 0;
1787 
1788  if (nlh->nlmsg_flags & NLM_F_EXCL)
1789  return -EEXIST;
1790  if (nlh->nlmsg_flags & NLM_F_REPLACE)
1791  return -EOPNOTSUPP;
1792 
1793  if (linkinfo[IFLA_INFO_DATA]) {
1794  if (!ops || ops != dev->rtnl_link_ops ||
1795  !ops->changelink)
1796  return -EOPNOTSUPP;
1797 
1798  err = ops->changelink(dev, tb, data);
1799  if (err < 0)
1800  return err;
1801  modified = 1;
1802  }
1803 
1804  return do_setlink(dev, ifm, tb, ifname, modified);
1805  }
1806 
1807  if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1808  if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
1809  return rtnl_group_changelink(net,
1810  nla_get_u32(tb[IFLA_GROUP]),
1811  ifm, tb);
1812  return -ENODEV;
1813  }
1814 
1815  if (tb[IFLA_MAP] || tb[IFLA_MASTER] || tb[IFLA_PROTINFO])
1816  return -EOPNOTSUPP;
1817 
1818  if (!ops) {
1819 #ifdef CONFIG_MODULES
1820  if (kind[0]) {
1821  __rtnl_unlock();
1822  request_module("rtnl-link-%s", kind);
1823  rtnl_lock();
1824  ops = rtnl_link_ops_get(kind);
1825  if (ops)
1826  goto replay;
1827  }
1828 #endif
1829  return -EOPNOTSUPP;
1830  }
1831 
1832  if (!ifname[0])
1833  snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
1834 
1835  dest_net = rtnl_link_get_net(net, tb);
1836  if (IS_ERR(dest_net))
1837  return PTR_ERR(dest_net);
1838 
1839  dev = rtnl_create_link(net, dest_net, ifname, ops, tb);
1840  if (IS_ERR(dev)) {
1841  err = PTR_ERR(dev);
1842  goto out;
1843  }
1844 
1845  dev->ifindex = ifm->ifi_index;
1846 
1847  if (ops->newlink)
1848  err = ops->newlink(net, dev, tb, data);
1849  else
1850  err = register_netdevice(dev);
1851 
1852  if (err < 0 && !IS_ERR(dev))
1853  free_netdev(dev);
1854  if (err < 0)
1855  goto out;
1856 
1857  err = rtnl_configure_link(dev, ifm);
1858  if (err < 0)
1859  unregister_netdevice(dev);
1860 out:
1861  put_net(dest_net);
1862  return err;
1863  }
1864 }
1865 
1866 static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1867 {
1868  struct net *net = sock_net(skb->sk);
1869  struct ifinfomsg *ifm;
1870  char ifname[IFNAMSIZ];
1871  struct nlattr *tb[IFLA_MAX+1];
1872  struct net_device *dev = NULL;
1873  struct sk_buff *nskb;
1874  int err;
1875  u32 ext_filter_mask = 0;
1876 
1877  err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
1878  if (err < 0)
1879  return err;
1880 
1881  if (tb[IFLA_IFNAME])
1882  nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
1883 
1884  if (tb[IFLA_EXT_MASK])
1885  ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
1886 
1887  ifm = nlmsg_data(nlh);
1888  if (ifm->ifi_index > 0)
1889  dev = __dev_get_by_index(net, ifm->ifi_index);
1890  else if (tb[IFLA_IFNAME])
1891  dev = __dev_get_by_name(net, ifname);
1892  else
1893  return -EINVAL;
1894 
1895  if (dev == NULL)
1896  return -ENODEV;
1897 
1898  nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
1899  if (nskb == NULL)
1900  return -ENOBUFS;
1901 
1902  err = rtnl_fill_ifinfo(nskb, dev, RTM_NEWLINK, NETLINK_CB(skb).portid,
1903  nlh->nlmsg_seq, 0, 0, ext_filter_mask);
1904  if (err < 0) {
1905  /* -EMSGSIZE implies BUG in if_nlmsg_size */
1906  WARN_ON(err == -EMSGSIZE);
1907  kfree_skb(nskb);
1908  } else
1909  err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
1910 
1911  return err;
1912 }
1913 
1914 static u16 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
1915 {
1916  struct net *net = sock_net(skb->sk);
1917  struct net_device *dev;
1918  struct nlattr *tb[IFLA_MAX+1];
1919  u32 ext_filter_mask = 0;
1920  u16 min_ifinfo_dump_size = 0;
1921 
1922  if (nlmsg_parse(nlh, sizeof(struct rtgenmsg), tb, IFLA_MAX,
1923  ifla_policy) >= 0) {
1924  if (tb[IFLA_EXT_MASK])
1925  ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
1926  }
1927 
1928  if (!ext_filter_mask)
1929  return NLMSG_GOODSIZE;
1930  /*
1931  * traverse the list of net devices and compute the minimum
1932  * buffer size based upon the filter mask.
1933  */
1934  list_for_each_entry(dev, &net->dev_base_head, dev_list) {
1935  min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size,
1936  if_nlmsg_size(dev,
1937  ext_filter_mask));
1938  }
1939 
1940  return min_ifinfo_dump_size;
1941 }
1942 
1943 static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
1944 {
1945  int idx;
1946  int s_idx = cb->family;
1947 
1948  if (s_idx == 0)
1949  s_idx = 1;
1950  for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
1951  int type = cb->nlh->nlmsg_type-RTM_BASE;
1952  if (idx < s_idx || idx == PF_PACKET)
1953  continue;
1954  if (rtnl_msg_handlers[idx] == NULL ||
1955  rtnl_msg_handlers[idx][type].dumpit == NULL)
1956  continue;
1957  if (idx > s_idx)
1958  memset(&cb->args[0], 0, sizeof(cb->args));
1959  if (rtnl_msg_handlers[idx][type].dumpit(skb, cb))
1960  break;
1961  }
1962  cb->family = idx;
1963 
1964  return skb->len;
1965 }
1966 
1967 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change)
1968 {
1969  struct net *net = dev_net(dev);
1970  struct sk_buff *skb;
1971  int err = -ENOBUFS;
1972  size_t if_info_size;
1973 
1974  skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), GFP_KERNEL);
1975  if (skb == NULL)
1976  goto errout;
1977 
1978  err = rtnl_fill_ifinfo(skb, dev, type, 0, 0, change, 0, 0);
1979  if (err < 0) {
1980  /* -EMSGSIZE implies BUG in if_nlmsg_size() */
1981  WARN_ON(err == -EMSGSIZE);
1982  kfree_skb(skb);
1983  goto errout;
1984  }
1985  rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
1986  return;
1987 errout:
1988  if (err < 0)
1989  rtnl_set_sk_err(net, RTNLGRP_LINK, err);
1990 }
1991 
1992 static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
1993  struct net_device *dev,
1994  u8 *addr, u32 pid, u32 seq,
1995  int type, unsigned int flags)
1996 {
1997  struct nlmsghdr *nlh;
1998  struct ndmsg *ndm;
1999 
2000  nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), NLM_F_MULTI);
2001  if (!nlh)
2002  return -EMSGSIZE;
2003 
2004  ndm = nlmsg_data(nlh);
2005  ndm->ndm_family = AF_BRIDGE;
2006  ndm->ndm_pad1 = 0;
2007  ndm->ndm_pad2 = 0;
2008  ndm->ndm_flags = flags;
2009  ndm->ndm_type = 0;
2010  ndm->ndm_ifindex = dev->ifindex;
2011  ndm->ndm_state = NUD_PERMANENT;
2012 
2013  if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr))
2014  goto nla_put_failure;
2015 
2016  return nlmsg_end(skb, nlh);
2017 
2018 nla_put_failure:
2019  nlmsg_cancel(skb, nlh);
2020  return -EMSGSIZE;
2021 }
2022 
2023 static inline size_t rtnl_fdb_nlmsg_size(void)
2024 {
2025  return NLMSG_ALIGN(sizeof(struct ndmsg)) + nla_total_size(ETH_ALEN);
2026 }
2027 
2028 static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, int type)
2029 {
2030  struct net *net = dev_net(dev);
2031  struct sk_buff *skb;
2032  int err = -ENOBUFS;
2033 
2034  skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC);
2035  if (!skb)
2036  goto errout;
2037 
2038  err = nlmsg_populate_fdb_fill(skb, dev, addr, 0, 0, type, NTF_SELF);
2039  if (err < 0) {
2040  kfree_skb(skb);
2041  goto errout;
2042  }
2043 
2044  rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2045  return;
2046 errout:
2047  rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
2048 }
2049 
2050 static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
2051 {
2052  struct net *net = sock_net(skb->sk);
2053  struct net_device *master = NULL;
2054  struct ndmsg *ndm;
2055  struct nlattr *tb[NDA_MAX+1];
2056  struct net_device *dev;
2057  u8 *addr;
2058  int err;
2059 
2060  err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
2061  if (err < 0)
2062  return err;
2063 
2064  ndm = nlmsg_data(nlh);
2065  if (ndm->ndm_ifindex == 0) {
2066  pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid ifindex\n");
2067  return -EINVAL;
2068  }
2069 
2070  dev = __dev_get_by_index(net, ndm->ndm_ifindex);
2071  if (dev == NULL) {
2072  pr_info("PF_BRIDGE: RTM_NEWNEIGH with unknown ifindex\n");
2073  return -ENODEV;
2074  }
2075 
2076  if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
2077  pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid address\n");
2078  return -EINVAL;
2079  }
2080 
2081  addr = nla_data(tb[NDA_LLADDR]);
2082  if (!is_valid_ether_addr(addr)) {
2083  pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid ether address\n");
2084  return -EINVAL;
2085  }
2086 
2087  err = -EOPNOTSUPP;
2088 
2089  /* Support fdb on master device the net/bridge default case */
2090  if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
2091  (dev->priv_flags & IFF_BRIDGE_PORT)) {
2092  master = dev->master;
2093  err = master->netdev_ops->ndo_fdb_add(ndm, tb,
2094  dev, addr,
2095  nlh->nlmsg_flags);
2096  if (err)
2097  goto out;
2098  else
2099  ndm->ndm_flags &= ~NTF_MASTER;
2100  }
2101 
2102  /* Embedded bridge, macvlan, and any other device support */
2103  if ((ndm->ndm_flags & NTF_SELF) && dev->netdev_ops->ndo_fdb_add) {
2104  err = dev->netdev_ops->ndo_fdb_add(ndm, tb,
2105  dev, addr,
2106  nlh->nlmsg_flags);
2107 
2108  if (!err) {
2109  rtnl_fdb_notify(dev, addr, RTM_NEWNEIGH);
2110  ndm->ndm_flags &= ~NTF_SELF;
2111  }
2112  }
2113 out:
2114  return err;
2115 }
2116 
2117 static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
2118 {
2119  struct net *net = sock_net(skb->sk);
2120  struct ndmsg *ndm;
2121  struct nlattr *llattr;
2122  struct net_device *dev;
2123  int err = -EINVAL;
2124  __u8 *addr;
2125 
2126  if (nlmsg_len(nlh) < sizeof(*ndm))
2127  return -EINVAL;
2128 
2129  ndm = nlmsg_data(nlh);
2130  if (ndm->ndm_ifindex == 0) {
2131  pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid ifindex\n");
2132  return -EINVAL;
2133  }
2134 
2135  dev = __dev_get_by_index(net, ndm->ndm_ifindex);
2136  if (dev == NULL) {
2137  pr_info("PF_BRIDGE: RTM_DELNEIGH with unknown ifindex\n");
2138  return -ENODEV;
2139  }
2140 
2141  llattr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_LLADDR);
2142  if (llattr == NULL || nla_len(llattr) != ETH_ALEN) {
2143  pr_info("PF_BRIGDE: RTM_DELNEIGH with invalid address\n");
2144  return -EINVAL;
2145  }
2146 
2147  addr = nla_data(llattr);
2148  err = -EOPNOTSUPP;
2149 
2150  /* Support fdb on master device the net/bridge default case */
2151  if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
2152  (dev->priv_flags & IFF_BRIDGE_PORT)) {
2153  struct net_device *master = dev->master;
2154 
2155  if (master->netdev_ops->ndo_fdb_del)
2156  err = master->netdev_ops->ndo_fdb_del(ndm, dev, addr);
2157 
2158  if (err)
2159  goto out;
2160  else
2161  ndm->ndm_flags &= ~NTF_MASTER;
2162  }
2163 
2164  /* Embedded bridge, macvlan, and any other device support */
2165  if ((ndm->ndm_flags & NTF_SELF) && dev->netdev_ops->ndo_fdb_del) {
2166  err = dev->netdev_ops->ndo_fdb_del(ndm, dev, addr);
2167 
2168  if (!err) {
2169  rtnl_fdb_notify(dev, addr, RTM_DELNEIGH);
2170  ndm->ndm_flags &= ~NTF_SELF;
2171  }
2172  }
2173 out:
2174  return err;
2175 }
2176 
2177 static int nlmsg_populate_fdb(struct sk_buff *skb,
2178  struct netlink_callback *cb,
2179  struct net_device *dev,
2180  int *idx,
2181  struct netdev_hw_addr_list *list)
2182 {
2183  struct netdev_hw_addr *ha;
2184  int err;
2185  u32 portid, seq;
2186 
2187  portid = NETLINK_CB(cb->skb).portid;
2188  seq = cb->nlh->nlmsg_seq;
2189 
2190  list_for_each_entry(ha, &list->list, list) {
2191  if (*idx < cb->args[0])
2192  goto skip;
2193 
2194  err = nlmsg_populate_fdb_fill(skb, dev, ha->addr,
2195  portid, seq,
2196  RTM_NEWNEIGH, NTF_SELF);
2197  if (err < 0)
2198  return err;
2199 skip:
2200  *idx += 1;
2201  }
2202  return 0;
2203 }
2204 
2213 int ndo_dflt_fdb_dump(struct sk_buff *skb,
2214  struct netlink_callback *cb,
2215  struct net_device *dev,
2216  int idx)
2217 {
2218  int err;
2219 
2220  netif_addr_lock_bh(dev);
2221  err = nlmsg_populate_fdb(skb, cb, dev, &idx, &dev->uc);
2222  if (err)
2223  goto out;
2224  nlmsg_populate_fdb(skb, cb, dev, &idx, &dev->mc);
2225 out:
2226  netif_addr_unlock_bh(dev);
2227  return idx;
2228 }
2229 EXPORT_SYMBOL(ndo_dflt_fdb_dump);
2230 
2231 static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
2232 {
2233  int idx = 0;
2234  struct net *net = sock_net(skb->sk);
2235  struct net_device *dev;
2236 
2237  rcu_read_lock();
2238  for_each_netdev_rcu(net, dev) {
2239  if (dev->priv_flags & IFF_BRIDGE_PORT) {
2240  struct net_device *master = dev->master;
2241  const struct net_device_ops *ops = master->netdev_ops;
2242 
2243  if (ops->ndo_fdb_dump)
2244  idx = ops->ndo_fdb_dump(skb, cb, dev, idx);
2245  }
2246 
2247  if (dev->netdev_ops->ndo_fdb_dump)
2248  idx = dev->netdev_ops->ndo_fdb_dump(skb, cb, dev, idx);
2249  }
2250  rcu_read_unlock();
2251 
2252  cb->args[0] = idx;
2253  return skb->len;
2254 }
2255 
2256 /* Protected by RTNL sempahore. */
2257 static struct rtattr **rta_buf;
2258 static int rtattr_max;
2259 
2260 /* Process one rtnetlink message. */
2261 
2262 static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
2263 {
2264  struct net *net = sock_net(skb->sk);
2265  rtnl_doit_func doit;
2266  int sz_idx, kind;
2267  int min_len;
2268  int family;
2269  int type;
2270  int err;
2271 
2272  type = nlh->nlmsg_type;
2273  if (type > RTM_MAX)
2274  return -EOPNOTSUPP;
2275 
2276  type -= RTM_BASE;
2277 
2278  /* All the messages must have at least 1 byte length */
2279  if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg)))
2280  return 0;
2281 
2282  family = ((struct rtgenmsg *)NLMSG_DATA(nlh))->rtgen_family;
2283  sz_idx = type>>2;
2284  kind = type&3;
2285 
2286  if (kind != 2 && !capable(CAP_NET_ADMIN))
2287  return -EPERM;
2288 
2289  if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
2290  struct sock *rtnl;
2291  rtnl_dumpit_func dumpit;
2292  rtnl_calcit_func calcit;
2293  u16 min_dump_alloc = 0;
2294 
2295  dumpit = rtnl_get_dumpit(family, type);
2296  if (dumpit == NULL)
2297  return -EOPNOTSUPP;
2298  calcit = rtnl_get_calcit(family, type);
2299  if (calcit)
2300  min_dump_alloc = calcit(skb, nlh);
2301 
2302  __rtnl_unlock();
2303  rtnl = net->rtnl;
2304  {
2305  struct netlink_dump_control c = {
2306  .dump = dumpit,
2307  .min_dump_alloc = min_dump_alloc,
2308  };
2309  err = netlink_dump_start(rtnl, skb, nlh, &c);
2310  }
2311  rtnl_lock();
2312  return err;
2313  }
2314 
2315  memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *)));
2316 
2317  min_len = rtm_min[sz_idx];
2318  if (nlh->nlmsg_len < min_len)
2319  return -EINVAL;
2320 
2321  if (nlh->nlmsg_len > min_len) {
2322  int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len);
2323  struct rtattr *attr = (void *)nlh + NLMSG_ALIGN(min_len);
2324 
2325  while (RTA_OK(attr, attrlen)) {
2326  unsigned int flavor = attr->rta_type;
2327  if (flavor) {
2328  if (flavor > rta_max[sz_idx])
2329  return -EINVAL;
2330  rta_buf[flavor-1] = attr;
2331  }
2332  attr = RTA_NEXT(attr, attrlen);
2333  }
2334  }
2335 
2336  doit = rtnl_get_doit(family, type);
2337  if (doit == NULL)
2338  return -EOPNOTSUPP;
2339 
2340  return doit(skb, nlh, (void *)&rta_buf[0]);
2341 }
2342 
2343 static void rtnetlink_rcv(struct sk_buff *skb)
2344 {
2345  rtnl_lock();
2346  netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
2347  rtnl_unlock();
2348 }
2349 
2350 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
2351 {
2352  struct net_device *dev = ptr;
2353 
2354  switch (event) {
2355  case NETDEV_UP:
2356  case NETDEV_DOWN:
2357  case NETDEV_PRE_UP:
2358  case NETDEV_POST_INIT:
2359  case NETDEV_REGISTER:
2360  case NETDEV_CHANGE:
2361  case NETDEV_PRE_TYPE_CHANGE:
2362  case NETDEV_GOING_DOWN:
2363  case NETDEV_UNREGISTER:
2364  case NETDEV_UNREGISTER_FINAL:
2365  case NETDEV_RELEASE:
2366  case NETDEV_JOIN:
2367  break;
2368  default:
2369  rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
2370  break;
2371  }
2372  return NOTIFY_DONE;
2373 }
2374 
2375 static struct notifier_block rtnetlink_dev_notifier = {
2376  .notifier_call = rtnetlink_event,
2377 };
2378 
2379 
2380 static int __net_init rtnetlink_net_init(struct net *net)
2381 {
2382  struct sock *sk;
2383  struct netlink_kernel_cfg cfg = {
2384  .groups = RTNLGRP_MAX,
2385  .input = rtnetlink_rcv,
2386  .cb_mutex = &rtnl_mutex,
2387  .flags = NL_CFG_F_NONROOT_RECV,
2388  };
2389 
2390  sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
2391  if (!sk)
2392  return -ENOMEM;
2393  net->rtnl = sk;
2394  return 0;
2395 }
2396 
2397 static void __net_exit rtnetlink_net_exit(struct net *net)
2398 {
2399  netlink_kernel_release(net->rtnl);
2400  net->rtnl = NULL;
2401 }
2402 
2403 static struct pernet_operations rtnetlink_net_ops = {
2404  .init = rtnetlink_net_init,
2405  .exit = rtnetlink_net_exit,
2406 };
2407 
2408 void __init rtnetlink_init(void)
2409 {
2410  int i;
2411 
2412  rtattr_max = 0;
2413  for (i = 0; i < ARRAY_SIZE(rta_max); i++)
2414  if (rta_max[i] > rtattr_max)
2415  rtattr_max = rta_max[i];
2416  rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL);
2417  if (!rta_buf)
2418  panic("rtnetlink_init: cannot allocate rta_buf\n");
2419 
2420  if (register_pernet_subsys(&rtnetlink_net_ops))
2421  panic("rtnetlink_init: cannot initialize rtnetlink\n");
2422 
2423  register_netdevice_notifier(&rtnetlink_dev_notifier);
2424 
2425  rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink,
2426  rtnl_dump_ifinfo, rtnl_calcit);
2427  rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, NULL);
2428  rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, NULL);
2429  rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, NULL);
2430 
2431  rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, NULL);
2432  rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, NULL);
2433 
2434  rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, NULL);
2435  rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, NULL);
2436  rtnl_register(PF_BRIDGE, RTM_GETNEIGH, NULL, rtnl_fdb_dump, NULL);
2437 }
2438 
Generated on Thu Jan 10 2013 14:57:46 for Linux Kernel by   doxygen 1.8.2