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_bcn_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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.