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