rtnetlink.c (df7dbcbbafc0b8f3fb31a40c6f3c4a7e15cb0b40) rtnetlink.c (ba7d49b1f0f8e5f24294a880ed576964059af5ef)
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, <kuznet@ms2.inr.ac.ru>

--- 351 unchanged lines hidden (view full) ---

360void rtnl_link_unregister(struct rtnl_link_ops *ops)
361{
362 rtnl_lock();
363 __rtnl_link_unregister(ops);
364 rtnl_unlock();
365}
366EXPORT_SYMBOL_GPL(rtnl_link_unregister);
367
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, <kuznet@ms2.inr.ac.ru>

--- 351 unchanged lines hidden (view full) ---

360void rtnl_link_unregister(struct rtnl_link_ops *ops)
361{
362 rtnl_lock();
363 __rtnl_link_unregister(ops);
364 rtnl_unlock();
365}
366EXPORT_SYMBOL_GPL(rtnl_link_unregister);
367
368static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
369{
370 struct net_device *master_dev;
371 const struct rtnl_link_ops *ops;
372
373 master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
374 if (!master_dev)
375 return 0;
376 ops = master_dev->rtnl_link_ops;
377 if (!ops->get_slave_size)
378 return 0;
379 /* IFLA_INFO_SLAVE_DATA + nested data */
380 return nla_total_size(sizeof(struct nlattr)) +
381 ops->get_slave_size(master_dev, dev);
382}
383
368static 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

--- 4 unchanged lines hidden (view full) ---

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
384static size_t rtnl_link_get_size(const struct net_device *dev)
385{
386 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
387 size_t size;
388
389 if (!ops)
390 return 0;
391

--- 4 unchanged lines hidden (view full) ---

396 /* IFLA_INFO_DATA + nested data */
397 size += nla_total_size(sizeof(struct nlattr)) +
398 ops->get_size(dev);
399
400 if (ops->get_xstats_size)
401 /* IFLA_INFO_XSTATS */
402 size += nla_total_size(ops->get_xstats_size(dev));
403
404 size += rtnl_link_get_slave_info_data_size(dev);
405
388 return size;
389}
390
391static LIST_HEAD(rtnl_af_ops);
392
393static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
394{
395 const struct rtnl_af_ops *ops;

--- 58 unchanged lines hidden (view full) ---

454 size += nla_total_size(sizeof(struct nlattr)) +
455 af_ops->get_link_af_size(dev);
456 }
457 }
458
459 return size;
460}
461
406 return size;
407}
408
409static LIST_HEAD(rtnl_af_ops);
410
411static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
412{
413 const struct rtnl_af_ops *ops;

--- 58 unchanged lines hidden (view full) ---

472 size += nla_total_size(sizeof(struct nlattr)) +
473 af_ops->get_link_af_size(dev);
474 }
475 }
476
477 return size;
478}
479
462static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
480static bool rtnl_have_link_slave_info(const struct net_device *dev)
463{
481{
464 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
465 struct nlattr *linkinfo, *data;
466 int err = -EMSGSIZE;
482 struct net_device *master_dev;
467
483
468 linkinfo = nla_nest_start(skb, IFLA_LINKINFO);
469 if (linkinfo == NULL)
470 goto out;
484 master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
485 if (master_dev && master_dev->rtnl_link_ops &&
486 master_dev->rtnl_link_ops->fill_slave_info)
487 return true;
488 return false;
489}
471
490
491static int rtnl_link_slave_info_fill(struct sk_buff *skb,
492 const struct net_device *dev)
493{
494 struct net_device *master_dev;
495 const struct rtnl_link_ops *ops;
496 struct nlattr *slave_data;
497 int err;
498
499 master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
500 if (!master_dev)
501 return 0;
502 ops = master_dev->rtnl_link_ops;
503 if (!ops)
504 return 0;
505 if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
506 return -EMSGSIZE;
507 if (ops->fill_slave_info) {
508 slave_data = nla_nest_start(skb, IFLA_INFO_SLAVE_DATA);
509 if (!slave_data)
510 return -EMSGSIZE;
511 err = ops->fill_slave_info(skb, master_dev, dev);
512 if (err < 0)
513 goto err_cancel_slave_data;
514 nla_nest_end(skb, slave_data);
515 }
516 return 0;
517
518err_cancel_slave_data:
519 nla_nest_cancel(skb, slave_data);
520 return err;
521}
522
523static int rtnl_link_info_fill(struct sk_buff *skb,
524 const struct net_device *dev)
525{
526 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
527 struct nlattr *data;
528 int err;
529
530 if (!ops)
531 return 0;
472 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
532 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
473 goto err_cancel_link;
533 return -EMSGSIZE;
474 if (ops->fill_xstats) {
475 err = ops->fill_xstats(skb, dev);
476 if (err < 0)
534 if (ops->fill_xstats) {
535 err = ops->fill_xstats(skb, dev);
536 if (err < 0)
477 goto err_cancel_link;
537 return err;
478 }
479 if (ops->fill_info) {
480 data = nla_nest_start(skb, IFLA_INFO_DATA);
538 }
539 if (ops->fill_info) {
540 data = nla_nest_start(skb, IFLA_INFO_DATA);
481 if (data == NULL) {
482 err = -EMSGSIZE;
483 goto err_cancel_link;
484 }
541 if (data == NULL)
542 return -EMSGSIZE;
485 err = ops->fill_info(skb, dev);
486 if (err < 0)
487 goto err_cancel_data;
488 nla_nest_end(skb, data);
489 }
543 err = ops->fill_info(skb, dev);
544 if (err < 0)
545 goto err_cancel_data;
546 nla_nest_end(skb, data);
547 }
490
491 nla_nest_end(skb, linkinfo);
492 return 0;
493
494err_cancel_data:
495 nla_nest_cancel(skb, data);
548 return 0;
549
550err_cancel_data:
551 nla_nest_cancel(skb, data);
552 return err;
553}
554
555static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
556{
557 struct nlattr *linkinfo;
558 int err = -EMSGSIZE;
559
560 linkinfo = nla_nest_start(skb, IFLA_LINKINFO);
561 if (linkinfo == NULL)
562 goto out;
563
564 err = rtnl_link_info_fill(skb, dev);
565 if (err < 0)
566 goto err_cancel_link;
567
568 err = rtnl_link_slave_info_fill(skb, dev);
569 if (err < 0)
570 goto err_cancel_link;
571
572 nla_nest_end(skb, linkinfo);
573 return 0;
574
496err_cancel_link:
497 nla_nest_cancel(skb, linkinfo);
498out:
499 return err;
500}
501
502int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
503{

--- 543 unchanged lines hidden (view full) ---

1047 nla_nest_end(skb, vf);
1048 }
1049 nla_nest_end(skb, vfinfo);
1050 }
1051
1052 if (rtnl_port_fill(skb, dev))
1053 goto nla_put_failure;
1054
575err_cancel_link:
576 nla_nest_cancel(skb, linkinfo);
577out:
578 return err;
579}
580
581int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
582{

--- 543 unchanged lines hidden (view full) ---

1126 nla_nest_end(skb, vf);
1127 }
1128 nla_nest_end(skb, vfinfo);
1129 }
1130
1131 if (rtnl_port_fill(skb, dev))
1132 goto nla_put_failure;
1133
1055 if (rtnl_bond_slave_fill(skb, dev))
1056 goto nla_put_failure;
1057
1058 if (dev->rtnl_link_ops) {
1134 if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
1059 if (rtnl_link_fill(skb, dev) < 0)
1060 goto nla_put_failure;
1061 }
1062
1063 if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC)))
1064 goto nla_put_failure;
1065
1066 list_for_each_entry(af_ops, &rtnl_af_ops, list) {

--- 106 unchanged lines hidden (view full) ---

1173 [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 },
1174 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_PORT_ID_LEN },
1175};
1176EXPORT_SYMBOL(ifla_policy);
1177
1178static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1179 [IFLA_INFO_KIND] = { .type = NLA_STRING },
1180 [IFLA_INFO_DATA] = { .type = NLA_NESTED },
1135 if (rtnl_link_fill(skb, dev) < 0)
1136 goto nla_put_failure;
1137 }
1138
1139 if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC)))
1140 goto nla_put_failure;
1141
1142 list_for_each_entry(af_ops, &rtnl_af_ops, list) {

--- 106 unchanged lines hidden (view full) ---

1249 [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 },
1250 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_PORT_ID_LEN },
1251};
1252EXPORT_SYMBOL(ifla_policy);
1253
1254static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1255 [IFLA_INFO_KIND] = { .type = NLA_STRING },
1256 [IFLA_INFO_DATA] = { .type = NLA_NESTED },
1257 [IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING },
1258 [IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED },
1181};
1182
1183static const struct nla_policy ifla_vfinfo_policy[IFLA_VF_INFO_MAX+1] = {
1184 [IFLA_VF_INFO] = { .type = NLA_NESTED },
1185};
1186
1187static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1188 [IFLA_VF_MAC] = { .type = NLA_BINARY,

--- 571 unchanged lines hidden (view full) ---

1760
1761 return 0;
1762}
1763
1764static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh)
1765{
1766 struct net *net = sock_net(skb->sk);
1767 const struct rtnl_link_ops *ops;
1259};
1260
1261static const struct nla_policy ifla_vfinfo_policy[IFLA_VF_INFO_MAX+1] = {
1262 [IFLA_VF_INFO] = { .type = NLA_NESTED },
1263};
1264
1265static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1266 [IFLA_VF_MAC] = { .type = NLA_BINARY,

--- 571 unchanged lines hidden (view full) ---

1838
1839 return 0;
1840}
1841
1842static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh)
1843{
1844 struct net *net = sock_net(skb->sk);
1845 const struct rtnl_link_ops *ops;
1846 const struct rtnl_link_ops *m_ops = NULL;
1768 struct net_device *dev;
1847 struct net_device *dev;
1848 struct net_device *master_dev = NULL;
1769 struct ifinfomsg *ifm;
1770 char kind[MODULE_NAME_LEN];
1771 char ifname[IFNAMSIZ];
1772 struct nlattr *tb[IFLA_MAX+1];
1773 struct nlattr *linkinfo[IFLA_INFO_MAX+1];
1774 int err;
1775
1776#ifdef CONFIG_MODULES

--- 13 unchanged lines hidden (view full) ---

1790 dev = __dev_get_by_index(net, ifm->ifi_index);
1791 else {
1792 if (ifname[0])
1793 dev = __dev_get_by_name(net, ifname);
1794 else
1795 dev = NULL;
1796 }
1797
1849 struct ifinfomsg *ifm;
1850 char kind[MODULE_NAME_LEN];
1851 char ifname[IFNAMSIZ];
1852 struct nlattr *tb[IFLA_MAX+1];
1853 struct nlattr *linkinfo[IFLA_INFO_MAX+1];
1854 int err;
1855
1856#ifdef CONFIG_MODULES

--- 13 unchanged lines hidden (view full) ---

1870 dev = __dev_get_by_index(net, ifm->ifi_index);
1871 else {
1872 if (ifname[0])
1873 dev = __dev_get_by_name(net, ifname);
1874 else
1875 dev = NULL;
1876 }
1877
1878 if (dev) {
1879 master_dev = netdev_master_upper_dev_get(dev);
1880 if (master_dev)
1881 m_ops = master_dev->rtnl_link_ops;
1882 }
1883
1798 err = validate_linkmsg(dev, tb);
1799 if (err < 0)
1800 return err;
1801
1802 if (tb[IFLA_LINKINFO]) {
1803 err = nla_parse_nested(linkinfo, IFLA_INFO_MAX,
1804 tb[IFLA_LINKINFO], ifla_info_policy);
1805 if (err < 0)

--- 5 unchanged lines hidden (view full) ---

1811 nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
1812 ops = rtnl_link_ops_get(kind);
1813 } else {
1814 kind[0] = '\0';
1815 ops = NULL;
1816 }
1817
1818 if (1) {
1884 err = validate_linkmsg(dev, tb);
1885 if (err < 0)
1886 return err;
1887
1888 if (tb[IFLA_LINKINFO]) {
1889 err = nla_parse_nested(linkinfo, IFLA_INFO_MAX,
1890 tb[IFLA_LINKINFO], ifla_info_policy);
1891 if (err < 0)

--- 5 unchanged lines hidden (view full) ---

1897 nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
1898 ops = rtnl_link_ops_get(kind);
1899 } else {
1900 kind[0] = '\0';
1901 ops = NULL;
1902 }
1903
1904 if (1) {
1819 struct nlattr *attr[ops ? ops->maxtype + 1 : 0], **data = NULL;
1905 struct nlattr *attr[ops ? ops->maxtype + 1 : 0];
1906 struct nlattr *slave_attr[m_ops ? m_ops->slave_maxtype + 1 : 0];
1907 struct nlattr **data = NULL;
1908 struct nlattr **slave_data = NULL;
1820 struct net *dest_net;
1821
1822 if (ops) {
1823 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
1824 err = nla_parse_nested(attr, ops->maxtype,
1825 linkinfo[IFLA_INFO_DATA],
1826 ops->policy);
1827 if (err < 0)
1828 return err;
1829 data = attr;
1830 }
1831 if (ops->validate) {
1832 err = ops->validate(tb, data);
1833 if (err < 0)
1834 return err;
1835 }
1836 }
1837
1909 struct net *dest_net;
1910
1911 if (ops) {
1912 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
1913 err = nla_parse_nested(attr, ops->maxtype,
1914 linkinfo[IFLA_INFO_DATA],
1915 ops->policy);
1916 if (err < 0)
1917 return err;
1918 data = attr;
1919 }
1920 if (ops->validate) {
1921 err = ops->validate(tb, data);
1922 if (err < 0)
1923 return err;
1924 }
1925 }
1926
1927 if (m_ops) {
1928 if (m_ops->slave_maxtype &&
1929 linkinfo[IFLA_INFO_SLAVE_DATA]) {
1930 err = nla_parse_nested(slave_attr,
1931 m_ops->slave_maxtype,
1932 linkinfo[IFLA_INFO_SLAVE_DATA],
1933 m_ops->slave_policy);
1934 if (err < 0)
1935 return err;
1936 slave_data = slave_attr;
1937 }
1938 if (m_ops->slave_validate) {
1939 err = m_ops->slave_validate(tb, slave_data);
1940 if (err < 0)
1941 return err;
1942 }
1943 }
1944
1838 if (dev) {
1839 int modified = 0;
1840
1841 if (nlh->nlmsg_flags & NLM_F_EXCL)
1842 return -EEXIST;
1843 if (nlh->nlmsg_flags & NLM_F_REPLACE)
1844 return -EOPNOTSUPP;
1845
1846 if (linkinfo[IFLA_INFO_DATA]) {
1847 if (!ops || ops != dev->rtnl_link_ops ||
1848 !ops->changelink)
1849 return -EOPNOTSUPP;
1850
1851 err = ops->changelink(dev, tb, data);
1852 if (err < 0)
1853 return err;
1854 modified = 1;
1855 }
1856
1945 if (dev) {
1946 int modified = 0;
1947
1948 if (nlh->nlmsg_flags & NLM_F_EXCL)
1949 return -EEXIST;
1950 if (nlh->nlmsg_flags & NLM_F_REPLACE)
1951 return -EOPNOTSUPP;
1952
1953 if (linkinfo[IFLA_INFO_DATA]) {
1954 if (!ops || ops != dev->rtnl_link_ops ||
1955 !ops->changelink)
1956 return -EOPNOTSUPP;
1957
1958 err = ops->changelink(dev, tb, data);
1959 if (err < 0)
1960 return err;
1961 modified = 1;
1962 }
1963
1964 if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
1965 if (!m_ops || !m_ops->slave_changelink)
1966 return -EOPNOTSUPP;
1967
1968 err = m_ops->slave_changelink(master_dev, dev,
1969 tb, slave_data);
1970 if (err < 0)
1971 return err;
1972 modified = 1;
1973 }
1974
1857 return do_setlink(dev, ifm, tb, ifname, modified);
1858 }
1859
1860 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1861 if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
1862 return rtnl_group_changelink(net,
1863 nla_get_u32(tb[IFLA_GROUP]),
1864 ifm, tb);

--- 955 unchanged lines hidden --- 		1975 return do_setlink(dev, ifm, tb, ifname, modified);
1976 }
1977
1978 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1979 if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
1980 return rtnl_group_changelink(net,
1981 nla_get_u32(tb[IFLA_GROUP]),
1982 ifm, tb);

--- 955 unchanged lines hidden ---