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 }; 170 171 /* DCB number of traffic classes nested attributes. */ 172 static const struct nla_policy dcbnl_featcfg_nest[DCB_FEATCFG_ATTR_MAX + 1] = { 173 [DCB_FEATCFG_ATTR_ALL] = {.type = NLA_FLAG}, 174 [DCB_FEATCFG_ATTR_PG] = {.type = NLA_U8}, 175 [DCB_FEATCFG_ATTR_PFC] = {.type = NLA_U8}, 176 [DCB_FEATCFG_ATTR_APP] = {.type = NLA_U8}, 177 }; 178 179 static LIST_HEAD(dcb_app_list); 180 static DEFINE_SPINLOCK(dcb_lock); 181 182 static struct sk_buff *dcbnl_newmsg(int type, u8 cmd, u32 port, u32 seq, 183 u32 flags, struct nlmsghdr **nlhp) 184 { 185 struct sk_buff *skb; 186 struct dcbmsg *dcb; 187 struct nlmsghdr *nlh; 188 189 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 190 if (!skb) 191 return NULL; 192 193 nlh = nlmsg_put(skb, port, seq, type, sizeof(*dcb), flags); 194 BUG_ON(!nlh); 195 196 dcb = nlmsg_data(nlh); 197 dcb->dcb_family = AF_UNSPEC; 198 dcb->cmd = cmd; 199 dcb->dcb_pad = 0; 200 201 if (nlhp) 202 *nlhp = nlh; 203 204 return skb; 205 } 206 207 static int dcbnl_getstate(struct net_device *netdev, struct nlmsghdr *nlh, 208 u32 seq, struct nlattr **tb, struct sk_buff *skb) 209 { 210 /* if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->getstate) */ 211 if (!netdev->dcbnl_ops->getstate) 212 return -EOPNOTSUPP; 213 214 return nla_put_u8(skb, DCB_ATTR_STATE, 215 netdev->dcbnl_ops->getstate(netdev)); 216 } 217 218 static int dcbnl_getpfccfg(struct net_device *netdev, struct nlmsghdr *nlh, 219 u32 seq, struct nlattr **tb, struct sk_buff *skb) 220 { 221 struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1], *nest; 222 u8 value; 223 int ret; 224 int i; 225 int getall = 0; 226 227 if (!tb[DCB_ATTR_PFC_CFG]) 228 return -EINVAL; 229 230 if (!netdev->dcbnl_ops->getpfccfg) 231 return -EOPNOTSUPP; 232 233 ret = nla_parse_nested_deprecated(data, DCB_PFC_UP_ATTR_MAX, 234 tb[DCB_ATTR_PFC_CFG], 235 dcbnl_pfc_up_nest, NULL); 236 if (ret) 237 return ret; 238 239 nest = nla_nest_start_noflag(skb, DCB_ATTR_PFC_CFG); 240 if (!nest) 241 return -EMSGSIZE; 242 243 if (data[DCB_PFC_UP_ATTR_ALL]) 244 getall = 1; 245 246 for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) { 247 if (!getall && !data[i]) 248 continue; 249 250 netdev->dcbnl_ops->getpfccfg(netdev, i - DCB_PFC_UP_ATTR_0, 251 &value); 252 ret = nla_put_u8(skb, i, value); 253 if (ret) { 254 nla_nest_cancel(skb, nest); 255 return ret; 256 } 257 } 258 nla_nest_end(skb, nest); 259 260 return 0; 261 } 262 263 static int dcbnl_getperm_hwaddr(struct net_device *netdev, struct nlmsghdr *nlh, 264 u32 seq, struct nlattr **tb, struct sk_buff *skb) 265 { 266 u8 perm_addr[MAX_ADDR_LEN]; 267 268 if (!netdev->dcbnl_ops->getpermhwaddr) 269 return -EOPNOTSUPP; 270 271 memset(perm_addr, 0, sizeof(perm_addr)); 272 netdev->dcbnl_ops->getpermhwaddr(netdev, perm_addr); 273 274 return nla_put(skb, DCB_ATTR_PERM_HWADDR, sizeof(perm_addr), perm_addr); 275 } 276 277 static int dcbnl_getcap(struct net_device *netdev, struct nlmsghdr *nlh, 278 u32 seq, struct nlattr **tb, struct sk_buff *skb) 279 { 280 struct nlattr *data[DCB_CAP_ATTR_MAX + 1], *nest; 281 u8 value; 282 int ret; 283 int i; 284 int getall = 0; 285 286 if (!tb[DCB_ATTR_CAP]) 287 return -EINVAL; 288 289 if (!netdev->dcbnl_ops->getcap) 290 return -EOPNOTSUPP; 291 292 ret = nla_parse_nested_deprecated(data, DCB_CAP_ATTR_MAX, 293 tb[DCB_ATTR_CAP], dcbnl_cap_nest, 294 NULL); 295 if (ret) 296 return ret; 297 298 nest = nla_nest_start_noflag(skb, DCB_ATTR_CAP); 299 if (!nest) 300 return -EMSGSIZE; 301 302 if (data[DCB_CAP_ATTR_ALL]) 303 getall = 1; 304 305 for (i = DCB_CAP_ATTR_ALL+1; i <= DCB_CAP_ATTR_MAX; i++) { 306 if (!getall && !data[i]) 307 continue; 308 309 if (!netdev->dcbnl_ops->getcap(netdev, i, &value)) { 310 ret = nla_put_u8(skb, i, value); 311 if (ret) { 312 nla_nest_cancel(skb, nest); 313 return ret; 314 } 315 } 316 } 317 nla_nest_end(skb, nest); 318 319 return 0; 320 } 321 322 static int dcbnl_getnumtcs(struct net_device *netdev, struct nlmsghdr *nlh, 323 u32 seq, struct nlattr **tb, struct sk_buff *skb) 324 { 325 struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1], *nest; 326 u8 value; 327 int ret; 328 int i; 329 int getall = 0; 330 331 if (!tb[DCB_ATTR_NUMTCS]) 332 return -EINVAL; 333 334 if (!netdev->dcbnl_ops->getnumtcs) 335 return -EOPNOTSUPP; 336 337 ret = nla_parse_nested_deprecated(data, DCB_NUMTCS_ATTR_MAX, 338 tb[DCB_ATTR_NUMTCS], 339 dcbnl_numtcs_nest, NULL); 340 if (ret) 341 return ret; 342 343 nest = nla_nest_start_noflag(skb, DCB_ATTR_NUMTCS); 344 if (!nest) 345 return -EMSGSIZE; 346 347 if (data[DCB_NUMTCS_ATTR_ALL]) 348 getall = 1; 349 350 for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) { 351 if (!getall && !data[i]) 352 continue; 353 354 ret = netdev->dcbnl_ops->getnumtcs(netdev, i, &value); 355 if (!ret) { 356 ret = nla_put_u8(skb, i, value); 357 if (ret) { 358 nla_nest_cancel(skb, nest); 359 return ret; 360 } 361 } else 362 return -EINVAL; 363 } 364 nla_nest_end(skb, nest); 365 366 return 0; 367 } 368 369 static int dcbnl_setnumtcs(struct net_device *netdev, struct nlmsghdr *nlh, 370 u32 seq, struct nlattr **tb, struct sk_buff *skb) 371 { 372 struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1]; 373 int ret; 374 u8 value; 375 int i; 376 377 if (!tb[DCB_ATTR_NUMTCS]) 378 return -EINVAL; 379 380 if (!netdev->dcbnl_ops->setnumtcs) 381 return -EOPNOTSUPP; 382 383 ret = nla_parse_nested_deprecated(data, DCB_NUMTCS_ATTR_MAX, 384 tb[DCB_ATTR_NUMTCS], 385 dcbnl_numtcs_nest, NULL); 386 if (ret) 387 return ret; 388 389 for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) { 390 if (data[i] == NULL) 391 continue; 392 393 value = nla_get_u8(data[i]); 394 395 ret = netdev->dcbnl_ops->setnumtcs(netdev, i, value); 396 if (ret) 397 break; 398 } 399 400 return nla_put_u8(skb, DCB_ATTR_NUMTCS, !!ret); 401 } 402 403 static int dcbnl_getpfcstate(struct net_device *netdev, struct nlmsghdr *nlh, 404 u32 seq, struct nlattr **tb, struct sk_buff *skb) 405 { 406 if (!netdev->dcbnl_ops->getpfcstate) 407 return -EOPNOTSUPP; 408 409 return nla_put_u8(skb, DCB_ATTR_PFC_STATE, 410 netdev->dcbnl_ops->getpfcstate(netdev)); 411 } 412 413 static int dcbnl_setpfcstate(struct net_device *netdev, struct nlmsghdr *nlh, 414 u32 seq, struct nlattr **tb, struct sk_buff *skb) 415 { 416 u8 value; 417 418 if (!tb[DCB_ATTR_PFC_STATE]) 419 return -EINVAL; 420 421 if (!netdev->dcbnl_ops->setpfcstate) 422 return -EOPNOTSUPP; 423 424 value = nla_get_u8(tb[DCB_ATTR_PFC_STATE]); 425 426 netdev->dcbnl_ops->setpfcstate(netdev, value); 427 428 return nla_put_u8(skb, DCB_ATTR_PFC_STATE, 0); 429 } 430 431 static int dcbnl_getapp(struct net_device *netdev, struct nlmsghdr *nlh, 432 u32 seq, struct nlattr **tb, struct sk_buff *skb) 433 { 434 struct nlattr *app_nest; 435 struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1]; 436 u16 id; 437 u8 up, idtype; 438 int ret; 439 440 if (!tb[DCB_ATTR_APP]) 441 return -EINVAL; 442 443 ret = nla_parse_nested_deprecated(app_tb, DCB_APP_ATTR_MAX, 444 tb[DCB_ATTR_APP], dcbnl_app_nest, 445 NULL); 446 if (ret) 447 return ret; 448 449 /* all must be non-null */ 450 if ((!app_tb[DCB_APP_ATTR_IDTYPE]) || 451 (!app_tb[DCB_APP_ATTR_ID])) 452 return -EINVAL; 453 454 /* either by eth type or by socket number */ 455 idtype = nla_get_u8(app_tb[DCB_APP_ATTR_IDTYPE]); 456 if ((idtype != DCB_APP_IDTYPE_ETHTYPE) && 457 (idtype != DCB_APP_IDTYPE_PORTNUM)) 458 return -EINVAL; 459 460 id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]); 461 462 if (netdev->dcbnl_ops->getapp) { 463 ret = netdev->dcbnl_ops->getapp(netdev, idtype, id); 464 if (ret < 0) 465 return ret; 466 else 467 up = ret; 468 } else { 469 struct dcb_app app = { 470 .selector = idtype, 471 .protocol = id, 472 }; 473 up = dcb_getapp(netdev, &app); 474 } 475 476 app_nest = nla_nest_start_noflag(skb, DCB_ATTR_APP); 477 if (!app_nest) 478 return -EMSGSIZE; 479 480 ret = nla_put_u8(skb, DCB_APP_ATTR_IDTYPE, idtype); 481 if (ret) 482 goto out_cancel; 483 484 ret = nla_put_u16(skb, DCB_APP_ATTR_ID, id); 485 if (ret) 486 goto out_cancel; 487 488 ret = nla_put_u8(skb, DCB_APP_ATTR_PRIORITY, up); 489 if (ret) 490 goto out_cancel; 491 492 nla_nest_end(skb, app_nest); 493 494 return 0; 495 496 out_cancel: 497 nla_nest_cancel(skb, app_nest); 498 return ret; 499 } 500 501 static int dcbnl_setapp(struct net_device *netdev, struct nlmsghdr *nlh, 502 u32 seq, struct nlattr **tb, struct sk_buff *skb) 503 { 504 int ret; 505 u16 id; 506 u8 up, idtype; 507 struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1]; 508 509 if (!tb[DCB_ATTR_APP]) 510 return -EINVAL; 511 512 ret = nla_parse_nested_deprecated(app_tb, DCB_APP_ATTR_MAX, 513 tb[DCB_ATTR_APP], dcbnl_app_nest, 514 NULL); 515 if (ret) 516 return ret; 517 518 /* all must be non-null */ 519 if ((!app_tb[DCB_APP_ATTR_IDTYPE]) || 520 (!app_tb[DCB_APP_ATTR_ID]) || 521 (!app_tb[DCB_APP_ATTR_PRIORITY])) 522 return -EINVAL; 523 524 /* either by eth type or by socket number */ 525 idtype = nla_get_u8(app_tb[DCB_APP_ATTR_IDTYPE]); 526 if ((idtype != DCB_APP_IDTYPE_ETHTYPE) && 527 (idtype != DCB_APP_IDTYPE_PORTNUM)) 528 return -EINVAL; 529 530 id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]); 531 up = nla_get_u8(app_tb[DCB_APP_ATTR_PRIORITY]); 532 533 if (netdev->dcbnl_ops->setapp) { 534 ret = netdev->dcbnl_ops->setapp(netdev, idtype, id, up); 535 if (ret < 0) 536 return ret; 537 } else { 538 struct dcb_app app; 539 app.selector = idtype; 540 app.protocol = id; 541 app.priority = up; 542 ret = dcb_setapp(netdev, &app); 543 } 544 545 ret = nla_put_u8(skb, DCB_ATTR_APP, ret); 546 dcbnl_cee_notify(netdev, RTM_SETDCB, DCB_CMD_SAPP, seq, 0); 547 548 return ret; 549 } 550 551 static int __dcbnl_pg_getcfg(struct net_device *netdev, struct nlmsghdr *nlh, 552 struct nlattr **tb, struct sk_buff *skb, int dir) 553 { 554 struct nlattr *pg_nest, *param_nest, *data; 555 struct nlattr *pg_tb[DCB_PG_ATTR_MAX + 1]; 556 struct nlattr *param_tb[DCB_TC_ATTR_PARAM_MAX + 1]; 557 u8 prio, pgid, tc_pct, up_map; 558 int ret; 559 int getall = 0; 560 int i; 561 562 if (!tb[DCB_ATTR_PG_CFG]) 563 return -EINVAL; 564 565 if (!netdev->dcbnl_ops->getpgtccfgtx || 566 !netdev->dcbnl_ops->getpgtccfgrx || 567 !netdev->dcbnl_ops->getpgbwgcfgtx || 568 !netdev->dcbnl_ops->getpgbwgcfgrx) 569 return -EOPNOTSUPP; 570 571 ret = nla_parse_nested_deprecated(pg_tb, DCB_PG_ATTR_MAX, 572 tb[DCB_ATTR_PG_CFG], dcbnl_pg_nest, 573 NULL); 574 if (ret) 575 return ret; 576 577 pg_nest = nla_nest_start_noflag(skb, DCB_ATTR_PG_CFG); 578 if (!pg_nest) 579 return -EMSGSIZE; 580 581 if (pg_tb[DCB_PG_ATTR_TC_ALL]) 582 getall = 1; 583 584 for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) { 585 if (!getall && !pg_tb[i]) 586 continue; 587 588 if (pg_tb[DCB_PG_ATTR_TC_ALL]) 589 data = pg_tb[DCB_PG_ATTR_TC_ALL]; 590 else 591 data = pg_tb[i]; 592 ret = nla_parse_nested_deprecated(param_tb, 593 DCB_TC_ATTR_PARAM_MAX, data, 594 dcbnl_tc_param_nest, NULL); 595 if (ret) 596 goto err_pg; 597 598 param_nest = nla_nest_start_noflag(skb, i); 599 if (!param_nest) 600 goto err_pg; 601 602 pgid = DCB_ATTR_VALUE_UNDEFINED; 603 prio = DCB_ATTR_VALUE_UNDEFINED; 604 tc_pct = DCB_ATTR_VALUE_UNDEFINED; 605 up_map = DCB_ATTR_VALUE_UNDEFINED; 606 607 if (dir) { 608 /* Rx */ 609 netdev->dcbnl_ops->getpgtccfgrx(netdev, 610 i - DCB_PG_ATTR_TC_0, &prio, 611 &pgid, &tc_pct, &up_map); 612 } else { 613 /* Tx */ 614 netdev->dcbnl_ops->getpgtccfgtx(netdev, 615 i - DCB_PG_ATTR_TC_0, &prio, 616 &pgid, &tc_pct, &up_map); 617 } 618 619 if (param_tb[DCB_TC_ATTR_PARAM_PGID] || 620 param_tb[DCB_TC_ATTR_PARAM_ALL]) { 621 ret = nla_put_u8(skb, 622 DCB_TC_ATTR_PARAM_PGID, pgid); 623 if (ret) 624 goto err_param; 625 } 626 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING] || 627 param_tb[DCB_TC_ATTR_PARAM_ALL]) { 628 ret = nla_put_u8(skb, 629 DCB_TC_ATTR_PARAM_UP_MAPPING, up_map); 630 if (ret) 631 goto err_param; 632 } 633 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO] || 634 param_tb[DCB_TC_ATTR_PARAM_ALL]) { 635 ret = nla_put_u8(skb, 636 DCB_TC_ATTR_PARAM_STRICT_PRIO, prio); 637 if (ret) 638 goto err_param; 639 } 640 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT] || 641 param_tb[DCB_TC_ATTR_PARAM_ALL]) { 642 ret = nla_put_u8(skb, DCB_TC_ATTR_PARAM_BW_PCT, 643 tc_pct); 644 if (ret) 645 goto err_param; 646 } 647 nla_nest_end(skb, param_nest); 648 } 649 650 if (pg_tb[DCB_PG_ATTR_BW_ID_ALL]) 651 getall = 1; 652 else 653 getall = 0; 654 655 for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) { 656 if (!getall && !pg_tb[i]) 657 continue; 658 659 tc_pct = DCB_ATTR_VALUE_UNDEFINED; 660 661 if (dir) { 662 /* Rx */ 663 netdev->dcbnl_ops->getpgbwgcfgrx(netdev, 664 i - DCB_PG_ATTR_BW_ID_0, &tc_pct); 665 } else { 666 /* Tx */ 667 netdev->dcbnl_ops->getpgbwgcfgtx(netdev, 668 i - DCB_PG_ATTR_BW_ID_0, &tc_pct); 669 } 670 ret = nla_put_u8(skb, i, tc_pct); 671 if (ret) 672 goto err_pg; 673 } 674 675 nla_nest_end(skb, pg_nest); 676 677 return 0; 678 679 err_param: 680 nla_nest_cancel(skb, param_nest); 681 err_pg: 682 nla_nest_cancel(skb, pg_nest); 683 684 return -EMSGSIZE; 685 } 686 687 static int dcbnl_pgtx_getcfg(struct net_device *netdev, struct nlmsghdr *nlh, 688 u32 seq, struct nlattr **tb, struct sk_buff *skb) 689 { 690 return __dcbnl_pg_getcfg(netdev, nlh, tb, skb, 0); 691 } 692 693 static int dcbnl_pgrx_getcfg(struct net_device *netdev, struct nlmsghdr *nlh, 694 u32 seq, struct nlattr **tb, struct sk_buff *skb) 695 { 696 return __dcbnl_pg_getcfg(netdev, nlh, tb, skb, 1); 697 } 698 699 static int dcbnl_setstate(struct net_device *netdev, struct nlmsghdr *nlh, 700 u32 seq, struct nlattr **tb, struct sk_buff *skb) 701 { 702 u8 value; 703 704 if (!tb[DCB_ATTR_STATE]) 705 return -EINVAL; 706 707 if (!netdev->dcbnl_ops->setstate) 708 return -EOPNOTSUPP; 709 710 value = nla_get_u8(tb[DCB_ATTR_STATE]); 711 712 return nla_put_u8(skb, DCB_ATTR_STATE, 713 netdev->dcbnl_ops->setstate(netdev, value)); 714 } 715 716 static int dcbnl_setpfccfg(struct net_device *netdev, struct nlmsghdr *nlh, 717 u32 seq, struct nlattr **tb, struct sk_buff *skb) 718 { 719 struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1]; 720 int i; 721 int ret; 722 u8 value; 723 724 if (!tb[DCB_ATTR_PFC_CFG]) 725 return -EINVAL; 726 727 if (!netdev->dcbnl_ops->setpfccfg) 728 return -EOPNOTSUPP; 729 730 ret = nla_parse_nested_deprecated(data, DCB_PFC_UP_ATTR_MAX, 731 tb[DCB_ATTR_PFC_CFG], 732 dcbnl_pfc_up_nest, NULL); 733 if (ret) 734 return ret; 735 736 for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) { 737 if (data[i] == NULL) 738 continue; 739 value = nla_get_u8(data[i]); 740 netdev->dcbnl_ops->setpfccfg(netdev, 741 data[i]->nla_type - DCB_PFC_UP_ATTR_0, value); 742 } 743 744 return nla_put_u8(skb, DCB_ATTR_PFC_CFG, 0); 745 } 746 747 static int dcbnl_setall(struct net_device *netdev, struct nlmsghdr *nlh, 748 u32 seq, struct nlattr **tb, struct sk_buff *skb) 749 { 750 int ret; 751 752 if (!tb[DCB_ATTR_SET_ALL]) 753 return -EINVAL; 754 755 if (!netdev->dcbnl_ops->setall) 756 return -EOPNOTSUPP; 757 758 ret = nla_put_u8(skb, DCB_ATTR_SET_ALL, 759 netdev->dcbnl_ops->setall(netdev)); 760 dcbnl_cee_notify(netdev, RTM_SETDCB, DCB_CMD_SET_ALL, seq, 0); 761 762 return ret; 763 } 764 765 static int __dcbnl_pg_setcfg(struct net_device *netdev, struct nlmsghdr *nlh, 766 u32 seq, struct nlattr **tb, struct sk_buff *skb, 767 int dir) 768 { 769 struct nlattr *pg_tb[DCB_PG_ATTR_MAX + 1]; 770 struct nlattr *param_tb[DCB_TC_ATTR_PARAM_MAX + 1]; 771 int ret; 772 int i; 773 u8 pgid; 774 u8 up_map; 775 u8 prio; 776 u8 tc_pct; 777 778 if (!tb[DCB_ATTR_PG_CFG]) 779 return -EINVAL; 780 781 if (!netdev->dcbnl_ops->setpgtccfgtx || 782 !netdev->dcbnl_ops->setpgtccfgrx || 783 !netdev->dcbnl_ops->setpgbwgcfgtx || 784 !netdev->dcbnl_ops->setpgbwgcfgrx) 785 return -EOPNOTSUPP; 786 787 ret = nla_parse_nested_deprecated(pg_tb, DCB_PG_ATTR_MAX, 788 tb[DCB_ATTR_PG_CFG], dcbnl_pg_nest, 789 NULL); 790 if (ret) 791 return ret; 792 793 for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) { 794 if (!pg_tb[i]) 795 continue; 796 797 ret = nla_parse_nested_deprecated(param_tb, 798 DCB_TC_ATTR_PARAM_MAX, 799 pg_tb[i], 800 dcbnl_tc_param_nest, NULL); 801 if (ret) 802 return ret; 803 804 pgid = DCB_ATTR_VALUE_UNDEFINED; 805 prio = DCB_ATTR_VALUE_UNDEFINED; 806 tc_pct = DCB_ATTR_VALUE_UNDEFINED; 807 up_map = DCB_ATTR_VALUE_UNDEFINED; 808 809 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO]) 810 prio = 811 nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO]); 812 813 if (param_tb[DCB_TC_ATTR_PARAM_PGID]) 814 pgid = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_PGID]); 815 816 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT]) 817 tc_pct = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_BW_PCT]); 818 819 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING]) 820 up_map = 821 nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING]); 822 823 /* dir: Tx = 0, Rx = 1 */ 824 if (dir) { 825 /* Rx */ 826 netdev->dcbnl_ops->setpgtccfgrx(netdev, 827 i - DCB_PG_ATTR_TC_0, 828 prio, pgid, tc_pct, up_map); 829 } else { 830 /* Tx */ 831 netdev->dcbnl_ops->setpgtccfgtx(netdev, 832 i - DCB_PG_ATTR_TC_0, 833 prio, pgid, tc_pct, up_map); 834 } 835 } 836 837 for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) { 838 if (!pg_tb[i]) 839 continue; 840 841 tc_pct = nla_get_u8(pg_tb[i]); 842 843 /* dir: Tx = 0, Rx = 1 */ 844 if (dir) { 845 /* Rx */ 846 netdev->dcbnl_ops->setpgbwgcfgrx(netdev, 847 i - DCB_PG_ATTR_BW_ID_0, tc_pct); 848 } else { 849 /* Tx */ 850 netdev->dcbnl_ops->setpgbwgcfgtx(netdev, 851 i - DCB_PG_ATTR_BW_ID_0, tc_pct); 852 } 853 } 854 855 return nla_put_u8(skb, DCB_ATTR_PG_CFG, 0); 856 } 857 858 static int dcbnl_pgtx_setcfg(struct net_device *netdev, struct nlmsghdr *nlh, 859 u32 seq, struct nlattr **tb, struct sk_buff *skb) 860 { 861 return __dcbnl_pg_setcfg(netdev, nlh, seq, tb, skb, 0); 862 } 863 864 static int dcbnl_pgrx_setcfg(struct net_device *netdev, struct nlmsghdr *nlh, 865 u32 seq, struct nlattr **tb, struct sk_buff *skb) 866 { 867 return __dcbnl_pg_setcfg(netdev, nlh, seq, tb, skb, 1); 868 } 869 870 static int dcbnl_bcn_getcfg(struct net_device *netdev, struct nlmsghdr *nlh, 871 u32 seq, struct nlattr **tb, struct sk_buff *skb) 872 { 873 struct nlattr *bcn_nest; 874 struct nlattr *bcn_tb[DCB_BCN_ATTR_MAX + 1]; 875 u8 value_byte; 876 u32 value_integer; 877 int ret; 878 bool getall = false; 879 int i; 880 881 if (!tb[DCB_ATTR_BCN]) 882 return -EINVAL; 883 884 if (!netdev->dcbnl_ops->getbcnrp || 885 !netdev->dcbnl_ops->getbcncfg) 886 return -EOPNOTSUPP; 887 888 ret = nla_parse_nested_deprecated(bcn_tb, DCB_BCN_ATTR_MAX, 889 tb[DCB_ATTR_BCN], dcbnl_bcn_nest, 890 NULL); 891 if (ret) 892 return ret; 893 894 bcn_nest = nla_nest_start_noflag(skb, DCB_ATTR_BCN); 895 if (!bcn_nest) 896 return -EMSGSIZE; 897 898 if (bcn_tb[DCB_BCN_ATTR_ALL]) 899 getall = true; 900 901 for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) { 902 if (!getall && !bcn_tb[i]) 903 continue; 904 905 netdev->dcbnl_ops->getbcnrp(netdev, i - DCB_BCN_ATTR_RP_0, 906 &value_byte); 907 ret = nla_put_u8(skb, i, value_byte); 908 if (ret) 909 goto err_bcn; 910 } 911 912 for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) { 913 if (!getall && !bcn_tb[i]) 914 continue; 915 916 netdev->dcbnl_ops->getbcncfg(netdev, i, 917 &value_integer); 918 ret = nla_put_u32(skb, i, value_integer); 919 if (ret) 920 goto err_bcn; 921 } 922 923 nla_nest_end(skb, bcn_nest); 924 925 return 0; 926 927 err_bcn: 928 nla_nest_cancel(skb, bcn_nest); 929 return ret; 930 } 931 932 static int dcbnl_bcn_setcfg(struct net_device *netdev, struct nlmsghdr *nlh, 933 u32 seq, struct nlattr **tb, struct sk_buff *skb) 934 { 935 struct nlattr *data[DCB_BCN_ATTR_MAX + 1]; 936 int i; 937 int ret; 938 u8 value_byte; 939 u32 value_int; 940 941 if (!tb[DCB_ATTR_BCN]) 942 return -EINVAL; 943 944 if (!netdev->dcbnl_ops->setbcncfg || 945 !netdev->dcbnl_ops->setbcnrp) 946 return -EOPNOTSUPP; 947 948 ret = nla_parse_nested_deprecated(data, DCB_BCN_ATTR_MAX, 949 tb[DCB_ATTR_BCN], dcbnl_pfc_up_nest, 950 NULL); 951 if (ret) 952 return ret; 953 954 for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) { 955 if (data[i] == NULL) 956 continue; 957 value_byte = nla_get_u8(data[i]); 958 netdev->dcbnl_ops->setbcnrp(netdev, 959 data[i]->nla_type - DCB_BCN_ATTR_RP_0, value_byte); 960 } 961 962 for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) { 963 if (data[i] == NULL) 964 continue; 965 value_int = nla_get_u32(data[i]); 966 netdev->dcbnl_ops->setbcncfg(netdev, 967 i, value_int); 968 } 969 970 return nla_put_u8(skb, DCB_ATTR_BCN, 0); 971 } 972 973 static int dcbnl_build_peer_app(struct net_device *netdev, struct sk_buff* skb, 974 int app_nested_type, int app_info_type, 975 int app_entry_type) 976 { 977 struct dcb_peer_app_info info; 978 struct dcb_app *table = NULL; 979 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops; 980 u16 app_count; 981 int err; 982 983 984 /** 985 * retrieve the peer app configuration form the driver. If the driver 986 * handlers fail exit without doing anything 987 */ 988 err = ops->peer_getappinfo(netdev, &info, &app_count); 989 if (!err && app_count) { 990 table = kmalloc_array(app_count, sizeof(struct dcb_app), 991 GFP_KERNEL); 992 if (!table) 993 return -ENOMEM; 994 995 err = ops->peer_getapptable(netdev, table); 996 } 997 998 if (!err) { 999 u16 i; 1000 struct nlattr *app; 1001 1002 /** 1003 * build the message, from here on the only possible failure 1004 * is due to the skb size 1005 */ 1006 err = -EMSGSIZE; 1007 1008 app = nla_nest_start_noflag(skb, app_nested_type); 1009 if (!app) 1010 goto nla_put_failure; 1011 1012 if (app_info_type && 1013 nla_put(skb, app_info_type, sizeof(info), &info)) 1014 goto nla_put_failure; 1015 1016 for (i = 0; i < app_count; i++) { 1017 if (nla_put(skb, app_entry_type, sizeof(struct dcb_app), 1018 &table[i])) 1019 goto nla_put_failure; 1020 } 1021 nla_nest_end(skb, app); 1022 } 1023 err = 0; 1024 1025 nla_put_failure: 1026 kfree(table); 1027 return err; 1028 } 1029 1030 /* Handle IEEE 802.1Qaz/802.1Qau/802.1Qbb GET commands. */ 1031 static int dcbnl_ieee_fill(struct sk_buff *skb, struct net_device *netdev) 1032 { 1033 struct nlattr *ieee, *app; 1034 struct dcb_app_type *itr; 1035 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops; 1036 int dcbx; 1037 int err; 1038 1039 if (nla_put_string(skb, DCB_ATTR_IFNAME, netdev->name)) 1040 return -EMSGSIZE; 1041 1042 ieee = nla_nest_start_noflag(skb, DCB_ATTR_IEEE); 1043 if (!ieee) 1044 return -EMSGSIZE; 1045 1046 if (ops->ieee_getets) { 1047 struct ieee_ets ets; 1048 memset(&ets, 0, sizeof(ets)); 1049 err = ops->ieee_getets(netdev, &ets); 1050 if (!err && 1051 nla_put(skb, DCB_ATTR_IEEE_ETS, sizeof(ets), &ets)) 1052 return -EMSGSIZE; 1053 } 1054 1055 if (ops->ieee_getmaxrate) { 1056 struct ieee_maxrate maxrate; 1057 memset(&maxrate, 0, sizeof(maxrate)); 1058 err = ops->ieee_getmaxrate(netdev, &maxrate); 1059 if (!err) { 1060 err = nla_put(skb, DCB_ATTR_IEEE_MAXRATE, 1061 sizeof(maxrate), &maxrate); 1062 if (err) 1063 return -EMSGSIZE; 1064 } 1065 } 1066 1067 if (ops->ieee_getqcn) { 1068 struct ieee_qcn qcn; 1069 1070 memset(&qcn, 0, sizeof(qcn)); 1071 err = ops->ieee_getqcn(netdev, &qcn); 1072 if (!err) { 1073 err = nla_put(skb, DCB_ATTR_IEEE_QCN, 1074 sizeof(qcn), &qcn); 1075 if (err) 1076 return -EMSGSIZE; 1077 } 1078 } 1079 1080 if (ops->ieee_getqcnstats) { 1081 struct ieee_qcn_stats qcn_stats; 1082 1083 memset(&qcn_stats, 0, sizeof(qcn_stats)); 1084 err = ops->ieee_getqcnstats(netdev, &qcn_stats); 1085 if (!err) { 1086 err = nla_put(skb, DCB_ATTR_IEEE_QCN_STATS, 1087 sizeof(qcn_stats), &qcn_stats); 1088 if (err) 1089 return -EMSGSIZE; 1090 } 1091 } 1092 1093 if (ops->ieee_getpfc) { 1094 struct ieee_pfc pfc; 1095 memset(&pfc, 0, sizeof(pfc)); 1096 err = ops->ieee_getpfc(netdev, &pfc); 1097 if (!err && 1098 nla_put(skb, DCB_ATTR_IEEE_PFC, sizeof(pfc), &pfc)) 1099 return -EMSGSIZE; 1100 } 1101 1102 if (ops->dcbnl_getbuffer) { 1103 struct dcbnl_buffer buffer; 1104 1105 memset(&buffer, 0, sizeof(buffer)); 1106 err = ops->dcbnl_getbuffer(netdev, &buffer); 1107 if (!err && 1108 nla_put(skb, DCB_ATTR_DCB_BUFFER, sizeof(buffer), &buffer)) 1109 return -EMSGSIZE; 1110 } 1111 1112 app = nla_nest_start_noflag(skb, DCB_ATTR_IEEE_APP_TABLE); 1113 if (!app) 1114 return -EMSGSIZE; 1115 1116 spin_lock_bh(&dcb_lock); 1117 list_for_each_entry(itr, &dcb_app_list, list) { 1118 if (itr->ifindex == netdev->ifindex) { 1119 err = nla_put(skb, DCB_ATTR_IEEE_APP, sizeof(itr->app), 1120 &itr->app); 1121 if (err) { 1122 spin_unlock_bh(&dcb_lock); 1123 return -EMSGSIZE; 1124 } 1125 } 1126 } 1127 1128 if (netdev->dcbnl_ops->getdcbx) 1129 dcbx = netdev->dcbnl_ops->getdcbx(netdev); 1130 else 1131 dcbx = -EOPNOTSUPP; 1132 1133 spin_unlock_bh(&dcb_lock); 1134 nla_nest_end(skb, app); 1135 1136 /* get peer info if available */ 1137 if (ops->ieee_peer_getets) { 1138 struct ieee_ets ets; 1139 memset(&ets, 0, sizeof(ets)); 1140 err = ops->ieee_peer_getets(netdev, &ets); 1141 if (!err && 1142 nla_put(skb, DCB_ATTR_IEEE_PEER_ETS, sizeof(ets), &ets)) 1143 return -EMSGSIZE; 1144 } 1145 1146 if (ops->ieee_peer_getpfc) { 1147 struct ieee_pfc pfc; 1148 memset(&pfc, 0, sizeof(pfc)); 1149 err = ops->ieee_peer_getpfc(netdev, &pfc); 1150 if (!err && 1151 nla_put(skb, DCB_ATTR_IEEE_PEER_PFC, sizeof(pfc), &pfc)) 1152 return -EMSGSIZE; 1153 } 1154 1155 if (ops->peer_getappinfo && ops->peer_getapptable) { 1156 err = dcbnl_build_peer_app(netdev, skb, 1157 DCB_ATTR_IEEE_PEER_APP, 1158 DCB_ATTR_IEEE_APP_UNSPEC, 1159 DCB_ATTR_IEEE_APP); 1160 if (err) 1161 return -EMSGSIZE; 1162 } 1163 1164 nla_nest_end(skb, ieee); 1165 if (dcbx >= 0) { 1166 err = nla_put_u8(skb, DCB_ATTR_DCBX, dcbx); 1167 if (err) 1168 return -EMSGSIZE; 1169 } 1170 1171 return 0; 1172 } 1173 1174 static int dcbnl_cee_pg_fill(struct sk_buff *skb, struct net_device *dev, 1175 int dir) 1176 { 1177 u8 pgid, up_map, prio, tc_pct; 1178 const struct dcbnl_rtnl_ops *ops = dev->dcbnl_ops; 1179 int i = dir ? DCB_ATTR_CEE_TX_PG : DCB_ATTR_CEE_RX_PG; 1180 struct nlattr *pg = nla_nest_start_noflag(skb, i); 1181 1182 if (!pg) 1183 return -EMSGSIZE; 1184 1185 for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) { 1186 struct nlattr *tc_nest = nla_nest_start_noflag(skb, i); 1187 1188 if (!tc_nest) 1189 return -EMSGSIZE; 1190 1191 pgid = DCB_ATTR_VALUE_UNDEFINED; 1192 prio = DCB_ATTR_VALUE_UNDEFINED; 1193 tc_pct = DCB_ATTR_VALUE_UNDEFINED; 1194 up_map = DCB_ATTR_VALUE_UNDEFINED; 1195 1196 if (!dir) 1197 ops->getpgtccfgrx(dev, i - DCB_PG_ATTR_TC_0, 1198 &prio, &pgid, &tc_pct, &up_map); 1199 else 1200 ops->getpgtccfgtx(dev, i - DCB_PG_ATTR_TC_0, 1201 &prio, &pgid, &tc_pct, &up_map); 1202 1203 if (nla_put_u8(skb, DCB_TC_ATTR_PARAM_PGID, pgid) || 1204 nla_put_u8(skb, DCB_TC_ATTR_PARAM_UP_MAPPING, up_map) || 1205 nla_put_u8(skb, DCB_TC_ATTR_PARAM_STRICT_PRIO, prio) || 1206 nla_put_u8(skb, DCB_TC_ATTR_PARAM_BW_PCT, tc_pct)) 1207 return -EMSGSIZE; 1208 nla_nest_end(skb, tc_nest); 1209 } 1210 1211 for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) { 1212 tc_pct = DCB_ATTR_VALUE_UNDEFINED; 1213 1214 if (!dir) 1215 ops->getpgbwgcfgrx(dev, i - DCB_PG_ATTR_BW_ID_0, 1216 &tc_pct); 1217 else 1218 ops->getpgbwgcfgtx(dev, i - DCB_PG_ATTR_BW_ID_0, 1219 &tc_pct); 1220 if (nla_put_u8(skb, i, tc_pct)) 1221 return -EMSGSIZE; 1222 } 1223 nla_nest_end(skb, pg); 1224 return 0; 1225 } 1226 1227 static int dcbnl_cee_fill(struct sk_buff *skb, struct net_device *netdev) 1228 { 1229 struct nlattr *cee, *app; 1230 struct dcb_app_type *itr; 1231 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops; 1232 int dcbx, i, err = -EMSGSIZE; 1233 u8 value; 1234 1235 if (nla_put_string(skb, DCB_ATTR_IFNAME, netdev->name)) 1236 goto nla_put_failure; 1237 cee = nla_nest_start_noflag(skb, DCB_ATTR_CEE); 1238 if (!cee) 1239 goto nla_put_failure; 1240 1241 /* local pg */ 1242 if (ops->getpgtccfgtx && ops->getpgbwgcfgtx) { 1243 err = dcbnl_cee_pg_fill(skb, netdev, 1); 1244 if (err) 1245 goto nla_put_failure; 1246 } 1247 1248 if (ops->getpgtccfgrx && ops->getpgbwgcfgrx) { 1249 err = dcbnl_cee_pg_fill(skb, netdev, 0); 1250 if (err) 1251 goto nla_put_failure; 1252 } 1253 1254 /* local pfc */ 1255 if (ops->getpfccfg) { 1256 struct nlattr *pfc_nest = nla_nest_start_noflag(skb, 1257 DCB_ATTR_CEE_PFC); 1258 1259 if (!pfc_nest) 1260 goto nla_put_failure; 1261 1262 for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) { 1263 ops->getpfccfg(netdev, i - DCB_PFC_UP_ATTR_0, &value); 1264 if (nla_put_u8(skb, i, value)) 1265 goto nla_put_failure; 1266 } 1267 nla_nest_end(skb, pfc_nest); 1268 } 1269 1270 /* local app */ 1271 spin_lock_bh(&dcb_lock); 1272 app = nla_nest_start_noflag(skb, DCB_ATTR_CEE_APP_TABLE); 1273 if (!app) 1274 goto dcb_unlock; 1275 1276 list_for_each_entry(itr, &dcb_app_list, list) { 1277 if (itr->ifindex == netdev->ifindex) { 1278 struct nlattr *app_nest = nla_nest_start_noflag(skb, 1279 DCB_ATTR_APP); 1280 if (!app_nest) 1281 goto dcb_unlock; 1282 1283 err = nla_put_u8(skb, DCB_APP_ATTR_IDTYPE, 1284 itr->app.selector); 1285 if (err) 1286 goto dcb_unlock; 1287 1288 err = nla_put_u16(skb, DCB_APP_ATTR_ID, 1289 itr->app.protocol); 1290 if (err) 1291 goto dcb_unlock; 1292 1293 err = nla_put_u8(skb, DCB_APP_ATTR_PRIORITY, 1294 itr->app.priority); 1295 if (err) 1296 goto dcb_unlock; 1297 1298 nla_nest_end(skb, app_nest); 1299 } 1300 } 1301 nla_nest_end(skb, app); 1302 1303 if (netdev->dcbnl_ops->getdcbx) 1304 dcbx = netdev->dcbnl_ops->getdcbx(netdev); 1305 else 1306 dcbx = -EOPNOTSUPP; 1307 1308 spin_unlock_bh(&dcb_lock); 1309 1310 /* features flags */ 1311 if (ops->getfeatcfg) { 1312 struct nlattr *feat = nla_nest_start_noflag(skb, 1313 DCB_ATTR_CEE_FEAT); 1314 if (!feat) 1315 goto nla_put_failure; 1316 1317 for (i = DCB_FEATCFG_ATTR_ALL + 1; i <= DCB_FEATCFG_ATTR_MAX; 1318 i++) 1319 if (!ops->getfeatcfg(netdev, i, &value) && 1320 nla_put_u8(skb, i, value)) 1321 goto nla_put_failure; 1322 1323 nla_nest_end(skb, feat); 1324 } 1325 1326 /* peer info if available */ 1327 if (ops->cee_peer_getpg) { 1328 struct cee_pg pg; 1329 memset(&pg, 0, sizeof(pg)); 1330 err = ops->cee_peer_getpg(netdev, &pg); 1331 if (!err && 1332 nla_put(skb, DCB_ATTR_CEE_PEER_PG, sizeof(pg), &pg)) 1333 goto nla_put_failure; 1334 } 1335 1336 if (ops->cee_peer_getpfc) { 1337 struct cee_pfc pfc; 1338 memset(&pfc, 0, sizeof(pfc)); 1339 err = ops->cee_peer_getpfc(netdev, &pfc); 1340 if (!err && 1341 nla_put(skb, DCB_ATTR_CEE_PEER_PFC, sizeof(pfc), &pfc)) 1342 goto nla_put_failure; 1343 } 1344 1345 if (ops->peer_getappinfo && ops->peer_getapptable) { 1346 err = dcbnl_build_peer_app(netdev, skb, 1347 DCB_ATTR_CEE_PEER_APP_TABLE, 1348 DCB_ATTR_CEE_PEER_APP_INFO, 1349 DCB_ATTR_CEE_PEER_APP); 1350 if (err) 1351 goto nla_put_failure; 1352 } 1353 nla_nest_end(skb, cee); 1354 1355 /* DCBX state */ 1356 if (dcbx >= 0) { 1357 err = nla_put_u8(skb, DCB_ATTR_DCBX, dcbx); 1358 if (err) 1359 goto nla_put_failure; 1360 } 1361 return 0; 1362 1363 dcb_unlock: 1364 spin_unlock_bh(&dcb_lock); 1365 nla_put_failure: 1366 err = -EMSGSIZE; 1367 return err; 1368 } 1369 1370 static int dcbnl_notify(struct net_device *dev, int event, int cmd, 1371 u32 seq, u32 portid, int dcbx_ver) 1372 { 1373 struct net *net = dev_net(dev); 1374 struct sk_buff *skb; 1375 struct nlmsghdr *nlh; 1376 const struct dcbnl_rtnl_ops *ops = dev->dcbnl_ops; 1377 int err; 1378 1379 if (!ops) 1380 return -EOPNOTSUPP; 1381 1382 skb = dcbnl_newmsg(event, cmd, portid, seq, 0, &nlh); 1383 if (!skb) 1384 return -ENOBUFS; 1385 1386 if (dcbx_ver == DCB_CAP_DCBX_VER_IEEE) 1387 err = dcbnl_ieee_fill(skb, dev); 1388 else 1389 err = dcbnl_cee_fill(skb, dev); 1390 1391 if (err < 0) { 1392 /* Report error to broadcast listeners */ 1393 nlmsg_free(skb); 1394 rtnl_set_sk_err(net, RTNLGRP_DCB, err); 1395 } else { 1396 /* End nlmsg and notify broadcast listeners */ 1397 nlmsg_end(skb, nlh); 1398 rtnl_notify(skb, net, 0, RTNLGRP_DCB, NULL, GFP_KERNEL); 1399 } 1400 1401 return err; 1402 } 1403 1404 int dcbnl_ieee_notify(struct net_device *dev, int event, int cmd, 1405 u32 seq, u32 portid) 1406 { 1407 return dcbnl_notify(dev, event, cmd, seq, portid, DCB_CAP_DCBX_VER_IEEE); 1408 } 1409 EXPORT_SYMBOL(dcbnl_ieee_notify); 1410 1411 int dcbnl_cee_notify(struct net_device *dev, int event, int cmd, 1412 u32 seq, u32 portid) 1413 { 1414 return dcbnl_notify(dev, event, cmd, seq, portid, DCB_CAP_DCBX_VER_CEE); 1415 } 1416 EXPORT_SYMBOL(dcbnl_cee_notify); 1417 1418 /* Handle IEEE 802.1Qaz/802.1Qau/802.1Qbb SET commands. 1419 * If any requested operation can not be completed 1420 * the entire msg is aborted and error value is returned. 1421 * No attempt is made to reconcile the case where only part of the 1422 * cmd can be completed. 1423 */ 1424 static int dcbnl_ieee_set(struct net_device *netdev, struct nlmsghdr *nlh, 1425 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1426 { 1427 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops; 1428 struct nlattr *ieee[DCB_ATTR_IEEE_MAX + 1]; 1429 int err; 1430 1431 if (!ops) 1432 return -EOPNOTSUPP; 1433 1434 if (!tb[DCB_ATTR_IEEE]) 1435 return -EINVAL; 1436 1437 err = nla_parse_nested_deprecated(ieee, DCB_ATTR_IEEE_MAX, 1438 tb[DCB_ATTR_IEEE], 1439 dcbnl_ieee_policy, NULL); 1440 if (err) 1441 return err; 1442 1443 if (ieee[DCB_ATTR_IEEE_ETS] && ops->ieee_setets) { 1444 struct ieee_ets *ets = nla_data(ieee[DCB_ATTR_IEEE_ETS]); 1445 err = ops->ieee_setets(netdev, ets); 1446 if (err) 1447 goto err; 1448 } 1449 1450 if (ieee[DCB_ATTR_IEEE_MAXRATE] && ops->ieee_setmaxrate) { 1451 struct ieee_maxrate *maxrate = 1452 nla_data(ieee[DCB_ATTR_IEEE_MAXRATE]); 1453 err = ops->ieee_setmaxrate(netdev, maxrate); 1454 if (err) 1455 goto err; 1456 } 1457 1458 if (ieee[DCB_ATTR_IEEE_QCN] && ops->ieee_setqcn) { 1459 struct ieee_qcn *qcn = 1460 nla_data(ieee[DCB_ATTR_IEEE_QCN]); 1461 1462 err = ops->ieee_setqcn(netdev, qcn); 1463 if (err) 1464 goto err; 1465 } 1466 1467 if (ieee[DCB_ATTR_IEEE_PFC] && ops->ieee_setpfc) { 1468 struct ieee_pfc *pfc = nla_data(ieee[DCB_ATTR_IEEE_PFC]); 1469 err = ops->ieee_setpfc(netdev, pfc); 1470 if (err) 1471 goto err; 1472 } 1473 1474 if (ieee[DCB_ATTR_DCB_BUFFER] && ops->dcbnl_setbuffer) { 1475 struct dcbnl_buffer *buffer = 1476 nla_data(ieee[DCB_ATTR_DCB_BUFFER]); 1477 1478 err = ops->dcbnl_setbuffer(netdev, buffer); 1479 if (err) 1480 goto err; 1481 } 1482 1483 if (ieee[DCB_ATTR_IEEE_APP_TABLE]) { 1484 struct nlattr *attr; 1485 int rem; 1486 1487 nla_for_each_nested(attr, ieee[DCB_ATTR_IEEE_APP_TABLE], rem) { 1488 struct dcb_app *app_data; 1489 1490 if (nla_type(attr) != DCB_ATTR_IEEE_APP) 1491 continue; 1492 1493 if (nla_len(attr) < sizeof(struct dcb_app)) { 1494 err = -ERANGE; 1495 goto err; 1496 } 1497 1498 app_data = nla_data(attr); 1499 if (ops->ieee_setapp) 1500 err = ops->ieee_setapp(netdev, app_data); 1501 else 1502 err = dcb_ieee_setapp(netdev, app_data); 1503 if (err) 1504 goto err; 1505 } 1506 } 1507 1508 err: 1509 err = nla_put_u8(skb, DCB_ATTR_IEEE, err); 1510 dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_SET, seq, 0); 1511 return err; 1512 } 1513 1514 static int dcbnl_ieee_get(struct net_device *netdev, struct nlmsghdr *nlh, 1515 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1516 { 1517 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops; 1518 1519 if (!ops) 1520 return -EOPNOTSUPP; 1521 1522 return dcbnl_ieee_fill(skb, netdev); 1523 } 1524 1525 static int dcbnl_ieee_del(struct net_device *netdev, struct nlmsghdr *nlh, 1526 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1527 { 1528 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops; 1529 struct nlattr *ieee[DCB_ATTR_IEEE_MAX + 1]; 1530 int err; 1531 1532 if (!ops) 1533 return -EOPNOTSUPP; 1534 1535 if (!tb[DCB_ATTR_IEEE]) 1536 return -EINVAL; 1537 1538 err = nla_parse_nested_deprecated(ieee, DCB_ATTR_IEEE_MAX, 1539 tb[DCB_ATTR_IEEE], 1540 dcbnl_ieee_policy, NULL); 1541 if (err) 1542 return err; 1543 1544 if (ieee[DCB_ATTR_IEEE_APP_TABLE]) { 1545 struct nlattr *attr; 1546 int rem; 1547 1548 nla_for_each_nested(attr, ieee[DCB_ATTR_IEEE_APP_TABLE], rem) { 1549 struct dcb_app *app_data; 1550 1551 if (nla_type(attr) != DCB_ATTR_IEEE_APP) 1552 continue; 1553 app_data = nla_data(attr); 1554 if (ops->ieee_delapp) 1555 err = ops->ieee_delapp(netdev, app_data); 1556 else 1557 err = dcb_ieee_delapp(netdev, app_data); 1558 if (err) 1559 goto err; 1560 } 1561 } 1562 1563 err: 1564 err = nla_put_u8(skb, DCB_ATTR_IEEE, err); 1565 dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_DEL, seq, 0); 1566 return err; 1567 } 1568 1569 1570 /* DCBX configuration */ 1571 static int dcbnl_getdcbx(struct net_device *netdev, struct nlmsghdr *nlh, 1572 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1573 { 1574 if (!netdev->dcbnl_ops->getdcbx) 1575 return -EOPNOTSUPP; 1576 1577 return nla_put_u8(skb, DCB_ATTR_DCBX, 1578 netdev->dcbnl_ops->getdcbx(netdev)); 1579 } 1580 1581 static int dcbnl_setdcbx(struct net_device *netdev, struct nlmsghdr *nlh, 1582 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1583 { 1584 u8 value; 1585 1586 if (!netdev->dcbnl_ops->setdcbx) 1587 return -EOPNOTSUPP; 1588 1589 if (!tb[DCB_ATTR_DCBX]) 1590 return -EINVAL; 1591 1592 value = nla_get_u8(tb[DCB_ATTR_DCBX]); 1593 1594 return nla_put_u8(skb, DCB_ATTR_DCBX, 1595 netdev->dcbnl_ops->setdcbx(netdev, value)); 1596 } 1597 1598 static int dcbnl_getfeatcfg(struct net_device *netdev, struct nlmsghdr *nlh, 1599 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1600 { 1601 struct nlattr *data[DCB_FEATCFG_ATTR_MAX + 1], *nest; 1602 u8 value; 1603 int ret, i; 1604 int getall = 0; 1605 1606 if (!netdev->dcbnl_ops->getfeatcfg) 1607 return -EOPNOTSUPP; 1608 1609 if (!tb[DCB_ATTR_FEATCFG]) 1610 return -EINVAL; 1611 1612 ret = nla_parse_nested_deprecated(data, DCB_FEATCFG_ATTR_MAX, 1613 tb[DCB_ATTR_FEATCFG], 1614 dcbnl_featcfg_nest, NULL); 1615 if (ret) 1616 return ret; 1617 1618 nest = nla_nest_start_noflag(skb, DCB_ATTR_FEATCFG); 1619 if (!nest) 1620 return -EMSGSIZE; 1621 1622 if (data[DCB_FEATCFG_ATTR_ALL]) 1623 getall = 1; 1624 1625 for (i = DCB_FEATCFG_ATTR_ALL+1; i <= DCB_FEATCFG_ATTR_MAX; i++) { 1626 if (!getall && !data[i]) 1627 continue; 1628 1629 ret = netdev->dcbnl_ops->getfeatcfg(netdev, i, &value); 1630 if (!ret) 1631 ret = nla_put_u8(skb, i, value); 1632 1633 if (ret) { 1634 nla_nest_cancel(skb, nest); 1635 goto nla_put_failure; 1636 } 1637 } 1638 nla_nest_end(skb, nest); 1639 1640 nla_put_failure: 1641 return ret; 1642 } 1643 1644 static int dcbnl_setfeatcfg(struct net_device *netdev, struct nlmsghdr *nlh, 1645 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1646 { 1647 struct nlattr *data[DCB_FEATCFG_ATTR_MAX + 1]; 1648 int ret, i; 1649 u8 value; 1650 1651 if (!netdev->dcbnl_ops->setfeatcfg) 1652 return -ENOTSUPP; 1653 1654 if (!tb[DCB_ATTR_FEATCFG]) 1655 return -EINVAL; 1656 1657 ret = nla_parse_nested_deprecated(data, DCB_FEATCFG_ATTR_MAX, 1658 tb[DCB_ATTR_FEATCFG], 1659 dcbnl_featcfg_nest, NULL); 1660 1661 if (ret) 1662 goto err; 1663 1664 for (i = DCB_FEATCFG_ATTR_ALL+1; i <= DCB_FEATCFG_ATTR_MAX; i++) { 1665 if (data[i] == NULL) 1666 continue; 1667 1668 value = nla_get_u8(data[i]); 1669 1670 ret = netdev->dcbnl_ops->setfeatcfg(netdev, i, value); 1671 1672 if (ret) 1673 goto err; 1674 } 1675 err: 1676 ret = nla_put_u8(skb, DCB_ATTR_FEATCFG, ret); 1677 1678 return ret; 1679 } 1680 1681 /* Handle CEE DCBX GET commands. */ 1682 static int dcbnl_cee_get(struct net_device *netdev, struct nlmsghdr *nlh, 1683 u32 seq, struct nlattr **tb, struct sk_buff *skb) 1684 { 1685 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops; 1686 1687 if (!ops) 1688 return -EOPNOTSUPP; 1689 1690 return dcbnl_cee_fill(skb, netdev); 1691 } 1692 1693 struct reply_func { 1694 /* reply netlink message type */ 1695 int type; 1696 1697 /* function to fill message contents */ 1698 int (*cb)(struct net_device *, struct nlmsghdr *, u32, 1699 struct nlattr **, struct sk_buff *); 1700 }; 1701 1702 static const struct reply_func reply_funcs[DCB_CMD_MAX+1] = { 1703 [DCB_CMD_GSTATE] = { RTM_GETDCB, dcbnl_getstate }, 1704 [DCB_CMD_SSTATE] = { RTM_SETDCB, dcbnl_setstate }, 1705 [DCB_CMD_PFC_GCFG] = { RTM_GETDCB, dcbnl_getpfccfg }, 1706 [DCB_CMD_PFC_SCFG] = { RTM_SETDCB, dcbnl_setpfccfg }, 1707 [DCB_CMD_GPERM_HWADDR] = { RTM_GETDCB, dcbnl_getperm_hwaddr }, 1708 [DCB_CMD_GCAP] = { RTM_GETDCB, dcbnl_getcap }, 1709 [DCB_CMD_GNUMTCS] = { RTM_GETDCB, dcbnl_getnumtcs }, 1710 [DCB_CMD_SNUMTCS] = { RTM_SETDCB, dcbnl_setnumtcs }, 1711 [DCB_CMD_PFC_GSTATE] = { RTM_GETDCB, dcbnl_getpfcstate }, 1712 [DCB_CMD_PFC_SSTATE] = { RTM_SETDCB, dcbnl_setpfcstate }, 1713 [DCB_CMD_GAPP] = { RTM_GETDCB, dcbnl_getapp }, 1714 [DCB_CMD_SAPP] = { RTM_SETDCB, dcbnl_setapp }, 1715 [DCB_CMD_PGTX_GCFG] = { RTM_GETDCB, dcbnl_pgtx_getcfg }, 1716 [DCB_CMD_PGTX_SCFG] = { RTM_SETDCB, dcbnl_pgtx_setcfg }, 1717 [DCB_CMD_PGRX_GCFG] = { RTM_GETDCB, dcbnl_pgrx_getcfg }, 1718 [DCB_CMD_PGRX_SCFG] = { RTM_SETDCB, dcbnl_pgrx_setcfg }, 1719 [DCB_CMD_SET_ALL] = { RTM_SETDCB, dcbnl_setall }, 1720 [DCB_CMD_BCN_GCFG] = { RTM_GETDCB, dcbnl_bcn_getcfg }, 1721 [DCB_CMD_BCN_SCFG] = { RTM_SETDCB, dcbnl_bcn_setcfg }, 1722 [DCB_CMD_IEEE_GET] = { RTM_GETDCB, dcbnl_ieee_get }, 1723 [DCB_CMD_IEEE_SET] = { RTM_SETDCB, dcbnl_ieee_set }, 1724 [DCB_CMD_IEEE_DEL] = { RTM_SETDCB, dcbnl_ieee_del }, 1725 [DCB_CMD_GDCBX] = { RTM_GETDCB, dcbnl_getdcbx }, 1726 [DCB_CMD_SDCBX] = { RTM_SETDCB, dcbnl_setdcbx }, 1727 [DCB_CMD_GFEATCFG] = { RTM_GETDCB, dcbnl_getfeatcfg }, 1728 [DCB_CMD_SFEATCFG] = { RTM_SETDCB, dcbnl_setfeatcfg }, 1729 [DCB_CMD_CEE_GET] = { RTM_GETDCB, dcbnl_cee_get }, 1730 }; 1731 1732 static int dcb_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 1733 struct netlink_ext_ack *extack) 1734 { 1735 struct net *net = sock_net(skb->sk); 1736 struct net_device *netdev; 1737 struct dcbmsg *dcb = nlmsg_data(nlh); 1738 struct nlattr *tb[DCB_ATTR_MAX + 1]; 1739 u32 portid = NETLINK_CB(skb).portid; 1740 int ret = -EINVAL; 1741 struct sk_buff *reply_skb; 1742 struct nlmsghdr *reply_nlh = NULL; 1743 const struct reply_func *fn; 1744 1745 if ((nlh->nlmsg_type == RTM_SETDCB) && !netlink_capable(skb, CAP_NET_ADMIN)) 1746 return -EPERM; 1747 1748 ret = nlmsg_parse_deprecated(nlh, sizeof(*dcb), tb, DCB_ATTR_MAX, 1749 dcbnl_rtnl_policy, extack); 1750 if (ret < 0) 1751 return ret; 1752 1753 if (dcb->cmd > DCB_CMD_MAX) 1754 return -EINVAL; 1755 1756 /* check if a reply function has been defined for the command */ 1757 fn = &reply_funcs[dcb->cmd]; 1758 if (!fn->cb) 1759 return -EOPNOTSUPP; 1760 1761 if (!tb[DCB_ATTR_IFNAME]) 1762 return -EINVAL; 1763 1764 netdev = __dev_get_by_name(net, nla_data(tb[DCB_ATTR_IFNAME])); 1765 if (!netdev) 1766 return -ENODEV; 1767 1768 if (!netdev->dcbnl_ops) 1769 return -EOPNOTSUPP; 1770 1771 reply_skb = dcbnl_newmsg(fn->type, dcb->cmd, portid, nlh->nlmsg_seq, 1772 nlh->nlmsg_flags, &reply_nlh); 1773 if (!reply_skb) 1774 return -ENOBUFS; 1775 1776 ret = fn->cb(netdev, nlh, nlh->nlmsg_seq, tb, reply_skb); 1777 if (ret < 0) { 1778 nlmsg_free(reply_skb); 1779 goto out; 1780 } 1781 1782 nlmsg_end(reply_skb, reply_nlh); 1783 1784 ret = rtnl_unicast(reply_skb, net, portid); 1785 out: 1786 return ret; 1787 } 1788 1789 static struct dcb_app_type *dcb_app_lookup(const struct dcb_app *app, 1790 int ifindex, int prio) 1791 { 1792 struct dcb_app_type *itr; 1793 1794 list_for_each_entry(itr, &dcb_app_list, list) { 1795 if (itr->app.selector == app->selector && 1796 itr->app.protocol == app->protocol && 1797 itr->ifindex == ifindex && 1798 ((prio == -1) || itr->app.priority == prio)) 1799 return itr; 1800 } 1801 1802 return NULL; 1803 } 1804 1805 static int dcb_app_add(const struct dcb_app *app, int ifindex) 1806 { 1807 struct dcb_app_type *entry; 1808 1809 entry = kmalloc(sizeof(*entry), GFP_ATOMIC); 1810 if (!entry) 1811 return -ENOMEM; 1812 1813 memcpy(&entry->app, app, sizeof(*app)); 1814 entry->ifindex = ifindex; 1815 list_add(&entry->list, &dcb_app_list); 1816 1817 return 0; 1818 } 1819 1820 /** 1821 * dcb_getapp - retrieve the DCBX application user priority 1822 * 1823 * On success returns a non-zero 802.1p user priority bitmap 1824 * otherwise returns 0 as the invalid user priority bitmap to 1825 * indicate an error. 1826 */ 1827 u8 dcb_getapp(struct net_device *dev, struct dcb_app *app) 1828 { 1829 struct dcb_app_type *itr; 1830 u8 prio = 0; 1831 1832 spin_lock_bh(&dcb_lock); 1833 itr = dcb_app_lookup(app, dev->ifindex, -1); 1834 if (itr) 1835 prio = itr->app.priority; 1836 spin_unlock_bh(&dcb_lock); 1837 1838 return prio; 1839 } 1840 EXPORT_SYMBOL(dcb_getapp); 1841 1842 /** 1843 * dcb_setapp - add CEE dcb application data to app list 1844 * 1845 * Priority 0 is an invalid priority in CEE spec. This routine 1846 * removes applications from the app list if the priority is 1847 * set to zero. Priority is expected to be 8-bit 802.1p user priority bitmap 1848 */ 1849 int dcb_setapp(struct net_device *dev, struct dcb_app *new) 1850 { 1851 struct dcb_app_type *itr; 1852 struct dcb_app_type event; 1853 int err = 0; 1854 1855 event.ifindex = dev->ifindex; 1856 memcpy(&event.app, new, sizeof(event.app)); 1857 if (dev->dcbnl_ops->getdcbx) 1858 event.dcbx = dev->dcbnl_ops->getdcbx(dev); 1859 1860 spin_lock_bh(&dcb_lock); 1861 /* Search for existing match and replace */ 1862 itr = dcb_app_lookup(new, dev->ifindex, -1); 1863 if (itr) { 1864 if (new->priority) 1865 itr->app.priority = new->priority; 1866 else { 1867 list_del(&itr->list); 1868 kfree(itr); 1869 } 1870 goto out; 1871 } 1872 /* App type does not exist add new application type */ 1873 if (new->priority) 1874 err = dcb_app_add(new, dev->ifindex); 1875 out: 1876 spin_unlock_bh(&dcb_lock); 1877 if (!err) 1878 call_dcbevent_notifiers(DCB_APP_EVENT, &event); 1879 return err; 1880 } 1881 EXPORT_SYMBOL(dcb_setapp); 1882 1883 /** 1884 * dcb_ieee_getapp_mask - retrieve the IEEE DCB application priority 1885 * 1886 * Helper routine which on success returns a non-zero 802.1Qaz user 1887 * priority bitmap otherwise returns 0 to indicate the dcb_app was 1888 * not found in APP list. 1889 */ 1890 u8 dcb_ieee_getapp_mask(struct net_device *dev, struct dcb_app *app) 1891 { 1892 struct dcb_app_type *itr; 1893 u8 prio = 0; 1894 1895 spin_lock_bh(&dcb_lock); 1896 itr = dcb_app_lookup(app, dev->ifindex, -1); 1897 if (itr) 1898 prio |= 1 << itr->app.priority; 1899 spin_unlock_bh(&dcb_lock); 1900 1901 return prio; 1902 } 1903 EXPORT_SYMBOL(dcb_ieee_getapp_mask); 1904 1905 /** 1906 * dcb_ieee_setapp - add IEEE dcb application data to app list 1907 * 1908 * This adds Application data to the list. Multiple application 1909 * entries may exists for the same selector and protocol as long 1910 * as the priorities are different. Priority is expected to be a 1911 * 3-bit unsigned integer 1912 */ 1913 int dcb_ieee_setapp(struct net_device *dev, struct dcb_app *new) 1914 { 1915 struct dcb_app_type event; 1916 int err = 0; 1917 1918 event.ifindex = dev->ifindex; 1919 memcpy(&event.app, new, sizeof(event.app)); 1920 if (dev->dcbnl_ops->getdcbx) 1921 event.dcbx = dev->dcbnl_ops->getdcbx(dev); 1922 1923 spin_lock_bh(&dcb_lock); 1924 /* Search for existing match and abort if found */ 1925 if (dcb_app_lookup(new, dev->ifindex, new->priority)) { 1926 err = -EEXIST; 1927 goto out; 1928 } 1929 1930 err = dcb_app_add(new, dev->ifindex); 1931 out: 1932 spin_unlock_bh(&dcb_lock); 1933 if (!err) 1934 call_dcbevent_notifiers(DCB_APP_EVENT, &event); 1935 return err; 1936 } 1937 EXPORT_SYMBOL(dcb_ieee_setapp); 1938 1939 /** 1940 * dcb_ieee_delapp - delete IEEE dcb application data from list 1941 * 1942 * This removes a matching APP data from the APP list 1943 */ 1944 int dcb_ieee_delapp(struct net_device *dev, struct dcb_app *del) 1945 { 1946 struct dcb_app_type *itr; 1947 struct dcb_app_type event; 1948 int err = -ENOENT; 1949 1950 event.ifindex = dev->ifindex; 1951 memcpy(&event.app, del, sizeof(event.app)); 1952 if (dev->dcbnl_ops->getdcbx) 1953 event.dcbx = dev->dcbnl_ops->getdcbx(dev); 1954 1955 spin_lock_bh(&dcb_lock); 1956 /* Search for existing match and remove it. */ 1957 if ((itr = dcb_app_lookup(del, dev->ifindex, del->priority))) { 1958 list_del(&itr->list); 1959 kfree(itr); 1960 err = 0; 1961 } 1962 1963 spin_unlock_bh(&dcb_lock); 1964 if (!err) 1965 call_dcbevent_notifiers(DCB_APP_EVENT, &event); 1966 return err; 1967 } 1968 EXPORT_SYMBOL(dcb_ieee_delapp); 1969 1970 /** 1971 * dcb_ieee_getapp_prio_dscp_mask_map - For a given device, find mapping from 1972 * priorities to the DSCP values assigned to that priority. Initialize p_map 1973 * such that each map element holds a bit mask of DSCP values configured for 1974 * that priority by APP entries. 1975 */ 1976 void dcb_ieee_getapp_prio_dscp_mask_map(const struct net_device *dev, 1977 struct dcb_ieee_app_prio_map *p_map) 1978 { 1979 int ifindex = dev->ifindex; 1980 struct dcb_app_type *itr; 1981 u8 prio; 1982 1983 memset(p_map->map, 0, sizeof(p_map->map)); 1984 1985 spin_lock_bh(&dcb_lock); 1986 list_for_each_entry(itr, &dcb_app_list, list) { 1987 if (itr->ifindex == ifindex && 1988 itr->app.selector == IEEE_8021QAZ_APP_SEL_DSCP && 1989 itr->app.protocol < 64 && 1990 itr->app.priority < IEEE_8021QAZ_MAX_TCS) { 1991 prio = itr->app.priority; 1992 p_map->map[prio] |= 1ULL << itr->app.protocol; 1993 } 1994 } 1995 spin_unlock_bh(&dcb_lock); 1996 } 1997 EXPORT_SYMBOL(dcb_ieee_getapp_prio_dscp_mask_map); 1998 1999 /** 2000 * dcb_ieee_getapp_dscp_prio_mask_map - For a given device, find mapping from 2001 * DSCP values to the priorities assigned to that DSCP value. Initialize p_map 2002 * such that each map element holds a bit mask of priorities configured for a 2003 * given DSCP value by APP entries. 2004 */ 2005 void 2006 dcb_ieee_getapp_dscp_prio_mask_map(const struct net_device *dev, 2007 struct dcb_ieee_app_dscp_map *p_map) 2008 { 2009 int ifindex = dev->ifindex; 2010 struct dcb_app_type *itr; 2011 2012 memset(p_map->map, 0, sizeof(p_map->map)); 2013 2014 spin_lock_bh(&dcb_lock); 2015 list_for_each_entry(itr, &dcb_app_list, list) { 2016 if (itr->ifindex == ifindex && 2017 itr->app.selector == IEEE_8021QAZ_APP_SEL_DSCP && 2018 itr->app.protocol < 64 && 2019 itr->app.priority < IEEE_8021QAZ_MAX_TCS) 2020 p_map->map[itr->app.protocol] |= 1 << itr->app.priority; 2021 } 2022 spin_unlock_bh(&dcb_lock); 2023 } 2024 EXPORT_SYMBOL(dcb_ieee_getapp_dscp_prio_mask_map); 2025 2026 /** 2027 * Per 802.1Q-2014, the selector value of 1 is used for matching on Ethernet 2028 * type, with valid PID values >= 1536. A special meaning is then assigned to 2029 * protocol value of 0: "default priority. For use when priority is not 2030 * otherwise specified". 2031 * 2032 * dcb_ieee_getapp_default_prio_mask - For a given device, find all APP entries 2033 * of the form {$PRIO, ETHERTYPE, 0} and construct a bit mask of all default 2034 * priorities set by these entries. 2035 */ 2036 u8 dcb_ieee_getapp_default_prio_mask(const struct net_device *dev) 2037 { 2038 int ifindex = dev->ifindex; 2039 struct dcb_app_type *itr; 2040 u8 mask = 0; 2041 2042 spin_lock_bh(&dcb_lock); 2043 list_for_each_entry(itr, &dcb_app_list, list) { 2044 if (itr->ifindex == ifindex && 2045 itr->app.selector == IEEE_8021QAZ_APP_SEL_ETHERTYPE && 2046 itr->app.protocol == 0 && 2047 itr->app.priority < IEEE_8021QAZ_MAX_TCS) 2048 mask |= 1 << itr->app.priority; 2049 } 2050 spin_unlock_bh(&dcb_lock); 2051 2052 return mask; 2053 } 2054 EXPORT_SYMBOL(dcb_ieee_getapp_default_prio_mask); 2055 2056 static int __init dcbnl_init(void) 2057 { 2058 INIT_LIST_HEAD(&dcb_app_list); 2059 2060 rtnl_register(PF_UNSPEC, RTM_GETDCB, dcb_doit, NULL, 0); 2061 rtnl_register(PF_UNSPEC, RTM_SETDCB, dcb_doit, NULL, 0); 2062 2063 return 0; 2064 } 2065 device_initcall(dcbnl_init); 2066