net/dcb/dcbnl.c

   1 /*
   2  * Copyright (c) 2008-2011, Intel Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15  * Place - Suite 330, Boston, MA 02111-1307 USA.
  16  *
  17  * Author: Lucy Liu <lucy.liu@intel.com>
  18  */
  19
  20 #include <linux/netdevice.h>
  21 #include <linux/netlink.h>
  22 #include <linux/slab.h>
  23 #include <net/netlink.h>
  24 #include <net/rtnetlink.h>
  25 #include <linux/dcbnl.h>
  26 #include <net/dcbevent.h>
  27 #include <linux/rtnetlink.h>
  28 #include <linux/module.h>
  29 #include <net/sock.h>
  30
  31 /**
  32  * Data Center Bridging (DCB) is a collection of Ethernet enhancements
  33  * intended to allow network traffic with differing requirements
  34  * (highly reliable, no drops vs. best effort vs. low latency) to operate
  35  * and co-exist on Ethernet.  Current DCB features are:
  36  *
  37  * Enhanced Transmission Selection (aka Priority Grouping [PG]) - provides a
  38  *   framework for assigning bandwidth guarantees to traffic classes.
  39  *
  40  * Priority-based Flow Control (PFC) - provides a flow control mechanism which
  41  *   can work independently for each 802.1p priority.
  42  *
  43  * Congestion Notification - provides a mechanism for end-to-end congestion
  44  *   control for protocols which do not have built-in congestion management.
  45  *
  46  * More information about the emerging standards for these Ethernet features
  47  * can be found at: http://www.ieee802.org/1/pages/dcbridges.html
  48  *
  49  * This file implements an rtnetlink interface to allow configuration of DCB
  50  * features for capable devices.
  51  */
  52
  53 MODULE_AUTHOR("Lucy Liu, <lucy.liu@intel.com>");
  54 MODULE_DESCRIPTION("Data Center Bridging netlink interface");
  55 MODULE_LICENSE("GPL");
  56
  57 /**************** DCB attribute policies *************************************/
  58
  59 /* DCB netlink attributes policy */
  60 static const struct nla_policy dcbnl_rtnl_policy[DCB_ATTR_MAX + 1] = {
  61         [DCB_ATTR_IFNAME]      = {.type = NLA_NUL_STRING, .len = IFNAMSIZ - 1},
  62         [DCB_ATTR_STATE]       = {.type = NLA_U8},
  63         [DCB_ATTR_PFC_CFG]     = {.type = NLA_NESTED},
  64         [DCB_ATTR_PG_CFG]      = {.type = NLA_NESTED},
  65         [DCB_ATTR_SET_ALL]     = {.type = NLA_U8},
  66         [DCB_ATTR_PERM_HWADDR] = {.type = NLA_FLAG},
  67         [DCB_ATTR_CAP]         = {.type = NLA_NESTED},
  68         [DCB_ATTR_PFC_STATE]   = {.type = NLA_U8},
  69         [DCB_ATTR_BCN]         = {.type = NLA_NESTED},
  70         [DCB_ATTR_APP]         = {.type = NLA_NESTED},
  71         [DCB_ATTR_IEEE]        = {.type = NLA_NESTED},
  72         [DCB_ATTR_DCBX]        = {.type = NLA_U8},
  73         [DCB_ATTR_FEATCFG]     = {.type = NLA_NESTED},
  74 };
  75
  76 /* DCB priority flow control to User Priority nested attributes */
  77 static const struct nla_policy dcbnl_pfc_up_nest[DCB_PFC_UP_ATTR_MAX + 1] = {
  78         [DCB_PFC_UP_ATTR_0]   = {.type = NLA_U8},
  79         [DCB_PFC_UP_ATTR_1]   = {.type = NLA_U8},
  80         [DCB_PFC_UP_ATTR_2]   = {.type = NLA_U8},
  81         [DCB_PFC_UP_ATTR_3]   = {.type = NLA_U8},
  82         [DCB_PFC_UP_ATTR_4]   = {.type = NLA_U8},
  83         [DCB_PFC_UP_ATTR_5]   = {.type = NLA_U8},
  84         [DCB_PFC_UP_ATTR_6]   = {.type = NLA_U8},
  85         [DCB_PFC_UP_ATTR_7]   = {.type = NLA_U8},
  86         [DCB_PFC_UP_ATTR_ALL] = {.type = NLA_FLAG},
  87 };
  88
  89 /* DCB priority grouping nested attributes */
  90 static const struct nla_policy dcbnl_pg_nest[DCB_PG_ATTR_MAX + 1] = {
  91         [DCB_PG_ATTR_TC_0]      = {.type = NLA_NESTED},
  92         [DCB_PG_ATTR_TC_1]      = {.type = NLA_NESTED},
  93         [DCB_PG_ATTR_TC_2]      = {.type = NLA_NESTED},
  94         [DCB_PG_ATTR_TC_3]      = {.type = NLA_NESTED},
  95         [DCB_PG_ATTR_TC_4]      = {.type = NLA_NESTED},
  96         [DCB_PG_ATTR_TC_5]      = {.type = NLA_NESTED},
  97         [DCB_PG_ATTR_TC_6]      = {.type = NLA_NESTED},
  98         [DCB_PG_ATTR_TC_7]      = {.type = NLA_NESTED},
  99         [DCB_PG_ATTR_TC_ALL]    = {.type = NLA_NESTED},
 100         [DCB_PG_ATTR_BW_ID_0]   = {.type = NLA_U8},
 101         [DCB_PG_ATTR_BW_ID_1]   = {.type = NLA_U8},
 102         [DCB_PG_ATTR_BW_ID_2]   = {.type = NLA_U8},
 103         [DCB_PG_ATTR_BW_ID_3]   = {.type = NLA_U8},
 104         [DCB_PG_ATTR_BW_ID_4]   = {.type = NLA_U8},
 105         [DCB_PG_ATTR_BW_ID_5]   = {.type = NLA_U8},
 106         [DCB_PG_ATTR_BW_ID_6]   = {.type = NLA_U8},
 107         [DCB_PG_ATTR_BW_ID_7]   = {.type = NLA_U8},
 108         [DCB_PG_ATTR_BW_ID_ALL] = {.type = NLA_FLAG},
 109 };
 110
 111 /* DCB traffic class nested attributes. */
 112 static const struct nla_policy dcbnl_tc_param_nest[DCB_TC_ATTR_PARAM_MAX + 1] = {
 113         [DCB_TC_ATTR_PARAM_PGID]            = {.type = NLA_U8},
 114         [DCB_TC_ATTR_PARAM_UP_MAPPING]      = {.type = NLA_U8},
 115         [DCB_TC_ATTR_PARAM_STRICT_PRIO]     = {.type = NLA_U8},
 116         [DCB_TC_ATTR_PARAM_BW_PCT]          = {.type = NLA_U8},
 117         [DCB_TC_ATTR_PARAM_ALL]             = {.type = NLA_FLAG},
 118 };
 119
 120 /* DCB capabilities nested attributes. */
 121 static const struct nla_policy dcbnl_cap_nest[DCB_CAP_ATTR_MAX + 1] = {
 122         [DCB_CAP_ATTR_ALL]     = {.type = NLA_FLAG},
 123         [DCB_CAP_ATTR_PG]      = {.type = NLA_U8},
 124         [DCB_CAP_ATTR_PFC]     = {.type = NLA_U8},
 125         [DCB_CAP_ATTR_UP2TC]   = {.type = NLA_U8},
 126         [DCB_CAP_ATTR_PG_TCS]  = {.type = NLA_U8},
 127         [DCB_CAP_ATTR_PFC_TCS] = {.type = NLA_U8},
 128         [DCB_CAP_ATTR_GSP]     = {.type = NLA_U8},
 129         [DCB_CAP_ATTR_BCN]     = {.type = NLA_U8},
 130         [DCB_CAP_ATTR_DCBX]    = {.type = NLA_U8},
 131 };
 132
 133 /* DCB capabilities nested attributes. */
 134 static const struct nla_policy dcbnl_numtcs_nest[DCB_NUMTCS_ATTR_MAX + 1] = {
 135         [DCB_NUMTCS_ATTR_ALL]     = {.type = NLA_FLAG},
 136         [DCB_NUMTCS_ATTR_PG]      = {.type = NLA_U8},
 137         [DCB_NUMTCS_ATTR_PFC]     = {.type = NLA_U8},
 138 };
 139
 140 /* DCB BCN nested attributes. */
 141 static const struct nla_policy dcbnl_bcn_nest[DCB_BCN_ATTR_MAX + 1] = {
 142         [DCB_BCN_ATTR_RP_0]         = {.type = NLA_U8},
 143         [DCB_BCN_ATTR_RP_1]         = {.type = NLA_U8},
 144         [DCB_BCN_ATTR_RP_2]         = {.type = NLA_U8},
 145         [DCB_BCN_ATTR_RP_3]         = {.type = NLA_U8},
 146         [DCB_BCN_ATTR_RP_4]         = {.type = NLA_U8},
 147         [DCB_BCN_ATTR_RP_5]         = {.type = NLA_U8},
 148         [DCB_BCN_ATTR_RP_6]         = {.type = NLA_U8},
 149         [DCB_BCN_ATTR_RP_7]         = {.type = NLA_U8},
 150         [DCB_BCN_ATTR_RP_ALL]       = {.type = NLA_FLAG},
 151         [DCB_BCN_ATTR_BCNA_0]       = {.type = NLA_U32},
 152         [DCB_BCN_ATTR_BCNA_1]       = {.type = NLA_U32},
 153         [DCB_BCN_ATTR_ALPHA]        = {.type = NLA_U32},
 154         [DCB_BCN_ATTR_BETA]         = {.type = NLA_U32},
 155         [DCB_BCN_ATTR_GD]           = {.type = NLA_U32},
 156         [DCB_BCN_ATTR_GI]           = {.type = NLA_U32},
 157         [DCB_BCN_ATTR_TMAX]         = {.type = NLA_U32},
 158         [DCB_BCN_ATTR_TD]           = {.type = NLA_U32},
 159         [DCB_BCN_ATTR_RMIN]         = {.type = NLA_U32},
 160         [DCB_BCN_ATTR_W]            = {.type = NLA_U32},
 161         [DCB_BCN_ATTR_RD]           = {.type = NLA_U32},
 162         [DCB_BCN_ATTR_RU]           = {.type = NLA_U32},
 163         [DCB_BCN_ATTR_WRTT]         = {.type = NLA_U32},
 164         [DCB_BCN_ATTR_RI]           = {.type = NLA_U32},
 165         [DCB_BCN_ATTR_C]            = {.type = NLA_U32},
 166         [DCB_BCN_ATTR_ALL]          = {.type = NLA_FLAG},
 167 };
 168
 169 /* DCB APP nested attributes. */
 170 static const struct nla_policy dcbnl_app_nest[DCB_APP_ATTR_MAX + 1] = {
 171         [DCB_APP_ATTR_IDTYPE]       = {.type = NLA_U8},
 172         [DCB_APP_ATTR_ID]           = {.type = NLA_U16},
 173         [DCB_APP_ATTR_PRIORITY]     = {.type = NLA_U8},
 174 };
 175
 176 /* IEEE 802.1Qaz nested attributes. */
 177 static const struct nla_policy dcbnl_ieee_policy[DCB_ATTR_IEEE_MAX + 1] = {
 178         [DCB_ATTR_IEEE_ETS]         = {.len = sizeof(struct ieee_ets)},
 179         [DCB_ATTR_IEEE_PFC]         = {.len = sizeof(struct ieee_pfc)},
 180         [DCB_ATTR_IEEE_APP_TABLE]   = {.type = NLA_NESTED},
 181         [DCB_ATTR_IEEE_MAXRATE]   = {.len = sizeof(struct ieee_maxrate)},
 182 };
 183
 184 static const struct nla_policy dcbnl_ieee_app[DCB_ATTR_IEEE_APP_MAX + 1] = {
 185         [DCB_ATTR_IEEE_APP]         = {.len = sizeof(struct dcb_app)},
 186 };
 187
 188 /* DCB number of traffic classes nested attributes. */
 189 static const struct nla_policy dcbnl_featcfg_nest[DCB_FEATCFG_ATTR_MAX + 1] = {
 190         [DCB_FEATCFG_ATTR_ALL]      = {.type = NLA_FLAG},
 191         [DCB_FEATCFG_ATTR_PG]       = {.type = NLA_U8},
 192         [DCB_FEATCFG_ATTR_PFC]      = {.type = NLA_U8},
 193         [DCB_FEATCFG_ATTR_APP]      = {.type = NLA_U8},
 194 };
 195
 196 static LIST_HEAD(dcb_app_list);
 197 static DEFINE_SPINLOCK(dcb_lock);
 198
 199 /* standard netlink reply call */
 200 static int dcbnl_reply(u8 value, u8 event, u8 cmd, u8 attr, u32 pid,
 201                        u32 seq, u16 flags)
 202 {
 203         struct sk_buff *dcbnl_skb;
 204         struct dcbmsg *dcb;
 205         struct nlmsghdr *nlh;
 206         int ret = -EINVAL;
 207
 208         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 209         if (!dcbnl_skb)
 210                 return ret;
 211
 212         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, event, sizeof(*dcb), flags);
 213
 214         dcb = NLMSG_DATA(nlh);
 215         dcb->dcb_family = AF_UNSPEC;
 216         dcb->cmd = cmd;
 217         dcb->dcb_pad = 0;
 218
 219         ret = nla_put_u8(dcbnl_skb, attr, value);
 220         if (ret)
 221                 goto err;
 222
 223         /* end the message, assign the nlmsg_len. */
 224         nlmsg_end(dcbnl_skb, nlh);
 225         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 226         if (ret)
 227                 return -EINVAL;
 228
 229         return 0;
 230 nlmsg_failure:
 231 err:
 232         kfree_skb(dcbnl_skb);
 233         return ret;
 234 }
 235
 236 static int dcbnl_getstate(struct net_device *netdev, struct nlattr **tb,
 237                           u32 pid, u32 seq, u16 flags)
 238 {
 239         int ret = -EINVAL;
 240
 241         /* if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->getstate) */
 242         if (!netdev->dcbnl_ops->getstate)
 243                 return ret;
 244
 245         ret = dcbnl_reply(netdev->dcbnl_ops->getstate(netdev), RTM_GETDCB,
 246                           DCB_CMD_GSTATE, DCB_ATTR_STATE, pid, seq, flags);
 247
 248         return ret;
 249 }
 250
 251 static int dcbnl_getpfccfg(struct net_device *netdev, struct nlattr **tb,
 252                            u32 pid, u32 seq, u16 flags)
 253 {
 254         struct sk_buff *dcbnl_skb;
 255         struct nlmsghdr *nlh;
 256         struct dcbmsg *dcb;
 257         struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1], *nest;
 258         u8 value;
 259         int ret = -EINVAL;
 260         int i;
 261         int getall = 0;
 262
 263         if (!tb[DCB_ATTR_PFC_CFG] || !netdev->dcbnl_ops->getpfccfg)
 264                 return ret;
 265
 266         ret = nla_parse_nested(data, DCB_PFC_UP_ATTR_MAX,
 267                                tb[DCB_ATTR_PFC_CFG],
 268                                dcbnl_pfc_up_nest);
 269         if (ret)
 270                 goto err_out;
 271
 272         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 273         if (!dcbnl_skb)
 274                 goto err_out;
 275
 276         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 277
 278         dcb = NLMSG_DATA(nlh);
 279         dcb->dcb_family = AF_UNSPEC;
 280         dcb->cmd = DCB_CMD_PFC_GCFG;
 281
 282         nest = nla_nest_start(dcbnl_skb, DCB_ATTR_PFC_CFG);
 283         if (!nest)
 284                 goto err;
 285
 286         if (data[DCB_PFC_UP_ATTR_ALL])
 287                 getall = 1;
 288
 289         for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) {
 290                 if (!getall && !data[i])
 291                         continue;
 292
 293                 netdev->dcbnl_ops->getpfccfg(netdev, i - DCB_PFC_UP_ATTR_0,
 294                                              &value);
 295                 ret = nla_put_u8(dcbnl_skb, i, value);
 296
 297                 if (ret) {
 298                         nla_nest_cancel(dcbnl_skb, nest);
 299                         goto err;
 300                 }
 301         }
 302         nla_nest_end(dcbnl_skb, nest);
 303
 304         nlmsg_end(dcbnl_skb, nlh);
 305
 306         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 307         if (ret)
 308                 goto err_out;
 309
 310         return 0;
 311 nlmsg_failure:
 312 err:
 313         kfree_skb(dcbnl_skb);
 314 err_out:
 315         return -EINVAL;
 316 }
 317
 318 static int dcbnl_getperm_hwaddr(struct net_device *netdev, struct nlattr **tb,
 319                                 u32 pid, u32 seq, u16 flags)
 320 {
 321         struct sk_buff *dcbnl_skb;
 322         struct nlmsghdr *nlh;
 323         struct dcbmsg *dcb;
 324         u8 perm_addr[MAX_ADDR_LEN];
 325         int ret = -EINVAL;
 326
 327         if (!netdev->dcbnl_ops->getpermhwaddr)
 328                 return ret;
 329
 330         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 331         if (!dcbnl_skb)
 332                 goto err_out;
 333
 334         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 335
 336         dcb = NLMSG_DATA(nlh);
 337         dcb->dcb_family = AF_UNSPEC;
 338         dcb->cmd = DCB_CMD_GPERM_HWADDR;
 339
 340         netdev->dcbnl_ops->getpermhwaddr(netdev, perm_addr);
 341
 342         ret = nla_put(dcbnl_skb, DCB_ATTR_PERM_HWADDR, sizeof(perm_addr),
 343                       perm_addr);
 344
 345         nlmsg_end(dcbnl_skb, nlh);
 346
 347         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 348         if (ret)
 349                 goto err_out;
 350
 351         return 0;
 352
 353 nlmsg_failure:
 354         kfree_skb(dcbnl_skb);
 355 err_out:
 356         return -EINVAL;
 357 }
 358
 359 static int dcbnl_getcap(struct net_device *netdev, struct nlattr **tb,
 360                         u32 pid, u32 seq, u16 flags)
 361 {
 362         struct sk_buff *dcbnl_skb;
 363         struct nlmsghdr *nlh;
 364         struct dcbmsg *dcb;
 365         struct nlattr *data[DCB_CAP_ATTR_MAX + 1], *nest;
 366         u8 value;
 367         int ret = -EINVAL;
 368         int i;
 369         int getall = 0;
 370
 371         if (!tb[DCB_ATTR_CAP] || !netdev->dcbnl_ops->getcap)
 372                 return ret;
 373
 374         ret = nla_parse_nested(data, DCB_CAP_ATTR_MAX, tb[DCB_ATTR_CAP],
 375                                dcbnl_cap_nest);
 376         if (ret)
 377                 goto err_out;
 378
 379         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 380         if (!dcbnl_skb)
 381                 goto err_out;
 382
 383         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 384
 385         dcb = NLMSG_DATA(nlh);
 386         dcb->dcb_family = AF_UNSPEC;
 387         dcb->cmd = DCB_CMD_GCAP;
 388
 389         nest = nla_nest_start(dcbnl_skb, DCB_ATTR_CAP);
 390         if (!nest)
 391                 goto err;
 392
 393         if (data[DCB_CAP_ATTR_ALL])
 394                 getall = 1;
 395
 396         for (i = DCB_CAP_ATTR_ALL+1; i <= DCB_CAP_ATTR_MAX; i++) {
 397                 if (!getall && !data[i])
 398                         continue;
 399
 400                 if (!netdev->dcbnl_ops->getcap(netdev, i, &value)) {
 401                         ret = nla_put_u8(dcbnl_skb, i, value);
 402
 403                         if (ret) {
 404                                 nla_nest_cancel(dcbnl_skb, nest);
 405                                 goto err;
 406                         }
 407                 }
 408         }
 409         nla_nest_end(dcbnl_skb, nest);
 410
 411         nlmsg_end(dcbnl_skb, nlh);
 412
 413         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 414         if (ret)
 415                 goto err_out;
 416
 417         return 0;
 418 nlmsg_failure:
 419 err:
 420         kfree_skb(dcbnl_skb);
 421 err_out:
 422         return -EINVAL;
 423 }
 424
 425 static int dcbnl_getnumtcs(struct net_device *netdev, struct nlattr **tb,
 426                            u32 pid, u32 seq, u16 flags)
 427 {
 428         struct sk_buff *dcbnl_skb;
 429         struct nlmsghdr *nlh;
 430         struct dcbmsg *dcb;
 431         struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1], *nest;
 432         u8 value;
 433         int ret = -EINVAL;
 434         int i;
 435         int getall = 0;
 436
 437         if (!tb[DCB_ATTR_NUMTCS] || !netdev->dcbnl_ops->getnumtcs)
 438                 return ret;
 439
 440         ret = nla_parse_nested(data, DCB_NUMTCS_ATTR_MAX, tb[DCB_ATTR_NUMTCS],
 441                                dcbnl_numtcs_nest);
 442         if (ret) {
 443                 ret = -EINVAL;
 444                 goto err_out;
 445         }
 446
 447         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 448         if (!dcbnl_skb) {
 449                 ret = -EINVAL;
 450                 goto err_out;
 451         }
 452
 453         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 454
 455         dcb = NLMSG_DATA(nlh);
 456         dcb->dcb_family = AF_UNSPEC;
 457         dcb->cmd = DCB_CMD_GNUMTCS;
 458
 459         nest = nla_nest_start(dcbnl_skb, DCB_ATTR_NUMTCS);
 460         if (!nest) {
 461                 ret = -EINVAL;
 462                 goto err;
 463         }
 464
 465         if (data[DCB_NUMTCS_ATTR_ALL])
 466                 getall = 1;
 467
 468         for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) {
 469                 if (!getall && !data[i])
 470                         continue;
 471
 472                 ret = netdev->dcbnl_ops->getnumtcs(netdev, i, &value);
 473                 if (!ret) {
 474                         ret = nla_put_u8(dcbnl_skb, i, value);
 475
 476                         if (ret) {
 477                                 nla_nest_cancel(dcbnl_skb, nest);
 478                                 ret = -EINVAL;
 479                                 goto err;
 480                         }
 481                 } else {
 482                         goto err;
 483                 }
 484         }
 485         nla_nest_end(dcbnl_skb, nest);
 486
 487         nlmsg_end(dcbnl_skb, nlh);
 488
 489         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 490         if (ret) {
 491                 ret = -EINVAL;
 492                 goto err_out;
 493         }
 494
 495         return 0;
 496 nlmsg_failure:
 497 err:
 498         kfree_skb(dcbnl_skb);
 499 err_out:
 500         return ret;
 501 }
 502
 503 static int dcbnl_setnumtcs(struct net_device *netdev, struct nlattr **tb,
 504                            u32 pid, u32 seq, u16 flags)
 505 {
 506         struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1];
 507         int ret = -EINVAL;
 508         u8 value;
 509         int i;
 510
 511         if (!tb[DCB_ATTR_NUMTCS] || !netdev->dcbnl_ops->setnumtcs)
 512                 return ret;
 513
 514         ret = nla_parse_nested(data, DCB_NUMTCS_ATTR_MAX, tb[DCB_ATTR_NUMTCS],
 515                                dcbnl_numtcs_nest);
 516
 517         if (ret) {
 518                 ret = -EINVAL;
 519                 goto err;
 520         }
 521
 522         for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) {
 523                 if (data[i] == NULL)
 524                         continue;
 525
 526                 value = nla_get_u8(data[i]);
 527
 528                 ret = netdev->dcbnl_ops->setnumtcs(netdev, i, value);
 529
 530                 if (ret)
 531                         goto operr;
 532         }
 533
 534 operr:
 535         ret = dcbnl_reply(!!ret, RTM_SETDCB, DCB_CMD_SNUMTCS,
 536                           DCB_ATTR_NUMTCS, pid, seq, flags);
 537
 538 err:
 539         return ret;
 540 }
 541
 542 static int dcbnl_getpfcstate(struct net_device *netdev, struct nlattr **tb,
 543                              u32 pid, u32 seq, u16 flags)
 544 {
 545         int ret = -EINVAL;
 546
 547         if (!netdev->dcbnl_ops->getpfcstate)
 548                 return ret;
 549
 550         ret = dcbnl_reply(netdev->dcbnl_ops->getpfcstate(netdev), RTM_GETDCB,
 551                           DCB_CMD_PFC_GSTATE, DCB_ATTR_PFC_STATE,
 552                           pid, seq, flags);
 553
 554         return ret;
 555 }
 556
 557 static int dcbnl_setpfcstate(struct net_device *netdev, struct nlattr **tb,
 558                              u32 pid, u32 seq, u16 flags)
 559 {
 560         int ret = -EINVAL;
 561         u8 value;
 562
 563         if (!tb[DCB_ATTR_PFC_STATE] || !netdev->dcbnl_ops->setpfcstate)
 564                 return ret;
 565
 566         value = nla_get_u8(tb[DCB_ATTR_PFC_STATE]);
 567
 568         netdev->dcbnl_ops->setpfcstate(netdev, value);
 569
 570         ret = dcbnl_reply(0, RTM_SETDCB, DCB_CMD_PFC_SSTATE, DCB_ATTR_PFC_STATE,
 571                           pid, seq, flags);
 572
 573         return ret;
 574 }
 575
 576 static int dcbnl_getapp(struct net_device *netdev, struct nlattr **tb,
 577                         u32 pid, u32 seq, u16 flags)
 578 {
 579         struct sk_buff *dcbnl_skb;
 580         struct nlmsghdr *nlh;
 581         struct dcbmsg *dcb;
 582         struct nlattr *app_nest;
 583         struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1];
 584         u16 id;
 585         u8 up, idtype;
 586         int ret = -EINVAL;
 587
 588         if (!tb[DCB_ATTR_APP])
 589                 goto out;
 590
 591         ret = nla_parse_nested(app_tb, DCB_APP_ATTR_MAX, tb[DCB_ATTR_APP],
 592                                dcbnl_app_nest);
 593         if (ret)
 594                 goto out;
 595
 596         ret = -EINVAL;
 597         /* all must be non-null */
 598         if ((!app_tb[DCB_APP_ATTR_IDTYPE]) ||
 599             (!app_tb[DCB_APP_ATTR_ID]))
 600                 goto out;
 601
 602         /* either by eth type or by socket number */
 603         idtype = nla_get_u8(app_tb[DCB_APP_ATTR_IDTYPE]);
 604         if ((idtype != DCB_APP_IDTYPE_ETHTYPE) &&
 605             (idtype != DCB_APP_IDTYPE_PORTNUM))
 606                 goto out;
 607
 608         id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]);
 609
 610         if (netdev->dcbnl_ops->getapp) {
 611                 up = netdev->dcbnl_ops->getapp(netdev, idtype, id);
 612         } else {
 613                 struct dcb_app app = {
 614                                         .selector = idtype,
 615                                         .protocol = id,
 616                                      };
 617                 up = dcb_getapp(netdev, &app);
 618         }
 619
 620         /* send this back */
 621         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 622         if (!dcbnl_skb)
 623                 goto out;
 624
 625         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 626         dcb = NLMSG_DATA(nlh);
 627         dcb->dcb_family = AF_UNSPEC;
 628         dcb->cmd = DCB_CMD_GAPP;
 629
 630         app_nest = nla_nest_start(dcbnl_skb, DCB_ATTR_APP);
 631         if (!app_nest)
 632                 goto out_cancel;
 633
 634         ret = nla_put_u8(dcbnl_skb, DCB_APP_ATTR_IDTYPE, idtype);
 635         if (ret)
 636                 goto out_cancel;
 637
 638         ret = nla_put_u16(dcbnl_skb, DCB_APP_ATTR_ID, id);
 639         if (ret)
 640                 goto out_cancel;
 641
 642         ret = nla_put_u8(dcbnl_skb, DCB_APP_ATTR_PRIORITY, up);
 643         if (ret)
 644                 goto out_cancel;
 645
 646         nla_nest_end(dcbnl_skb, app_nest);
 647         nlmsg_end(dcbnl_skb, nlh);
 648
 649         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 650         if (ret)
 651                 goto nlmsg_failure;
 652
 653         goto out;
 654
 655 out_cancel:
 656         nla_nest_cancel(dcbnl_skb, app_nest);
 657 nlmsg_failure:
 658         kfree_skb(dcbnl_skb);
 659 out:
 660         return ret;
 661 }
 662
 663 static int dcbnl_setapp(struct net_device *netdev, struct nlattr **tb,
 664                         u32 pid, u32 seq, u16 flags)
 665 {
 666         int err, ret = -EINVAL;
 667         u16 id;
 668         u8 up, idtype;
 669         struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1];
 670
 671         if (!tb[DCB_ATTR_APP])
 672                 goto out;
 673
 674         ret = nla_parse_nested(app_tb, DCB_APP_ATTR_MAX, tb[DCB_ATTR_APP],
 675                                dcbnl_app_nest);
 676         if (ret)
 677                 goto out;
 678
 679         ret = -EINVAL;
 680         /* all must be non-null */
 681         if ((!app_tb[DCB_APP_ATTR_IDTYPE]) ||
 682             (!app_tb[DCB_APP_ATTR_ID]) ||
 683             (!app_tb[DCB_APP_ATTR_PRIORITY]))
 684                 goto out;
 685
 686         /* either by eth type or by socket number */
 687         idtype = nla_get_u8(app_tb[DCB_APP_ATTR_IDTYPE]);
 688         if ((idtype != DCB_APP_IDTYPE_ETHTYPE) &&
 689             (idtype != DCB_APP_IDTYPE_PORTNUM))
 690                 goto out;
 691
 692         id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]);
 693         up = nla_get_u8(app_tb[DCB_APP_ATTR_PRIORITY]);
 694
 695         if (netdev->dcbnl_ops->setapp) {
 696                 err = netdev->dcbnl_ops->setapp(netdev, idtype, id, up);
 697         } else {
 698                 struct dcb_app app;
 699                 app.selector = idtype;
 700                 app.protocol = id;
 701                 app.priority = up;
 702                 err = dcb_setapp(netdev, &app);
 703         }
 704
 705         ret = dcbnl_reply(err, RTM_SETDCB, DCB_CMD_SAPP, DCB_ATTR_APP,
 706                           pid, seq, flags);
 707         dcbnl_cee_notify(netdev, RTM_SETDCB, DCB_CMD_SAPP, seq, 0);
 708 out:
 709         return ret;
 710 }
 711
 712 static int __dcbnl_pg_getcfg(struct net_device *netdev, struct nlattr **tb,
 713                              u32 pid, u32 seq, u16 flags, int dir)
 714 {
 715         struct sk_buff *dcbnl_skb;
 716         struct nlmsghdr *nlh;
 717         struct dcbmsg *dcb;
 718         struct nlattr *pg_nest, *param_nest, *data;
 719         struct nlattr *pg_tb[DCB_PG_ATTR_MAX + 1];
 720         struct nlattr *param_tb[DCB_TC_ATTR_PARAM_MAX + 1];
 721         u8 prio, pgid, tc_pct, up_map;
 722         int ret  = -EINVAL;
 723         int getall = 0;
 724         int i;
 725
 726         if (!tb[DCB_ATTR_PG_CFG] ||
 727             !netdev->dcbnl_ops->getpgtccfgtx ||
 728             !netdev->dcbnl_ops->getpgtccfgrx ||
 729             !netdev->dcbnl_ops->getpgbwgcfgtx ||
 730             !netdev->dcbnl_ops->getpgbwgcfgrx)
 731                 return ret;
 732
 733         ret = nla_parse_nested(pg_tb, DCB_PG_ATTR_MAX,
 734                                tb[DCB_ATTR_PG_CFG], dcbnl_pg_nest);
 735
 736         if (ret)
 737                 goto err_out;
 738
 739         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 740         if (!dcbnl_skb)
 741                 goto err_out;
 742
 743         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 744
 745         dcb = NLMSG_DATA(nlh);
 746         dcb->dcb_family = AF_UNSPEC;
 747         dcb->cmd = (dir) ? DCB_CMD_PGRX_GCFG : DCB_CMD_PGTX_GCFG;
 748
 749         pg_nest = nla_nest_start(dcbnl_skb, DCB_ATTR_PG_CFG);
 750         if (!pg_nest)
 751                 goto err;
 752
 753         if (pg_tb[DCB_PG_ATTR_TC_ALL])
 754                 getall = 1;
 755
 756         for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) {
 757                 if (!getall && !pg_tb[i])
 758                         continue;
 759
 760                 if (pg_tb[DCB_PG_ATTR_TC_ALL])
 761                         data = pg_tb[DCB_PG_ATTR_TC_ALL];
 762                 else
 763                         data = pg_tb[i];
 764                 ret = nla_parse_nested(param_tb, DCB_TC_ATTR_PARAM_MAX,
 765                                        data, dcbnl_tc_param_nest);
 766                 if (ret)
 767                         goto err_pg;
 768
 769                 param_nest = nla_nest_start(dcbnl_skb, i);
 770                 if (!param_nest)
 771                         goto err_pg;
 772
 773                 pgid = DCB_ATTR_VALUE_UNDEFINED;
 774                 prio = DCB_ATTR_VALUE_UNDEFINED;
 775                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
 776                 up_map = DCB_ATTR_VALUE_UNDEFINED;
 777
 778                 if (dir) {
 779                         /* Rx */
 780                         netdev->dcbnl_ops->getpgtccfgrx(netdev,
 781                                                 i - DCB_PG_ATTR_TC_0, &prio,
 782                                                 &pgid, &tc_pct, &up_map);
 783                 } else {
 784                         /* Tx */
 785                         netdev->dcbnl_ops->getpgtccfgtx(netdev,
 786                                                 i - DCB_PG_ATTR_TC_0, &prio,
 787                                                 &pgid, &tc_pct, &up_map);
 788                 }
 789
 790                 if (param_tb[DCB_TC_ATTR_PARAM_PGID] ||
 791                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 792                         ret = nla_put_u8(dcbnl_skb,
 793                                          DCB_TC_ATTR_PARAM_PGID, pgid);
 794                         if (ret)
 795                                 goto err_param;
 796                 }
 797                 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING] ||
 798                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 799                         ret = nla_put_u8(dcbnl_skb,
 800                                          DCB_TC_ATTR_PARAM_UP_MAPPING, up_map);
 801                         if (ret)
 802                                 goto err_param;
 803                 }
 804                 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO] ||
 805                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 806                         ret = nla_put_u8(dcbnl_skb,
 807                                          DCB_TC_ATTR_PARAM_STRICT_PRIO, prio);
 808                         if (ret)
 809                                 goto err_param;
 810                 }
 811                 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT] ||
 812                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 813                         ret = nla_put_u8(dcbnl_skb, DCB_TC_ATTR_PARAM_BW_PCT,
 814                                          tc_pct);
 815                         if (ret)
 816                                 goto err_param;
 817                 }
 818                 nla_nest_end(dcbnl_skb, param_nest);
 819         }
 820
 821         if (pg_tb[DCB_PG_ATTR_BW_ID_ALL])
 822                 getall = 1;
 823         else
 824                 getall = 0;
 825
 826         for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
 827                 if (!getall && !pg_tb[i])
 828                         continue;
 829
 830                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
 831
 832                 if (dir) {
 833                         /* Rx */
 834                         netdev->dcbnl_ops->getpgbwgcfgrx(netdev,
 835                                         i - DCB_PG_ATTR_BW_ID_0, &tc_pct);
 836                 } else {
 837                         /* Tx */
 838                         netdev->dcbnl_ops->getpgbwgcfgtx(netdev,
 839                                         i - DCB_PG_ATTR_BW_ID_0, &tc_pct);
 840                 }
 841                 ret = nla_put_u8(dcbnl_skb, i, tc_pct);
 842
 843                 if (ret)
 844                         goto err_pg;
 845         }
 846
 847         nla_nest_end(dcbnl_skb, pg_nest);
 848
 849         nlmsg_end(dcbnl_skb, nlh);
 850
 851         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 852         if (ret)
 853                 goto err_out;
 854
 855         return 0;
 856
 857 err_param:
 858         nla_nest_cancel(dcbnl_skb, param_nest);
 859 err_pg:
 860         nla_nest_cancel(dcbnl_skb, pg_nest);
 861 nlmsg_failure:
 862 err:
 863         kfree_skb(dcbnl_skb);
 864 err_out:
 865         ret  = -EINVAL;
 866         return ret;
 867 }
 868
 869 static int dcbnl_pgtx_getcfg(struct net_device *netdev, struct nlattr **tb,
 870                              u32 pid, u32 seq, u16 flags)
 871 {
 872         return __dcbnl_pg_getcfg(netdev, tb, pid, seq, flags, 0);
 873 }
 874
 875 static int dcbnl_pgrx_getcfg(struct net_device *netdev, struct nlattr **tb,
 876                              u32 pid, u32 seq, u16 flags)
 877 {
 878         return __dcbnl_pg_getcfg(netdev, tb, pid, seq, flags, 1);
 879 }
 880
 881 static int dcbnl_setstate(struct net_device *netdev, struct nlattr **tb,
 882                           u32 pid, u32 seq, u16 flags)
 883 {
 884         int ret = -EINVAL;
 885         u8 value;
 886
 887         if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->setstate)
 888                 return ret;
 889
 890         value = nla_get_u8(tb[DCB_ATTR_STATE]);
 891
 892         ret = dcbnl_reply(netdev->dcbnl_ops->setstate(netdev, value),
 893                           RTM_SETDCB, DCB_CMD_SSTATE, DCB_ATTR_STATE,
 894                           pid, seq, flags);
 895
 896         return ret;
 897 }
 898
 899 static int dcbnl_setpfccfg(struct net_device *netdev, struct nlattr **tb,
 900                            u32 pid, u32 seq, u16 flags)
 901 {
 902         struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1];
 903         int i;
 904         int ret = -EINVAL;
 905         u8 value;
 906
 907         if (!tb[DCB_ATTR_PFC_CFG] || !netdev->dcbnl_ops->setpfccfg)
 908                 return ret;
 909
 910         ret = nla_parse_nested(data, DCB_PFC_UP_ATTR_MAX,
 911                                tb[DCB_ATTR_PFC_CFG],
 912                                dcbnl_pfc_up_nest);
 913         if (ret)
 914                 goto err;
 915
 916         for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) {
 917                 if (data[i] == NULL)
 918                         continue;
 919                 value = nla_get_u8(data[i]);
 920                 netdev->dcbnl_ops->setpfccfg(netdev,
 921                         data[i]->nla_type - DCB_PFC_UP_ATTR_0, value);
 922         }
 923
 924         ret = dcbnl_reply(0, RTM_SETDCB, DCB_CMD_PFC_SCFG, DCB_ATTR_PFC_CFG,
 925                           pid, seq, flags);
 926 err:
 927         return ret;
 928 }
 929
 930 static int dcbnl_setall(struct net_device *netdev, struct nlattr **tb,
 931                         u32 pid, u32 seq, u16 flags)
 932 {
 933         int ret = -EINVAL;
 934
 935         if (!tb[DCB_ATTR_SET_ALL] || !netdev->dcbnl_ops->setall)
 936                 return ret;
 937
 938         ret = dcbnl_reply(netdev->dcbnl_ops->setall(netdev), RTM_SETDCB,
 939                           DCB_CMD_SET_ALL, DCB_ATTR_SET_ALL, pid, seq, flags);
 940         dcbnl_cee_notify(netdev, RTM_SETDCB, DCB_CMD_SET_ALL, seq, 0);
 941
 942         return ret;
 943 }
 944
 945 static int __dcbnl_pg_setcfg(struct net_device *netdev, struct nlattr **tb,
 946                              u32 pid, u32 seq, u16 flags, int dir)
 947 {
 948         struct nlattr *pg_tb[DCB_PG_ATTR_MAX + 1];
 949         struct nlattr *param_tb[DCB_TC_ATTR_PARAM_MAX + 1];
 950         int ret = -EINVAL;
 951         int i;
 952         u8 pgid;
 953         u8 up_map;
 954         u8 prio;
 955         u8 tc_pct;
 956
 957         if (!tb[DCB_ATTR_PG_CFG] ||
 958             !netdev->dcbnl_ops->setpgtccfgtx ||
 959             !netdev->dcbnl_ops->setpgtccfgrx ||
 960             !netdev->dcbnl_ops->setpgbwgcfgtx ||
 961             !netdev->dcbnl_ops->setpgbwgcfgrx)
 962                 return ret;
 963
 964         ret = nla_parse_nested(pg_tb, DCB_PG_ATTR_MAX,
 965                                tb[DCB_ATTR_PG_CFG], dcbnl_pg_nest);
 966         if (ret)
 967                 goto err;
 968
 969         for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) {
 970                 if (!pg_tb[i])
 971                         continue;
 972
 973                 ret = nla_parse_nested(param_tb, DCB_TC_ATTR_PARAM_MAX,
 974                                        pg_tb[i], dcbnl_tc_param_nest);
 975                 if (ret)
 976                         goto err;
 977
 978                 pgid = DCB_ATTR_VALUE_UNDEFINED;
 979                 prio = DCB_ATTR_VALUE_UNDEFINED;
 980                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
 981                 up_map = DCB_ATTR_VALUE_UNDEFINED;
 982
 983                 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO])
 984                         prio =
 985                             nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO]);
 986
 987                 if (param_tb[DCB_TC_ATTR_PARAM_PGID])
 988                         pgid = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_PGID]);
 989
 990                 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT])
 991                         tc_pct = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_BW_PCT]);
 992
 993                 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING])
 994                         up_map =
 995                              nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING]);
 996
 997                 /* dir: Tx = 0, Rx = 1 */
 998                 if (dir) {
 999                         /* Rx */
1000                         netdev->dcbnl_ops->setpgtccfgrx(netdev,
1001                                 i - DCB_PG_ATTR_TC_0,
1002                                 prio, pgid, tc_pct, up_map);
1003                 } else {
1004                         /* Tx */
1005                         netdev->dcbnl_ops->setpgtccfgtx(netdev,
1006                                 i - DCB_PG_ATTR_TC_0,
1007                                 prio, pgid, tc_pct, up_map);
1008                 }
1009         }
1010
1011         for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
1012                 if (!pg_tb[i])
1013                         continue;
1014
1015                 tc_pct = nla_get_u8(pg_tb[i]);
1016
1017                 /* dir: Tx = 0, Rx = 1 */
1018                 if (dir) {
1019                         /* Rx */
1020                         netdev->dcbnl_ops->setpgbwgcfgrx(netdev,
1021                                          i - DCB_PG_ATTR_BW_ID_0, tc_pct);
1022                 } else {
1023                         /* Tx */
1024                         netdev->dcbnl_ops->setpgbwgcfgtx(netdev,
1025                                          i - DCB_PG_ATTR_BW_ID_0, tc_pct);
1026                 }
1027         }
1028
1029         ret = dcbnl_reply(0, RTM_SETDCB,
1030                           (dir ? DCB_CMD_PGRX_SCFG : DCB_CMD_PGTX_SCFG),
1031                           DCB_ATTR_PG_CFG, pid, seq, flags);
1032
1033 err:
1034         return ret;
1035 }
1036
1037 static int dcbnl_pgtx_setcfg(struct net_device *netdev, struct nlattr **tb,
1038                              u32 pid, u32 seq, u16 flags)
1039 {
1040         return __dcbnl_pg_setcfg(netdev, tb, pid, seq, flags, 0);
1041 }
1042
1043 static int dcbnl_pgrx_setcfg(struct net_device *netdev, struct nlattr **tb,
1044                              u32 pid, u32 seq, u16 flags)
1045 {
1046         return __dcbnl_pg_setcfg(netdev, tb, pid, seq, flags, 1);
1047 }
1048
1049 static int dcbnl_bcn_getcfg(struct net_device *netdev, struct nlattr **tb,
1050                             u32 pid, u32 seq, u16 flags)
1051 {
1052         struct sk_buff *dcbnl_skb;
1053         struct nlmsghdr *nlh;
1054         struct dcbmsg *dcb;
1055         struct nlattr *bcn_nest;
1056         struct nlattr *bcn_tb[DCB_BCN_ATTR_MAX + 1];
1057         u8 value_byte;
1058         u32 value_integer;
1059         int ret  = -EINVAL;
1060         bool getall = false;
1061         int i;
1062
1063         if (!tb[DCB_ATTR_BCN] || !netdev->dcbnl_ops->getbcnrp ||
1064             !netdev->dcbnl_ops->getbcncfg)
1065                 return ret;
1066
1067         ret = nla_parse_nested(bcn_tb, DCB_BCN_ATTR_MAX,
1068                                tb[DCB_ATTR_BCN], dcbnl_bcn_nest);
1069
1070         if (ret)
1071                 goto err_out;
1072
1073         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1074         if (!dcbnl_skb)
1075                 goto err_out;
1076
1077         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
1078
1079         dcb = NLMSG_DATA(nlh);
1080         dcb->dcb_family = AF_UNSPEC;
1081         dcb->cmd = DCB_CMD_BCN_GCFG;
1082
1083         bcn_nest = nla_nest_start(dcbnl_skb, DCB_ATTR_BCN);
1084         if (!bcn_nest)
1085                 goto err;
1086
1087         if (bcn_tb[DCB_BCN_ATTR_ALL])
1088                 getall = true;
1089
1090         for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) {
1091                 if (!getall && !bcn_tb[i])
1092                         continue;
1093
1094                 netdev->dcbnl_ops->getbcnrp(netdev, i - DCB_BCN_ATTR_RP_0,
1095                                             &value_byte);
1096                 ret = nla_put_u8(dcbnl_skb, i, value_byte);
1097                 if (ret)
1098                         goto err_bcn;
1099         }
1100
1101         for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) {
1102                 if (!getall && !bcn_tb[i])
1103                         continue;
1104
1105                 netdev->dcbnl_ops->getbcncfg(netdev, i,
1106                                              &value_integer);
1107                 ret = nla_put_u32(dcbnl_skb, i, value_integer);
1108                 if (ret)
1109                         goto err_bcn;
1110         }
1111
1112         nla_nest_end(dcbnl_skb, bcn_nest);
1113
1114         nlmsg_end(dcbnl_skb, nlh);
1115
1116         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
1117         if (ret)
1118                 goto err_out;
1119
1120         return 0;
1121
1122 err_bcn:
1123         nla_nest_cancel(dcbnl_skb, bcn_nest);
1124 nlmsg_failure:
1125 err:
1126         kfree_skb(dcbnl_skb);
1127 err_out:
1128         ret  = -EINVAL;
1129         return ret;
1130 }
1131
1132 static int dcbnl_bcn_setcfg(struct net_device *netdev, struct nlattr **tb,
1133                             u32 pid, u32 seq, u16 flags)
1134 {
1135         struct nlattr *data[DCB_BCN_ATTR_MAX + 1];
1136         int i;
1137         int ret = -EINVAL;
1138         u8 value_byte;
1139         u32 value_int;
1140
1141         if (!tb[DCB_ATTR_BCN] || !netdev->dcbnl_ops->setbcncfg ||
1142             !netdev->dcbnl_ops->setbcnrp)
1143                 return ret;
1144
1145         ret = nla_parse_nested(data, DCB_BCN_ATTR_MAX,
1146                                tb[DCB_ATTR_BCN],
1147                                dcbnl_pfc_up_nest);
1148         if (ret)
1149                 goto err;
1150
1151         for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) {
1152                 if (data[i] == NULL)
1153                         continue;
1154                 value_byte = nla_get_u8(data[i]);
1155                 netdev->dcbnl_ops->setbcnrp(netdev,
1156                         data[i]->nla_type - DCB_BCN_ATTR_RP_0, value_byte);
1157         }
1158
1159         for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) {
1160                 if (data[i] == NULL)
1161                         continue;
1162                 value_int = nla_get_u32(data[i]);
1163                 netdev->dcbnl_ops->setbcncfg(netdev,
1164                                              i, value_int);
1165         }
1166
1167         ret = dcbnl_reply(0, RTM_SETDCB, DCB_CMD_BCN_SCFG, DCB_ATTR_BCN,
1168                           pid, seq, flags);
1169 err:
1170         return ret;
1171 }
1172
1173 static int dcbnl_build_peer_app(struct net_device *netdev, struct sk_buff* skb,
1174                                 int app_nested_type, int app_info_type,
1175                                 int app_entry_type)
1176 {
1177         struct dcb_peer_app_info info;
1178         struct dcb_app *table = NULL;
1179         const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1180         u16 app_count;
1181         int err;
1182
1183
1184         /**
1185          * retrieve the peer app configuration form the driver. If the driver
1186          * handlers fail exit without doing anything
1187          */
1188         err = ops->peer_getappinfo(netdev, &info, &app_count);
1189         if (!err && app_count) {
1190                 table = kmalloc(sizeof(struct dcb_app) * app_count, GFP_KERNEL);
1191                 if (!table)
1192                         return -ENOMEM;
1193
1194                 err = ops->peer_getapptable(netdev, table);
1195         }
1196
1197         if (!err) {
1198                 u16 i;
1199                 struct nlattr *app;
1200
1201                 /**
1202                  * build the message, from here on the only possible failure
1203                  * is due to the skb size
1204                  */
1205                 err = -EMSGSIZE;
1206
1207                 app = nla_nest_start(skb, app_nested_type);
1208                 if (!app)
1209                         goto nla_put_failure;
1210
1211                 if (app_info_type &&
1212                     nla_put(skb, app_info_type, sizeof(info), &info))
1213                         goto nla_put_failure;
1214
1215                 for (i = 0; i < app_count; i++) {
1216                         if (nla_put(skb, app_entry_type, sizeof(struct dcb_app),
1217                                     &table[i]))
1218                                 goto nla_put_failure;
1219                 }
1220                 nla_nest_end(skb, app);
1221         }
1222         err = 0;
1223
1224 nla_put_failure:
1225         kfree(table);
1226         return err;
1227 }
1228
1229 /* Handle IEEE 802.1Qaz GET commands. */
1230 static int dcbnl_ieee_fill(struct sk_buff *skb, struct net_device *netdev)
1231 {
1232         struct nlattr *ieee, *app;
1233         struct dcb_app_type *itr;
1234         const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1235         int dcbx;
1236         int err = -EMSGSIZE;
1237
1238         if (nla_put_string(skb, DCB_ATTR_IFNAME, netdev->name))
1239                 goto nla_put_failure;
1240         ieee = nla_nest_start(skb, DCB_ATTR_IEEE);
1241         if (!ieee)
1242                 goto nla_put_failure;
1243
1244         if (ops->ieee_getets) {
1245                 struct ieee_ets ets;
1246                 err = ops->ieee_getets(netdev, &ets);
1247                 if (!err &&
1248                     nla_put(skb, DCB_ATTR_IEEE_ETS, sizeof(ets), &ets))
1249                         goto nla_put_failure;
1250         }
1251
1252         if (ops->ieee_getmaxrate) {
1253                 struct ieee_maxrate maxrate;
1254                 err = ops->ieee_getmaxrate(netdev, &maxrate);
1255                 if (!err) {
1256                         err = nla_put(skb, DCB_ATTR_IEEE_MAXRATE,
1257                                       sizeof(maxrate), &maxrate);
1258                         if (err)
1259                                 goto nla_put_failure;
1260                 }
1261         }
1262
1263         if (ops->ieee_getpfc) {
1264                 struct ieee_pfc pfc;
1265                 err = ops->ieee_getpfc(netdev, &pfc);
1266                 if (!err &&
1267                     nla_put(skb, DCB_ATTR_IEEE_PFC, sizeof(pfc), &pfc))
1268                         goto nla_put_failure;
1269         }
1270
1271         app = nla_nest_start(skb, DCB_ATTR_IEEE_APP_TABLE);
1272         if (!app)
1273                 goto nla_put_failure;
1274
1275         spin_lock(&dcb_lock);
1276         list_for_each_entry(itr, &dcb_app_list, list) {
1277                 if (itr->ifindex == netdev->ifindex) {
1278                         err = nla_put(skb, DCB_ATTR_IEEE_APP, sizeof(itr->app),
1279                                          &itr->app);
1280                         if (err) {
1281                                 spin_unlock(&dcb_lock);
1282                                 goto nla_put_failure;
1283                         }
1284                 }
1285         }
1286
1287         if (netdev->dcbnl_ops->getdcbx)
1288                 dcbx = netdev->dcbnl_ops->getdcbx(netdev);
1289         else
1290                 dcbx = -EOPNOTSUPP;
1291
1292         spin_unlock(&dcb_lock);
1293         nla_nest_end(skb, app);
1294
1295         /* get peer info if available */
1296         if (ops->ieee_peer_getets) {
1297                 struct ieee_ets ets;
1298                 err = ops->ieee_peer_getets(netdev, &ets);
1299                 if (!err &&
1300                     nla_put(skb, DCB_ATTR_IEEE_PEER_ETS, sizeof(ets), &ets))
1301                         goto nla_put_failure;
1302         }
1303
1304         if (ops->ieee_peer_getpfc) {
1305                 struct ieee_pfc pfc;
1306                 err = ops->ieee_peer_getpfc(netdev, &pfc);
1307                 if (!err &&
1308                     nla_put(skb, DCB_ATTR_IEEE_PEER_PFC, sizeof(pfc), &pfc))
1309                         goto nla_put_failure;
1310         }
1311
1312         if (ops->peer_getappinfo && ops->peer_getapptable) {
1313                 err = dcbnl_build_peer_app(netdev, skb,
1314                                            DCB_ATTR_IEEE_PEER_APP,
1315                                            DCB_ATTR_IEEE_APP_UNSPEC,
1316                                            DCB_ATTR_IEEE_APP);
1317                 if (err)
1318                         goto nla_put_failure;
1319         }
1320
1321         nla_nest_end(skb, ieee);
1322         if (dcbx >= 0) {
1323                 err = nla_put_u8(skb, DCB_ATTR_DCBX, dcbx);
1324                 if (err)
1325                         goto nla_put_failure;
1326         }
1327
1328         return 0;
1329
1330 nla_put_failure:
1331         return err;
1332 }
1333
1334 static int dcbnl_cee_pg_fill(struct sk_buff *skb, struct net_device *dev,
1335                              int dir)
1336 {
1337         u8 pgid, up_map, prio, tc_pct;
1338         const struct dcbnl_rtnl_ops *ops = dev->dcbnl_ops;
1339         int i = dir ? DCB_ATTR_CEE_TX_PG : DCB_ATTR_CEE_RX_PG;
1340         struct nlattr *pg = nla_nest_start(skb, i);
1341
1342         if (!pg)
1343                 goto nla_put_failure;
1344
1345         for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) {
1346                 struct nlattr *tc_nest = nla_nest_start(skb, i);
1347
1348                 if (!tc_nest)
1349                         goto nla_put_failure;
1350
1351                 pgid = DCB_ATTR_VALUE_UNDEFINED;
1352                 prio = DCB_ATTR_VALUE_UNDEFINED;
1353                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
1354                 up_map = DCB_ATTR_VALUE_UNDEFINED;
1355
1356                 if (!dir)
1357                         ops->getpgtccfgrx(dev, i - DCB_PG_ATTR_TC_0,
1358                                           &prio, &pgid, &tc_pct, &up_map);
1359                 else
1360                         ops->getpgtccfgtx(dev, i - DCB_PG_ATTR_TC_0,
1361                                           &prio, &pgid, &tc_pct, &up_map);
1362
1363                 if (nla_put_u8(skb, DCB_TC_ATTR_PARAM_PGID, pgid) ||
1364                     nla_put_u8(skb, DCB_TC_ATTR_PARAM_UP_MAPPING, up_map) ||
1365                     nla_put_u8(skb, DCB_TC_ATTR_PARAM_STRICT_PRIO, prio) ||
1366                     nla_put_u8(skb, DCB_TC_ATTR_PARAM_BW_PCT, tc_pct))
1367                         goto nla_put_failure;
1368                 nla_nest_end(skb, tc_nest);
1369         }
1370
1371         for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
1372                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
1373
1374                 if (!dir)
1375                         ops->getpgbwgcfgrx(dev, i - DCB_PG_ATTR_BW_ID_0,
1376                                            &tc_pct);
1377                 else
1378                         ops->getpgbwgcfgtx(dev, i - DCB_PG_ATTR_BW_ID_0,
1379                                            &tc_pct);
1380                 if (nla_put_u8(skb, i, tc_pct))
1381                         goto nla_put_failure;
1382         }
1383         nla_nest_end(skb, pg);
1384         return 0;
1385
1386 nla_put_failure:
1387         return -EMSGSIZE;
1388 }
1389
1390 static int dcbnl_cee_fill(struct sk_buff *skb, struct net_device *netdev)
1391 {
1392         struct nlattr *cee, *app;
1393         struct dcb_app_type *itr;
1394         const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1395         int dcbx, i, err = -EMSGSIZE;
1396         u8 value;
1397
1398         if (nla_put_string(skb, DCB_ATTR_IFNAME, netdev->name))
1399                 goto nla_put_failure;
1400         cee = nla_nest_start(skb, DCB_ATTR_CEE);
1401         if (!cee)
1402                 goto nla_put_failure;
1403
1404         /* local pg */
1405         if (ops->getpgtccfgtx && ops->getpgbwgcfgtx) {
1406                 err = dcbnl_cee_pg_fill(skb, netdev, 1);
1407                 if (err)
1408                         goto nla_put_failure;
1409         }
1410
1411         if (ops->getpgtccfgrx && ops->getpgbwgcfgrx) {
1412                 err = dcbnl_cee_pg_fill(skb, netdev, 0);
1413                 if (err)
1414                         goto nla_put_failure;
1415         }
1416
1417         /* local pfc */
1418         if (ops->getpfccfg) {
1419                 struct nlattr *pfc_nest = nla_nest_start(skb, DCB_ATTR_CEE_PFC);
1420
1421                 if (!pfc_nest)
1422                         goto nla_put_failure;
1423
1424                 for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) {
1425                         ops->getpfccfg(netdev, i - DCB_PFC_UP_ATTR_0, &value);
1426                         if (nla_put_u8(skb, i, value))
1427                                 goto nla_put_failure;
1428                 }
1429                 nla_nest_end(skb, pfc_nest);
1430         }
1431
1432         /* local app */
1433         spin_lock(&dcb_lock);
1434         app = nla_nest_start(skb, DCB_ATTR_CEE_APP_TABLE);
1435         if (!app)
1436                 goto dcb_unlock;
1437
1438         list_for_each_entry(itr, &dcb_app_list, list) {
1439                 if (itr->ifindex == netdev->ifindex) {
1440                         struct nlattr *app_nest = nla_nest_start(skb,
1441                                                                  DCB_ATTR_APP);
1442                         if (!app_nest)
1443                                 goto dcb_unlock;
1444
1445                         err = nla_put_u8(skb, DCB_APP_ATTR_IDTYPE,
1446                                          itr->app.selector);
1447                         if (err)
1448                                 goto dcb_unlock;
1449
1450                         err = nla_put_u16(skb, DCB_APP_ATTR_ID,
1451                                           itr->app.protocol);
1452                         if (err)
1453                                 goto dcb_unlock;
1454
1455                         err = nla_put_u8(skb, DCB_APP_ATTR_PRIORITY,
1456                                          itr->app.priority);
1457                         if (err)
1458                                 goto dcb_unlock;
1459
1460                         nla_nest_end(skb, app_nest);
1461                 }
1462         }
1463         nla_nest_end(skb, app);
1464
1465         if (netdev->dcbnl_ops->getdcbx)
1466                 dcbx = netdev->dcbnl_ops->getdcbx(netdev);
1467         else
1468                 dcbx = -EOPNOTSUPP;
1469
1470         spin_unlock(&dcb_lock);
1471
1472         /* features flags */
1473         if (ops->getfeatcfg) {
1474                 struct nlattr *feat = nla_nest_start(skb, DCB_ATTR_CEE_FEAT);
1475                 if (!feat)
1476                         goto nla_put_failure;
1477
1478                 for (i = DCB_FEATCFG_ATTR_ALL + 1; i <= DCB_FEATCFG_ATTR_MAX;
1479                      i++)
1480                         if (!ops->getfeatcfg(netdev, i, &value) &&
1481                             nla_put_u8(skb, i, value))
1482                                 goto nla_put_failure;
1483
1484                 nla_nest_end(skb, feat);
1485         }
1486
1487         /* peer info if available */
1488         if (ops->cee_peer_getpg) {
1489                 struct cee_pg pg;
1490                 err = ops->cee_peer_getpg(netdev, &pg);
1491                 if (!err &&
1492                     nla_put(skb, DCB_ATTR_CEE_PEER_PG, sizeof(pg), &pg))
1493                         goto nla_put_failure;
1494         }
1495
1496         if (ops->cee_peer_getpfc) {
1497                 struct cee_pfc pfc;
1498                 err = ops->cee_peer_getpfc(netdev, &pfc);
1499                 if (!err &&
1500                     nla_put(skb, DCB_ATTR_CEE_PEER_PFC, sizeof(pfc), &pfc))
1501                         goto nla_put_failure;
1502         }
1503
1504         if (ops->peer_getappinfo && ops->peer_getapptable) {
1505                 err = dcbnl_build_peer_app(netdev, skb,
1506                                            DCB_ATTR_CEE_PEER_APP_TABLE,
1507                                            DCB_ATTR_CEE_PEER_APP_INFO,
1508                                            DCB_ATTR_CEE_PEER_APP);
1509                 if (err)
1510                         goto nla_put_failure;
1511         }
1512         nla_nest_end(skb, cee);
1513
1514         /* DCBX state */
1515         if (dcbx >= 0) {
1516                 err = nla_put_u8(skb, DCB_ATTR_DCBX, dcbx);
1517                 if (err)
1518                         goto nla_put_failure;
1519         }
1520         return 0;
1521
1522 dcb_unlock:
1523         spin_unlock(&dcb_lock);
1524 nla_put_failure:
1525         return err;
1526 }
1527
1528 static int dcbnl_notify(struct net_device *dev, int event, int cmd,
1529                         u32 seq, u32 pid, int dcbx_ver)
1530 {
1531         struct net *net = dev_net(dev);
1532         struct sk_buff *skb;
1533         struct nlmsghdr *nlh;
1534         struct dcbmsg *dcb;
1535         const struct dcbnl_rtnl_ops *ops = dev->dcbnl_ops;
1536         int err;
1537
1538         if (!ops)
1539                 return -EOPNOTSUPP;
1540
1541         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1542         if (!skb)
1543                 return -ENOBUFS;
1544
1545         nlh = nlmsg_put(skb, pid, 0, event, sizeof(*dcb), 0);
1546         if (nlh == NULL) {
1547                 nlmsg_free(skb);
1548                 return -EMSGSIZE;
1549         }
1550
1551         dcb = NLMSG_DATA(nlh);
1552         dcb->dcb_family = AF_UNSPEC;
1553         dcb->cmd = cmd;
1554
1555         if (dcbx_ver == DCB_CAP_DCBX_VER_IEEE)
1556                 err = dcbnl_ieee_fill(skb, dev);
1557         else
1558                 err = dcbnl_cee_fill(skb, dev);
1559
1560         if (err < 0) {
1561                 /* Report error to broadcast listeners */
1562                 nlmsg_cancel(skb, nlh);
1563                 kfree_skb(skb);
1564                 rtnl_set_sk_err(net, RTNLGRP_DCB, err);
1565         } else {
1566                 /* End nlmsg and notify broadcast listeners */
1567                 nlmsg_end(skb, nlh);
1568                 rtnl_notify(skb, net, 0, RTNLGRP_DCB, NULL, GFP_KERNEL);
1569         }
1570
1571         return err;
1572 }
1573
1574 int dcbnl_ieee_notify(struct net_device *dev, int event, int cmd,
1575                       u32 seq, u32 pid)
1576 {
1577         return dcbnl_notify(dev, event, cmd, seq, pid, DCB_CAP_DCBX_VER_IEEE);
1578 }
1579 EXPORT_SYMBOL(dcbnl_ieee_notify);
1580
1581 int dcbnl_cee_notify(struct net_device *dev, int event, int cmd,
1582                      u32 seq, u32 pid)
1583 {
1584         return dcbnl_notify(dev, event, cmd, seq, pid, DCB_CAP_DCBX_VER_CEE);
1585 }
1586 EXPORT_SYMBOL(dcbnl_cee_notify);
1587
1588 /* Handle IEEE 802.1Qaz SET commands. If any requested operation can not
1589  * be completed the entire msg is aborted and error value is returned.
1590  * No attempt is made to reconcile the case where only part of the
1591  * cmd can be completed.
1592  */
1593 static int dcbnl_ieee_set(struct net_device *netdev, struct nlattr **tb,
1594                           u32 pid, u32 seq, u16 flags)
1595 {
1596         const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1597         struct nlattr *ieee[DCB_ATTR_IEEE_MAX + 1];
1598         int err = -EOPNOTSUPP;
1599
1600         if (!ops)
1601                 return err;
1602
1603         if (!tb[DCB_ATTR_IEEE])
1604                 return -EINVAL;
1605
1606         err = nla_parse_nested(ieee, DCB_ATTR_IEEE_MAX,
1607                                tb[DCB_ATTR_IEEE], dcbnl_ieee_policy);
1608         if (err)
1609                 return err;
1610
1611         if (ieee[DCB_ATTR_IEEE_ETS] && ops->ieee_setets) {
1612                 struct ieee_ets *ets = nla_data(ieee[DCB_ATTR_IEEE_ETS]);
1613                 err = ops->ieee_setets(netdev, ets);
1614                 if (err)
1615                         goto err;
1616         }
1617
1618         if (ieee[DCB_ATTR_IEEE_MAXRATE] && ops->ieee_setmaxrate) {
1619                 struct ieee_maxrate *maxrate =
1620                         nla_data(ieee[DCB_ATTR_IEEE_MAXRATE]);
1621                 err = ops->ieee_setmaxrate(netdev, maxrate);
1622                 if (err)
1623                         goto err;
1624         }
1625
1626         if (ieee[DCB_ATTR_IEEE_PFC] && ops->ieee_setpfc) {
1627                 struct ieee_pfc *pfc = nla_data(ieee[DCB_ATTR_IEEE_PFC]);
1628                 err = ops->ieee_setpfc(netdev, pfc);
1629                 if (err)
1630                         goto err;
1631         }
1632
1633         if (ieee[DCB_ATTR_IEEE_APP_TABLE]) {
1634                 struct nlattr *attr;
1635                 int rem;
1636
1637                 nla_for_each_nested(attr, ieee[DCB_ATTR_IEEE_APP_TABLE], rem) {
1638                         struct dcb_app *app_data;
1639                         if (nla_type(attr) != DCB_ATTR_IEEE_APP)
1640                                 continue;
1641                         app_data = nla_data(attr);
1642                         if (ops->ieee_setapp)
1643                                 err = ops->ieee_setapp(netdev, app_data);
1644                         else
1645                                 err = dcb_ieee_setapp(netdev, app_data);
1646                         if (err)
1647                                 goto err;
1648                 }
1649         }
1650
1651 err:
1652         dcbnl_reply(err, RTM_SETDCB, DCB_CMD_IEEE_SET, DCB_ATTR_IEEE,
1653                     pid, seq, flags);
1654         dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_SET, seq, 0);
1655         return err;
1656 }
1657
1658 static int dcbnl_ieee_get(struct net_device *netdev, struct nlattr **tb,
1659                           u32 pid, u32 seq, u16 flags)
1660 {
1661         struct net *net = dev_net(netdev);
1662         struct sk_buff *skb;
1663         struct nlmsghdr *nlh;
1664         struct dcbmsg *dcb;
1665         const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1666         int err;
1667
1668         if (!ops)
1669                 return -EOPNOTSUPP;
1670
1671         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1672         if (!skb)
1673                 return -ENOBUFS;
1674
1675         nlh = nlmsg_put(skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
1676         if (nlh == NULL) {
1677                 nlmsg_free(skb);
1678                 return -EMSGSIZE;
1679         }
1680
1681         dcb = NLMSG_DATA(nlh);
1682         dcb->dcb_family = AF_UNSPEC;
1683         dcb->cmd = DCB_CMD_IEEE_GET;
1684
1685         err = dcbnl_ieee_fill(skb, netdev);
1686
1687         if (err < 0) {
1688                 nlmsg_cancel(skb, nlh);
1689                 kfree_skb(skb);
1690         } else {
1691                 nlmsg_end(skb, nlh);
1692                 err = rtnl_unicast(skb, net, pid);
1693         }
1694
1695         return err;
1696 }
1697
1698 static int dcbnl_ieee_del(struct net_device *netdev, struct nlattr **tb,
1699                           u32 pid, u32 seq, u16 flags)
1700 {
1701         const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1702         struct nlattr *ieee[DCB_ATTR_IEEE_MAX + 1];
1703         int err = -EOPNOTSUPP;
1704
1705         if (!ops)
1706                 return -EOPNOTSUPP;
1707
1708         if (!tb[DCB_ATTR_IEEE])
1709                 return -EINVAL;
1710
1711         err = nla_parse_nested(ieee, DCB_ATTR_IEEE_MAX,
1712                                tb[DCB_ATTR_IEEE], dcbnl_ieee_policy);
1713         if (err)
1714                 return err;
1715
1716         if (ieee[DCB_ATTR_IEEE_APP_TABLE]) {
1717                 struct nlattr *attr;
1718                 int rem;
1719
1720                 nla_for_each_nested(attr, ieee[DCB_ATTR_IEEE_APP_TABLE], rem) {
1721                         struct dcb_app *app_data;
1722
1723                         if (nla_type(attr) != DCB_ATTR_IEEE_APP)
1724                                 continue;
1725                         app_data = nla_data(attr);
1726                         if (ops->ieee_delapp)
1727                                 err = ops->ieee_delapp(netdev, app_data);
1728                         else
1729                                 err = dcb_ieee_delapp(netdev, app_data);
1730                         if (err)
1731                                 goto err;
1732                 }
1733         }
1734
1735 err:
1736         dcbnl_reply(err, RTM_SETDCB, DCB_CMD_IEEE_DEL, DCB_ATTR_IEEE,
1737                     pid, seq, flags);
1738         dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_DEL, seq, 0);
1739         return err;
1740 }
1741
1742
1743 /* DCBX configuration */
1744 static int dcbnl_getdcbx(struct net_device *netdev, struct nlattr **tb,
1745                          u32 pid, u32 seq, u16 flags)
1746 {
1747         int ret;
1748
1749         if (!netdev->dcbnl_ops->getdcbx)
1750                 return -EOPNOTSUPP;
1751
1752         ret = dcbnl_reply(netdev->dcbnl_ops->getdcbx(netdev), RTM_GETDCB,
1753                           DCB_CMD_GDCBX, DCB_ATTR_DCBX, pid, seq, flags);
1754
1755         return ret;
1756 }
1757
1758 static int dcbnl_setdcbx(struct net_device *netdev, struct nlattr **tb,
1759                          u32 pid, u32 seq, u16 flags)
1760 {
1761         int ret;
1762         u8 value;
1763
1764         if (!netdev->dcbnl_ops->setdcbx)
1765                 return -EOPNOTSUPP;
1766
1767         if (!tb[DCB_ATTR_DCBX])
1768                 return -EINVAL;
1769
1770         value = nla_get_u8(tb[DCB_ATTR_DCBX]);
1771
1772         ret = dcbnl_reply(netdev->dcbnl_ops->setdcbx(netdev, value),
1773                           RTM_SETDCB, DCB_CMD_SDCBX, DCB_ATTR_DCBX,
1774                           pid, seq, flags);
1775
1776         return ret;
1777 }
1778
1779 static int dcbnl_getfeatcfg(struct net_device *netdev, struct nlattr **tb,
1780                             u32 pid, u32 seq, u16 flags)
1781 {
1782         struct sk_buff *dcbnl_skb;
1783         struct nlmsghdr *nlh;
1784         struct dcbmsg *dcb;
1785         struct nlattr *data[DCB_FEATCFG_ATTR_MAX + 1], *nest;
1786         u8 value;
1787         int ret, i;
1788         int getall = 0;
1789
1790         if (!netdev->dcbnl_ops->getfeatcfg)
1791                 return -EOPNOTSUPP;
1792
1793         if (!tb[DCB_ATTR_FEATCFG])
1794                 return -EINVAL;
1795
1796         ret = nla_parse_nested(data, DCB_FEATCFG_ATTR_MAX, tb[DCB_ATTR_FEATCFG],
1797                                dcbnl_featcfg_nest);
1798         if (ret)
1799                 goto err_out;
1800
1801         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1802         if (!dcbnl_skb) {
1803                 ret = -ENOBUFS;
1804                 goto err_out;
1805         }
1806
1807         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
1808
1809         dcb = NLMSG_DATA(nlh);
1810         dcb->dcb_family = AF_UNSPEC;
1811         dcb->cmd = DCB_CMD_GFEATCFG;
1812
1813         nest = nla_nest_start(dcbnl_skb, DCB_ATTR_FEATCFG);
1814         if (!nest) {
1815                 ret = -EMSGSIZE;
1816                 goto nla_put_failure;
1817         }
1818
1819         if (data[DCB_FEATCFG_ATTR_ALL])
1820                 getall = 1;
1821
1822         for (i = DCB_FEATCFG_ATTR_ALL+1; i <= DCB_FEATCFG_ATTR_MAX; i++) {
1823                 if (!getall && !data[i])
1824                         continue;
1825
1826                 ret = netdev->dcbnl_ops->getfeatcfg(netdev, i, &value);
1827                 if (!ret)
1828                         ret = nla_put_u8(dcbnl_skb, i, value);
1829
1830                 if (ret) {
1831                         nla_nest_cancel(dcbnl_skb, nest);
1832                         goto nla_put_failure;
1833                 }
1834         }
1835         nla_nest_end(dcbnl_skb, nest);
1836
1837         nlmsg_end(dcbnl_skb, nlh);
1838
1839         return rtnl_unicast(dcbnl_skb, &init_net, pid);
1840 nla_put_failure:
1841         nlmsg_cancel(dcbnl_skb, nlh);
1842 nlmsg_failure:
1843         kfree_skb(dcbnl_skb);
1844 err_out:
1845         return ret;
1846 }
1847
1848 static int dcbnl_setfeatcfg(struct net_device *netdev, struct nlattr **tb,
1849                             u32 pid, u32 seq, u16 flags)
1850 {
1851         struct nlattr *data[DCB_FEATCFG_ATTR_MAX + 1];
1852         int ret, i;
1853         u8 value;
1854
1855         if (!netdev->dcbnl_ops->setfeatcfg)
1856                 return -ENOTSUPP;
1857
1858         if (!tb[DCB_ATTR_FEATCFG])
1859                 return -EINVAL;
1860
1861         ret = nla_parse_nested(data, DCB_FEATCFG_ATTR_MAX, tb[DCB_ATTR_FEATCFG],
1862                                dcbnl_featcfg_nest);
1863
1864         if (ret)
1865                 goto err;
1866
1867         for (i = DCB_FEATCFG_ATTR_ALL+1; i <= DCB_FEATCFG_ATTR_MAX; i++) {
1868                 if (data[i] == NULL)
1869                         continue;
1870
1871                 value = nla_get_u8(data[i]);
1872
1873                 ret = netdev->dcbnl_ops->setfeatcfg(netdev, i, value);
1874
1875                 if (ret)
1876                         goto err;
1877         }
1878 err:
1879         dcbnl_reply(ret, RTM_SETDCB, DCB_CMD_SFEATCFG, DCB_ATTR_FEATCFG,
1880                     pid, seq, flags);
1881
1882         return ret;
1883 }
1884
1885 /* Handle CEE DCBX GET commands. */
1886 static int dcbnl_cee_get(struct net_device *netdev, struct nlattr **tb,
1887                          u32 pid, u32 seq, u16 flags)
1888 {
1889         struct net *net = dev_net(netdev);
1890         struct sk_buff *skb;
1891         struct nlmsghdr *nlh;
1892         struct dcbmsg *dcb;
1893         const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1894         int err;
1895
1896         if (!ops)
1897                 return -EOPNOTSUPP;
1898
1899         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1900         if (!skb)
1901                 return -ENOBUFS;
1902
1903         nlh = nlmsg_put(skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
1904         if (nlh == NULL) {
1905                 nlmsg_free(skb);
1906                 return -EMSGSIZE;
1907         }
1908
1909         dcb = NLMSG_DATA(nlh);
1910         dcb->dcb_family = AF_UNSPEC;
1911         dcb->cmd = DCB_CMD_CEE_GET;
1912
1913         err = dcbnl_cee_fill(skb, netdev);
1914
1915         if (err < 0) {
1916                 nlmsg_cancel(skb, nlh);
1917                 nlmsg_free(skb);
1918         } else {
1919                 nlmsg_end(skb, nlh);
1920                 err = rtnl_unicast(skb, net, pid);
1921         }
1922         return err;
1923 }
1924
1925 static int dcb_doit(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1926 {
1927         struct net *net = sock_net(skb->sk);
1928         struct net_device *netdev;
1929         struct dcbmsg  *dcb = (struct dcbmsg *)NLMSG_DATA(nlh);
1930         struct nlattr *tb[DCB_ATTR_MAX + 1];
1931         u32 pid = skb ? NETLINK_CB(skb).pid : 0;
1932         int ret = -EINVAL;
1933
1934         if (!net_eq(net, &init_net))
1935                 return -EINVAL;
1936
1937         ret = nlmsg_parse(nlh, sizeof(*dcb), tb, DCB_ATTR_MAX,
1938                           dcbnl_rtnl_policy);
1939         if (ret < 0)
1940                 return ret;
1941
1942         if (!tb[DCB_ATTR_IFNAME])
1943                 return -EINVAL;
1944
1945         netdev = dev_get_by_name(&init_net, nla_data(tb[DCB_ATTR_IFNAME]));
1946         if (!netdev)
1947                 return -EINVAL;
1948
1949         if (!netdev->dcbnl_ops)
1950                 goto errout;
1951
1952         switch (dcb->cmd) {
1953         case DCB_CMD_GSTATE:
1954                 ret = dcbnl_getstate(netdev, tb, pid, nlh->nlmsg_seq,
1955                                      nlh->nlmsg_flags);
1956                 goto out;
1957         case DCB_CMD_PFC_GCFG:
1958                 ret = dcbnl_getpfccfg(netdev, tb, pid, nlh->nlmsg_seq,
1959                                       nlh->nlmsg_flags);
1960                 goto out;
1961         case DCB_CMD_GPERM_HWADDR:
1962                 ret = dcbnl_getperm_hwaddr(netdev, tb, pid, nlh->nlmsg_seq,
1963                                            nlh->nlmsg_flags);
1964                 goto out;
1965         case DCB_CMD_PGTX_GCFG:
1966                 ret = dcbnl_pgtx_getcfg(netdev, tb, pid, nlh->nlmsg_seq,
1967                                         nlh->nlmsg_flags);
1968                 goto out;
1969         case DCB_CMD_PGRX_GCFG:
1970                 ret = dcbnl_pgrx_getcfg(netdev, tb, pid, nlh->nlmsg_seq,
1971                                         nlh->nlmsg_flags);
1972                 goto out;
1973         case DCB_CMD_BCN_GCFG:
1974                 ret = dcbnl_bcn_getcfg(netdev, tb, pid, nlh->nlmsg_seq,
1975                                        nlh->nlmsg_flags);
1976                 goto out;
1977         case DCB_CMD_SSTATE:
1978                 ret = dcbnl_setstate(netdev, tb, pid, nlh->nlmsg_seq,
1979                                      nlh->nlmsg_flags);
1980                 goto out;
1981         case DCB_CMD_PFC_SCFG:
1982                 ret = dcbnl_setpfccfg(netdev, tb, pid, nlh->nlmsg_seq,
1983                                       nlh->nlmsg_flags);
1984                 goto out;
1985
1986         case DCB_CMD_SET_ALL:
1987                 ret = dcbnl_setall(netdev, tb, pid, nlh->nlmsg_seq,
1988                                    nlh->nlmsg_flags);
1989                 goto out;
1990         case DCB_CMD_PGTX_SCFG:
1991                 ret = dcbnl_pgtx_setcfg(netdev, tb, pid, nlh->nlmsg_seq,
1992                                         nlh->nlmsg_flags);
1993                 goto out;
1994         case DCB_CMD_PGRX_SCFG:
1995                 ret = dcbnl_pgrx_setcfg(netdev, tb, pid, nlh->nlmsg_seq,
1996                                         nlh->nlmsg_flags);
1997                 goto out;
1998         case DCB_CMD_GCAP:
1999                 ret = dcbnl_getcap(netdev, tb, pid, nlh->nlmsg_seq,
2000                                    nlh->nlmsg_flags);
2001                 goto out;
2002         case DCB_CMD_GNUMTCS:
2003                 ret = dcbnl_getnumtcs(netdev, tb, pid, nlh->nlmsg_seq,
2004                                       nlh->nlmsg_flags);
2005                 goto out;
2006         case DCB_CMD_SNUMTCS:
2007                 ret = dcbnl_setnumtcs(netdev, tb, pid, nlh->nlmsg_seq,
2008                                       nlh->nlmsg_flags);
2009                 goto out;
2010         case DCB_CMD_PFC_GSTATE:
2011                 ret = dcbnl_getpfcstate(netdev, tb, pid, nlh->nlmsg_seq,
2012                                         nlh->nlmsg_flags);
2013                 goto out;
2014         case DCB_CMD_PFC_SSTATE:
2015                 ret = dcbnl_setpfcstate(netdev, tb, pid, nlh->nlmsg_seq,
2016                                         nlh->nlmsg_flags);
2017                 goto out;
2018         case DCB_CMD_BCN_SCFG:
2019                 ret = dcbnl_bcn_setcfg(netdev, tb, pid, nlh->nlmsg_seq,
2020                                        nlh->nlmsg_flags);
2021                 goto out;
2022         case DCB_CMD_GAPP:
2023                 ret = dcbnl_getapp(netdev, tb, pid, nlh->nlmsg_seq,
2024                                    nlh->nlmsg_flags);
2025                 goto out;
2026         case DCB_CMD_SAPP:
2027                 ret = dcbnl_setapp(netdev, tb, pid, nlh->nlmsg_seq,
2028                                    nlh->nlmsg_flags);
2029                 goto out;
2030         case DCB_CMD_IEEE_SET:
2031                 ret = dcbnl_ieee_set(netdev, tb, pid, nlh->nlmsg_seq,
2032                                      nlh->nlmsg_flags);
2033                 goto out;
2034         case DCB_CMD_IEEE_GET:
2035                 ret = dcbnl_ieee_get(netdev, tb, pid, nlh->nlmsg_seq,
2036                                      nlh->nlmsg_flags);
2037                 goto out;
2038         case DCB_CMD_IEEE_DEL:
2039                 ret = dcbnl_ieee_del(netdev, tb, pid, nlh->nlmsg_seq,
2040                                      nlh->nlmsg_flags);
2041                 goto out;
2042         case DCB_CMD_GDCBX:
2043                 ret = dcbnl_getdcbx(netdev, tb, pid, nlh->nlmsg_seq,
2044                                     nlh->nlmsg_flags);
2045                 goto out;
2046         case DCB_CMD_SDCBX:
2047                 ret = dcbnl_setdcbx(netdev, tb, pid, nlh->nlmsg_seq,
2048                                     nlh->nlmsg_flags);
2049                 goto out;
2050         case DCB_CMD_GFEATCFG:
2051                 ret = dcbnl_getfeatcfg(netdev, tb, pid, nlh->nlmsg_seq,
2052                                        nlh->nlmsg_flags);
2053                 goto out;
2054         case DCB_CMD_SFEATCFG:
2055                 ret = dcbnl_setfeatcfg(netdev, tb, pid, nlh->nlmsg_seq,
2056                                        nlh->nlmsg_flags);
2057                 goto out;
2058         case DCB_CMD_CEE_GET:
2059                 ret = dcbnl_cee_get(netdev, tb, pid, nlh->nlmsg_seq,
2060                                     nlh->nlmsg_flags);
2061                 goto out;
2062         default:
2063                 goto errout;
2064         }
2065 errout:
2066         ret = -EINVAL;
2067 out:
2068         dev_put(netdev);
2069         return ret;
2070 }
2071
2072 /**
2073  * dcb_getapp - retrieve the DCBX application user priority
2074  *
2075  * On success returns a non-zero 802.1p user priority bitmap
2076  * otherwise returns 0 as the invalid user priority bitmap to
2077  * indicate an error.
2078  */
2079 u8 dcb_getapp(struct net_device *dev, struct dcb_app *app)
2080 {
2081         struct dcb_app_type *itr;
2082         u8 prio = 0;
2083
2084         spin_lock(&dcb_lock);
2085         list_for_each_entry(itr, &dcb_app_list, list) {
2086                 if (itr->app.selector == app->selector &&
2087                     itr->app.protocol == app->protocol &&
2088                     itr->ifindex == dev->ifindex) {
2089                         prio = itr->app.priority;
2090                         break;
2091                 }
2092         }
2093         spin_unlock(&dcb_lock);
2094
2095         return prio;
2096 }
2097 EXPORT_SYMBOL(dcb_getapp);
2098
2099 /**
2100  * dcb_setapp - add CEE dcb application data to app list
2101  *
2102  * Priority 0 is an invalid priority in CEE spec. This routine
2103  * removes applications from the app list if the priority is
2104  * set to zero.
2105  */
2106 int dcb_setapp(struct net_device *dev, struct dcb_app *new)
2107 {
2108         struct dcb_app_type *itr;
2109         struct dcb_app_type event;
2110
2111         event.ifindex = dev->ifindex;
2112         memcpy(&event.app, new, sizeof(event.app));
2113         if (dev->dcbnl_ops->getdcbx)
2114                 event.dcbx = dev->dcbnl_ops->getdcbx(dev);
2115
2116         spin_lock(&dcb_lock);
2117         /* Search for existing match and replace */
2118         list_for_each_entry(itr, &dcb_app_list, list) {
2119                 if (itr->app.selector == new->selector &&
2120                     itr->app.protocol == new->protocol &&
2121                     itr->ifindex == dev->ifindex) {
2122                         if (new->priority)
2123                                 itr->app.priority = new->priority;
2124                         else {
2125                                 list_del(&itr->list);
2126                                 kfree(itr);
2127                         }
2128                         goto out;
2129                 }
2130         }
2131         /* App type does not exist add new application type */
2132         if (new->priority) {
2133                 struct dcb_app_type *entry;
2134                 entry = kmalloc(sizeof(struct dcb_app_type), GFP_ATOMIC);
2135                 if (!entry) {
2136                         spin_unlock(&dcb_lock);
2137                         return -ENOMEM;
2138                 }
2139
2140                 memcpy(&entry->app, new, sizeof(*new));
2141                 entry->ifindex = dev->ifindex;
2142                 list_add(&entry->list, &dcb_app_list);
2143         }
2144 out:
2145         spin_unlock(&dcb_lock);
2146         call_dcbevent_notifiers(DCB_APP_EVENT, &event);
2147         return 0;
2148 }
2149 EXPORT_SYMBOL(dcb_setapp);
2150
2151 /**
2152  * dcb_ieee_getapp_mask - retrieve the IEEE DCB application priority
2153  *
2154  * Helper routine which on success returns a non-zero 802.1Qaz user
2155  * priority bitmap otherwise returns 0 to indicate the dcb_app was
2156  * not found in APP list.
2157  */
2158 u8 dcb_ieee_getapp_mask(struct net_device *dev, struct dcb_app *app)
2159 {
2160         struct dcb_app_type *itr;
2161         u8 prio = 0;
2162
2163         spin_lock(&dcb_lock);
2164         list_for_each_entry(itr, &dcb_app_list, list) {
2165                 if (itr->app.selector == app->selector &&
2166                     itr->app.protocol == app->protocol &&
2167                     itr->ifindex == dev->ifindex) {
2168                         prio |= 1 << itr->app.priority;
2169                 }
2170         }
2171         spin_unlock(&dcb_lock);
2172
2173         return prio;
2174 }
2175 EXPORT_SYMBOL(dcb_ieee_getapp_mask);
2176
2177 /**
2178  * dcb_ieee_setapp - add IEEE dcb application data to app list
2179  *
2180  * This adds Application data to the list. Multiple application
2181  * entries may exists for the same selector and protocol as long
2182  * as the priorities are different.
2183  */
2184 int dcb_ieee_setapp(struct net_device *dev, struct dcb_app *new)
2185 {
2186         struct dcb_app_type *itr, *entry;
2187         struct dcb_app_type event;
2188         int err = 0;
2189
2190         event.ifindex = dev->ifindex;
2191         memcpy(&event.app, new, sizeof(event.app));
2192         if (dev->dcbnl_ops->getdcbx)
2193                 event.dcbx = dev->dcbnl_ops->getdcbx(dev);
2194
2195         spin_lock(&dcb_lock);
2196         /* Search for existing match and abort if found */
2197         list_for_each_entry(itr, &dcb_app_list, list) {
2198                 if (itr->app.selector == new->selector &&
2199                     itr->app.protocol == new->protocol &&
2200                     itr->app.priority == new->priority &&
2201                     itr->ifindex == dev->ifindex) {
2202                         err = -EEXIST;
2203                         goto out;
2204                 }
2205         }
2206
2207         /* App entry does not exist add new entry */
2208         entry = kmalloc(sizeof(struct dcb_app_type), GFP_ATOMIC);
2209         if (!entry) {
2210                 err = -ENOMEM;
2211                 goto out;
2212         }
2213
2214         memcpy(&entry->app, new, sizeof(*new));
2215         entry->ifindex = dev->ifindex;
2216         list_add(&entry->list, &dcb_app_list);
2217 out:
2218         spin_unlock(&dcb_lock);
2219         if (!err)
2220                 call_dcbevent_notifiers(DCB_APP_EVENT, &event);
2221         return err;
2222 }
2223 EXPORT_SYMBOL(dcb_ieee_setapp);
2224
2225 /**
2226  * dcb_ieee_delapp - delete IEEE dcb application data from list
2227  *
2228  * This removes a matching APP data from the APP list
2229  */
2230 int dcb_ieee_delapp(struct net_device *dev, struct dcb_app *del)
2231 {
2232         struct dcb_app_type *itr;
2233         struct dcb_app_type event;
2234         int err = -ENOENT;
2235
2236         event.ifindex = dev->ifindex;
2237         memcpy(&event.app, del, sizeof(event.app));
2238         if (dev->dcbnl_ops->getdcbx)
2239                 event.dcbx = dev->dcbnl_ops->getdcbx(dev);
2240
2241         spin_lock(&dcb_lock);
2242         /* Search for existing match and remove it. */
2243         list_for_each_entry(itr, &dcb_app_list, list) {
2244                 if (itr->app.selector == del->selector &&
2245                     itr->app.protocol == del->protocol &&
2246                     itr->app.priority == del->priority &&
2247                     itr->ifindex == dev->ifindex) {
2248                         list_del(&itr->list);
2249                         kfree(itr);
2250                         err = 0;
2251                         goto out;
2252                 }
2253         }
2254
2255 out:
2256         spin_unlock(&dcb_lock);
2257         if (!err)
2258                 call_dcbevent_notifiers(DCB_APP_EVENT, &event);
2259         return err;
2260 }
2261 EXPORT_SYMBOL(dcb_ieee_delapp);
2262
2263 static void dcb_flushapp(void)
2264 {
2265         struct dcb_app_type *app;
2266         struct dcb_app_type *tmp;
2267
2268         spin_lock(&dcb_lock);
2269         list_for_each_entry_safe(app, tmp, &dcb_app_list, list) {
2270                 list_del(&app->list);
2271                 kfree(app);
2272         }
2273         spin_unlock(&dcb_lock);
2274 }
2275
2276 static int __init dcbnl_init(void)
2277 {
2278         INIT_LIST_HEAD(&dcb_app_list);
2279
2280         rtnl_register(PF_UNSPEC, RTM_GETDCB, dcb_doit, NULL, NULL);
2281         rtnl_register(PF_UNSPEC, RTM_SETDCB, dcb_doit, NULL, NULL);
2282
2283         return 0;
2284 }
2285 module_init(dcbnl_init);
2286
2287 static void __exit dcbnl_exit(void)
2288 {
2289         rtnl_unregister(PF_UNSPEC, RTM_GETDCB);
2290         rtnl_unregister(PF_UNSPEC, RTM_SETDCB);
2291         dcb_flushapp();
2292 }
2293 module_exit(dcbnl_exit);