net/dcb/dcbnl.c

   1 /*
   2  * Copyright (c) 2008, 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 <linux/rtnetlink.h>
  27 #include <net/sock.h>
  28
  29 /**
  30  * Data Center Bridging (DCB) is a collection of Ethernet enhancements
  31  * intended to allow network traffic with differing requirements
  32  * (highly reliable, no drops vs. best effort vs. low latency) to operate
  33  * and co-exist on Ethernet.  Current DCB features are:
  34  *
  35  * Enhanced Transmission Selection (aka Priority Grouping [PG]) - provides a
  36  *   framework for assigning bandwidth guarantees to traffic classes.
  37  *
  38  * Priority-based Flow Control (PFC) - provides a flow control mechanism which
  39  *   can work independently for each 802.1p priority.
  40  *
  41  * Congestion Notification - provides a mechanism for end-to-end congestion
  42  *   control for protocols which do not have built-in congestion management.
  43  *
  44  * More information about the emerging standards for these Ethernet features
  45  * can be found at: http://www.ieee802.org/1/pages/dcbridges.html
  46  *
  47  * This file implements an rtnetlink interface to allow configuration of DCB
  48  * features for capable devices.
  49  */
  50
  51 MODULE_AUTHOR("Lucy Liu, <lucy.liu@intel.com>");
  52 MODULE_DESCRIPTION("Data Center Bridging netlink interface");
  53 MODULE_LICENSE("GPL");
  54
  55 /**************** DCB attribute policies *************************************/
  56
  57 /* DCB netlink attributes policy */
  58 static const struct nla_policy dcbnl_rtnl_policy[DCB_ATTR_MAX + 1] = {
  59         [DCB_ATTR_IFNAME]      = {.type = NLA_NUL_STRING, .len = IFNAMSIZ - 1},
  60         [DCB_ATTR_STATE]       = {.type = NLA_U8},
  61         [DCB_ATTR_PFC_CFG]     = {.type = NLA_NESTED},
  62         [DCB_ATTR_PG_CFG]      = {.type = NLA_NESTED},
  63         [DCB_ATTR_SET_ALL]     = {.type = NLA_U8},
  64         [DCB_ATTR_PERM_HWADDR] = {.type = NLA_FLAG},
  65         [DCB_ATTR_CAP]         = {.type = NLA_NESTED},
  66         [DCB_ATTR_PFC_STATE]   = {.type = NLA_U8},
  67         [DCB_ATTR_BCN]         = {.type = NLA_NESTED},
  68         [DCB_ATTR_APP]         = {.type = NLA_NESTED},
  69 };
  70
  71 /* DCB priority flow control to User Priority nested attributes */
  72 static const struct nla_policy dcbnl_pfc_up_nest[DCB_PFC_UP_ATTR_MAX + 1] = {
  73         [DCB_PFC_UP_ATTR_0]   = {.type = NLA_U8},
  74         [DCB_PFC_UP_ATTR_1]   = {.type = NLA_U8},
  75         [DCB_PFC_UP_ATTR_2]   = {.type = NLA_U8},
  76         [DCB_PFC_UP_ATTR_3]   = {.type = NLA_U8},
  77         [DCB_PFC_UP_ATTR_4]   = {.type = NLA_U8},
  78         [DCB_PFC_UP_ATTR_5]   = {.type = NLA_U8},
  79         [DCB_PFC_UP_ATTR_6]   = {.type = NLA_U8},
  80         [DCB_PFC_UP_ATTR_7]   = {.type = NLA_U8},
  81         [DCB_PFC_UP_ATTR_ALL] = {.type = NLA_FLAG},
  82 };
  83
  84 /* DCB priority grouping nested attributes */
  85 static const struct nla_policy dcbnl_pg_nest[DCB_PG_ATTR_MAX + 1] = {
  86         [DCB_PG_ATTR_TC_0]      = {.type = NLA_NESTED},
  87         [DCB_PG_ATTR_TC_1]      = {.type = NLA_NESTED},
  88         [DCB_PG_ATTR_TC_2]      = {.type = NLA_NESTED},
  89         [DCB_PG_ATTR_TC_3]      = {.type = NLA_NESTED},
  90         [DCB_PG_ATTR_TC_4]      = {.type = NLA_NESTED},
  91         [DCB_PG_ATTR_TC_5]      = {.type = NLA_NESTED},
  92         [DCB_PG_ATTR_TC_6]      = {.type = NLA_NESTED},
  93         [DCB_PG_ATTR_TC_7]      = {.type = NLA_NESTED},
  94         [DCB_PG_ATTR_TC_ALL]    = {.type = NLA_NESTED},
  95         [DCB_PG_ATTR_BW_ID_0]   = {.type = NLA_U8},
  96         [DCB_PG_ATTR_BW_ID_1]   = {.type = NLA_U8},
  97         [DCB_PG_ATTR_BW_ID_2]   = {.type = NLA_U8},
  98         [DCB_PG_ATTR_BW_ID_3]   = {.type = NLA_U8},
  99         [DCB_PG_ATTR_BW_ID_4]   = {.type = NLA_U8},
 100         [DCB_PG_ATTR_BW_ID_5]   = {.type = NLA_U8},
 101         [DCB_PG_ATTR_BW_ID_6]   = {.type = NLA_U8},
 102         [DCB_PG_ATTR_BW_ID_7]   = {.type = NLA_U8},
 103         [DCB_PG_ATTR_BW_ID_ALL] = {.type = NLA_FLAG},
 104 };
 105
 106 /* DCB traffic class nested attributes. */
 107 static const struct nla_policy dcbnl_tc_param_nest[DCB_TC_ATTR_PARAM_MAX + 1] = {
 108         [DCB_TC_ATTR_PARAM_PGID]            = {.type = NLA_U8},
 109         [DCB_TC_ATTR_PARAM_UP_MAPPING]      = {.type = NLA_U8},
 110         [DCB_TC_ATTR_PARAM_STRICT_PRIO]     = {.type = NLA_U8},
 111         [DCB_TC_ATTR_PARAM_BW_PCT]          = {.type = NLA_U8},
 112         [DCB_TC_ATTR_PARAM_ALL]             = {.type = NLA_FLAG},
 113 };
 114
 115 /* DCB capabilities nested attributes. */
 116 static const struct nla_policy dcbnl_cap_nest[DCB_CAP_ATTR_MAX + 1] = {
 117         [DCB_CAP_ATTR_ALL]     = {.type = NLA_FLAG},
 118         [DCB_CAP_ATTR_PG]      = {.type = NLA_U8},
 119         [DCB_CAP_ATTR_PFC]     = {.type = NLA_U8},
 120         [DCB_CAP_ATTR_UP2TC]   = {.type = NLA_U8},
 121         [DCB_CAP_ATTR_PG_TCS]  = {.type = NLA_U8},
 122         [DCB_CAP_ATTR_PFC_TCS] = {.type = NLA_U8},
 123         [DCB_CAP_ATTR_GSP]     = {.type = NLA_U8},
 124         [DCB_CAP_ATTR_BCN]     = {.type = NLA_U8},
 125 };
 126
 127 /* DCB capabilities nested attributes. */
 128 static const struct nla_policy dcbnl_numtcs_nest[DCB_NUMTCS_ATTR_MAX + 1] = {
 129         [DCB_NUMTCS_ATTR_ALL]     = {.type = NLA_FLAG},
 130         [DCB_NUMTCS_ATTR_PG]      = {.type = NLA_U8},
 131         [DCB_NUMTCS_ATTR_PFC]     = {.type = NLA_U8},
 132 };
 133
 134 /* DCB BCN nested attributes. */
 135 static const struct nla_policy dcbnl_bcn_nest[DCB_BCN_ATTR_MAX + 1] = {
 136         [DCB_BCN_ATTR_RP_0]         = {.type = NLA_U8},
 137         [DCB_BCN_ATTR_RP_1]         = {.type = NLA_U8},
 138         [DCB_BCN_ATTR_RP_2]         = {.type = NLA_U8},
 139         [DCB_BCN_ATTR_RP_3]         = {.type = NLA_U8},
 140         [DCB_BCN_ATTR_RP_4]         = {.type = NLA_U8},
 141         [DCB_BCN_ATTR_RP_5]         = {.type = NLA_U8},
 142         [DCB_BCN_ATTR_RP_6]         = {.type = NLA_U8},
 143         [DCB_BCN_ATTR_RP_7]         = {.type = NLA_U8},
 144         [DCB_BCN_ATTR_RP_ALL]       = {.type = NLA_FLAG},
 145         [DCB_BCN_ATTR_BCNA_0]       = {.type = NLA_U32},
 146         [DCB_BCN_ATTR_BCNA_1]       = {.type = NLA_U32},
 147         [DCB_BCN_ATTR_ALPHA]        = {.type = NLA_U32},
 148         [DCB_BCN_ATTR_BETA]         = {.type = NLA_U32},
 149         [DCB_BCN_ATTR_GD]           = {.type = NLA_U32},
 150         [DCB_BCN_ATTR_GI]           = {.type = NLA_U32},
 151         [DCB_BCN_ATTR_TMAX]         = {.type = NLA_U32},
 152         [DCB_BCN_ATTR_TD]           = {.type = NLA_U32},
 153         [DCB_BCN_ATTR_RMIN]         = {.type = NLA_U32},
 154         [DCB_BCN_ATTR_W]            = {.type = NLA_U32},
 155         [DCB_BCN_ATTR_RD]           = {.type = NLA_U32},
 156         [DCB_BCN_ATTR_RU]           = {.type = NLA_U32},
 157         [DCB_BCN_ATTR_WRTT]         = {.type = NLA_U32},
 158         [DCB_BCN_ATTR_RI]           = {.type = NLA_U32},
 159         [DCB_BCN_ATTR_C]            = {.type = NLA_U32},
 160         [DCB_BCN_ATTR_ALL]          = {.type = NLA_FLAG},
 161 };
 162
 163 /* DCB APP nested attributes. */
 164 static const struct nla_policy dcbnl_app_nest[DCB_APP_ATTR_MAX + 1] = {
 165         [DCB_APP_ATTR_IDTYPE]       = {.type = NLA_U8},
 166         [DCB_APP_ATTR_ID]           = {.type = NLA_U16},
 167         [DCB_APP_ATTR_PRIORITY]     = {.type = NLA_U8},
 168 };
 169
 170 /* standard netlink reply call */
 171 static int dcbnl_reply(u8 value, u8 event, u8 cmd, u8 attr, u32 pid,
 172                        u32 seq, u16 flags)
 173 {
 174         struct sk_buff *dcbnl_skb;
 175         struct dcbmsg *dcb;
 176         struct nlmsghdr *nlh;
 177         int ret = -EINVAL;
 178
 179         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 180         if (!dcbnl_skb)
 181                 return ret;
 182
 183         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, event, sizeof(*dcb), flags);
 184
 185         dcb = NLMSG_DATA(nlh);
 186         dcb->dcb_family = AF_UNSPEC;
 187         dcb->cmd = cmd;
 188         dcb->dcb_pad = 0;
 189
 190         ret = nla_put_u8(dcbnl_skb, attr, value);
 191         if (ret)
 192                 goto err;
 193
 194         /* end the message, assign the nlmsg_len. */
 195         nlmsg_end(dcbnl_skb, nlh);
 196         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 197         if (ret)
 198                 return -EINVAL;
 199
 200         return 0;
 201 nlmsg_failure:
 202 err:
 203         kfree_skb(dcbnl_skb);
 204         return ret;
 205 }
 206
 207 static int dcbnl_getstate(struct net_device *netdev, struct nlattr **tb,
 208                           u32 pid, u32 seq, u16 flags)
 209 {
 210         int ret = -EINVAL;
 211
 212         /* if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->getstate) */
 213         if (!netdev->dcbnl_ops->getstate)
 214                 return ret;
 215
 216         ret = dcbnl_reply(netdev->dcbnl_ops->getstate(netdev), RTM_GETDCB,
 217                           DCB_CMD_GSTATE, DCB_ATTR_STATE, pid, seq, flags);
 218
 219         return ret;
 220 }
 221
 222 static int dcbnl_getpfccfg(struct net_device *netdev, struct nlattr **tb,
 223                            u32 pid, u32 seq, u16 flags)
 224 {
 225         struct sk_buff *dcbnl_skb;
 226         struct nlmsghdr *nlh;
 227         struct dcbmsg *dcb;
 228         struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1], *nest;
 229         u8 value;
 230         int ret = -EINVAL;
 231         int i;
 232         int getall = 0;
 233
 234         if (!tb[DCB_ATTR_PFC_CFG] || !netdev->dcbnl_ops->getpfccfg)
 235                 return ret;
 236
 237         ret = nla_parse_nested(data, DCB_PFC_UP_ATTR_MAX,
 238                                tb[DCB_ATTR_PFC_CFG],
 239                                dcbnl_pfc_up_nest);
 240         if (ret)
 241                 goto err_out;
 242
 243         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 244         if (!dcbnl_skb)
 245                 goto err_out;
 246
 247         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 248
 249         dcb = NLMSG_DATA(nlh);
 250         dcb->dcb_family = AF_UNSPEC;
 251         dcb->cmd = DCB_CMD_PFC_GCFG;
 252
 253         nest = nla_nest_start(dcbnl_skb, DCB_ATTR_PFC_CFG);
 254         if (!nest)
 255                 goto err;
 256
 257         if (data[DCB_PFC_UP_ATTR_ALL])
 258                 getall = 1;
 259
 260         for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) {
 261                 if (!getall && !data[i])
 262                         continue;
 263
 264                 netdev->dcbnl_ops->getpfccfg(netdev, i - DCB_PFC_UP_ATTR_0,
 265                                              &value);
 266                 ret = nla_put_u8(dcbnl_skb, i, value);
 267
 268                 if (ret) {
 269                         nla_nest_cancel(dcbnl_skb, nest);
 270                         goto err;
 271                 }
 272         }
 273         nla_nest_end(dcbnl_skb, nest);
 274
 275         nlmsg_end(dcbnl_skb, nlh);
 276
 277         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 278         if (ret)
 279                 goto err_out;
 280
 281         return 0;
 282 nlmsg_failure:
 283 err:
 284         kfree_skb(dcbnl_skb);
 285 err_out:
 286         return -EINVAL;
 287 }
 288
 289 static int dcbnl_getperm_hwaddr(struct net_device *netdev, struct nlattr **tb,
 290                                 u32 pid, u32 seq, u16 flags)
 291 {
 292         struct sk_buff *dcbnl_skb;
 293         struct nlmsghdr *nlh;
 294         struct dcbmsg *dcb;
 295         u8 perm_addr[MAX_ADDR_LEN];
 296         int ret = -EINVAL;
 297
 298         if (!netdev->dcbnl_ops->getpermhwaddr)
 299                 return ret;
 300
 301         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 302         if (!dcbnl_skb)
 303                 goto err_out;
 304
 305         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 306
 307         dcb = NLMSG_DATA(nlh);
 308         dcb->dcb_family = AF_UNSPEC;
 309         dcb->cmd = DCB_CMD_GPERM_HWADDR;
 310
 311         netdev->dcbnl_ops->getpermhwaddr(netdev, perm_addr);
 312
 313         ret = nla_put(dcbnl_skb, DCB_ATTR_PERM_HWADDR, sizeof(perm_addr),
 314                       perm_addr);
 315
 316         nlmsg_end(dcbnl_skb, nlh);
 317
 318         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 319         if (ret)
 320                 goto err_out;
 321
 322         return 0;
 323
 324 nlmsg_failure:
 325         kfree_skb(dcbnl_skb);
 326 err_out:
 327         return -EINVAL;
 328 }
 329
 330 static int dcbnl_getcap(struct net_device *netdev, struct nlattr **tb,
 331                         u32 pid, u32 seq, u16 flags)
 332 {
 333         struct sk_buff *dcbnl_skb;
 334         struct nlmsghdr *nlh;
 335         struct dcbmsg *dcb;
 336         struct nlattr *data[DCB_CAP_ATTR_MAX + 1], *nest;
 337         u8 value;
 338         int ret = -EINVAL;
 339         int i;
 340         int getall = 0;
 341
 342         if (!tb[DCB_ATTR_CAP] || !netdev->dcbnl_ops->getcap)
 343                 return ret;
 344
 345         ret = nla_parse_nested(data, DCB_CAP_ATTR_MAX, tb[DCB_ATTR_CAP],
 346                                dcbnl_cap_nest);
 347         if (ret)
 348                 goto err_out;
 349
 350         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 351         if (!dcbnl_skb)
 352                 goto err_out;
 353
 354         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 355
 356         dcb = NLMSG_DATA(nlh);
 357         dcb->dcb_family = AF_UNSPEC;
 358         dcb->cmd = DCB_CMD_GCAP;
 359
 360         nest = nla_nest_start(dcbnl_skb, DCB_ATTR_CAP);
 361         if (!nest)
 362                 goto err;
 363
 364         if (data[DCB_CAP_ATTR_ALL])
 365                 getall = 1;
 366
 367         for (i = DCB_CAP_ATTR_ALL+1; i <= DCB_CAP_ATTR_MAX; i++) {
 368                 if (!getall && !data[i])
 369                         continue;
 370
 371                 if (!netdev->dcbnl_ops->getcap(netdev, i, &value)) {
 372                         ret = nla_put_u8(dcbnl_skb, i, value);
 373
 374                         if (ret) {
 375                                 nla_nest_cancel(dcbnl_skb, nest);
 376                                 goto err;
 377                         }
 378                 }
 379         }
 380         nla_nest_end(dcbnl_skb, nest);
 381
 382         nlmsg_end(dcbnl_skb, nlh);
 383
 384         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 385         if (ret)
 386                 goto err_out;
 387
 388         return 0;
 389 nlmsg_failure:
 390 err:
 391         kfree_skb(dcbnl_skb);
 392 err_out:
 393         return -EINVAL;
 394 }
 395
 396 static int dcbnl_getnumtcs(struct net_device *netdev, struct nlattr **tb,
 397                            u32 pid, u32 seq, u16 flags)
 398 {
 399         struct sk_buff *dcbnl_skb;
 400         struct nlmsghdr *nlh;
 401         struct dcbmsg *dcb;
 402         struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1], *nest;
 403         u8 value;
 404         int ret = -EINVAL;
 405         int i;
 406         int getall = 0;
 407
 408         if (!tb[DCB_ATTR_NUMTCS] || !netdev->dcbnl_ops->getnumtcs)
 409                 return ret;
 410
 411         ret = nla_parse_nested(data, DCB_NUMTCS_ATTR_MAX, tb[DCB_ATTR_NUMTCS],
 412                                dcbnl_numtcs_nest);
 413         if (ret) {
 414                 ret = -EINVAL;
 415                 goto err_out;
 416         }
 417
 418         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 419         if (!dcbnl_skb) {
 420                 ret = -EINVAL;
 421                 goto err_out;
 422         }
 423
 424         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 425
 426         dcb = NLMSG_DATA(nlh);
 427         dcb->dcb_family = AF_UNSPEC;
 428         dcb->cmd = DCB_CMD_GNUMTCS;
 429
 430         nest = nla_nest_start(dcbnl_skb, DCB_ATTR_NUMTCS);
 431         if (!nest) {
 432                 ret = -EINVAL;
 433                 goto err;
 434         }
 435
 436         if (data[DCB_NUMTCS_ATTR_ALL])
 437                 getall = 1;
 438
 439         for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) {
 440                 if (!getall && !data[i])
 441                         continue;
 442
 443                 ret = netdev->dcbnl_ops->getnumtcs(netdev, i, &value);
 444                 if (!ret) {
 445                         ret = nla_put_u8(dcbnl_skb, i, value);
 446
 447                         if (ret) {
 448                                 nla_nest_cancel(dcbnl_skb, nest);
 449                                 ret = -EINVAL;
 450                                 goto err;
 451                         }
 452                 } else {
 453                         goto err;
 454                 }
 455         }
 456         nla_nest_end(dcbnl_skb, nest);
 457
 458         nlmsg_end(dcbnl_skb, nlh);
 459
 460         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 461         if (ret) {
 462                 ret = -EINVAL;
 463                 goto err_out;
 464         }
 465
 466         return 0;
 467 nlmsg_failure:
 468 err:
 469         kfree_skb(dcbnl_skb);
 470 err_out:
 471         return ret;
 472 }
 473
 474 static int dcbnl_setnumtcs(struct net_device *netdev, struct nlattr **tb,
 475                            u32 pid, u32 seq, u16 flags)
 476 {
 477         struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1];
 478         int ret = -EINVAL;
 479         u8 value;
 480         int i;
 481
 482         if (!tb[DCB_ATTR_NUMTCS] || !netdev->dcbnl_ops->setnumtcs)
 483                 return ret;
 484
 485         ret = nla_parse_nested(data, DCB_NUMTCS_ATTR_MAX, tb[DCB_ATTR_NUMTCS],
 486                                dcbnl_numtcs_nest);
 487
 488         if (ret) {
 489                 ret = -EINVAL;
 490                 goto err;
 491         }
 492
 493         for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) {
 494                 if (data[i] == NULL)
 495                         continue;
 496
 497                 value = nla_get_u8(data[i]);
 498
 499                 ret = netdev->dcbnl_ops->setnumtcs(netdev, i, value);
 500
 501                 if (ret)
 502                         goto operr;
 503         }
 504
 505 operr:
 506         ret = dcbnl_reply(!!ret, RTM_SETDCB, DCB_CMD_SNUMTCS,
 507                           DCB_ATTR_NUMTCS, pid, seq, flags);
 508
 509 err:
 510         return ret;
 511 }
 512
 513 static int dcbnl_getpfcstate(struct net_device *netdev, struct nlattr **tb,
 514                              u32 pid, u32 seq, u16 flags)
 515 {
 516         int ret = -EINVAL;
 517
 518         if (!netdev->dcbnl_ops->getpfcstate)
 519                 return ret;
 520
 521         ret = dcbnl_reply(netdev->dcbnl_ops->getpfcstate(netdev), RTM_GETDCB,
 522                           DCB_CMD_PFC_GSTATE, DCB_ATTR_PFC_STATE,
 523                           pid, seq, flags);
 524
 525         return ret;
 526 }
 527
 528 static int dcbnl_setpfcstate(struct net_device *netdev, struct nlattr **tb,
 529                              u32 pid, u32 seq, u16 flags)
 530 {
 531         int ret = -EINVAL;
 532         u8 value;
 533
 534         if (!tb[DCB_ATTR_PFC_STATE] || !netdev->dcbnl_ops->setpfcstate)
 535                 return ret;
 536
 537         value = nla_get_u8(tb[DCB_ATTR_PFC_STATE]);
 538
 539         netdev->dcbnl_ops->setpfcstate(netdev, value);
 540
 541         ret = dcbnl_reply(0, RTM_SETDCB, DCB_CMD_PFC_SSTATE, DCB_ATTR_PFC_STATE,
 542                           pid, seq, flags);
 543
 544         return ret;
 545 }
 546
 547 static int dcbnl_getapp(struct net_device *netdev, struct nlattr **tb,
 548                         u32 pid, u32 seq, u16 flags)
 549 {
 550         struct sk_buff *dcbnl_skb;
 551         struct nlmsghdr *nlh;
 552         struct dcbmsg *dcb;
 553         struct nlattr *app_nest;
 554         struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1];
 555         u16 id;
 556         u8 up, idtype;
 557         int ret = -EINVAL;
 558
 559         if (!tb[DCB_ATTR_APP] || !netdev->dcbnl_ops->getapp)
 560                 goto out;
 561
 562         ret = nla_parse_nested(app_tb, DCB_APP_ATTR_MAX, tb[DCB_ATTR_APP],
 563                                dcbnl_app_nest);
 564         if (ret)
 565                 goto out;
 566
 567         ret = -EINVAL;
 568         /* all must be non-null */
 569         if ((!app_tb[DCB_APP_ATTR_IDTYPE]) ||
 570             (!app_tb[DCB_APP_ATTR_ID]))
 571                 goto out;
 572
 573         /* either by eth type or by socket number */
 574         idtype = nla_get_u8(app_tb[DCB_APP_ATTR_IDTYPE]);
 575         if ((idtype != DCB_APP_IDTYPE_ETHTYPE) &&
 576             (idtype != DCB_APP_IDTYPE_PORTNUM))
 577                 goto out;
 578
 579         id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]);
 580         up = netdev->dcbnl_ops->getapp(netdev, idtype, id);
 581
 582         /* send this back */
 583         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 584         if (!dcbnl_skb)
 585                 goto out;
 586
 587         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 588         dcb = NLMSG_DATA(nlh);
 589         dcb->dcb_family = AF_UNSPEC;
 590         dcb->cmd = DCB_CMD_GAPP;
 591
 592         app_nest = nla_nest_start(dcbnl_skb, DCB_ATTR_APP);
 593         ret = nla_put_u8(dcbnl_skb, DCB_APP_ATTR_IDTYPE, idtype);
 594         if (ret)
 595                 goto out_cancel;
 596
 597         ret = nla_put_u16(dcbnl_skb, DCB_APP_ATTR_ID, id);
 598         if (ret)
 599                 goto out_cancel;
 600
 601         ret = nla_put_u8(dcbnl_skb, DCB_APP_ATTR_PRIORITY, up);
 602         if (ret)
 603                 goto out_cancel;
 604
 605         nla_nest_end(dcbnl_skb, app_nest);
 606         nlmsg_end(dcbnl_skb, nlh);
 607
 608         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 609         if (ret)
 610                 goto nlmsg_failure;
 611
 612         goto out;
 613
 614 out_cancel:
 615         nla_nest_cancel(dcbnl_skb, app_nest);
 616 nlmsg_failure:
 617         kfree_skb(dcbnl_skb);
 618 out:
 619         return ret;
 620 }
 621
 622 static int dcbnl_setapp(struct net_device *netdev, struct nlattr **tb,
 623                         u32 pid, u32 seq, u16 flags)
 624 {
 625         int ret = -EINVAL;
 626         u16 id;
 627         u8 up, idtype;
 628         struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1];
 629
 630         if (!tb[DCB_ATTR_APP] || !netdev->dcbnl_ops->setapp)
 631                 goto out;
 632
 633         ret = nla_parse_nested(app_tb, DCB_APP_ATTR_MAX, tb[DCB_ATTR_APP],
 634                                dcbnl_app_nest);
 635         if (ret)
 636                 goto out;
 637
 638         ret = -EINVAL;
 639         /* all must be non-null */
 640         if ((!app_tb[DCB_APP_ATTR_IDTYPE]) ||
 641             (!app_tb[DCB_APP_ATTR_ID]) ||
 642             (!app_tb[DCB_APP_ATTR_PRIORITY]))
 643                 goto out;
 644
 645         /* either by eth type or by socket number */
 646         idtype = nla_get_u8(app_tb[DCB_APP_ATTR_IDTYPE]);
 647         if ((idtype != DCB_APP_IDTYPE_ETHTYPE) &&
 648             (idtype != DCB_APP_IDTYPE_PORTNUM))
 649                 goto out;
 650
 651         id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]);
 652         up = nla_get_u8(app_tb[DCB_APP_ATTR_PRIORITY]);
 653
 654         ret = dcbnl_reply(netdev->dcbnl_ops->setapp(netdev, idtype, id, up),
 655                           RTM_SETDCB, DCB_CMD_SAPP, DCB_ATTR_APP,
 656                           pid, seq, flags);
 657 out:
 658         return ret;
 659 }
 660
 661 static int __dcbnl_pg_getcfg(struct net_device *netdev, struct nlattr **tb,
 662                              u32 pid, u32 seq, u16 flags, int dir)
 663 {
 664         struct sk_buff *dcbnl_skb;
 665         struct nlmsghdr *nlh;
 666         struct dcbmsg *dcb;
 667         struct nlattr *pg_nest, *param_nest, *data;
 668         struct nlattr *pg_tb[DCB_PG_ATTR_MAX + 1];
 669         struct nlattr *param_tb[DCB_TC_ATTR_PARAM_MAX + 1];
 670         u8 prio, pgid, tc_pct, up_map;
 671         int ret  = -EINVAL;
 672         int getall = 0;
 673         int i;
 674
 675         if (!tb[DCB_ATTR_PG_CFG] ||
 676             !netdev->dcbnl_ops->getpgtccfgtx ||
 677             !netdev->dcbnl_ops->getpgtccfgrx ||
 678             !netdev->dcbnl_ops->getpgbwgcfgtx ||
 679             !netdev->dcbnl_ops->getpgbwgcfgrx)
 680                 return ret;
 681
 682         ret = nla_parse_nested(pg_tb, DCB_PG_ATTR_MAX,
 683                                tb[DCB_ATTR_PG_CFG], dcbnl_pg_nest);
 684
 685         if (ret)
 686                 goto err_out;
 687
 688         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 689         if (!dcbnl_skb)
 690                 goto err_out;
 691
 692         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
 693
 694         dcb = NLMSG_DATA(nlh);
 695         dcb->dcb_family = AF_UNSPEC;
 696         dcb->cmd = (dir) ? DCB_CMD_PGRX_GCFG : DCB_CMD_PGTX_GCFG;
 697
 698         pg_nest = nla_nest_start(dcbnl_skb, DCB_ATTR_PG_CFG);
 699         if (!pg_nest)
 700                 goto err;
 701
 702         if (pg_tb[DCB_PG_ATTR_TC_ALL])
 703                 getall = 1;
 704
 705         for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) {
 706                 if (!getall && !pg_tb[i])
 707                         continue;
 708
 709                 if (pg_tb[DCB_PG_ATTR_TC_ALL])
 710                         data = pg_tb[DCB_PG_ATTR_TC_ALL];
 711                 else
 712                         data = pg_tb[i];
 713                 ret = nla_parse_nested(param_tb, DCB_TC_ATTR_PARAM_MAX,
 714                                        data, dcbnl_tc_param_nest);
 715                 if (ret)
 716                         goto err_pg;
 717
 718                 param_nest = nla_nest_start(dcbnl_skb, i);
 719                 if (!param_nest)
 720                         goto err_pg;
 721
 722                 pgid = DCB_ATTR_VALUE_UNDEFINED;
 723                 prio = DCB_ATTR_VALUE_UNDEFINED;
 724                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
 725                 up_map = DCB_ATTR_VALUE_UNDEFINED;
 726
 727                 if (dir) {
 728                         /* Rx */
 729                         netdev->dcbnl_ops->getpgtccfgrx(netdev,
 730                                                 i - DCB_PG_ATTR_TC_0, &prio,
 731                                                 &pgid, &tc_pct, &up_map);
 732                 } else {
 733                         /* Tx */
 734                         netdev->dcbnl_ops->getpgtccfgtx(netdev,
 735                                                 i - DCB_PG_ATTR_TC_0, &prio,
 736                                                 &pgid, &tc_pct, &up_map);
 737                 }
 738
 739                 if (param_tb[DCB_TC_ATTR_PARAM_PGID] ||
 740                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 741                         ret = nla_put_u8(dcbnl_skb,
 742                                          DCB_TC_ATTR_PARAM_PGID, pgid);
 743                         if (ret)
 744                                 goto err_param;
 745                 }
 746                 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING] ||
 747                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 748                         ret = nla_put_u8(dcbnl_skb,
 749                                          DCB_TC_ATTR_PARAM_UP_MAPPING, up_map);
 750                         if (ret)
 751                                 goto err_param;
 752                 }
 753                 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO] ||
 754                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 755                         ret = nla_put_u8(dcbnl_skb,
 756                                          DCB_TC_ATTR_PARAM_STRICT_PRIO, prio);
 757                         if (ret)
 758                                 goto err_param;
 759                 }
 760                 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT] ||
 761                     param_tb[DCB_TC_ATTR_PARAM_ALL]) {
 762                         ret = nla_put_u8(dcbnl_skb, DCB_TC_ATTR_PARAM_BW_PCT,
 763                                          tc_pct);
 764                         if (ret)
 765                                 goto err_param;
 766                 }
 767                 nla_nest_end(dcbnl_skb, param_nest);
 768         }
 769
 770         if (pg_tb[DCB_PG_ATTR_BW_ID_ALL])
 771                 getall = 1;
 772         else
 773                 getall = 0;
 774
 775         for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
 776                 if (!getall && !pg_tb[i])
 777                         continue;
 778
 779                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
 780
 781                 if (dir) {
 782                         /* Rx */
 783                         netdev->dcbnl_ops->getpgbwgcfgrx(netdev,
 784                                         i - DCB_PG_ATTR_BW_ID_0, &tc_pct);
 785                 } else {
 786                         /* Tx */
 787                         netdev->dcbnl_ops->getpgbwgcfgtx(netdev,
 788                                         i - DCB_PG_ATTR_BW_ID_0, &tc_pct);
 789                 }
 790                 ret = nla_put_u8(dcbnl_skb, i, tc_pct);
 791
 792                 if (ret)
 793                         goto err_pg;
 794         }
 795
 796         nla_nest_end(dcbnl_skb, pg_nest);
 797
 798         nlmsg_end(dcbnl_skb, nlh);
 799
 800         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
 801         if (ret)
 802                 goto err_out;
 803
 804         return 0;
 805
 806 err_param:
 807         nla_nest_cancel(dcbnl_skb, param_nest);
 808 err_pg:
 809         nla_nest_cancel(dcbnl_skb, pg_nest);
 810 nlmsg_failure:
 811 err:
 812         kfree_skb(dcbnl_skb);
 813 err_out:
 814         ret  = -EINVAL;
 815         return ret;
 816 }
 817
 818 static int dcbnl_pgtx_getcfg(struct net_device *netdev, struct nlattr **tb,
 819                              u32 pid, u32 seq, u16 flags)
 820 {
 821         return __dcbnl_pg_getcfg(netdev, tb, pid, seq, flags, 0);
 822 }
 823
 824 static int dcbnl_pgrx_getcfg(struct net_device *netdev, struct nlattr **tb,
 825                              u32 pid, u32 seq, u16 flags)
 826 {
 827         return __dcbnl_pg_getcfg(netdev, tb, pid, seq, flags, 1);
 828 }
 829
 830 static int dcbnl_setstate(struct net_device *netdev, struct nlattr **tb,
 831                           u32 pid, u32 seq, u16 flags)
 832 {
 833         int ret = -EINVAL;
 834         u8 value;
 835
 836         if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->setstate)
 837                 return ret;
 838
 839         value = nla_get_u8(tb[DCB_ATTR_STATE]);
 840
 841         ret = dcbnl_reply(netdev->dcbnl_ops->setstate(netdev, value),
 842                           RTM_SETDCB, DCB_CMD_SSTATE, DCB_ATTR_STATE,
 843                           pid, seq, flags);
 844
 845         return ret;
 846 }
 847
 848 static int dcbnl_setpfccfg(struct net_device *netdev, struct nlattr **tb,
 849                            u32 pid, u32 seq, u16 flags)
 850 {
 851         struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1];
 852         int i;
 853         int ret = -EINVAL;
 854         u8 value;
 855
 856         if (!tb[DCB_ATTR_PFC_CFG] || !netdev->dcbnl_ops->setpfccfg)
 857                 return ret;
 858
 859         ret = nla_parse_nested(data, DCB_PFC_UP_ATTR_MAX,
 860                                tb[DCB_ATTR_PFC_CFG],
 861                                dcbnl_pfc_up_nest);
 862         if (ret)
 863                 goto err;
 864
 865         for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) {
 866                 if (data[i] == NULL)
 867                         continue;
 868                 value = nla_get_u8(data[i]);
 869                 netdev->dcbnl_ops->setpfccfg(netdev,
 870                         data[i]->nla_type - DCB_PFC_UP_ATTR_0, value);
 871         }
 872
 873         ret = dcbnl_reply(0, RTM_SETDCB, DCB_CMD_PFC_SCFG, DCB_ATTR_PFC_CFG,
 874                           pid, seq, flags);
 875 err:
 876         return ret;
 877 }
 878
 879 static int dcbnl_setall(struct net_device *netdev, struct nlattr **tb,
 880                         u32 pid, u32 seq, u16 flags)
 881 {
 882         int ret = -EINVAL;
 883
 884         if (!tb[DCB_ATTR_SET_ALL] || !netdev->dcbnl_ops->setall)
 885                 return ret;
 886
 887         ret = dcbnl_reply(netdev->dcbnl_ops->setall(netdev), RTM_SETDCB,
 888                           DCB_CMD_SET_ALL, DCB_ATTR_SET_ALL, pid, seq, flags);
 889
 890         return ret;
 891 }
 892
 893 static int __dcbnl_pg_setcfg(struct net_device *netdev, struct nlattr **tb,
 894                              u32 pid, u32 seq, u16 flags, int dir)
 895 {
 896         struct nlattr *pg_tb[DCB_PG_ATTR_MAX + 1];
 897         struct nlattr *param_tb[DCB_TC_ATTR_PARAM_MAX + 1];
 898         int ret = -EINVAL;
 899         int i;
 900         u8 pgid;
 901         u8 up_map;
 902         u8 prio;
 903         u8 tc_pct;
 904
 905         if (!tb[DCB_ATTR_PG_CFG] ||
 906             !netdev->dcbnl_ops->setpgtccfgtx ||
 907             !netdev->dcbnl_ops->setpgtccfgrx ||
 908             !netdev->dcbnl_ops->setpgbwgcfgtx ||
 909             !netdev->dcbnl_ops->setpgbwgcfgrx)
 910                 return ret;
 911
 912         ret = nla_parse_nested(pg_tb, DCB_PG_ATTR_MAX,
 913                                tb[DCB_ATTR_PG_CFG], dcbnl_pg_nest);
 914         if (ret)
 915                 goto err;
 916
 917         for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) {
 918                 if (!pg_tb[i])
 919                         continue;
 920
 921                 ret = nla_parse_nested(param_tb, DCB_TC_ATTR_PARAM_MAX,
 922                                        pg_tb[i], dcbnl_tc_param_nest);
 923                 if (ret)
 924                         goto err;
 925
 926                 pgid = DCB_ATTR_VALUE_UNDEFINED;
 927                 prio = DCB_ATTR_VALUE_UNDEFINED;
 928                 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
 929                 up_map = DCB_ATTR_VALUE_UNDEFINED;
 930
 931                 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO])
 932                         prio =
 933                             nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO]);
 934
 935                 if (param_tb[DCB_TC_ATTR_PARAM_PGID])
 936                         pgid = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_PGID]);
 937
 938                 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT])
 939                         tc_pct = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_BW_PCT]);
 940
 941                 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING])
 942                         up_map =
 943                              nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING]);
 944
 945                 /* dir: Tx = 0, Rx = 1 */
 946                 if (dir) {
 947                         /* Rx */
 948                         netdev->dcbnl_ops->setpgtccfgrx(netdev,
 949                                 i - DCB_PG_ATTR_TC_0,
 950                                 prio, pgid, tc_pct, up_map);
 951                 } else {
 952                         /* Tx */
 953                         netdev->dcbnl_ops->setpgtccfgtx(netdev,
 954                                 i - DCB_PG_ATTR_TC_0,
 955                                 prio, pgid, tc_pct, up_map);
 956                 }
 957         }
 958
 959         for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
 960                 if (!pg_tb[i])
 961                         continue;
 962
 963                 tc_pct = nla_get_u8(pg_tb[i]);
 964
 965                 /* dir: Tx = 0, Rx = 1 */
 966                 if (dir) {
 967                         /* Rx */
 968                         netdev->dcbnl_ops->setpgbwgcfgrx(netdev,
 969                                          i - DCB_PG_ATTR_BW_ID_0, tc_pct);
 970                 } else {
 971                         /* Tx */
 972                         netdev->dcbnl_ops->setpgbwgcfgtx(netdev,
 973                                          i - DCB_PG_ATTR_BW_ID_0, tc_pct);
 974                 }
 975         }
 976
 977         ret = dcbnl_reply(0, RTM_SETDCB,
 978                           (dir ? DCB_CMD_PGRX_SCFG : DCB_CMD_PGTX_SCFG),
 979                           DCB_ATTR_PG_CFG, pid, seq, flags);
 980
 981 err:
 982         return ret;
 983 }
 984
 985 static int dcbnl_pgtx_setcfg(struct net_device *netdev, struct nlattr **tb,
 986                              u32 pid, u32 seq, u16 flags)
 987 {
 988         return __dcbnl_pg_setcfg(netdev, tb, pid, seq, flags, 0);
 989 }
 990
 991 static int dcbnl_pgrx_setcfg(struct net_device *netdev, struct nlattr **tb,
 992                              u32 pid, u32 seq, u16 flags)
 993 {
 994         return __dcbnl_pg_setcfg(netdev, tb, pid, seq, flags, 1);
 995 }
 996
 997 static int dcbnl_bcn_getcfg(struct net_device *netdev, struct nlattr **tb,
 998                             u32 pid, u32 seq, u16 flags)
 999 {
1000         struct sk_buff *dcbnl_skb;
1001         struct nlmsghdr *nlh;
1002         struct dcbmsg *dcb;
1003         struct nlattr *bcn_nest;
1004         struct nlattr *bcn_tb[DCB_BCN_ATTR_MAX + 1];
1005         u8 value_byte;
1006         u32 value_integer;
1007         int ret  = -EINVAL;
1008         bool getall = false;
1009         int i;
1010
1011         if (!tb[DCB_ATTR_BCN] || !netdev->dcbnl_ops->getbcnrp ||
1012             !netdev->dcbnl_ops->getbcncfg)
1013                 return ret;
1014
1015         ret = nla_parse_nested(bcn_tb, DCB_BCN_ATTR_MAX,
1016                                tb[DCB_ATTR_BCN], dcbnl_bcn_nest);
1017
1018         if (ret)
1019                 goto err_out;
1020
1021         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1022         if (!dcbnl_skb)
1023                 goto err_out;
1024
1025         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, RTM_GETDCB, sizeof(*dcb), flags);
1026
1027         dcb = NLMSG_DATA(nlh);
1028         dcb->dcb_family = AF_UNSPEC;
1029         dcb->cmd = DCB_CMD_BCN_GCFG;
1030
1031         bcn_nest = nla_nest_start(dcbnl_skb, DCB_ATTR_BCN);
1032         if (!bcn_nest)
1033                 goto err;
1034
1035         if (bcn_tb[DCB_BCN_ATTR_ALL])
1036                 getall = true;
1037
1038         for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) {
1039                 if (!getall && !bcn_tb[i])
1040                         continue;
1041
1042                 netdev->dcbnl_ops->getbcnrp(netdev, i - DCB_BCN_ATTR_RP_0,
1043                                             &value_byte);
1044                 ret = nla_put_u8(dcbnl_skb, i, value_byte);
1045                 if (ret)
1046                         goto err_bcn;
1047         }
1048
1049         for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) {
1050                 if (!getall && !bcn_tb[i])
1051                         continue;
1052
1053                 netdev->dcbnl_ops->getbcncfg(netdev, i,
1054                                              &value_integer);
1055                 ret = nla_put_u32(dcbnl_skb, i, value_integer);
1056                 if (ret)
1057                         goto err_bcn;
1058         }
1059
1060         nla_nest_end(dcbnl_skb, bcn_nest);
1061
1062         nlmsg_end(dcbnl_skb, nlh);
1063
1064         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);
1065         if (ret)
1066                 goto err_out;
1067
1068         return 0;
1069
1070 err_bcn:
1071         nla_nest_cancel(dcbnl_skb, bcn_nest);
1072 nlmsg_failure:
1073 err:
1074         kfree_skb(dcbnl_skb);
1075 err_out:
1076         ret  = -EINVAL;
1077         return ret;
1078 }
1079
1080 static int dcbnl_bcn_setcfg(struct net_device *netdev, struct nlattr **tb,
1081                             u32 pid, u32 seq, u16 flags)
1082 {
1083         struct nlattr *data[DCB_BCN_ATTR_MAX + 1];
1084         int i;
1085         int ret = -EINVAL;
1086         u8 value_byte;
1087         u32 value_int;
1088
1089         if (!tb[DCB_ATTR_BCN] || !netdev->dcbnl_ops->setbcncfg ||
1090             !netdev->dcbnl_ops->setbcnrp)
1091                 return ret;
1092
1093         ret = nla_parse_nested(data, DCB_BCN_ATTR_MAX,
1094                                tb[DCB_ATTR_BCN],
1095                                dcbnl_pfc_up_nest);
1096         if (ret)
1097                 goto err;
1098
1099         for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) {
1100                 if (data[i] == NULL)
1101                         continue;
1102                 value_byte = nla_get_u8(data[i]);
1103                 netdev->dcbnl_ops->setbcnrp(netdev,
1104                         data[i]->nla_type - DCB_BCN_ATTR_RP_0, value_byte);
1105         }
1106
1107         for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) {
1108                 if (data[i] == NULL)
1109                         continue;
1110                 value_int = nla_get_u32(data[i]);
1111                 netdev->dcbnl_ops->setbcncfg(netdev,
1112                                              i, value_int);
1113         }
1114
1115         ret = dcbnl_reply(0, RTM_SETDCB, DCB_CMD_BCN_SCFG, DCB_ATTR_BCN,
1116                           pid, seq, flags);
1117 err:
1118         return ret;
1119 }
1120
1121 static int dcb_doit(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
1122 {
1123         struct net *net = sock_net(skb->sk);
1124         struct net_device *netdev;
1125         struct dcbmsg  *dcb = (struct dcbmsg *)NLMSG_DATA(nlh);
1126         struct nlattr *tb[DCB_ATTR_MAX + 1];
1127         u32 pid = skb ? NETLINK_CB(skb).pid : 0;
1128         int ret = -EINVAL;
1129
1130         if (!net_eq(net, &init_net))
1131                 return -EINVAL;
1132
1133         ret = nlmsg_parse(nlh, sizeof(*dcb), tb, DCB_ATTR_MAX,
1134                           dcbnl_rtnl_policy);
1135         if (ret < 0)
1136                 return ret;
1137
1138         if (!tb[DCB_ATTR_IFNAME])
1139                 return -EINVAL;
1140
1141         netdev = dev_get_by_name(&init_net, nla_data(tb[DCB_ATTR_IFNAME]));
1142         if (!netdev)
1143                 return -EINVAL;
1144
1145         if (!netdev->dcbnl_ops)
1146                 goto errout;
1147
1148         switch (dcb->cmd) {
1149         case DCB_CMD_GSTATE:
1150                 ret = dcbnl_getstate(netdev, tb, pid, nlh->nlmsg_seq,
1151                                      nlh->nlmsg_flags);
1152                 goto out;
1153         case DCB_CMD_PFC_GCFG:
1154                 ret = dcbnl_getpfccfg(netdev, tb, pid, nlh->nlmsg_seq,
1155                                       nlh->nlmsg_flags);
1156                 goto out;
1157         case DCB_CMD_GPERM_HWADDR:
1158                 ret = dcbnl_getperm_hwaddr(netdev, tb, pid, nlh->nlmsg_seq,
1159                                            nlh->nlmsg_flags);
1160                 goto out;
1161         case DCB_CMD_PGTX_GCFG:
1162                 ret = dcbnl_pgtx_getcfg(netdev, tb, pid, nlh->nlmsg_seq,
1163                                         nlh->nlmsg_flags);
1164                 goto out;
1165         case DCB_CMD_PGRX_GCFG:
1166                 ret = dcbnl_pgrx_getcfg(netdev, tb, pid, nlh->nlmsg_seq,
1167                                         nlh->nlmsg_flags);
1168                 goto out;
1169         case DCB_CMD_BCN_GCFG:
1170                 ret = dcbnl_bcn_getcfg(netdev, tb, pid, nlh->nlmsg_seq,
1171                                        nlh->nlmsg_flags);
1172                 goto out;
1173         case DCB_CMD_SSTATE:
1174                 ret = dcbnl_setstate(netdev, tb, pid, nlh->nlmsg_seq,
1175                                      nlh->nlmsg_flags);
1176                 goto out;
1177         case DCB_CMD_PFC_SCFG:
1178                 ret = dcbnl_setpfccfg(netdev, tb, pid, nlh->nlmsg_seq,
1179                                       nlh->nlmsg_flags);
1180                 goto out;
1181
1182         case DCB_CMD_SET_ALL:
1183                 ret = dcbnl_setall(netdev, tb, pid, nlh->nlmsg_seq,
1184                                    nlh->nlmsg_flags);
1185                 goto out;
1186         case DCB_CMD_PGTX_SCFG:
1187                 ret = dcbnl_pgtx_setcfg(netdev, tb, pid, nlh->nlmsg_seq,
1188                                         nlh->nlmsg_flags);
1189                 goto out;
1190         case DCB_CMD_PGRX_SCFG:
1191                 ret = dcbnl_pgrx_setcfg(netdev, tb, pid, nlh->nlmsg_seq,
1192                                         nlh->nlmsg_flags);
1193                 goto out;
1194         case DCB_CMD_GCAP:
1195                 ret = dcbnl_getcap(netdev, tb, pid, nlh->nlmsg_seq,
1196                                    nlh->nlmsg_flags);
1197                 goto out;
1198         case DCB_CMD_GNUMTCS:
1199                 ret = dcbnl_getnumtcs(netdev, tb, pid, nlh->nlmsg_seq,
1200                                       nlh->nlmsg_flags);
1201                 goto out;
1202         case DCB_CMD_SNUMTCS:
1203                 ret = dcbnl_setnumtcs(netdev, tb, pid, nlh->nlmsg_seq,
1204                                       nlh->nlmsg_flags);
1205                 goto out;
1206         case DCB_CMD_PFC_GSTATE:
1207                 ret = dcbnl_getpfcstate(netdev, tb, pid, nlh->nlmsg_seq,
1208                                         nlh->nlmsg_flags);
1209                 goto out;
1210         case DCB_CMD_PFC_SSTATE:
1211                 ret = dcbnl_setpfcstate(netdev, tb, pid, nlh->nlmsg_seq,
1212                                         nlh->nlmsg_flags);
1213                 goto out;
1214         case DCB_CMD_BCN_SCFG:
1215                 ret = dcbnl_bcn_setcfg(netdev, tb, pid, nlh->nlmsg_seq,
1216                                        nlh->nlmsg_flags);
1217                 goto out;
1218         case DCB_CMD_GAPP:
1219                 ret = dcbnl_getapp(netdev, tb, pid, nlh->nlmsg_seq,
1220                                    nlh->nlmsg_flags);
1221                 goto out;
1222         case DCB_CMD_SAPP:
1223                 ret = dcbnl_setapp(netdev, tb, pid, nlh->nlmsg_seq,
1224                                    nlh->nlmsg_flags);
1225                 goto out;
1226         default:
1227                 goto errout;
1228         }
1229 errout:
1230         ret = -EINVAL;
1231 out:
1232         dev_put(netdev);
1233         return ret;
1234 }
1235
1236 static int __init dcbnl_init(void)
1237 {
1238         rtnl_register(PF_UNSPEC, RTM_GETDCB, dcb_doit, NULL);
1239         rtnl_register(PF_UNSPEC, RTM_SETDCB, dcb_doit, NULL);
1240
1241         return 0;
1242 }
1243 module_init(dcbnl_init);
1244
1245 static void __exit dcbnl_exit(void)
1246 {
1247         rtnl_unregister(PF_UNSPEC, RTM_GETDCB);
1248         rtnl_unregister(PF_UNSPEC, RTM_SETDCB);
1249 }
1250 module_exit(dcbnl_exit);
1251
1252