2 * Copyright (c) 2008-2011, Intel Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, see <http://www.gnu.org/licenses/>.
16 * Description: Data Center Bridging netlink interface
17 * Author: Lucy Liu <lucy.liu@intel.com>
20 #include <linux/netdevice.h>
21 #include <linux/netlink.h>
22 #include <linux/slab.h>
23 #include <net/netlink.h>
24 #include <net/rtnetlink.h>
25 #include <linux/dcbnl.h>
26 #include <net/dcbevent.h>
27 #include <linux/rtnetlink.h>
28 #include <linux/init.h>
31 /* Data Center Bridging (DCB) is a collection of Ethernet enhancements
32 * intended to allow network traffic with differing requirements
33 * (highly reliable, no drops vs. best effort vs. low latency) to operate
34 * and co-exist on Ethernet. Current DCB features are:
36 * Enhanced Transmission Selection (aka Priority Grouping [PG]) - provides a
37 * framework for assigning bandwidth guarantees to traffic classes.
39 * Priority-based Flow Control (PFC) - provides a flow control mechanism which
40 * can work independently for each 802.1p priority.
42 * Congestion Notification - provides a mechanism for end-to-end congestion
43 * control for protocols which do not have built-in congestion management.
45 * More information about the emerging standards for these Ethernet features
46 * can be found at: http://www.ieee802.org/1/pages/dcbridges.html
48 * This file implements an rtnetlink interface to allow configuration of DCB
49 * features for capable devices.
52 /**************** DCB attribute policies *************************************/
54 /* DCB netlink attributes policy */
55 static const struct nla_policy dcbnl_rtnl_policy
[DCB_ATTR_MAX
+ 1] = {
56 [DCB_ATTR_IFNAME
] = {.type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
- 1},
57 [DCB_ATTR_STATE
] = {.type
= NLA_U8
},
58 [DCB_ATTR_PFC_CFG
] = {.type
= NLA_NESTED
},
59 [DCB_ATTR_PG_CFG
] = {.type
= NLA_NESTED
},
60 [DCB_ATTR_SET_ALL
] = {.type
= NLA_U8
},
61 [DCB_ATTR_PERM_HWADDR
] = {.type
= NLA_FLAG
},
62 [DCB_ATTR_CAP
] = {.type
= NLA_NESTED
},
63 [DCB_ATTR_PFC_STATE
] = {.type
= NLA_U8
},
64 [DCB_ATTR_BCN
] = {.type
= NLA_NESTED
},
65 [DCB_ATTR_APP
] = {.type
= NLA_NESTED
},
66 [DCB_ATTR_IEEE
] = {.type
= NLA_NESTED
},
67 [DCB_ATTR_DCBX
] = {.type
= NLA_U8
},
68 [DCB_ATTR_FEATCFG
] = {.type
= NLA_NESTED
},
71 /* DCB priority flow control to User Priority nested attributes */
72 static const struct nla_policy dcbnl_pfc_up_nest
[DCB_PFC_UP_ATTR_MAX
+ 1] = {
73 [DCB_PFC_UP_ATTR_0
] = {.type
= NLA_U8
},
74 [DCB_PFC_UP_ATTR_1
] = {.type
= NLA_U8
},
75 [DCB_PFC_UP_ATTR_2
] = {.type
= NLA_U8
},
76 [DCB_PFC_UP_ATTR_3
] = {.type
= NLA_U8
},
77 [DCB_PFC_UP_ATTR_4
] = {.type
= NLA_U8
},
78 [DCB_PFC_UP_ATTR_5
] = {.type
= NLA_U8
},
79 [DCB_PFC_UP_ATTR_6
] = {.type
= NLA_U8
},
80 [DCB_PFC_UP_ATTR_7
] = {.type
= NLA_U8
},
81 [DCB_PFC_UP_ATTR_ALL
] = {.type
= NLA_FLAG
},
84 /* DCB priority grouping nested attributes */
85 static const struct nla_policy dcbnl_pg_nest
[DCB_PG_ATTR_MAX
+ 1] = {
86 [DCB_PG_ATTR_TC_0
] = {.type
= NLA_NESTED
},
87 [DCB_PG_ATTR_TC_1
] = {.type
= NLA_NESTED
},
88 [DCB_PG_ATTR_TC_2
] = {.type
= NLA_NESTED
},
89 [DCB_PG_ATTR_TC_3
] = {.type
= NLA_NESTED
},
90 [DCB_PG_ATTR_TC_4
] = {.type
= NLA_NESTED
},
91 [DCB_PG_ATTR_TC_5
] = {.type
= NLA_NESTED
},
92 [DCB_PG_ATTR_TC_6
] = {.type
= NLA_NESTED
},
93 [DCB_PG_ATTR_TC_7
] = {.type
= NLA_NESTED
},
94 [DCB_PG_ATTR_TC_ALL
] = {.type
= NLA_NESTED
},
95 [DCB_PG_ATTR_BW_ID_0
] = {.type
= NLA_U8
},
96 [DCB_PG_ATTR_BW_ID_1
] = {.type
= NLA_U8
},
97 [DCB_PG_ATTR_BW_ID_2
] = {.type
= NLA_U8
},
98 [DCB_PG_ATTR_BW_ID_3
] = {.type
= NLA_U8
},
99 [DCB_PG_ATTR_BW_ID_4
] = {.type
= NLA_U8
},
100 [DCB_PG_ATTR_BW_ID_5
] = {.type
= NLA_U8
},
101 [DCB_PG_ATTR_BW_ID_6
] = {.type
= NLA_U8
},
102 [DCB_PG_ATTR_BW_ID_7
] = {.type
= NLA_U8
},
103 [DCB_PG_ATTR_BW_ID_ALL
] = {.type
= NLA_FLAG
},
106 /* DCB traffic class nested attributes. */
107 static const struct nla_policy dcbnl_tc_param_nest
[DCB_TC_ATTR_PARAM_MAX
+ 1] = {
108 [DCB_TC_ATTR_PARAM_PGID
] = {.type
= NLA_U8
},
109 [DCB_TC_ATTR_PARAM_UP_MAPPING
] = {.type
= NLA_U8
},
110 [DCB_TC_ATTR_PARAM_STRICT_PRIO
] = {.type
= NLA_U8
},
111 [DCB_TC_ATTR_PARAM_BW_PCT
] = {.type
= NLA_U8
},
112 [DCB_TC_ATTR_PARAM_ALL
] = {.type
= NLA_FLAG
},
115 /* DCB capabilities nested attributes. */
116 static const struct nla_policy dcbnl_cap_nest
[DCB_CAP_ATTR_MAX
+ 1] = {
117 [DCB_CAP_ATTR_ALL
] = {.type
= NLA_FLAG
},
118 [DCB_CAP_ATTR_PG
] = {.type
= NLA_U8
},
119 [DCB_CAP_ATTR_PFC
] = {.type
= NLA_U8
},
120 [DCB_CAP_ATTR_UP2TC
] = {.type
= NLA_U8
},
121 [DCB_CAP_ATTR_PG_TCS
] = {.type
= NLA_U8
},
122 [DCB_CAP_ATTR_PFC_TCS
] = {.type
= NLA_U8
},
123 [DCB_CAP_ATTR_GSP
] = {.type
= NLA_U8
},
124 [DCB_CAP_ATTR_BCN
] = {.type
= NLA_U8
},
125 [DCB_CAP_ATTR_DCBX
] = {.type
= NLA_U8
},
128 /* DCB capabilities nested attributes. */
129 static const struct nla_policy dcbnl_numtcs_nest
[DCB_NUMTCS_ATTR_MAX
+ 1] = {
130 [DCB_NUMTCS_ATTR_ALL
] = {.type
= NLA_FLAG
},
131 [DCB_NUMTCS_ATTR_PG
] = {.type
= NLA_U8
},
132 [DCB_NUMTCS_ATTR_PFC
] = {.type
= NLA_U8
},
135 /* DCB BCN nested attributes. */
136 static const struct nla_policy dcbnl_bcn_nest
[DCB_BCN_ATTR_MAX
+ 1] = {
137 [DCB_BCN_ATTR_RP_0
] = {.type
= NLA_U8
},
138 [DCB_BCN_ATTR_RP_1
] = {.type
= NLA_U8
},
139 [DCB_BCN_ATTR_RP_2
] = {.type
= NLA_U8
},
140 [DCB_BCN_ATTR_RP_3
] = {.type
= NLA_U8
},
141 [DCB_BCN_ATTR_RP_4
] = {.type
= NLA_U8
},
142 [DCB_BCN_ATTR_RP_5
] = {.type
= NLA_U8
},
143 [DCB_BCN_ATTR_RP_6
] = {.type
= NLA_U8
},
144 [DCB_BCN_ATTR_RP_7
] = {.type
= NLA_U8
},
145 [DCB_BCN_ATTR_RP_ALL
] = {.type
= NLA_FLAG
},
146 [DCB_BCN_ATTR_BCNA_0
] = {.type
= NLA_U32
},
147 [DCB_BCN_ATTR_BCNA_1
] = {.type
= NLA_U32
},
148 [DCB_BCN_ATTR_ALPHA
] = {.type
= NLA_U32
},
149 [DCB_BCN_ATTR_BETA
] = {.type
= NLA_U32
},
150 [DCB_BCN_ATTR_GD
] = {.type
= NLA_U32
},
151 [DCB_BCN_ATTR_GI
] = {.type
= NLA_U32
},
152 [DCB_BCN_ATTR_TMAX
] = {.type
= NLA_U32
},
153 [DCB_BCN_ATTR_TD
] = {.type
= NLA_U32
},
154 [DCB_BCN_ATTR_RMIN
] = {.type
= NLA_U32
},
155 [DCB_BCN_ATTR_W
] = {.type
= NLA_U32
},
156 [DCB_BCN_ATTR_RD
] = {.type
= NLA_U32
},
157 [DCB_BCN_ATTR_RU
] = {.type
= NLA_U32
},
158 [DCB_BCN_ATTR_WRTT
] = {.type
= NLA_U32
},
159 [DCB_BCN_ATTR_RI
] = {.type
= NLA_U32
},
160 [DCB_BCN_ATTR_C
] = {.type
= NLA_U32
},
161 [DCB_BCN_ATTR_ALL
] = {.type
= NLA_FLAG
},
164 /* DCB APP nested attributes. */
165 static const struct nla_policy dcbnl_app_nest
[DCB_APP_ATTR_MAX
+ 1] = {
166 [DCB_APP_ATTR_IDTYPE
] = {.type
= NLA_U8
},
167 [DCB_APP_ATTR_ID
] = {.type
= NLA_U16
},
168 [DCB_APP_ATTR_PRIORITY
] = {.type
= NLA_U8
},
171 /* IEEE 802.1Qaz nested attributes. */
172 static const struct nla_policy dcbnl_ieee_policy
[DCB_ATTR_IEEE_MAX
+ 1] = {
173 [DCB_ATTR_IEEE_ETS
] = {.len
= sizeof(struct ieee_ets
)},
174 [DCB_ATTR_IEEE_PFC
] = {.len
= sizeof(struct ieee_pfc
)},
175 [DCB_ATTR_IEEE_APP_TABLE
] = {.type
= NLA_NESTED
},
176 [DCB_ATTR_IEEE_MAXRATE
] = {.len
= sizeof(struct ieee_maxrate
)},
177 [DCB_ATTR_IEEE_QCN
] = {.len
= sizeof(struct ieee_qcn
)},
178 [DCB_ATTR_IEEE_QCN_STATS
] = {.len
= sizeof(struct ieee_qcn_stats
)},
181 static const struct nla_policy dcbnl_ieee_app
[DCB_ATTR_IEEE_APP_MAX
+ 1] = {
182 [DCB_ATTR_IEEE_APP
] = {.len
= sizeof(struct dcb_app
)},
185 /* DCB number of traffic classes nested attributes. */
186 static const struct nla_policy dcbnl_featcfg_nest
[DCB_FEATCFG_ATTR_MAX
+ 1] = {
187 [DCB_FEATCFG_ATTR_ALL
] = {.type
= NLA_FLAG
},
188 [DCB_FEATCFG_ATTR_PG
] = {.type
= NLA_U8
},
189 [DCB_FEATCFG_ATTR_PFC
] = {.type
= NLA_U8
},
190 [DCB_FEATCFG_ATTR_APP
] = {.type
= NLA_U8
},
193 static LIST_HEAD(dcb_app_list
);
194 static DEFINE_SPINLOCK(dcb_lock
);
196 static struct sk_buff
*dcbnl_newmsg(int type
, u8 cmd
, u32 port
, u32 seq
,
197 u32 flags
, struct nlmsghdr
**nlhp
)
201 struct nlmsghdr
*nlh
;
203 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
207 nlh
= nlmsg_put(skb
, port
, seq
, type
, sizeof(*dcb
), flags
);
210 dcb
= nlmsg_data(nlh
);
211 dcb
->dcb_family
= AF_UNSPEC
;
221 static int dcbnl_getstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
222 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
224 /* if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->getstate) */
225 if (!netdev
->dcbnl_ops
->getstate
)
228 return nla_put_u8(skb
, DCB_ATTR_STATE
,
229 netdev
->dcbnl_ops
->getstate(netdev
));
232 static int dcbnl_getpfccfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
233 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
235 struct nlattr
*data
[DCB_PFC_UP_ATTR_MAX
+ 1], *nest
;
241 if (!tb
[DCB_ATTR_PFC_CFG
])
244 if (!netdev
->dcbnl_ops
->getpfccfg
)
247 ret
= nla_parse_nested(data
, DCB_PFC_UP_ATTR_MAX
,
248 tb
[DCB_ATTR_PFC_CFG
], dcbnl_pfc_up_nest
, NULL
);
252 nest
= nla_nest_start(skb
, DCB_ATTR_PFC_CFG
);
256 if (data
[DCB_PFC_UP_ATTR_ALL
])
259 for (i
= DCB_PFC_UP_ATTR_0
; i
<= DCB_PFC_UP_ATTR_7
; i
++) {
260 if (!getall
&& !data
[i
])
263 netdev
->dcbnl_ops
->getpfccfg(netdev
, i
- DCB_PFC_UP_ATTR_0
,
265 ret
= nla_put_u8(skb
, i
, value
);
267 nla_nest_cancel(skb
, nest
);
271 nla_nest_end(skb
, nest
);
276 static int dcbnl_getperm_hwaddr(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
277 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
279 u8 perm_addr
[MAX_ADDR_LEN
];
281 if (!netdev
->dcbnl_ops
->getpermhwaddr
)
284 memset(perm_addr
, 0, sizeof(perm_addr
));
285 netdev
->dcbnl_ops
->getpermhwaddr(netdev
, perm_addr
);
287 return nla_put(skb
, DCB_ATTR_PERM_HWADDR
, sizeof(perm_addr
), perm_addr
);
290 static int dcbnl_getcap(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
291 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
293 struct nlattr
*data
[DCB_CAP_ATTR_MAX
+ 1], *nest
;
299 if (!tb
[DCB_ATTR_CAP
])
302 if (!netdev
->dcbnl_ops
->getcap
)
305 ret
= nla_parse_nested(data
, DCB_CAP_ATTR_MAX
, tb
[DCB_ATTR_CAP
],
306 dcbnl_cap_nest
, NULL
);
310 nest
= nla_nest_start(skb
, DCB_ATTR_CAP
);
314 if (data
[DCB_CAP_ATTR_ALL
])
317 for (i
= DCB_CAP_ATTR_ALL
+1; i
<= DCB_CAP_ATTR_MAX
; i
++) {
318 if (!getall
&& !data
[i
])
321 if (!netdev
->dcbnl_ops
->getcap(netdev
, i
, &value
)) {
322 ret
= nla_put_u8(skb
, i
, value
);
324 nla_nest_cancel(skb
, nest
);
329 nla_nest_end(skb
, nest
);
334 static int dcbnl_getnumtcs(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
335 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
337 struct nlattr
*data
[DCB_NUMTCS_ATTR_MAX
+ 1], *nest
;
343 if (!tb
[DCB_ATTR_NUMTCS
])
346 if (!netdev
->dcbnl_ops
->getnumtcs
)
349 ret
= nla_parse_nested(data
, DCB_NUMTCS_ATTR_MAX
, tb
[DCB_ATTR_NUMTCS
],
350 dcbnl_numtcs_nest
, NULL
);
354 nest
= nla_nest_start(skb
, DCB_ATTR_NUMTCS
);
358 if (data
[DCB_NUMTCS_ATTR_ALL
])
361 for (i
= DCB_NUMTCS_ATTR_ALL
+1; i
<= DCB_NUMTCS_ATTR_MAX
; i
++) {
362 if (!getall
&& !data
[i
])
365 ret
= netdev
->dcbnl_ops
->getnumtcs(netdev
, i
, &value
);
367 ret
= nla_put_u8(skb
, i
, value
);
369 nla_nest_cancel(skb
, nest
);
375 nla_nest_end(skb
, nest
);
380 static int dcbnl_setnumtcs(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
381 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
383 struct nlattr
*data
[DCB_NUMTCS_ATTR_MAX
+ 1];
388 if (!tb
[DCB_ATTR_NUMTCS
])
391 if (!netdev
->dcbnl_ops
->setnumtcs
)
394 ret
= nla_parse_nested(data
, DCB_NUMTCS_ATTR_MAX
, tb
[DCB_ATTR_NUMTCS
],
395 dcbnl_numtcs_nest
, NULL
);
399 for (i
= DCB_NUMTCS_ATTR_ALL
+1; i
<= DCB_NUMTCS_ATTR_MAX
; i
++) {
403 value
= nla_get_u8(data
[i
]);
405 ret
= netdev
->dcbnl_ops
->setnumtcs(netdev
, i
, value
);
410 return nla_put_u8(skb
, DCB_ATTR_NUMTCS
, !!ret
);
413 static int dcbnl_getpfcstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
414 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
416 if (!netdev
->dcbnl_ops
->getpfcstate
)
419 return nla_put_u8(skb
, DCB_ATTR_PFC_STATE
,
420 netdev
->dcbnl_ops
->getpfcstate(netdev
));
423 static int dcbnl_setpfcstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
424 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
428 if (!tb
[DCB_ATTR_PFC_STATE
])
431 if (!netdev
->dcbnl_ops
->setpfcstate
)
434 value
= nla_get_u8(tb
[DCB_ATTR_PFC_STATE
]);
436 netdev
->dcbnl_ops
->setpfcstate(netdev
, value
);
438 return nla_put_u8(skb
, DCB_ATTR_PFC_STATE
, 0);
441 static int dcbnl_getapp(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
442 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
444 struct nlattr
*app_nest
;
445 struct nlattr
*app_tb
[DCB_APP_ATTR_MAX
+ 1];
450 if (!tb
[DCB_ATTR_APP
])
453 ret
= nla_parse_nested(app_tb
, DCB_APP_ATTR_MAX
, tb
[DCB_ATTR_APP
],
454 dcbnl_app_nest
, NULL
);
458 /* all must be non-null */
459 if ((!app_tb
[DCB_APP_ATTR_IDTYPE
]) ||
460 (!app_tb
[DCB_APP_ATTR_ID
]))
463 /* either by eth type or by socket number */
464 idtype
= nla_get_u8(app_tb
[DCB_APP_ATTR_IDTYPE
]);
465 if ((idtype
!= DCB_APP_IDTYPE_ETHTYPE
) &&
466 (idtype
!= DCB_APP_IDTYPE_PORTNUM
))
469 id
= nla_get_u16(app_tb
[DCB_APP_ATTR_ID
]);
471 if (netdev
->dcbnl_ops
->getapp
) {
472 ret
= netdev
->dcbnl_ops
->getapp(netdev
, idtype
, id
);
478 struct dcb_app app
= {
482 up
= dcb_getapp(netdev
, &app
);
485 app_nest
= nla_nest_start(skb
, DCB_ATTR_APP
);
489 ret
= nla_put_u8(skb
, DCB_APP_ATTR_IDTYPE
, idtype
);
493 ret
= nla_put_u16(skb
, DCB_APP_ATTR_ID
, id
);
497 ret
= nla_put_u8(skb
, DCB_APP_ATTR_PRIORITY
, up
);
501 nla_nest_end(skb
, app_nest
);
506 nla_nest_cancel(skb
, app_nest
);
510 static int dcbnl_setapp(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
511 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
516 struct nlattr
*app_tb
[DCB_APP_ATTR_MAX
+ 1];
518 if (!tb
[DCB_ATTR_APP
])
521 ret
= nla_parse_nested(app_tb
, DCB_APP_ATTR_MAX
, tb
[DCB_ATTR_APP
],
522 dcbnl_app_nest
, NULL
);
526 /* all must be non-null */
527 if ((!app_tb
[DCB_APP_ATTR_IDTYPE
]) ||
528 (!app_tb
[DCB_APP_ATTR_ID
]) ||
529 (!app_tb
[DCB_APP_ATTR_PRIORITY
]))
532 /* either by eth type or by socket number */
533 idtype
= nla_get_u8(app_tb
[DCB_APP_ATTR_IDTYPE
]);
534 if ((idtype
!= DCB_APP_IDTYPE_ETHTYPE
) &&
535 (idtype
!= DCB_APP_IDTYPE_PORTNUM
))
538 id
= nla_get_u16(app_tb
[DCB_APP_ATTR_ID
]);
539 up
= nla_get_u8(app_tb
[DCB_APP_ATTR_PRIORITY
]);
541 if (netdev
->dcbnl_ops
->setapp
) {
542 ret
= netdev
->dcbnl_ops
->setapp(netdev
, idtype
, id
, up
);
547 app
.selector
= idtype
;
550 ret
= dcb_setapp(netdev
, &app
);
553 ret
= nla_put_u8(skb
, DCB_ATTR_APP
, ret
);
554 dcbnl_cee_notify(netdev
, RTM_SETDCB
, DCB_CMD_SAPP
, seq
, 0);
559 static int __dcbnl_pg_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
560 struct nlattr
**tb
, struct sk_buff
*skb
, int dir
)
562 struct nlattr
*pg_nest
, *param_nest
, *data
;
563 struct nlattr
*pg_tb
[DCB_PG_ATTR_MAX
+ 1];
564 struct nlattr
*param_tb
[DCB_TC_ATTR_PARAM_MAX
+ 1];
565 u8 prio
, pgid
, tc_pct
, up_map
;
570 if (!tb
[DCB_ATTR_PG_CFG
])
573 if (!netdev
->dcbnl_ops
->getpgtccfgtx
||
574 !netdev
->dcbnl_ops
->getpgtccfgrx
||
575 !netdev
->dcbnl_ops
->getpgbwgcfgtx
||
576 !netdev
->dcbnl_ops
->getpgbwgcfgrx
)
579 ret
= nla_parse_nested(pg_tb
, DCB_PG_ATTR_MAX
, tb
[DCB_ATTR_PG_CFG
],
580 dcbnl_pg_nest
, NULL
);
584 pg_nest
= nla_nest_start(skb
, DCB_ATTR_PG_CFG
);
588 if (pg_tb
[DCB_PG_ATTR_TC_ALL
])
591 for (i
= DCB_PG_ATTR_TC_0
; i
<= DCB_PG_ATTR_TC_7
; i
++) {
592 if (!getall
&& !pg_tb
[i
])
595 if (pg_tb
[DCB_PG_ATTR_TC_ALL
])
596 data
= pg_tb
[DCB_PG_ATTR_TC_ALL
];
599 ret
= nla_parse_nested(param_tb
, DCB_TC_ATTR_PARAM_MAX
, data
,
600 dcbnl_tc_param_nest
, NULL
);
604 param_nest
= nla_nest_start(skb
, i
);
608 pgid
= DCB_ATTR_VALUE_UNDEFINED
;
609 prio
= DCB_ATTR_VALUE_UNDEFINED
;
610 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
611 up_map
= DCB_ATTR_VALUE_UNDEFINED
;
615 netdev
->dcbnl_ops
->getpgtccfgrx(netdev
,
616 i
- DCB_PG_ATTR_TC_0
, &prio
,
617 &pgid
, &tc_pct
, &up_map
);
620 netdev
->dcbnl_ops
->getpgtccfgtx(netdev
,
621 i
- DCB_PG_ATTR_TC_0
, &prio
,
622 &pgid
, &tc_pct
, &up_map
);
625 if (param_tb
[DCB_TC_ATTR_PARAM_PGID
] ||
626 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
627 ret
= nla_put_u8(skb
,
628 DCB_TC_ATTR_PARAM_PGID
, pgid
);
632 if (param_tb
[DCB_TC_ATTR_PARAM_UP_MAPPING
] ||
633 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
634 ret
= nla_put_u8(skb
,
635 DCB_TC_ATTR_PARAM_UP_MAPPING
, up_map
);
639 if (param_tb
[DCB_TC_ATTR_PARAM_STRICT_PRIO
] ||
640 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
641 ret
= nla_put_u8(skb
,
642 DCB_TC_ATTR_PARAM_STRICT_PRIO
, prio
);
646 if (param_tb
[DCB_TC_ATTR_PARAM_BW_PCT
] ||
647 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
648 ret
= nla_put_u8(skb
, DCB_TC_ATTR_PARAM_BW_PCT
,
653 nla_nest_end(skb
, param_nest
);
656 if (pg_tb
[DCB_PG_ATTR_BW_ID_ALL
])
661 for (i
= DCB_PG_ATTR_BW_ID_0
; i
<= DCB_PG_ATTR_BW_ID_7
; i
++) {
662 if (!getall
&& !pg_tb
[i
])
665 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
669 netdev
->dcbnl_ops
->getpgbwgcfgrx(netdev
,
670 i
- DCB_PG_ATTR_BW_ID_0
, &tc_pct
);
673 netdev
->dcbnl_ops
->getpgbwgcfgtx(netdev
,
674 i
- DCB_PG_ATTR_BW_ID_0
, &tc_pct
);
676 ret
= nla_put_u8(skb
, i
, tc_pct
);
681 nla_nest_end(skb
, pg_nest
);
686 nla_nest_cancel(skb
, param_nest
);
688 nla_nest_cancel(skb
, pg_nest
);
693 static int dcbnl_pgtx_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
694 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
696 return __dcbnl_pg_getcfg(netdev
, nlh
, tb
, skb
, 0);
699 static int dcbnl_pgrx_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
700 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
702 return __dcbnl_pg_getcfg(netdev
, nlh
, tb
, skb
, 1);
705 static int dcbnl_setstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
706 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
710 if (!tb
[DCB_ATTR_STATE
])
713 if (!netdev
->dcbnl_ops
->setstate
)
716 value
= nla_get_u8(tb
[DCB_ATTR_STATE
]);
718 return nla_put_u8(skb
, DCB_ATTR_STATE
,
719 netdev
->dcbnl_ops
->setstate(netdev
, value
));
722 static int dcbnl_setpfccfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
723 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
725 struct nlattr
*data
[DCB_PFC_UP_ATTR_MAX
+ 1];
730 if (!tb
[DCB_ATTR_PFC_CFG
])
733 if (!netdev
->dcbnl_ops
->setpfccfg
)
736 ret
= nla_parse_nested(data
, DCB_PFC_UP_ATTR_MAX
,
737 tb
[DCB_ATTR_PFC_CFG
], dcbnl_pfc_up_nest
, NULL
);
741 for (i
= DCB_PFC_UP_ATTR_0
; i
<= DCB_PFC_UP_ATTR_7
; i
++) {
744 value
= nla_get_u8(data
[i
]);
745 netdev
->dcbnl_ops
->setpfccfg(netdev
,
746 data
[i
]->nla_type
- DCB_PFC_UP_ATTR_0
, value
);
749 return nla_put_u8(skb
, DCB_ATTR_PFC_CFG
, 0);
752 static int dcbnl_setall(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
753 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
757 if (!tb
[DCB_ATTR_SET_ALL
])
760 if (!netdev
->dcbnl_ops
->setall
)
763 ret
= nla_put_u8(skb
, DCB_ATTR_SET_ALL
,
764 netdev
->dcbnl_ops
->setall(netdev
));
765 dcbnl_cee_notify(netdev
, RTM_SETDCB
, DCB_CMD_SET_ALL
, seq
, 0);
770 static int __dcbnl_pg_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
771 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
,
774 struct nlattr
*pg_tb
[DCB_PG_ATTR_MAX
+ 1];
775 struct nlattr
*param_tb
[DCB_TC_ATTR_PARAM_MAX
+ 1];
783 if (!tb
[DCB_ATTR_PG_CFG
])
786 if (!netdev
->dcbnl_ops
->setpgtccfgtx
||
787 !netdev
->dcbnl_ops
->setpgtccfgrx
||
788 !netdev
->dcbnl_ops
->setpgbwgcfgtx
||
789 !netdev
->dcbnl_ops
->setpgbwgcfgrx
)
792 ret
= nla_parse_nested(pg_tb
, DCB_PG_ATTR_MAX
, tb
[DCB_ATTR_PG_CFG
],
793 dcbnl_pg_nest
, NULL
);
797 for (i
= DCB_PG_ATTR_TC_0
; i
<= DCB_PG_ATTR_TC_7
; i
++) {
801 ret
= nla_parse_nested(param_tb
, DCB_TC_ATTR_PARAM_MAX
,
802 pg_tb
[i
], dcbnl_tc_param_nest
, NULL
);
806 pgid
= DCB_ATTR_VALUE_UNDEFINED
;
807 prio
= DCB_ATTR_VALUE_UNDEFINED
;
808 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
809 up_map
= DCB_ATTR_VALUE_UNDEFINED
;
811 if (param_tb
[DCB_TC_ATTR_PARAM_STRICT_PRIO
])
813 nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_STRICT_PRIO
]);
815 if (param_tb
[DCB_TC_ATTR_PARAM_PGID
])
816 pgid
= nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_PGID
]);
818 if (param_tb
[DCB_TC_ATTR_PARAM_BW_PCT
])
819 tc_pct
= nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_BW_PCT
]);
821 if (param_tb
[DCB_TC_ATTR_PARAM_UP_MAPPING
])
823 nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_UP_MAPPING
]);
825 /* dir: Tx = 0, Rx = 1 */
828 netdev
->dcbnl_ops
->setpgtccfgrx(netdev
,
829 i
- DCB_PG_ATTR_TC_0
,
830 prio
, pgid
, tc_pct
, up_map
);
833 netdev
->dcbnl_ops
->setpgtccfgtx(netdev
,
834 i
- DCB_PG_ATTR_TC_0
,
835 prio
, pgid
, tc_pct
, up_map
);
839 for (i
= DCB_PG_ATTR_BW_ID_0
; i
<= DCB_PG_ATTR_BW_ID_7
; i
++) {
843 tc_pct
= nla_get_u8(pg_tb
[i
]);
845 /* dir: Tx = 0, Rx = 1 */
848 netdev
->dcbnl_ops
->setpgbwgcfgrx(netdev
,
849 i
- DCB_PG_ATTR_BW_ID_0
, tc_pct
);
852 netdev
->dcbnl_ops
->setpgbwgcfgtx(netdev
,
853 i
- DCB_PG_ATTR_BW_ID_0
, tc_pct
);
857 return nla_put_u8(skb
, DCB_ATTR_PG_CFG
, 0);
860 static int dcbnl_pgtx_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
861 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
863 return __dcbnl_pg_setcfg(netdev
, nlh
, seq
, tb
, skb
, 0);
866 static int dcbnl_pgrx_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
867 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
869 return __dcbnl_pg_setcfg(netdev
, nlh
, seq
, tb
, skb
, 1);
872 static int dcbnl_bcn_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
873 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
875 struct nlattr
*bcn_nest
;
876 struct nlattr
*bcn_tb
[DCB_BCN_ATTR_MAX
+ 1];
883 if (!tb
[DCB_ATTR_BCN
])
886 if (!netdev
->dcbnl_ops
->getbcnrp
||
887 !netdev
->dcbnl_ops
->getbcncfg
)
890 ret
= nla_parse_nested(bcn_tb
, DCB_BCN_ATTR_MAX
, tb
[DCB_ATTR_BCN
],
891 dcbnl_bcn_nest
, NULL
);
895 bcn_nest
= nla_nest_start(skb
, DCB_ATTR_BCN
);
899 if (bcn_tb
[DCB_BCN_ATTR_ALL
])
902 for (i
= DCB_BCN_ATTR_RP_0
; i
<= DCB_BCN_ATTR_RP_7
; i
++) {
903 if (!getall
&& !bcn_tb
[i
])
906 netdev
->dcbnl_ops
->getbcnrp(netdev
, i
- DCB_BCN_ATTR_RP_0
,
908 ret
= nla_put_u8(skb
, i
, value_byte
);
913 for (i
= DCB_BCN_ATTR_BCNA_0
; i
<= DCB_BCN_ATTR_RI
; i
++) {
914 if (!getall
&& !bcn_tb
[i
])
917 netdev
->dcbnl_ops
->getbcncfg(netdev
, i
,
919 ret
= nla_put_u32(skb
, i
, value_integer
);
924 nla_nest_end(skb
, bcn_nest
);
929 nla_nest_cancel(skb
, bcn_nest
);
933 static int dcbnl_bcn_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
934 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
936 struct nlattr
*data
[DCB_BCN_ATTR_MAX
+ 1];
942 if (!tb
[DCB_ATTR_BCN
])
945 if (!netdev
->dcbnl_ops
->setbcncfg
||
946 !netdev
->dcbnl_ops
->setbcnrp
)
949 ret
= nla_parse_nested(data
, DCB_BCN_ATTR_MAX
, tb
[DCB_ATTR_BCN
],
950 dcbnl_pfc_up_nest
, NULL
);
954 for (i
= DCB_BCN_ATTR_RP_0
; i
<= DCB_BCN_ATTR_RP_7
; i
++) {
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
);
962 for (i
= DCB_BCN_ATTR_BCNA_0
; i
<= DCB_BCN_ATTR_RI
; i
++) {
965 value_int
= nla_get_u32(data
[i
]);
966 netdev
->dcbnl_ops
->setbcncfg(netdev
,
970 return nla_put_u8(skb
, DCB_ATTR_BCN
, 0);
973 static int dcbnl_build_peer_app(struct net_device
*netdev
, struct sk_buff
* skb
,
974 int app_nested_type
, int app_info_type
,
977 struct dcb_peer_app_info info
;
978 struct dcb_app
*table
= NULL
;
979 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
985 * retrieve the peer app configuration form the driver. If the driver
986 * handlers fail exit without doing anything
988 err
= ops
->peer_getappinfo(netdev
, &info
, &app_count
);
989 if (!err
&& app_count
) {
990 table
= kmalloc(sizeof(struct dcb_app
) * app_count
, GFP_KERNEL
);
994 err
= ops
->peer_getapptable(netdev
, table
);
1002 * build the message, from here on the only possible failure
1003 * is due to the skb size
1007 app
= nla_nest_start(skb
, app_nested_type
);
1009 goto nla_put_failure
;
1011 if (app_info_type
&&
1012 nla_put(skb
, app_info_type
, sizeof(info
), &info
))
1013 goto nla_put_failure
;
1015 for (i
= 0; i
< app_count
; i
++) {
1016 if (nla_put(skb
, app_entry_type
, sizeof(struct dcb_app
),
1018 goto nla_put_failure
;
1020 nla_nest_end(skb
, app
);
1029 /* Handle IEEE 802.1Qaz/802.1Qau/802.1Qbb GET commands. */
1030 static int dcbnl_ieee_fill(struct sk_buff
*skb
, struct net_device
*netdev
)
1032 struct nlattr
*ieee
, *app
;
1033 struct dcb_app_type
*itr
;
1034 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1038 if (nla_put_string(skb
, DCB_ATTR_IFNAME
, netdev
->name
))
1041 ieee
= nla_nest_start(skb
, DCB_ATTR_IEEE
);
1045 if (ops
->ieee_getets
) {
1046 struct ieee_ets ets
;
1047 memset(&ets
, 0, sizeof(ets
));
1048 err
= ops
->ieee_getets(netdev
, &ets
);
1050 nla_put(skb
, DCB_ATTR_IEEE_ETS
, sizeof(ets
), &ets
))
1054 if (ops
->ieee_getmaxrate
) {
1055 struct ieee_maxrate maxrate
;
1056 memset(&maxrate
, 0, sizeof(maxrate
));
1057 err
= ops
->ieee_getmaxrate(netdev
, &maxrate
);
1059 err
= nla_put(skb
, DCB_ATTR_IEEE_MAXRATE
,
1060 sizeof(maxrate
), &maxrate
);
1066 if (ops
->ieee_getqcn
) {
1067 struct ieee_qcn qcn
;
1069 memset(&qcn
, 0, sizeof(qcn
));
1070 err
= ops
->ieee_getqcn(netdev
, &qcn
);
1072 err
= nla_put(skb
, DCB_ATTR_IEEE_QCN
,
1079 if (ops
->ieee_getqcnstats
) {
1080 struct ieee_qcn_stats qcn_stats
;
1082 memset(&qcn_stats
, 0, sizeof(qcn_stats
));
1083 err
= ops
->ieee_getqcnstats(netdev
, &qcn_stats
);
1085 err
= nla_put(skb
, DCB_ATTR_IEEE_QCN_STATS
,
1086 sizeof(qcn_stats
), &qcn_stats
);
1092 if (ops
->ieee_getpfc
) {
1093 struct ieee_pfc pfc
;
1094 memset(&pfc
, 0, sizeof(pfc
));
1095 err
= ops
->ieee_getpfc(netdev
, &pfc
);
1097 nla_put(skb
, DCB_ATTR_IEEE_PFC
, sizeof(pfc
), &pfc
))
1101 app
= nla_nest_start(skb
, DCB_ATTR_IEEE_APP_TABLE
);
1105 spin_lock_bh(&dcb_lock
);
1106 list_for_each_entry(itr
, &dcb_app_list
, list
) {
1107 if (itr
->ifindex
== netdev
->ifindex
) {
1108 err
= nla_put(skb
, DCB_ATTR_IEEE_APP
, sizeof(itr
->app
),
1111 spin_unlock_bh(&dcb_lock
);
1117 if (netdev
->dcbnl_ops
->getdcbx
)
1118 dcbx
= netdev
->dcbnl_ops
->getdcbx(netdev
);
1122 spin_unlock_bh(&dcb_lock
);
1123 nla_nest_end(skb
, app
);
1125 /* get peer info if available */
1126 if (ops
->ieee_peer_getets
) {
1127 struct ieee_ets ets
;
1128 memset(&ets
, 0, sizeof(ets
));
1129 err
= ops
->ieee_peer_getets(netdev
, &ets
);
1131 nla_put(skb
, DCB_ATTR_IEEE_PEER_ETS
, sizeof(ets
), &ets
))
1135 if (ops
->ieee_peer_getpfc
) {
1136 struct ieee_pfc pfc
;
1137 memset(&pfc
, 0, sizeof(pfc
));
1138 err
= ops
->ieee_peer_getpfc(netdev
, &pfc
);
1140 nla_put(skb
, DCB_ATTR_IEEE_PEER_PFC
, sizeof(pfc
), &pfc
))
1144 if (ops
->peer_getappinfo
&& ops
->peer_getapptable
) {
1145 err
= dcbnl_build_peer_app(netdev
, skb
,
1146 DCB_ATTR_IEEE_PEER_APP
,
1147 DCB_ATTR_IEEE_APP_UNSPEC
,
1153 nla_nest_end(skb
, ieee
);
1155 err
= nla_put_u8(skb
, DCB_ATTR_DCBX
, dcbx
);
1163 static int dcbnl_cee_pg_fill(struct sk_buff
*skb
, struct net_device
*dev
,
1166 u8 pgid
, up_map
, prio
, tc_pct
;
1167 const struct dcbnl_rtnl_ops
*ops
= dev
->dcbnl_ops
;
1168 int i
= dir
? DCB_ATTR_CEE_TX_PG
: DCB_ATTR_CEE_RX_PG
;
1169 struct nlattr
*pg
= nla_nest_start(skb
, i
);
1174 for (i
= DCB_PG_ATTR_TC_0
; i
<= DCB_PG_ATTR_TC_7
; i
++) {
1175 struct nlattr
*tc_nest
= nla_nest_start(skb
, i
);
1180 pgid
= DCB_ATTR_VALUE_UNDEFINED
;
1181 prio
= DCB_ATTR_VALUE_UNDEFINED
;
1182 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
1183 up_map
= DCB_ATTR_VALUE_UNDEFINED
;
1186 ops
->getpgtccfgrx(dev
, i
- DCB_PG_ATTR_TC_0
,
1187 &prio
, &pgid
, &tc_pct
, &up_map
);
1189 ops
->getpgtccfgtx(dev
, i
- DCB_PG_ATTR_TC_0
,
1190 &prio
, &pgid
, &tc_pct
, &up_map
);
1192 if (nla_put_u8(skb
, DCB_TC_ATTR_PARAM_PGID
, pgid
) ||
1193 nla_put_u8(skb
, DCB_TC_ATTR_PARAM_UP_MAPPING
, up_map
) ||
1194 nla_put_u8(skb
, DCB_TC_ATTR_PARAM_STRICT_PRIO
, prio
) ||
1195 nla_put_u8(skb
, DCB_TC_ATTR_PARAM_BW_PCT
, tc_pct
))
1197 nla_nest_end(skb
, tc_nest
);
1200 for (i
= DCB_PG_ATTR_BW_ID_0
; i
<= DCB_PG_ATTR_BW_ID_7
; i
++) {
1201 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
1204 ops
->getpgbwgcfgrx(dev
, i
- DCB_PG_ATTR_BW_ID_0
,
1207 ops
->getpgbwgcfgtx(dev
, i
- DCB_PG_ATTR_BW_ID_0
,
1209 if (nla_put_u8(skb
, i
, tc_pct
))
1212 nla_nest_end(skb
, pg
);
1216 static int dcbnl_cee_fill(struct sk_buff
*skb
, struct net_device
*netdev
)
1218 struct nlattr
*cee
, *app
;
1219 struct dcb_app_type
*itr
;
1220 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1221 int dcbx
, i
, err
= -EMSGSIZE
;
1224 if (nla_put_string(skb
, DCB_ATTR_IFNAME
, netdev
->name
))
1225 goto nla_put_failure
;
1226 cee
= nla_nest_start(skb
, DCB_ATTR_CEE
);
1228 goto nla_put_failure
;
1231 if (ops
->getpgtccfgtx
&& ops
->getpgbwgcfgtx
) {
1232 err
= dcbnl_cee_pg_fill(skb
, netdev
, 1);
1234 goto nla_put_failure
;
1237 if (ops
->getpgtccfgrx
&& ops
->getpgbwgcfgrx
) {
1238 err
= dcbnl_cee_pg_fill(skb
, netdev
, 0);
1240 goto nla_put_failure
;
1244 if (ops
->getpfccfg
) {
1245 struct nlattr
*pfc_nest
= nla_nest_start(skb
, DCB_ATTR_CEE_PFC
);
1248 goto nla_put_failure
;
1250 for (i
= DCB_PFC_UP_ATTR_0
; i
<= DCB_PFC_UP_ATTR_7
; i
++) {
1251 ops
->getpfccfg(netdev
, i
- DCB_PFC_UP_ATTR_0
, &value
);
1252 if (nla_put_u8(skb
, i
, value
))
1253 goto nla_put_failure
;
1255 nla_nest_end(skb
, pfc_nest
);
1259 spin_lock_bh(&dcb_lock
);
1260 app
= nla_nest_start(skb
, DCB_ATTR_CEE_APP_TABLE
);
1264 list_for_each_entry(itr
, &dcb_app_list
, list
) {
1265 if (itr
->ifindex
== netdev
->ifindex
) {
1266 struct nlattr
*app_nest
= nla_nest_start(skb
,
1271 err
= nla_put_u8(skb
, DCB_APP_ATTR_IDTYPE
,
1276 err
= nla_put_u16(skb
, DCB_APP_ATTR_ID
,
1281 err
= nla_put_u8(skb
, DCB_APP_ATTR_PRIORITY
,
1286 nla_nest_end(skb
, app_nest
);
1289 nla_nest_end(skb
, app
);
1291 if (netdev
->dcbnl_ops
->getdcbx
)
1292 dcbx
= netdev
->dcbnl_ops
->getdcbx(netdev
);
1296 spin_unlock_bh(&dcb_lock
);
1298 /* features flags */
1299 if (ops
->getfeatcfg
) {
1300 struct nlattr
*feat
= nla_nest_start(skb
, DCB_ATTR_CEE_FEAT
);
1302 goto nla_put_failure
;
1304 for (i
= DCB_FEATCFG_ATTR_ALL
+ 1; i
<= DCB_FEATCFG_ATTR_MAX
;
1306 if (!ops
->getfeatcfg(netdev
, i
, &value
) &&
1307 nla_put_u8(skb
, i
, value
))
1308 goto nla_put_failure
;
1310 nla_nest_end(skb
, feat
);
1313 /* peer info if available */
1314 if (ops
->cee_peer_getpg
) {
1316 memset(&pg
, 0, sizeof(pg
));
1317 err
= ops
->cee_peer_getpg(netdev
, &pg
);
1319 nla_put(skb
, DCB_ATTR_CEE_PEER_PG
, sizeof(pg
), &pg
))
1320 goto nla_put_failure
;
1323 if (ops
->cee_peer_getpfc
) {
1325 memset(&pfc
, 0, sizeof(pfc
));
1326 err
= ops
->cee_peer_getpfc(netdev
, &pfc
);
1328 nla_put(skb
, DCB_ATTR_CEE_PEER_PFC
, sizeof(pfc
), &pfc
))
1329 goto nla_put_failure
;
1332 if (ops
->peer_getappinfo
&& ops
->peer_getapptable
) {
1333 err
= dcbnl_build_peer_app(netdev
, skb
,
1334 DCB_ATTR_CEE_PEER_APP_TABLE
,
1335 DCB_ATTR_CEE_PEER_APP_INFO
,
1336 DCB_ATTR_CEE_PEER_APP
);
1338 goto nla_put_failure
;
1340 nla_nest_end(skb
, cee
);
1344 err
= nla_put_u8(skb
, DCB_ATTR_DCBX
, dcbx
);
1346 goto nla_put_failure
;
1351 spin_unlock_bh(&dcb_lock
);
1357 static int dcbnl_notify(struct net_device
*dev
, int event
, int cmd
,
1358 u32 seq
, u32 portid
, int dcbx_ver
)
1360 struct net
*net
= dev_net(dev
);
1361 struct sk_buff
*skb
;
1362 struct nlmsghdr
*nlh
;
1363 const struct dcbnl_rtnl_ops
*ops
= dev
->dcbnl_ops
;
1369 skb
= dcbnl_newmsg(event
, cmd
, portid
, seq
, 0, &nlh
);
1373 if (dcbx_ver
== DCB_CAP_DCBX_VER_IEEE
)
1374 err
= dcbnl_ieee_fill(skb
, dev
);
1376 err
= dcbnl_cee_fill(skb
, dev
);
1379 /* Report error to broadcast listeners */
1381 rtnl_set_sk_err(net
, RTNLGRP_DCB
, err
);
1383 /* End nlmsg and notify broadcast listeners */
1384 nlmsg_end(skb
, nlh
);
1385 rtnl_notify(skb
, net
, 0, RTNLGRP_DCB
, NULL
, GFP_KERNEL
);
1391 int dcbnl_ieee_notify(struct net_device
*dev
, int event
, int cmd
,
1392 u32 seq
, u32 portid
)
1394 return dcbnl_notify(dev
, event
, cmd
, seq
, portid
, DCB_CAP_DCBX_VER_IEEE
);
1396 EXPORT_SYMBOL(dcbnl_ieee_notify
);
1398 int dcbnl_cee_notify(struct net_device
*dev
, int event
, int cmd
,
1399 u32 seq
, u32 portid
)
1401 return dcbnl_notify(dev
, event
, cmd
, seq
, portid
, DCB_CAP_DCBX_VER_CEE
);
1403 EXPORT_SYMBOL(dcbnl_cee_notify
);
1405 /* Handle IEEE 802.1Qaz/802.1Qau/802.1Qbb SET commands.
1406 * If any requested operation can not be completed
1407 * the entire msg is aborted and error value is returned.
1408 * No attempt is made to reconcile the case where only part of the
1409 * cmd can be completed.
1411 static int dcbnl_ieee_set(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1412 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1414 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1415 struct nlattr
*ieee
[DCB_ATTR_IEEE_MAX
+ 1];
1421 if (!tb
[DCB_ATTR_IEEE
])
1424 err
= nla_parse_nested(ieee
, DCB_ATTR_IEEE_MAX
, tb
[DCB_ATTR_IEEE
],
1425 dcbnl_ieee_policy
, NULL
);
1429 if (ieee
[DCB_ATTR_IEEE_ETS
] && ops
->ieee_setets
) {
1430 struct ieee_ets
*ets
= nla_data(ieee
[DCB_ATTR_IEEE_ETS
]);
1431 err
= ops
->ieee_setets(netdev
, ets
);
1436 if (ieee
[DCB_ATTR_IEEE_MAXRATE
] && ops
->ieee_setmaxrate
) {
1437 struct ieee_maxrate
*maxrate
=
1438 nla_data(ieee
[DCB_ATTR_IEEE_MAXRATE
]);
1439 err
= ops
->ieee_setmaxrate(netdev
, maxrate
);
1444 if (ieee
[DCB_ATTR_IEEE_QCN
] && ops
->ieee_setqcn
) {
1445 struct ieee_qcn
*qcn
=
1446 nla_data(ieee
[DCB_ATTR_IEEE_QCN
]);
1448 err
= ops
->ieee_setqcn(netdev
, qcn
);
1453 if (ieee
[DCB_ATTR_IEEE_PFC
] && ops
->ieee_setpfc
) {
1454 struct ieee_pfc
*pfc
= nla_data(ieee
[DCB_ATTR_IEEE_PFC
]);
1455 err
= ops
->ieee_setpfc(netdev
, pfc
);
1460 if (ieee
[DCB_ATTR_IEEE_APP_TABLE
]) {
1461 struct nlattr
*attr
;
1464 nla_for_each_nested(attr
, ieee
[DCB_ATTR_IEEE_APP_TABLE
], rem
) {
1465 struct dcb_app
*app_data
;
1466 if (nla_type(attr
) != DCB_ATTR_IEEE_APP
)
1468 app_data
= nla_data(attr
);
1469 if (ops
->ieee_setapp
)
1470 err
= ops
->ieee_setapp(netdev
, app_data
);
1472 err
= dcb_ieee_setapp(netdev
, app_data
);
1479 err
= nla_put_u8(skb
, DCB_ATTR_IEEE
, err
);
1480 dcbnl_ieee_notify(netdev
, RTM_SETDCB
, DCB_CMD_IEEE_SET
, seq
, 0);
1484 static int dcbnl_ieee_get(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1485 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1487 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1492 return dcbnl_ieee_fill(skb
, netdev
);
1495 static int dcbnl_ieee_del(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1496 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1498 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1499 struct nlattr
*ieee
[DCB_ATTR_IEEE_MAX
+ 1];
1505 if (!tb
[DCB_ATTR_IEEE
])
1508 err
= nla_parse_nested(ieee
, DCB_ATTR_IEEE_MAX
, tb
[DCB_ATTR_IEEE
],
1509 dcbnl_ieee_policy
, NULL
);
1513 if (ieee
[DCB_ATTR_IEEE_APP_TABLE
]) {
1514 struct nlattr
*attr
;
1517 nla_for_each_nested(attr
, ieee
[DCB_ATTR_IEEE_APP_TABLE
], rem
) {
1518 struct dcb_app
*app_data
;
1520 if (nla_type(attr
) != DCB_ATTR_IEEE_APP
)
1522 app_data
= nla_data(attr
);
1523 if (ops
->ieee_delapp
)
1524 err
= ops
->ieee_delapp(netdev
, app_data
);
1526 err
= dcb_ieee_delapp(netdev
, app_data
);
1533 err
= nla_put_u8(skb
, DCB_ATTR_IEEE
, err
);
1534 dcbnl_ieee_notify(netdev
, RTM_SETDCB
, DCB_CMD_IEEE_DEL
, seq
, 0);
1539 /* DCBX configuration */
1540 static int dcbnl_getdcbx(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1541 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1543 if (!netdev
->dcbnl_ops
->getdcbx
)
1546 return nla_put_u8(skb
, DCB_ATTR_DCBX
,
1547 netdev
->dcbnl_ops
->getdcbx(netdev
));
1550 static int dcbnl_setdcbx(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1551 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1555 if (!netdev
->dcbnl_ops
->setdcbx
)
1558 if (!tb
[DCB_ATTR_DCBX
])
1561 value
= nla_get_u8(tb
[DCB_ATTR_DCBX
]);
1563 return nla_put_u8(skb
, DCB_ATTR_DCBX
,
1564 netdev
->dcbnl_ops
->setdcbx(netdev
, value
));
1567 static int dcbnl_getfeatcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1568 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1570 struct nlattr
*data
[DCB_FEATCFG_ATTR_MAX
+ 1], *nest
;
1575 if (!netdev
->dcbnl_ops
->getfeatcfg
)
1578 if (!tb
[DCB_ATTR_FEATCFG
])
1581 ret
= nla_parse_nested(data
, DCB_FEATCFG_ATTR_MAX
,
1582 tb
[DCB_ATTR_FEATCFG
], dcbnl_featcfg_nest
, NULL
);
1586 nest
= nla_nest_start(skb
, DCB_ATTR_FEATCFG
);
1590 if (data
[DCB_FEATCFG_ATTR_ALL
])
1593 for (i
= DCB_FEATCFG_ATTR_ALL
+1; i
<= DCB_FEATCFG_ATTR_MAX
; i
++) {
1594 if (!getall
&& !data
[i
])
1597 ret
= netdev
->dcbnl_ops
->getfeatcfg(netdev
, i
, &value
);
1599 ret
= nla_put_u8(skb
, i
, value
);
1602 nla_nest_cancel(skb
, nest
);
1603 goto nla_put_failure
;
1606 nla_nest_end(skb
, nest
);
1612 static int dcbnl_setfeatcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1613 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1615 struct nlattr
*data
[DCB_FEATCFG_ATTR_MAX
+ 1];
1619 if (!netdev
->dcbnl_ops
->setfeatcfg
)
1622 if (!tb
[DCB_ATTR_FEATCFG
])
1625 ret
= nla_parse_nested(data
, DCB_FEATCFG_ATTR_MAX
,
1626 tb
[DCB_ATTR_FEATCFG
], dcbnl_featcfg_nest
, NULL
);
1631 for (i
= DCB_FEATCFG_ATTR_ALL
+1; i
<= DCB_FEATCFG_ATTR_MAX
; i
++) {
1632 if (data
[i
] == NULL
)
1635 value
= nla_get_u8(data
[i
]);
1637 ret
= netdev
->dcbnl_ops
->setfeatcfg(netdev
, i
, value
);
1643 ret
= nla_put_u8(skb
, DCB_ATTR_FEATCFG
, ret
);
1648 /* Handle CEE DCBX GET commands. */
1649 static int dcbnl_cee_get(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1650 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1652 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1657 return dcbnl_cee_fill(skb
, netdev
);
1661 /* reply netlink message type */
1664 /* function to fill message contents */
1665 int (*cb
)(struct net_device
*, struct nlmsghdr
*, u32
,
1666 struct nlattr
**, struct sk_buff
*);
1669 static const struct reply_func reply_funcs
[DCB_CMD_MAX
+1] = {
1670 [DCB_CMD_GSTATE
] = { RTM_GETDCB
, dcbnl_getstate
},
1671 [DCB_CMD_SSTATE
] = { RTM_SETDCB
, dcbnl_setstate
},
1672 [DCB_CMD_PFC_GCFG
] = { RTM_GETDCB
, dcbnl_getpfccfg
},
1673 [DCB_CMD_PFC_SCFG
] = { RTM_SETDCB
, dcbnl_setpfccfg
},
1674 [DCB_CMD_GPERM_HWADDR
] = { RTM_GETDCB
, dcbnl_getperm_hwaddr
},
1675 [DCB_CMD_GCAP
] = { RTM_GETDCB
, dcbnl_getcap
},
1676 [DCB_CMD_GNUMTCS
] = { RTM_GETDCB
, dcbnl_getnumtcs
},
1677 [DCB_CMD_SNUMTCS
] = { RTM_SETDCB
, dcbnl_setnumtcs
},
1678 [DCB_CMD_PFC_GSTATE
] = { RTM_GETDCB
, dcbnl_getpfcstate
},
1679 [DCB_CMD_PFC_SSTATE
] = { RTM_SETDCB
, dcbnl_setpfcstate
},
1680 [DCB_CMD_GAPP
] = { RTM_GETDCB
, dcbnl_getapp
},
1681 [DCB_CMD_SAPP
] = { RTM_SETDCB
, dcbnl_setapp
},
1682 [DCB_CMD_PGTX_GCFG
] = { RTM_GETDCB
, dcbnl_pgtx_getcfg
},
1683 [DCB_CMD_PGTX_SCFG
] = { RTM_SETDCB
, dcbnl_pgtx_setcfg
},
1684 [DCB_CMD_PGRX_GCFG
] = { RTM_GETDCB
, dcbnl_pgrx_getcfg
},
1685 [DCB_CMD_PGRX_SCFG
] = { RTM_SETDCB
, dcbnl_pgrx_setcfg
},
1686 [DCB_CMD_SET_ALL
] = { RTM_SETDCB
, dcbnl_setall
},
1687 [DCB_CMD_BCN_GCFG
] = { RTM_GETDCB
, dcbnl_bcn_getcfg
},
1688 [DCB_CMD_BCN_SCFG
] = { RTM_SETDCB
, dcbnl_bcn_setcfg
},
1689 [DCB_CMD_IEEE_GET
] = { RTM_GETDCB
, dcbnl_ieee_get
},
1690 [DCB_CMD_IEEE_SET
] = { RTM_SETDCB
, dcbnl_ieee_set
},
1691 [DCB_CMD_IEEE_DEL
] = { RTM_SETDCB
, dcbnl_ieee_del
},
1692 [DCB_CMD_GDCBX
] = { RTM_GETDCB
, dcbnl_getdcbx
},
1693 [DCB_CMD_SDCBX
] = { RTM_SETDCB
, dcbnl_setdcbx
},
1694 [DCB_CMD_GFEATCFG
] = { RTM_GETDCB
, dcbnl_getfeatcfg
},
1695 [DCB_CMD_SFEATCFG
] = { RTM_SETDCB
, dcbnl_setfeatcfg
},
1696 [DCB_CMD_CEE_GET
] = { RTM_GETDCB
, dcbnl_cee_get
},
1699 static int dcb_doit(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1701 struct net
*net
= sock_net(skb
->sk
);
1702 struct net_device
*netdev
;
1703 struct dcbmsg
*dcb
= nlmsg_data(nlh
);
1704 struct nlattr
*tb
[DCB_ATTR_MAX
+ 1];
1705 u32 portid
= skb
? NETLINK_CB(skb
).portid
: 0;
1707 struct sk_buff
*reply_skb
;
1708 struct nlmsghdr
*reply_nlh
= NULL
;
1709 const struct reply_func
*fn
;
1711 if ((nlh
->nlmsg_type
== RTM_SETDCB
) && !netlink_capable(skb
, CAP_NET_ADMIN
))
1714 ret
= nlmsg_parse(nlh
, sizeof(*dcb
), tb
, DCB_ATTR_MAX
,
1715 dcbnl_rtnl_policy
, NULL
);
1719 if (dcb
->cmd
> DCB_CMD_MAX
)
1722 /* check if a reply function has been defined for the command */
1723 fn
= &reply_funcs
[dcb
->cmd
];
1727 if (!tb
[DCB_ATTR_IFNAME
])
1730 netdev
= __dev_get_by_name(net
, nla_data(tb
[DCB_ATTR_IFNAME
]));
1734 if (!netdev
->dcbnl_ops
)
1737 reply_skb
= dcbnl_newmsg(fn
->type
, dcb
->cmd
, portid
, nlh
->nlmsg_seq
,
1738 nlh
->nlmsg_flags
, &reply_nlh
);
1742 ret
= fn
->cb(netdev
, nlh
, nlh
->nlmsg_seq
, tb
, reply_skb
);
1744 nlmsg_free(reply_skb
);
1748 nlmsg_end(reply_skb
, reply_nlh
);
1750 ret
= rtnl_unicast(reply_skb
, net
, portid
);
1755 static struct dcb_app_type
*dcb_app_lookup(const struct dcb_app
*app
,
1756 int ifindex
, int prio
)
1758 struct dcb_app_type
*itr
;
1760 list_for_each_entry(itr
, &dcb_app_list
, list
) {
1761 if (itr
->app
.selector
== app
->selector
&&
1762 itr
->app
.protocol
== app
->protocol
&&
1763 itr
->ifindex
== ifindex
&&
1764 (!prio
|| itr
->app
.priority
== prio
))
1771 static int dcb_app_add(const struct dcb_app
*app
, int ifindex
)
1773 struct dcb_app_type
*entry
;
1775 entry
= kmalloc(sizeof(*entry
), GFP_ATOMIC
);
1779 memcpy(&entry
->app
, app
, sizeof(*app
));
1780 entry
->ifindex
= ifindex
;
1781 list_add(&entry
->list
, &dcb_app_list
);
1787 * dcb_getapp - retrieve the DCBX application user priority
1789 * On success returns a non-zero 802.1p user priority bitmap
1790 * otherwise returns 0 as the invalid user priority bitmap to
1791 * indicate an error.
1793 u8
dcb_getapp(struct net_device
*dev
, struct dcb_app
*app
)
1795 struct dcb_app_type
*itr
;
1798 spin_lock_bh(&dcb_lock
);
1799 if ((itr
= dcb_app_lookup(app
, dev
->ifindex
, 0)))
1800 prio
= itr
->app
.priority
;
1801 spin_unlock_bh(&dcb_lock
);
1805 EXPORT_SYMBOL(dcb_getapp
);
1808 * dcb_setapp - add CEE dcb application data to app list
1810 * Priority 0 is an invalid priority in CEE spec. This routine
1811 * removes applications from the app list if the priority is
1812 * set to zero. Priority is expected to be 8-bit 802.1p user priority bitmap
1814 int dcb_setapp(struct net_device
*dev
, struct dcb_app
*new)
1816 struct dcb_app_type
*itr
;
1817 struct dcb_app_type event
;
1820 event
.ifindex
= dev
->ifindex
;
1821 memcpy(&event
.app
, new, sizeof(event
.app
));
1822 if (dev
->dcbnl_ops
->getdcbx
)
1823 event
.dcbx
= dev
->dcbnl_ops
->getdcbx(dev
);
1825 spin_lock_bh(&dcb_lock
);
1826 /* Search for existing match and replace */
1827 if ((itr
= dcb_app_lookup(new, dev
->ifindex
, 0))) {
1829 itr
->app
.priority
= new->priority
;
1831 list_del(&itr
->list
);
1836 /* App type does not exist add new application type */
1838 err
= dcb_app_add(new, dev
->ifindex
);
1840 spin_unlock_bh(&dcb_lock
);
1842 call_dcbevent_notifiers(DCB_APP_EVENT
, &event
);
1845 EXPORT_SYMBOL(dcb_setapp
);
1848 * dcb_ieee_getapp_mask - retrieve the IEEE DCB application priority
1850 * Helper routine which on success returns a non-zero 802.1Qaz user
1851 * priority bitmap otherwise returns 0 to indicate the dcb_app was
1852 * not found in APP list.
1854 u8
dcb_ieee_getapp_mask(struct net_device
*dev
, struct dcb_app
*app
)
1856 struct dcb_app_type
*itr
;
1859 spin_lock_bh(&dcb_lock
);
1860 if ((itr
= dcb_app_lookup(app
, dev
->ifindex
, 0)))
1861 prio
|= 1 << itr
->app
.priority
;
1862 spin_unlock_bh(&dcb_lock
);
1866 EXPORT_SYMBOL(dcb_ieee_getapp_mask
);
1869 * dcb_ieee_setapp - add IEEE dcb application data to app list
1871 * This adds Application data to the list. Multiple application
1872 * entries may exists for the same selector and protocol as long
1873 * as the priorities are different. Priority is expected to be a
1874 * 3-bit unsigned integer
1876 int dcb_ieee_setapp(struct net_device
*dev
, struct dcb_app
*new)
1878 struct dcb_app_type event
;
1881 event
.ifindex
= dev
->ifindex
;
1882 memcpy(&event
.app
, new, sizeof(event
.app
));
1883 if (dev
->dcbnl_ops
->getdcbx
)
1884 event
.dcbx
= dev
->dcbnl_ops
->getdcbx(dev
);
1886 spin_lock_bh(&dcb_lock
);
1887 /* Search for existing match and abort if found */
1888 if (dcb_app_lookup(new, dev
->ifindex
, new->priority
)) {
1893 err
= dcb_app_add(new, dev
->ifindex
);
1895 spin_unlock_bh(&dcb_lock
);
1897 call_dcbevent_notifiers(DCB_APP_EVENT
, &event
);
1900 EXPORT_SYMBOL(dcb_ieee_setapp
);
1903 * dcb_ieee_delapp - delete IEEE dcb application data from list
1905 * This removes a matching APP data from the APP list
1907 int dcb_ieee_delapp(struct net_device
*dev
, struct dcb_app
*del
)
1909 struct dcb_app_type
*itr
;
1910 struct dcb_app_type event
;
1913 event
.ifindex
= dev
->ifindex
;
1914 memcpy(&event
.app
, del
, sizeof(event
.app
));
1915 if (dev
->dcbnl_ops
->getdcbx
)
1916 event
.dcbx
= dev
->dcbnl_ops
->getdcbx(dev
);
1918 spin_lock_bh(&dcb_lock
);
1919 /* Search for existing match and remove it. */
1920 if ((itr
= dcb_app_lookup(del
, dev
->ifindex
, del
->priority
))) {
1921 list_del(&itr
->list
);
1926 spin_unlock_bh(&dcb_lock
);
1928 call_dcbevent_notifiers(DCB_APP_EVENT
, &event
);
1931 EXPORT_SYMBOL(dcb_ieee_delapp
);
1933 static int __init
dcbnl_init(void)
1935 INIT_LIST_HEAD(&dcb_app_list
);
1937 rtnl_register(PF_UNSPEC
, RTM_GETDCB
, dcb_doit
, NULL
, NULL
);
1938 rtnl_register(PF_UNSPEC
, RTM_SETDCB
, dcb_doit
, NULL
, NULL
);
1942 device_initcall(dcbnl_init
);