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 * Author: Lucy Liu <lucy.liu@intel.com>
19 #include <linux/netdevice.h>
20 #include <linux/netlink.h>
21 #include <linux/slab.h>
22 #include <net/netlink.h>
23 #include <net/rtnetlink.h>
24 #include <linux/dcbnl.h>
25 #include <net/dcbevent.h>
26 #include <linux/rtnetlink.h>
27 #include <linux/module.h>
30 /* Data Center Bridging (DCB) is a collection of Ethernet enhancements
31 * intended to allow network traffic with differing requirements
32 * (highly reliable, no drops vs. best effort vs. low latency) to operate
33 * and co-exist on Ethernet. Current DCB features are:
35 * Enhanced Transmission Selection (aka Priority Grouping [PG]) - provides a
36 * framework for assigning bandwidth guarantees to traffic classes.
38 * Priority-based Flow Control (PFC) - provides a flow control mechanism which
39 * can work independently for each 802.1p priority.
41 * Congestion Notification - provides a mechanism for end-to-end congestion
42 * control for protocols which do not have built-in congestion management.
44 * More information about the emerging standards for these Ethernet features
45 * can be found at: http://www.ieee802.org/1/pages/dcbridges.html
47 * This file implements an rtnetlink interface to allow configuration of DCB
48 * features for capable devices.
51 MODULE_AUTHOR("Lucy Liu, <lucy.liu@intel.com>");
52 MODULE_DESCRIPTION("Data Center Bridging netlink interface");
53 MODULE_LICENSE("GPL");
55 /**************** DCB attribute policies *************************************/
57 /* DCB netlink attributes policy */
58 static const struct nla_policy dcbnl_rtnl_policy
[DCB_ATTR_MAX
+ 1] = {
59 [DCB_ATTR_IFNAME
] = {.type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
- 1},
60 [DCB_ATTR_STATE
] = {.type
= NLA_U8
},
61 [DCB_ATTR_PFC_CFG
] = {.type
= NLA_NESTED
},
62 [DCB_ATTR_PG_CFG
] = {.type
= NLA_NESTED
},
63 [DCB_ATTR_SET_ALL
] = {.type
= NLA_U8
},
64 [DCB_ATTR_PERM_HWADDR
] = {.type
= NLA_FLAG
},
65 [DCB_ATTR_CAP
] = {.type
= NLA_NESTED
},
66 [DCB_ATTR_PFC_STATE
] = {.type
= NLA_U8
},
67 [DCB_ATTR_BCN
] = {.type
= NLA_NESTED
},
68 [DCB_ATTR_APP
] = {.type
= NLA_NESTED
},
69 [DCB_ATTR_IEEE
] = {.type
= NLA_NESTED
},
70 [DCB_ATTR_DCBX
] = {.type
= NLA_U8
},
71 [DCB_ATTR_FEATCFG
] = {.type
= NLA_NESTED
},
74 /* DCB priority flow control to User Priority nested attributes */
75 static const struct nla_policy dcbnl_pfc_up_nest
[DCB_PFC_UP_ATTR_MAX
+ 1] = {
76 [DCB_PFC_UP_ATTR_0
] = {.type
= NLA_U8
},
77 [DCB_PFC_UP_ATTR_1
] = {.type
= NLA_U8
},
78 [DCB_PFC_UP_ATTR_2
] = {.type
= NLA_U8
},
79 [DCB_PFC_UP_ATTR_3
] = {.type
= NLA_U8
},
80 [DCB_PFC_UP_ATTR_4
] = {.type
= NLA_U8
},
81 [DCB_PFC_UP_ATTR_5
] = {.type
= NLA_U8
},
82 [DCB_PFC_UP_ATTR_6
] = {.type
= NLA_U8
},
83 [DCB_PFC_UP_ATTR_7
] = {.type
= NLA_U8
},
84 [DCB_PFC_UP_ATTR_ALL
] = {.type
= NLA_FLAG
},
87 /* DCB priority grouping nested attributes */
88 static const struct nla_policy dcbnl_pg_nest
[DCB_PG_ATTR_MAX
+ 1] = {
89 [DCB_PG_ATTR_TC_0
] = {.type
= NLA_NESTED
},
90 [DCB_PG_ATTR_TC_1
] = {.type
= NLA_NESTED
},
91 [DCB_PG_ATTR_TC_2
] = {.type
= NLA_NESTED
},
92 [DCB_PG_ATTR_TC_3
] = {.type
= NLA_NESTED
},
93 [DCB_PG_ATTR_TC_4
] = {.type
= NLA_NESTED
},
94 [DCB_PG_ATTR_TC_5
] = {.type
= NLA_NESTED
},
95 [DCB_PG_ATTR_TC_6
] = {.type
= NLA_NESTED
},
96 [DCB_PG_ATTR_TC_7
] = {.type
= NLA_NESTED
},
97 [DCB_PG_ATTR_TC_ALL
] = {.type
= NLA_NESTED
},
98 [DCB_PG_ATTR_BW_ID_0
] = {.type
= NLA_U8
},
99 [DCB_PG_ATTR_BW_ID_1
] = {.type
= NLA_U8
},
100 [DCB_PG_ATTR_BW_ID_2
] = {.type
= NLA_U8
},
101 [DCB_PG_ATTR_BW_ID_3
] = {.type
= NLA_U8
},
102 [DCB_PG_ATTR_BW_ID_4
] = {.type
= NLA_U8
},
103 [DCB_PG_ATTR_BW_ID_5
] = {.type
= NLA_U8
},
104 [DCB_PG_ATTR_BW_ID_6
] = {.type
= NLA_U8
},
105 [DCB_PG_ATTR_BW_ID_7
] = {.type
= NLA_U8
},
106 [DCB_PG_ATTR_BW_ID_ALL
] = {.type
= NLA_FLAG
},
109 /* DCB traffic class nested attributes. */
110 static const struct nla_policy dcbnl_tc_param_nest
[DCB_TC_ATTR_PARAM_MAX
+ 1] = {
111 [DCB_TC_ATTR_PARAM_PGID
] = {.type
= NLA_U8
},
112 [DCB_TC_ATTR_PARAM_UP_MAPPING
] = {.type
= NLA_U8
},
113 [DCB_TC_ATTR_PARAM_STRICT_PRIO
] = {.type
= NLA_U8
},
114 [DCB_TC_ATTR_PARAM_BW_PCT
] = {.type
= NLA_U8
},
115 [DCB_TC_ATTR_PARAM_ALL
] = {.type
= NLA_FLAG
},
118 /* DCB capabilities nested attributes. */
119 static const struct nla_policy dcbnl_cap_nest
[DCB_CAP_ATTR_MAX
+ 1] = {
120 [DCB_CAP_ATTR_ALL
] = {.type
= NLA_FLAG
},
121 [DCB_CAP_ATTR_PG
] = {.type
= NLA_U8
},
122 [DCB_CAP_ATTR_PFC
] = {.type
= NLA_U8
},
123 [DCB_CAP_ATTR_UP2TC
] = {.type
= NLA_U8
},
124 [DCB_CAP_ATTR_PG_TCS
] = {.type
= NLA_U8
},
125 [DCB_CAP_ATTR_PFC_TCS
] = {.type
= NLA_U8
},
126 [DCB_CAP_ATTR_GSP
] = {.type
= NLA_U8
},
127 [DCB_CAP_ATTR_BCN
] = {.type
= NLA_U8
},
128 [DCB_CAP_ATTR_DCBX
] = {.type
= NLA_U8
},
131 /* DCB capabilities nested attributes. */
132 static const struct nla_policy dcbnl_numtcs_nest
[DCB_NUMTCS_ATTR_MAX
+ 1] = {
133 [DCB_NUMTCS_ATTR_ALL
] = {.type
= NLA_FLAG
},
134 [DCB_NUMTCS_ATTR_PG
] = {.type
= NLA_U8
},
135 [DCB_NUMTCS_ATTR_PFC
] = {.type
= NLA_U8
},
138 /* DCB BCN nested attributes. */
139 static const struct nla_policy dcbnl_bcn_nest
[DCB_BCN_ATTR_MAX
+ 1] = {
140 [DCB_BCN_ATTR_RP_0
] = {.type
= NLA_U8
},
141 [DCB_BCN_ATTR_RP_1
] = {.type
= NLA_U8
},
142 [DCB_BCN_ATTR_RP_2
] = {.type
= NLA_U8
},
143 [DCB_BCN_ATTR_RP_3
] = {.type
= NLA_U8
},
144 [DCB_BCN_ATTR_RP_4
] = {.type
= NLA_U8
},
145 [DCB_BCN_ATTR_RP_5
] = {.type
= NLA_U8
},
146 [DCB_BCN_ATTR_RP_6
] = {.type
= NLA_U8
},
147 [DCB_BCN_ATTR_RP_7
] = {.type
= NLA_U8
},
148 [DCB_BCN_ATTR_RP_ALL
] = {.type
= NLA_FLAG
},
149 [DCB_BCN_ATTR_BCNA_0
] = {.type
= NLA_U32
},
150 [DCB_BCN_ATTR_BCNA_1
] = {.type
= NLA_U32
},
151 [DCB_BCN_ATTR_ALPHA
] = {.type
= NLA_U32
},
152 [DCB_BCN_ATTR_BETA
] = {.type
= NLA_U32
},
153 [DCB_BCN_ATTR_GD
] = {.type
= NLA_U32
},
154 [DCB_BCN_ATTR_GI
] = {.type
= NLA_U32
},
155 [DCB_BCN_ATTR_TMAX
] = {.type
= NLA_U32
},
156 [DCB_BCN_ATTR_TD
] = {.type
= NLA_U32
},
157 [DCB_BCN_ATTR_RMIN
] = {.type
= NLA_U32
},
158 [DCB_BCN_ATTR_W
] = {.type
= NLA_U32
},
159 [DCB_BCN_ATTR_RD
] = {.type
= NLA_U32
},
160 [DCB_BCN_ATTR_RU
] = {.type
= NLA_U32
},
161 [DCB_BCN_ATTR_WRTT
] = {.type
= NLA_U32
},
162 [DCB_BCN_ATTR_RI
] = {.type
= NLA_U32
},
163 [DCB_BCN_ATTR_C
] = {.type
= NLA_U32
},
164 [DCB_BCN_ATTR_ALL
] = {.type
= NLA_FLAG
},
167 /* DCB APP nested attributes. */
168 static const struct nla_policy dcbnl_app_nest
[DCB_APP_ATTR_MAX
+ 1] = {
169 [DCB_APP_ATTR_IDTYPE
] = {.type
= NLA_U8
},
170 [DCB_APP_ATTR_ID
] = {.type
= NLA_U16
},
171 [DCB_APP_ATTR_PRIORITY
] = {.type
= NLA_U8
},
174 /* IEEE 802.1Qaz nested attributes. */
175 static const struct nla_policy dcbnl_ieee_policy
[DCB_ATTR_IEEE_MAX
+ 1] = {
176 [DCB_ATTR_IEEE_ETS
] = {.len
= sizeof(struct ieee_ets
)},
177 [DCB_ATTR_IEEE_PFC
] = {.len
= sizeof(struct ieee_pfc
)},
178 [DCB_ATTR_IEEE_APP_TABLE
] = {.type
= NLA_NESTED
},
179 [DCB_ATTR_IEEE_MAXRATE
] = {.len
= sizeof(struct ieee_maxrate
)},
182 static const struct nla_policy dcbnl_ieee_app
[DCB_ATTR_IEEE_APP_MAX
+ 1] = {
183 [DCB_ATTR_IEEE_APP
] = {.len
= sizeof(struct dcb_app
)},
186 /* DCB number of traffic classes nested attributes. */
187 static const struct nla_policy dcbnl_featcfg_nest
[DCB_FEATCFG_ATTR_MAX
+ 1] = {
188 [DCB_FEATCFG_ATTR_ALL
] = {.type
= NLA_FLAG
},
189 [DCB_FEATCFG_ATTR_PG
] = {.type
= NLA_U8
},
190 [DCB_FEATCFG_ATTR_PFC
] = {.type
= NLA_U8
},
191 [DCB_FEATCFG_ATTR_APP
] = {.type
= NLA_U8
},
194 static LIST_HEAD(dcb_app_list
);
195 static DEFINE_SPINLOCK(dcb_lock
);
197 static struct sk_buff
*dcbnl_newmsg(int type
, u8 cmd
, u32 port
, u32 seq
,
198 u32 flags
, struct nlmsghdr
**nlhp
)
202 struct nlmsghdr
*nlh
;
204 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
208 nlh
= nlmsg_put(skb
, port
, seq
, type
, sizeof(*dcb
), flags
);
211 dcb
= nlmsg_data(nlh
);
212 dcb
->dcb_family
= AF_UNSPEC
;
222 static int dcbnl_getstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
223 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
225 /* if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->getstate) */
226 if (!netdev
->dcbnl_ops
->getstate
)
229 return nla_put_u8(skb
, DCB_ATTR_STATE
,
230 netdev
->dcbnl_ops
->getstate(netdev
));
233 static int dcbnl_getpfccfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
234 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
236 struct nlattr
*data
[DCB_PFC_UP_ATTR_MAX
+ 1], *nest
;
242 if (!tb
[DCB_ATTR_PFC_CFG
])
245 if (!netdev
->dcbnl_ops
->getpfccfg
)
248 ret
= nla_parse_nested(data
, DCB_PFC_UP_ATTR_MAX
,
249 tb
[DCB_ATTR_PFC_CFG
],
254 nest
= nla_nest_start(skb
, DCB_ATTR_PFC_CFG
);
258 if (data
[DCB_PFC_UP_ATTR_ALL
])
261 for (i
= DCB_PFC_UP_ATTR_0
; i
<= DCB_PFC_UP_ATTR_7
; i
++) {
262 if (!getall
&& !data
[i
])
265 netdev
->dcbnl_ops
->getpfccfg(netdev
, i
- DCB_PFC_UP_ATTR_0
,
267 ret
= nla_put_u8(skb
, i
, value
);
269 nla_nest_cancel(skb
, nest
);
273 nla_nest_end(skb
, nest
);
278 static int dcbnl_getperm_hwaddr(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
279 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
281 u8 perm_addr
[MAX_ADDR_LEN
];
283 if (!netdev
->dcbnl_ops
->getpermhwaddr
)
286 memset(perm_addr
, 0, sizeof(perm_addr
));
287 netdev
->dcbnl_ops
->getpermhwaddr(netdev
, perm_addr
);
289 return nla_put(skb
, DCB_ATTR_PERM_HWADDR
, sizeof(perm_addr
), perm_addr
);
292 static int dcbnl_getcap(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
293 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
295 struct nlattr
*data
[DCB_CAP_ATTR_MAX
+ 1], *nest
;
301 if (!tb
[DCB_ATTR_CAP
])
304 if (!netdev
->dcbnl_ops
->getcap
)
307 ret
= nla_parse_nested(data
, DCB_CAP_ATTR_MAX
, tb
[DCB_ATTR_CAP
],
312 nest
= nla_nest_start(skb
, DCB_ATTR_CAP
);
316 if (data
[DCB_CAP_ATTR_ALL
])
319 for (i
= DCB_CAP_ATTR_ALL
+1; i
<= DCB_CAP_ATTR_MAX
; i
++) {
320 if (!getall
&& !data
[i
])
323 if (!netdev
->dcbnl_ops
->getcap(netdev
, i
, &value
)) {
324 ret
= nla_put_u8(skb
, i
, value
);
326 nla_nest_cancel(skb
, nest
);
331 nla_nest_end(skb
, nest
);
336 static int dcbnl_getnumtcs(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
337 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
339 struct nlattr
*data
[DCB_NUMTCS_ATTR_MAX
+ 1], *nest
;
345 if (!tb
[DCB_ATTR_NUMTCS
])
348 if (!netdev
->dcbnl_ops
->getnumtcs
)
351 ret
= nla_parse_nested(data
, DCB_NUMTCS_ATTR_MAX
, tb
[DCB_ATTR_NUMTCS
],
356 nest
= nla_nest_start(skb
, DCB_ATTR_NUMTCS
);
360 if (data
[DCB_NUMTCS_ATTR_ALL
])
363 for (i
= DCB_NUMTCS_ATTR_ALL
+1; i
<= DCB_NUMTCS_ATTR_MAX
; i
++) {
364 if (!getall
&& !data
[i
])
367 ret
= netdev
->dcbnl_ops
->getnumtcs(netdev
, i
, &value
);
369 ret
= nla_put_u8(skb
, i
, value
);
371 nla_nest_cancel(skb
, nest
);
377 nla_nest_end(skb
, nest
);
382 static int dcbnl_setnumtcs(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
383 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
385 struct nlattr
*data
[DCB_NUMTCS_ATTR_MAX
+ 1];
390 if (!tb
[DCB_ATTR_NUMTCS
])
393 if (!netdev
->dcbnl_ops
->setnumtcs
)
396 ret
= nla_parse_nested(data
, DCB_NUMTCS_ATTR_MAX
, tb
[DCB_ATTR_NUMTCS
],
401 for (i
= DCB_NUMTCS_ATTR_ALL
+1; i
<= DCB_NUMTCS_ATTR_MAX
; i
++) {
405 value
= nla_get_u8(data
[i
]);
407 ret
= netdev
->dcbnl_ops
->setnumtcs(netdev
, i
, value
);
412 return nla_put_u8(skb
, DCB_ATTR_NUMTCS
, !!ret
);
415 static int dcbnl_getpfcstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
416 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
418 if (!netdev
->dcbnl_ops
->getpfcstate
)
421 return nla_put_u8(skb
, DCB_ATTR_PFC_STATE
,
422 netdev
->dcbnl_ops
->getpfcstate(netdev
));
425 static int dcbnl_setpfcstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
426 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
430 if (!tb
[DCB_ATTR_PFC_STATE
])
433 if (!netdev
->dcbnl_ops
->setpfcstate
)
436 value
= nla_get_u8(tb
[DCB_ATTR_PFC_STATE
]);
438 netdev
->dcbnl_ops
->setpfcstate(netdev
, value
);
440 return nla_put_u8(skb
, DCB_ATTR_PFC_STATE
, 0);
443 static int dcbnl_getapp(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
444 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
446 struct nlattr
*app_nest
;
447 struct nlattr
*app_tb
[DCB_APP_ATTR_MAX
+ 1];
452 if (!tb
[DCB_ATTR_APP
])
455 ret
= nla_parse_nested(app_tb
, DCB_APP_ATTR_MAX
, tb
[DCB_ATTR_APP
],
460 /* all must be non-null */
461 if ((!app_tb
[DCB_APP_ATTR_IDTYPE
]) ||
462 (!app_tb
[DCB_APP_ATTR_ID
]))
465 /* either by eth type or by socket number */
466 idtype
= nla_get_u8(app_tb
[DCB_APP_ATTR_IDTYPE
]);
467 if ((idtype
!= DCB_APP_IDTYPE_ETHTYPE
) &&
468 (idtype
!= DCB_APP_IDTYPE_PORTNUM
))
471 id
= nla_get_u16(app_tb
[DCB_APP_ATTR_ID
]);
473 if (netdev
->dcbnl_ops
->getapp
) {
474 up
= netdev
->dcbnl_ops
->getapp(netdev
, idtype
, id
);
476 struct dcb_app app
= {
480 up
= dcb_getapp(netdev
, &app
);
483 app_nest
= nla_nest_start(skb
, DCB_ATTR_APP
);
487 ret
= nla_put_u8(skb
, DCB_APP_ATTR_IDTYPE
, idtype
);
491 ret
= nla_put_u16(skb
, DCB_APP_ATTR_ID
, id
);
495 ret
= nla_put_u8(skb
, DCB_APP_ATTR_PRIORITY
, up
);
499 nla_nest_end(skb
, app_nest
);
504 nla_nest_cancel(skb
, app_nest
);
508 static int dcbnl_setapp(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
509 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
514 struct nlattr
*app_tb
[DCB_APP_ATTR_MAX
+ 1];
516 if (!tb
[DCB_ATTR_APP
])
519 ret
= nla_parse_nested(app_tb
, DCB_APP_ATTR_MAX
, tb
[DCB_ATTR_APP
],
524 /* all must be non-null */
525 if ((!app_tb
[DCB_APP_ATTR_IDTYPE
]) ||
526 (!app_tb
[DCB_APP_ATTR_ID
]) ||
527 (!app_tb
[DCB_APP_ATTR_PRIORITY
]))
530 /* either by eth type or by socket number */
531 idtype
= nla_get_u8(app_tb
[DCB_APP_ATTR_IDTYPE
]);
532 if ((idtype
!= DCB_APP_IDTYPE_ETHTYPE
) &&
533 (idtype
!= DCB_APP_IDTYPE_PORTNUM
))
536 id
= nla_get_u16(app_tb
[DCB_APP_ATTR_ID
]);
537 up
= nla_get_u8(app_tb
[DCB_APP_ATTR_PRIORITY
]);
539 if (netdev
->dcbnl_ops
->setapp
) {
540 ret
= netdev
->dcbnl_ops
->setapp(netdev
, idtype
, id
, up
);
543 app
.selector
= idtype
;
546 ret
= dcb_setapp(netdev
, &app
);
549 ret
= nla_put_u8(skb
, DCB_ATTR_APP
, ret
);
550 dcbnl_cee_notify(netdev
, RTM_SETDCB
, DCB_CMD_SAPP
, seq
, 0);
555 static int __dcbnl_pg_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
556 struct nlattr
**tb
, struct sk_buff
*skb
, int dir
)
558 struct nlattr
*pg_nest
, *param_nest
, *data
;
559 struct nlattr
*pg_tb
[DCB_PG_ATTR_MAX
+ 1];
560 struct nlattr
*param_tb
[DCB_TC_ATTR_PARAM_MAX
+ 1];
561 u8 prio
, pgid
, tc_pct
, up_map
;
566 if (!tb
[DCB_ATTR_PG_CFG
])
569 if (!netdev
->dcbnl_ops
->getpgtccfgtx
||
570 !netdev
->dcbnl_ops
->getpgtccfgrx
||
571 !netdev
->dcbnl_ops
->getpgbwgcfgtx
||
572 !netdev
->dcbnl_ops
->getpgbwgcfgrx
)
575 ret
= nla_parse_nested(pg_tb
, DCB_PG_ATTR_MAX
,
576 tb
[DCB_ATTR_PG_CFG
], dcbnl_pg_nest
);
580 pg_nest
= nla_nest_start(skb
, DCB_ATTR_PG_CFG
);
584 if (pg_tb
[DCB_PG_ATTR_TC_ALL
])
587 for (i
= DCB_PG_ATTR_TC_0
; i
<= DCB_PG_ATTR_TC_7
; i
++) {
588 if (!getall
&& !pg_tb
[i
])
591 if (pg_tb
[DCB_PG_ATTR_TC_ALL
])
592 data
= pg_tb
[DCB_PG_ATTR_TC_ALL
];
595 ret
= nla_parse_nested(param_tb
, DCB_TC_ATTR_PARAM_MAX
,
596 data
, dcbnl_tc_param_nest
);
600 param_nest
= nla_nest_start(skb
, i
);
604 pgid
= DCB_ATTR_VALUE_UNDEFINED
;
605 prio
= DCB_ATTR_VALUE_UNDEFINED
;
606 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
607 up_map
= DCB_ATTR_VALUE_UNDEFINED
;
611 netdev
->dcbnl_ops
->getpgtccfgrx(netdev
,
612 i
- DCB_PG_ATTR_TC_0
, &prio
,
613 &pgid
, &tc_pct
, &up_map
);
616 netdev
->dcbnl_ops
->getpgtccfgtx(netdev
,
617 i
- DCB_PG_ATTR_TC_0
, &prio
,
618 &pgid
, &tc_pct
, &up_map
);
621 if (param_tb
[DCB_TC_ATTR_PARAM_PGID
] ||
622 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
623 ret
= nla_put_u8(skb
,
624 DCB_TC_ATTR_PARAM_PGID
, pgid
);
628 if (param_tb
[DCB_TC_ATTR_PARAM_UP_MAPPING
] ||
629 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
630 ret
= nla_put_u8(skb
,
631 DCB_TC_ATTR_PARAM_UP_MAPPING
, up_map
);
635 if (param_tb
[DCB_TC_ATTR_PARAM_STRICT_PRIO
] ||
636 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
637 ret
= nla_put_u8(skb
,
638 DCB_TC_ATTR_PARAM_STRICT_PRIO
, prio
);
642 if (param_tb
[DCB_TC_ATTR_PARAM_BW_PCT
] ||
643 param_tb
[DCB_TC_ATTR_PARAM_ALL
]) {
644 ret
= nla_put_u8(skb
, DCB_TC_ATTR_PARAM_BW_PCT
,
649 nla_nest_end(skb
, param_nest
);
652 if (pg_tb
[DCB_PG_ATTR_BW_ID_ALL
])
657 for (i
= DCB_PG_ATTR_BW_ID_0
; i
<= DCB_PG_ATTR_BW_ID_7
; i
++) {
658 if (!getall
&& !pg_tb
[i
])
661 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
665 netdev
->dcbnl_ops
->getpgbwgcfgrx(netdev
,
666 i
- DCB_PG_ATTR_BW_ID_0
, &tc_pct
);
669 netdev
->dcbnl_ops
->getpgbwgcfgtx(netdev
,
670 i
- DCB_PG_ATTR_BW_ID_0
, &tc_pct
);
672 ret
= nla_put_u8(skb
, i
, tc_pct
);
677 nla_nest_end(skb
, pg_nest
);
682 nla_nest_cancel(skb
, param_nest
);
684 nla_nest_cancel(skb
, pg_nest
);
689 static int dcbnl_pgtx_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
690 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
692 return __dcbnl_pg_getcfg(netdev
, nlh
, tb
, skb
, 0);
695 static int dcbnl_pgrx_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
696 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
698 return __dcbnl_pg_getcfg(netdev
, nlh
, tb
, skb
, 1);
701 static int dcbnl_setstate(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
702 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
706 if (!tb
[DCB_ATTR_STATE
])
709 if (!netdev
->dcbnl_ops
->setstate
)
712 value
= nla_get_u8(tb
[DCB_ATTR_STATE
]);
714 return nla_put_u8(skb
, DCB_ATTR_STATE
,
715 netdev
->dcbnl_ops
->setstate(netdev
, value
));
718 static int dcbnl_setpfccfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
719 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
721 struct nlattr
*data
[DCB_PFC_UP_ATTR_MAX
+ 1];
726 if (!tb
[DCB_ATTR_PFC_CFG
])
729 if (!netdev
->dcbnl_ops
->setpfccfg
)
732 ret
= nla_parse_nested(data
, DCB_PFC_UP_ATTR_MAX
,
733 tb
[DCB_ATTR_PFC_CFG
],
738 for (i
= DCB_PFC_UP_ATTR_0
; i
<= DCB_PFC_UP_ATTR_7
; i
++) {
741 value
= nla_get_u8(data
[i
]);
742 netdev
->dcbnl_ops
->setpfccfg(netdev
,
743 data
[i
]->nla_type
- DCB_PFC_UP_ATTR_0
, value
);
746 return nla_put_u8(skb
, DCB_ATTR_PFC_CFG
, 0);
749 static int dcbnl_setall(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
750 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
754 if (!tb
[DCB_ATTR_SET_ALL
])
757 if (!netdev
->dcbnl_ops
->setall
)
760 ret
= nla_put_u8(skb
, DCB_ATTR_SET_ALL
,
761 netdev
->dcbnl_ops
->setall(netdev
));
762 dcbnl_cee_notify(netdev
, RTM_SETDCB
, DCB_CMD_SET_ALL
, seq
, 0);
767 static int __dcbnl_pg_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
768 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
,
771 struct nlattr
*pg_tb
[DCB_PG_ATTR_MAX
+ 1];
772 struct nlattr
*param_tb
[DCB_TC_ATTR_PARAM_MAX
+ 1];
780 if (!tb
[DCB_ATTR_PG_CFG
])
783 if (!netdev
->dcbnl_ops
->setpgtccfgtx
||
784 !netdev
->dcbnl_ops
->setpgtccfgrx
||
785 !netdev
->dcbnl_ops
->setpgbwgcfgtx
||
786 !netdev
->dcbnl_ops
->setpgbwgcfgrx
)
789 ret
= nla_parse_nested(pg_tb
, DCB_PG_ATTR_MAX
,
790 tb
[DCB_ATTR_PG_CFG
], dcbnl_pg_nest
);
794 for (i
= DCB_PG_ATTR_TC_0
; i
<= DCB_PG_ATTR_TC_7
; i
++) {
798 ret
= nla_parse_nested(param_tb
, DCB_TC_ATTR_PARAM_MAX
,
799 pg_tb
[i
], dcbnl_tc_param_nest
);
803 pgid
= DCB_ATTR_VALUE_UNDEFINED
;
804 prio
= DCB_ATTR_VALUE_UNDEFINED
;
805 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
806 up_map
= DCB_ATTR_VALUE_UNDEFINED
;
808 if (param_tb
[DCB_TC_ATTR_PARAM_STRICT_PRIO
])
810 nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_STRICT_PRIO
]);
812 if (param_tb
[DCB_TC_ATTR_PARAM_PGID
])
813 pgid
= nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_PGID
]);
815 if (param_tb
[DCB_TC_ATTR_PARAM_BW_PCT
])
816 tc_pct
= nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_BW_PCT
]);
818 if (param_tb
[DCB_TC_ATTR_PARAM_UP_MAPPING
])
820 nla_get_u8(param_tb
[DCB_TC_ATTR_PARAM_UP_MAPPING
]);
822 /* dir: Tx = 0, Rx = 1 */
825 netdev
->dcbnl_ops
->setpgtccfgrx(netdev
,
826 i
- DCB_PG_ATTR_TC_0
,
827 prio
, pgid
, tc_pct
, up_map
);
830 netdev
->dcbnl_ops
->setpgtccfgtx(netdev
,
831 i
- DCB_PG_ATTR_TC_0
,
832 prio
, pgid
, tc_pct
, up_map
);
836 for (i
= DCB_PG_ATTR_BW_ID_0
; i
<= DCB_PG_ATTR_BW_ID_7
; i
++) {
840 tc_pct
= nla_get_u8(pg_tb
[i
]);
842 /* dir: Tx = 0, Rx = 1 */
845 netdev
->dcbnl_ops
->setpgbwgcfgrx(netdev
,
846 i
- DCB_PG_ATTR_BW_ID_0
, tc_pct
);
849 netdev
->dcbnl_ops
->setpgbwgcfgtx(netdev
,
850 i
- DCB_PG_ATTR_BW_ID_0
, tc_pct
);
854 return nla_put_u8(skb
, DCB_ATTR_PG_CFG
, 0);
857 static int dcbnl_pgtx_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
858 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
860 return __dcbnl_pg_setcfg(netdev
, nlh
, seq
, tb
, skb
, 0);
863 static int dcbnl_pgrx_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
864 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
866 return __dcbnl_pg_setcfg(netdev
, nlh
, seq
, tb
, skb
, 1);
869 static int dcbnl_bcn_getcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
870 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
872 struct nlattr
*bcn_nest
;
873 struct nlattr
*bcn_tb
[DCB_BCN_ATTR_MAX
+ 1];
880 if (!tb
[DCB_ATTR_BCN
])
883 if (!netdev
->dcbnl_ops
->getbcnrp
||
884 !netdev
->dcbnl_ops
->getbcncfg
)
887 ret
= nla_parse_nested(bcn_tb
, DCB_BCN_ATTR_MAX
,
888 tb
[DCB_ATTR_BCN
], dcbnl_bcn_nest
);
892 bcn_nest
= nla_nest_start(skb
, DCB_ATTR_BCN
);
896 if (bcn_tb
[DCB_BCN_ATTR_ALL
])
899 for (i
= DCB_BCN_ATTR_RP_0
; i
<= DCB_BCN_ATTR_RP_7
; i
++) {
900 if (!getall
&& !bcn_tb
[i
])
903 netdev
->dcbnl_ops
->getbcnrp(netdev
, i
- DCB_BCN_ATTR_RP_0
,
905 ret
= nla_put_u8(skb
, i
, value_byte
);
910 for (i
= DCB_BCN_ATTR_BCNA_0
; i
<= DCB_BCN_ATTR_RI
; i
++) {
911 if (!getall
&& !bcn_tb
[i
])
914 netdev
->dcbnl_ops
->getbcncfg(netdev
, i
,
916 ret
= nla_put_u32(skb
, i
, value_integer
);
921 nla_nest_end(skb
, bcn_nest
);
926 nla_nest_cancel(skb
, bcn_nest
);
930 static int dcbnl_bcn_setcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
931 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
933 struct nlattr
*data
[DCB_BCN_ATTR_MAX
+ 1];
939 if (!tb
[DCB_ATTR_BCN
])
942 if (!netdev
->dcbnl_ops
->setbcncfg
||
943 !netdev
->dcbnl_ops
->setbcnrp
)
946 ret
= nla_parse_nested(data
, DCB_BCN_ATTR_MAX
,
952 for (i
= DCB_BCN_ATTR_RP_0
; i
<= DCB_BCN_ATTR_RP_7
; i
++) {
955 value_byte
= nla_get_u8(data
[i
]);
956 netdev
->dcbnl_ops
->setbcnrp(netdev
,
957 data
[i
]->nla_type
- DCB_BCN_ATTR_RP_0
, value_byte
);
960 for (i
= DCB_BCN_ATTR_BCNA_0
; i
<= DCB_BCN_ATTR_RI
; i
++) {
963 value_int
= nla_get_u32(data
[i
]);
964 netdev
->dcbnl_ops
->setbcncfg(netdev
,
968 return nla_put_u8(skb
, DCB_ATTR_BCN
, 0);
971 static int dcbnl_build_peer_app(struct net_device
*netdev
, struct sk_buff
* skb
,
972 int app_nested_type
, int app_info_type
,
975 struct dcb_peer_app_info info
;
976 struct dcb_app
*table
= NULL
;
977 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
983 * retrieve the peer app configuration form the driver. If the driver
984 * handlers fail exit without doing anything
986 err
= ops
->peer_getappinfo(netdev
, &info
, &app_count
);
987 if (!err
&& app_count
) {
988 table
= kmalloc(sizeof(struct dcb_app
) * app_count
, GFP_KERNEL
);
992 err
= ops
->peer_getapptable(netdev
, table
);
1000 * build the message, from here on the only possible failure
1001 * is due to the skb size
1005 app
= nla_nest_start(skb
, app_nested_type
);
1007 goto nla_put_failure
;
1009 if (app_info_type
&&
1010 nla_put(skb
, app_info_type
, sizeof(info
), &info
))
1011 goto nla_put_failure
;
1013 for (i
= 0; i
< app_count
; i
++) {
1014 if (nla_put(skb
, app_entry_type
, sizeof(struct dcb_app
),
1016 goto nla_put_failure
;
1018 nla_nest_end(skb
, app
);
1027 /* Handle IEEE 802.1Qaz GET commands. */
1028 static int dcbnl_ieee_fill(struct sk_buff
*skb
, struct net_device
*netdev
)
1030 struct nlattr
*ieee
, *app
;
1031 struct dcb_app_type
*itr
;
1032 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1036 if (nla_put_string(skb
, DCB_ATTR_IFNAME
, netdev
->name
))
1039 ieee
= nla_nest_start(skb
, DCB_ATTR_IEEE
);
1043 if (ops
->ieee_getets
) {
1044 struct ieee_ets ets
;
1045 memset(&ets
, 0, sizeof(ets
));
1046 err
= ops
->ieee_getets(netdev
, &ets
);
1048 nla_put(skb
, DCB_ATTR_IEEE_ETS
, sizeof(ets
), &ets
))
1052 if (ops
->ieee_getmaxrate
) {
1053 struct ieee_maxrate maxrate
;
1054 memset(&maxrate
, 0, sizeof(maxrate
));
1055 err
= ops
->ieee_getmaxrate(netdev
, &maxrate
);
1057 err
= nla_put(skb
, DCB_ATTR_IEEE_MAXRATE
,
1058 sizeof(maxrate
), &maxrate
);
1064 if (ops
->ieee_getpfc
) {
1065 struct ieee_pfc pfc
;
1066 memset(&pfc
, 0, sizeof(pfc
));
1067 err
= ops
->ieee_getpfc(netdev
, &pfc
);
1069 nla_put(skb
, DCB_ATTR_IEEE_PFC
, sizeof(pfc
), &pfc
))
1073 app
= nla_nest_start(skb
, DCB_ATTR_IEEE_APP_TABLE
);
1077 spin_lock(&dcb_lock
);
1078 list_for_each_entry(itr
, &dcb_app_list
, list
) {
1079 if (itr
->ifindex
== netdev
->ifindex
) {
1080 err
= nla_put(skb
, DCB_ATTR_IEEE_APP
, sizeof(itr
->app
),
1083 spin_unlock(&dcb_lock
);
1089 if (netdev
->dcbnl_ops
->getdcbx
)
1090 dcbx
= netdev
->dcbnl_ops
->getdcbx(netdev
);
1094 spin_unlock(&dcb_lock
);
1095 nla_nest_end(skb
, app
);
1097 /* get peer info if available */
1098 if (ops
->ieee_peer_getets
) {
1099 struct ieee_ets ets
;
1100 memset(&ets
, 0, sizeof(ets
));
1101 err
= ops
->ieee_peer_getets(netdev
, &ets
);
1103 nla_put(skb
, DCB_ATTR_IEEE_PEER_ETS
, sizeof(ets
), &ets
))
1107 if (ops
->ieee_peer_getpfc
) {
1108 struct ieee_pfc pfc
;
1109 memset(&pfc
, 0, sizeof(pfc
));
1110 err
= ops
->ieee_peer_getpfc(netdev
, &pfc
);
1112 nla_put(skb
, DCB_ATTR_IEEE_PEER_PFC
, sizeof(pfc
), &pfc
))
1116 if (ops
->peer_getappinfo
&& ops
->peer_getapptable
) {
1117 err
= dcbnl_build_peer_app(netdev
, skb
,
1118 DCB_ATTR_IEEE_PEER_APP
,
1119 DCB_ATTR_IEEE_APP_UNSPEC
,
1125 nla_nest_end(skb
, ieee
);
1127 err
= nla_put_u8(skb
, DCB_ATTR_DCBX
, dcbx
);
1135 static int dcbnl_cee_pg_fill(struct sk_buff
*skb
, struct net_device
*dev
,
1138 u8 pgid
, up_map
, prio
, tc_pct
;
1139 const struct dcbnl_rtnl_ops
*ops
= dev
->dcbnl_ops
;
1140 int i
= dir
? DCB_ATTR_CEE_TX_PG
: DCB_ATTR_CEE_RX_PG
;
1141 struct nlattr
*pg
= nla_nest_start(skb
, i
);
1146 for (i
= DCB_PG_ATTR_TC_0
; i
<= DCB_PG_ATTR_TC_7
; i
++) {
1147 struct nlattr
*tc_nest
= nla_nest_start(skb
, i
);
1152 pgid
= DCB_ATTR_VALUE_UNDEFINED
;
1153 prio
= DCB_ATTR_VALUE_UNDEFINED
;
1154 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
1155 up_map
= DCB_ATTR_VALUE_UNDEFINED
;
1158 ops
->getpgtccfgrx(dev
, i
- DCB_PG_ATTR_TC_0
,
1159 &prio
, &pgid
, &tc_pct
, &up_map
);
1161 ops
->getpgtccfgtx(dev
, i
- DCB_PG_ATTR_TC_0
,
1162 &prio
, &pgid
, &tc_pct
, &up_map
);
1164 if (nla_put_u8(skb
, DCB_TC_ATTR_PARAM_PGID
, pgid
) ||
1165 nla_put_u8(skb
, DCB_TC_ATTR_PARAM_UP_MAPPING
, up_map
) ||
1166 nla_put_u8(skb
, DCB_TC_ATTR_PARAM_STRICT_PRIO
, prio
) ||
1167 nla_put_u8(skb
, DCB_TC_ATTR_PARAM_BW_PCT
, tc_pct
))
1169 nla_nest_end(skb
, tc_nest
);
1172 for (i
= DCB_PG_ATTR_BW_ID_0
; i
<= DCB_PG_ATTR_BW_ID_7
; i
++) {
1173 tc_pct
= DCB_ATTR_VALUE_UNDEFINED
;
1176 ops
->getpgbwgcfgrx(dev
, i
- DCB_PG_ATTR_BW_ID_0
,
1179 ops
->getpgbwgcfgtx(dev
, i
- DCB_PG_ATTR_BW_ID_0
,
1181 if (nla_put_u8(skb
, i
, tc_pct
))
1184 nla_nest_end(skb
, pg
);
1188 static int dcbnl_cee_fill(struct sk_buff
*skb
, struct net_device
*netdev
)
1190 struct nlattr
*cee
, *app
;
1191 struct dcb_app_type
*itr
;
1192 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1193 int dcbx
, i
, err
= -EMSGSIZE
;
1196 if (nla_put_string(skb
, DCB_ATTR_IFNAME
, netdev
->name
))
1197 goto nla_put_failure
;
1198 cee
= nla_nest_start(skb
, DCB_ATTR_CEE
);
1200 goto nla_put_failure
;
1203 if (ops
->getpgtccfgtx
&& ops
->getpgbwgcfgtx
) {
1204 err
= dcbnl_cee_pg_fill(skb
, netdev
, 1);
1206 goto nla_put_failure
;
1209 if (ops
->getpgtccfgrx
&& ops
->getpgbwgcfgrx
) {
1210 err
= dcbnl_cee_pg_fill(skb
, netdev
, 0);
1212 goto nla_put_failure
;
1216 if (ops
->getpfccfg
) {
1217 struct nlattr
*pfc_nest
= nla_nest_start(skb
, DCB_ATTR_CEE_PFC
);
1220 goto nla_put_failure
;
1222 for (i
= DCB_PFC_UP_ATTR_0
; i
<= DCB_PFC_UP_ATTR_7
; i
++) {
1223 ops
->getpfccfg(netdev
, i
- DCB_PFC_UP_ATTR_0
, &value
);
1224 if (nla_put_u8(skb
, i
, value
))
1225 goto nla_put_failure
;
1227 nla_nest_end(skb
, pfc_nest
);
1231 spin_lock(&dcb_lock
);
1232 app
= nla_nest_start(skb
, DCB_ATTR_CEE_APP_TABLE
);
1236 list_for_each_entry(itr
, &dcb_app_list
, list
) {
1237 if (itr
->ifindex
== netdev
->ifindex
) {
1238 struct nlattr
*app_nest
= nla_nest_start(skb
,
1243 err
= nla_put_u8(skb
, DCB_APP_ATTR_IDTYPE
,
1248 err
= nla_put_u16(skb
, DCB_APP_ATTR_ID
,
1253 err
= nla_put_u8(skb
, DCB_APP_ATTR_PRIORITY
,
1258 nla_nest_end(skb
, app_nest
);
1261 nla_nest_end(skb
, app
);
1263 if (netdev
->dcbnl_ops
->getdcbx
)
1264 dcbx
= netdev
->dcbnl_ops
->getdcbx(netdev
);
1268 spin_unlock(&dcb_lock
);
1270 /* features flags */
1271 if (ops
->getfeatcfg
) {
1272 struct nlattr
*feat
= nla_nest_start(skb
, DCB_ATTR_CEE_FEAT
);
1274 goto nla_put_failure
;
1276 for (i
= DCB_FEATCFG_ATTR_ALL
+ 1; i
<= DCB_FEATCFG_ATTR_MAX
;
1278 if (!ops
->getfeatcfg(netdev
, i
, &value
) &&
1279 nla_put_u8(skb
, i
, value
))
1280 goto nla_put_failure
;
1282 nla_nest_end(skb
, feat
);
1285 /* peer info if available */
1286 if (ops
->cee_peer_getpg
) {
1288 memset(&pg
, 0, sizeof(pg
));
1289 err
= ops
->cee_peer_getpg(netdev
, &pg
);
1291 nla_put(skb
, DCB_ATTR_CEE_PEER_PG
, sizeof(pg
), &pg
))
1292 goto nla_put_failure
;
1295 if (ops
->cee_peer_getpfc
) {
1297 memset(&pfc
, 0, sizeof(pfc
));
1298 err
= ops
->cee_peer_getpfc(netdev
, &pfc
);
1300 nla_put(skb
, DCB_ATTR_CEE_PEER_PFC
, sizeof(pfc
), &pfc
))
1301 goto nla_put_failure
;
1304 if (ops
->peer_getappinfo
&& ops
->peer_getapptable
) {
1305 err
= dcbnl_build_peer_app(netdev
, skb
,
1306 DCB_ATTR_CEE_PEER_APP_TABLE
,
1307 DCB_ATTR_CEE_PEER_APP_INFO
,
1308 DCB_ATTR_CEE_PEER_APP
);
1310 goto nla_put_failure
;
1312 nla_nest_end(skb
, cee
);
1316 err
= nla_put_u8(skb
, DCB_ATTR_DCBX
, dcbx
);
1318 goto nla_put_failure
;
1323 spin_unlock(&dcb_lock
);
1328 static int dcbnl_notify(struct net_device
*dev
, int event
, int cmd
,
1329 u32 seq
, u32 portid
, int dcbx_ver
)
1331 struct net
*net
= dev_net(dev
);
1332 struct sk_buff
*skb
;
1333 struct nlmsghdr
*nlh
;
1334 const struct dcbnl_rtnl_ops
*ops
= dev
->dcbnl_ops
;
1340 skb
= dcbnl_newmsg(event
, cmd
, portid
, seq
, 0, &nlh
);
1344 if (dcbx_ver
== DCB_CAP_DCBX_VER_IEEE
)
1345 err
= dcbnl_ieee_fill(skb
, dev
);
1347 err
= dcbnl_cee_fill(skb
, dev
);
1350 /* Report error to broadcast listeners */
1352 rtnl_set_sk_err(net
, RTNLGRP_DCB
, err
);
1354 /* End nlmsg and notify broadcast listeners */
1355 nlmsg_end(skb
, nlh
);
1356 rtnl_notify(skb
, net
, 0, RTNLGRP_DCB
, NULL
, GFP_KERNEL
);
1362 int dcbnl_ieee_notify(struct net_device
*dev
, int event
, int cmd
,
1363 u32 seq
, u32 portid
)
1365 return dcbnl_notify(dev
, event
, cmd
, seq
, portid
, DCB_CAP_DCBX_VER_IEEE
);
1367 EXPORT_SYMBOL(dcbnl_ieee_notify
);
1369 int dcbnl_cee_notify(struct net_device
*dev
, int event
, int cmd
,
1370 u32 seq
, u32 portid
)
1372 return dcbnl_notify(dev
, event
, cmd
, seq
, portid
, DCB_CAP_DCBX_VER_CEE
);
1374 EXPORT_SYMBOL(dcbnl_cee_notify
);
1376 /* Handle IEEE 802.1Qaz SET commands. If any requested operation can not
1377 * be completed the entire msg is aborted and error value is returned.
1378 * No attempt is made to reconcile the case where only part of the
1379 * cmd can be completed.
1381 static int dcbnl_ieee_set(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1382 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1384 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1385 struct nlattr
*ieee
[DCB_ATTR_IEEE_MAX
+ 1];
1391 if (!tb
[DCB_ATTR_IEEE
])
1394 err
= nla_parse_nested(ieee
, DCB_ATTR_IEEE_MAX
,
1395 tb
[DCB_ATTR_IEEE
], dcbnl_ieee_policy
);
1399 if (ieee
[DCB_ATTR_IEEE_ETS
] && ops
->ieee_setets
) {
1400 struct ieee_ets
*ets
= nla_data(ieee
[DCB_ATTR_IEEE_ETS
]);
1401 err
= ops
->ieee_setets(netdev
, ets
);
1406 if (ieee
[DCB_ATTR_IEEE_MAXRATE
] && ops
->ieee_setmaxrate
) {
1407 struct ieee_maxrate
*maxrate
=
1408 nla_data(ieee
[DCB_ATTR_IEEE_MAXRATE
]);
1409 err
= ops
->ieee_setmaxrate(netdev
, maxrate
);
1414 if (ieee
[DCB_ATTR_IEEE_PFC
] && ops
->ieee_setpfc
) {
1415 struct ieee_pfc
*pfc
= nla_data(ieee
[DCB_ATTR_IEEE_PFC
]);
1416 err
= ops
->ieee_setpfc(netdev
, pfc
);
1421 if (ieee
[DCB_ATTR_IEEE_APP_TABLE
]) {
1422 struct nlattr
*attr
;
1425 nla_for_each_nested(attr
, ieee
[DCB_ATTR_IEEE_APP_TABLE
], rem
) {
1426 struct dcb_app
*app_data
;
1427 if (nla_type(attr
) != DCB_ATTR_IEEE_APP
)
1429 app_data
= nla_data(attr
);
1430 if (ops
->ieee_setapp
)
1431 err
= ops
->ieee_setapp(netdev
, app_data
);
1433 err
= dcb_ieee_setapp(netdev
, app_data
);
1440 err
= nla_put_u8(skb
, DCB_ATTR_IEEE
, err
);
1441 dcbnl_ieee_notify(netdev
, RTM_SETDCB
, DCB_CMD_IEEE_SET
, seq
, 0);
1445 static int dcbnl_ieee_get(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1446 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1448 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1453 return dcbnl_ieee_fill(skb
, netdev
);
1456 static int dcbnl_ieee_del(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1457 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1459 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1460 struct nlattr
*ieee
[DCB_ATTR_IEEE_MAX
+ 1];
1466 if (!tb
[DCB_ATTR_IEEE
])
1469 err
= nla_parse_nested(ieee
, DCB_ATTR_IEEE_MAX
,
1470 tb
[DCB_ATTR_IEEE
], dcbnl_ieee_policy
);
1474 if (ieee
[DCB_ATTR_IEEE_APP_TABLE
]) {
1475 struct nlattr
*attr
;
1478 nla_for_each_nested(attr
, ieee
[DCB_ATTR_IEEE_APP_TABLE
], rem
) {
1479 struct dcb_app
*app_data
;
1481 if (nla_type(attr
) != DCB_ATTR_IEEE_APP
)
1483 app_data
= nla_data(attr
);
1484 if (ops
->ieee_delapp
)
1485 err
= ops
->ieee_delapp(netdev
, app_data
);
1487 err
= dcb_ieee_delapp(netdev
, app_data
);
1494 err
= nla_put_u8(skb
, DCB_ATTR_IEEE
, err
);
1495 dcbnl_ieee_notify(netdev
, RTM_SETDCB
, DCB_CMD_IEEE_DEL
, seq
, 0);
1500 /* DCBX configuration */
1501 static int dcbnl_getdcbx(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1502 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1504 if (!netdev
->dcbnl_ops
->getdcbx
)
1507 return nla_put_u8(skb
, DCB_ATTR_DCBX
,
1508 netdev
->dcbnl_ops
->getdcbx(netdev
));
1511 static int dcbnl_setdcbx(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1512 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1516 if (!netdev
->dcbnl_ops
->setdcbx
)
1519 if (!tb
[DCB_ATTR_DCBX
])
1522 value
= nla_get_u8(tb
[DCB_ATTR_DCBX
]);
1524 return nla_put_u8(skb
, DCB_ATTR_DCBX
,
1525 netdev
->dcbnl_ops
->setdcbx(netdev
, value
));
1528 static int dcbnl_getfeatcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1529 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1531 struct nlattr
*data
[DCB_FEATCFG_ATTR_MAX
+ 1], *nest
;
1536 if (!netdev
->dcbnl_ops
->getfeatcfg
)
1539 if (!tb
[DCB_ATTR_FEATCFG
])
1542 ret
= nla_parse_nested(data
, DCB_FEATCFG_ATTR_MAX
, tb
[DCB_ATTR_FEATCFG
],
1543 dcbnl_featcfg_nest
);
1547 nest
= nla_nest_start(skb
, DCB_ATTR_FEATCFG
);
1551 if (data
[DCB_FEATCFG_ATTR_ALL
])
1554 for (i
= DCB_FEATCFG_ATTR_ALL
+1; i
<= DCB_FEATCFG_ATTR_MAX
; i
++) {
1555 if (!getall
&& !data
[i
])
1558 ret
= netdev
->dcbnl_ops
->getfeatcfg(netdev
, i
, &value
);
1560 ret
= nla_put_u8(skb
, i
, value
);
1563 nla_nest_cancel(skb
, nest
);
1564 goto nla_put_failure
;
1567 nla_nest_end(skb
, nest
);
1573 static int dcbnl_setfeatcfg(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1574 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1576 struct nlattr
*data
[DCB_FEATCFG_ATTR_MAX
+ 1];
1580 if (!netdev
->dcbnl_ops
->setfeatcfg
)
1583 if (!tb
[DCB_ATTR_FEATCFG
])
1586 ret
= nla_parse_nested(data
, DCB_FEATCFG_ATTR_MAX
, tb
[DCB_ATTR_FEATCFG
],
1587 dcbnl_featcfg_nest
);
1592 for (i
= DCB_FEATCFG_ATTR_ALL
+1; i
<= DCB_FEATCFG_ATTR_MAX
; i
++) {
1593 if (data
[i
] == NULL
)
1596 value
= nla_get_u8(data
[i
]);
1598 ret
= netdev
->dcbnl_ops
->setfeatcfg(netdev
, i
, value
);
1604 ret
= nla_put_u8(skb
, DCB_ATTR_FEATCFG
, ret
);
1609 /* Handle CEE DCBX GET commands. */
1610 static int dcbnl_cee_get(struct net_device
*netdev
, struct nlmsghdr
*nlh
,
1611 u32 seq
, struct nlattr
**tb
, struct sk_buff
*skb
)
1613 const struct dcbnl_rtnl_ops
*ops
= netdev
->dcbnl_ops
;
1618 return dcbnl_cee_fill(skb
, netdev
);
1622 /* reply netlink message type */
1625 /* function to fill message contents */
1626 int (*cb
)(struct net_device
*, struct nlmsghdr
*, u32
,
1627 struct nlattr
**, struct sk_buff
*);
1630 static const struct reply_func reply_funcs
[DCB_CMD_MAX
+1] = {
1631 [DCB_CMD_GSTATE
] = { RTM_GETDCB
, dcbnl_getstate
},
1632 [DCB_CMD_SSTATE
] = { RTM_SETDCB
, dcbnl_setstate
},
1633 [DCB_CMD_PFC_GCFG
] = { RTM_GETDCB
, dcbnl_getpfccfg
},
1634 [DCB_CMD_PFC_SCFG
] = { RTM_SETDCB
, dcbnl_setpfccfg
},
1635 [DCB_CMD_GPERM_HWADDR
] = { RTM_GETDCB
, dcbnl_getperm_hwaddr
},
1636 [DCB_CMD_GCAP
] = { RTM_GETDCB
, dcbnl_getcap
},
1637 [DCB_CMD_GNUMTCS
] = { RTM_GETDCB
, dcbnl_getnumtcs
},
1638 [DCB_CMD_SNUMTCS
] = { RTM_SETDCB
, dcbnl_setnumtcs
},
1639 [DCB_CMD_PFC_GSTATE
] = { RTM_GETDCB
, dcbnl_getpfcstate
},
1640 [DCB_CMD_PFC_SSTATE
] = { RTM_SETDCB
, dcbnl_setpfcstate
},
1641 [DCB_CMD_GAPP
] = { RTM_GETDCB
, dcbnl_getapp
},
1642 [DCB_CMD_SAPP
] = { RTM_SETDCB
, dcbnl_setapp
},
1643 [DCB_CMD_PGTX_GCFG
] = { RTM_GETDCB
, dcbnl_pgtx_getcfg
},
1644 [DCB_CMD_PGTX_SCFG
] = { RTM_SETDCB
, dcbnl_pgtx_setcfg
},
1645 [DCB_CMD_PGRX_GCFG
] = { RTM_GETDCB
, dcbnl_pgrx_getcfg
},
1646 [DCB_CMD_PGRX_SCFG
] = { RTM_SETDCB
, dcbnl_pgrx_setcfg
},
1647 [DCB_CMD_SET_ALL
] = { RTM_SETDCB
, dcbnl_setall
},
1648 [DCB_CMD_BCN_GCFG
] = { RTM_GETDCB
, dcbnl_bcn_getcfg
},
1649 [DCB_CMD_BCN_SCFG
] = { RTM_SETDCB
, dcbnl_bcn_setcfg
},
1650 [DCB_CMD_IEEE_GET
] = { RTM_GETDCB
, dcbnl_ieee_get
},
1651 [DCB_CMD_IEEE_SET
] = { RTM_SETDCB
, dcbnl_ieee_set
},
1652 [DCB_CMD_IEEE_DEL
] = { RTM_SETDCB
, dcbnl_ieee_del
},
1653 [DCB_CMD_GDCBX
] = { RTM_GETDCB
, dcbnl_getdcbx
},
1654 [DCB_CMD_SDCBX
] = { RTM_SETDCB
, dcbnl_setdcbx
},
1655 [DCB_CMD_GFEATCFG
] = { RTM_GETDCB
, dcbnl_getfeatcfg
},
1656 [DCB_CMD_SFEATCFG
] = { RTM_SETDCB
, dcbnl_setfeatcfg
},
1657 [DCB_CMD_CEE_GET
] = { RTM_GETDCB
, dcbnl_cee_get
},
1660 static int dcb_doit(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1662 struct net
*net
= sock_net(skb
->sk
);
1663 struct net_device
*netdev
;
1664 struct dcbmsg
*dcb
= nlmsg_data(nlh
);
1665 struct nlattr
*tb
[DCB_ATTR_MAX
+ 1];
1666 u32 portid
= skb
? NETLINK_CB(skb
).portid
: 0;
1668 struct sk_buff
*reply_skb
;
1669 struct nlmsghdr
*reply_nlh
= NULL
;
1670 const struct reply_func
*fn
;
1672 if ((nlh
->nlmsg_type
== RTM_SETDCB
) && !capable(CAP_NET_ADMIN
))
1675 ret
= nlmsg_parse(nlh
, sizeof(*dcb
), tb
, DCB_ATTR_MAX
,
1680 if (dcb
->cmd
> DCB_CMD_MAX
)
1683 /* check if a reply function has been defined for the command */
1684 fn
= &reply_funcs
[dcb
->cmd
];
1688 if (!tb
[DCB_ATTR_IFNAME
])
1691 netdev
= dev_get_by_name(net
, nla_data(tb
[DCB_ATTR_IFNAME
]));
1695 if (!netdev
->dcbnl_ops
) {
1700 reply_skb
= dcbnl_newmsg(fn
->type
, dcb
->cmd
, portid
, nlh
->nlmsg_seq
,
1701 nlh
->nlmsg_flags
, &reply_nlh
);
1707 ret
= fn
->cb(netdev
, nlh
, nlh
->nlmsg_seq
, tb
, reply_skb
);
1709 nlmsg_free(reply_skb
);
1713 nlmsg_end(reply_skb
, reply_nlh
);
1715 ret
= rtnl_unicast(reply_skb
, net
, portid
);
1721 static struct dcb_app_type
*dcb_app_lookup(const struct dcb_app
*app
,
1722 int ifindex
, int prio
)
1724 struct dcb_app_type
*itr
;
1726 list_for_each_entry(itr
, &dcb_app_list
, list
) {
1727 if (itr
->app
.selector
== app
->selector
&&
1728 itr
->app
.protocol
== app
->protocol
&&
1729 itr
->ifindex
== ifindex
&&
1730 (!prio
|| itr
->app
.priority
== prio
))
1737 static int dcb_app_add(const struct dcb_app
*app
, int ifindex
)
1739 struct dcb_app_type
*entry
;
1741 entry
= kmalloc(sizeof(*entry
), GFP_ATOMIC
);
1745 memcpy(&entry
->app
, app
, sizeof(*app
));
1746 entry
->ifindex
= ifindex
;
1747 list_add(&entry
->list
, &dcb_app_list
);
1753 * dcb_getapp - retrieve the DCBX application user priority
1755 * On success returns a non-zero 802.1p user priority bitmap
1756 * otherwise returns 0 as the invalid user priority bitmap to
1757 * indicate an error.
1759 u8
dcb_getapp(struct net_device
*dev
, struct dcb_app
*app
)
1761 struct dcb_app_type
*itr
;
1764 spin_lock(&dcb_lock
);
1765 if ((itr
= dcb_app_lookup(app
, dev
->ifindex
, 0)))
1766 prio
= itr
->app
.priority
;
1767 spin_unlock(&dcb_lock
);
1771 EXPORT_SYMBOL(dcb_getapp
);
1774 * dcb_setapp - add CEE dcb application data to app list
1776 * Priority 0 is an invalid priority in CEE spec. This routine
1777 * removes applications from the app list if the priority is
1780 int dcb_setapp(struct net_device
*dev
, struct dcb_app
*new)
1782 struct dcb_app_type
*itr
;
1783 struct dcb_app_type event
;
1786 event
.ifindex
= dev
->ifindex
;
1787 memcpy(&event
.app
, new, sizeof(event
.app
));
1788 if (dev
->dcbnl_ops
->getdcbx
)
1789 event
.dcbx
= dev
->dcbnl_ops
->getdcbx(dev
);
1791 spin_lock(&dcb_lock
);
1792 /* Search for existing match and replace */
1793 if ((itr
= dcb_app_lookup(new, dev
->ifindex
, 0))) {
1795 itr
->app
.priority
= new->priority
;
1797 list_del(&itr
->list
);
1802 /* App type does not exist add new application type */
1804 err
= dcb_app_add(new, dev
->ifindex
);
1806 spin_unlock(&dcb_lock
);
1808 call_dcbevent_notifiers(DCB_APP_EVENT
, &event
);
1811 EXPORT_SYMBOL(dcb_setapp
);
1814 * dcb_ieee_getapp_mask - retrieve the IEEE DCB application priority
1816 * Helper routine which on success returns a non-zero 802.1Qaz user
1817 * priority bitmap otherwise returns 0 to indicate the dcb_app was
1818 * not found in APP list.
1820 u8
dcb_ieee_getapp_mask(struct net_device
*dev
, struct dcb_app
*app
)
1822 struct dcb_app_type
*itr
;
1825 spin_lock(&dcb_lock
);
1826 if ((itr
= dcb_app_lookup(app
, dev
->ifindex
, 0)))
1827 prio
|= 1 << itr
->app
.priority
;
1828 spin_unlock(&dcb_lock
);
1832 EXPORT_SYMBOL(dcb_ieee_getapp_mask
);
1835 * dcb_ieee_setapp - add IEEE dcb application data to app list
1837 * This adds Application data to the list. Multiple application
1838 * entries may exists for the same selector and protocol as long
1839 * as the priorities are different.
1841 int dcb_ieee_setapp(struct net_device
*dev
, struct dcb_app
*new)
1843 struct dcb_app_type event
;
1846 event
.ifindex
= dev
->ifindex
;
1847 memcpy(&event
.app
, new, sizeof(event
.app
));
1848 if (dev
->dcbnl_ops
->getdcbx
)
1849 event
.dcbx
= dev
->dcbnl_ops
->getdcbx(dev
);
1851 spin_lock(&dcb_lock
);
1852 /* Search for existing match and abort if found */
1853 if (dcb_app_lookup(new, dev
->ifindex
, new->priority
)) {
1858 err
= dcb_app_add(new, dev
->ifindex
);
1860 spin_unlock(&dcb_lock
);
1862 call_dcbevent_notifiers(DCB_APP_EVENT
, &event
);
1865 EXPORT_SYMBOL(dcb_ieee_setapp
);
1868 * dcb_ieee_delapp - delete IEEE dcb application data from list
1870 * This removes a matching APP data from the APP list
1872 int dcb_ieee_delapp(struct net_device
*dev
, struct dcb_app
*del
)
1874 struct dcb_app_type
*itr
;
1875 struct dcb_app_type event
;
1878 event
.ifindex
= dev
->ifindex
;
1879 memcpy(&event
.app
, del
, sizeof(event
.app
));
1880 if (dev
->dcbnl_ops
->getdcbx
)
1881 event
.dcbx
= dev
->dcbnl_ops
->getdcbx(dev
);
1883 spin_lock(&dcb_lock
);
1884 /* Search for existing match and remove it. */
1885 if ((itr
= dcb_app_lookup(del
, dev
->ifindex
, del
->priority
))) {
1886 list_del(&itr
->list
);
1891 spin_unlock(&dcb_lock
);
1893 call_dcbevent_notifiers(DCB_APP_EVENT
, &event
);
1896 EXPORT_SYMBOL(dcb_ieee_delapp
);
1898 static void dcb_flushapp(void)
1900 struct dcb_app_type
*app
;
1901 struct dcb_app_type
*tmp
;
1903 spin_lock(&dcb_lock
);
1904 list_for_each_entry_safe(app
, tmp
, &dcb_app_list
, list
) {
1905 list_del(&app
->list
);
1908 spin_unlock(&dcb_lock
);
1911 static int __init
dcbnl_init(void)
1913 INIT_LIST_HEAD(&dcb_app_list
);
1915 rtnl_register(PF_UNSPEC
, RTM_GETDCB
, dcb_doit
, NULL
, NULL
);
1916 rtnl_register(PF_UNSPEC
, RTM_SETDCB
, dcb_doit
, NULL
, NULL
);
1920 module_init(dcbnl_init
);
1922 static void __exit
dcbnl_exit(void)
1924 rtnl_unregister(PF_UNSPEC
, RTM_GETDCB
);
1925 rtnl_unregister(PF_UNSPEC
, RTM_SETDCB
);
1928 module_exit(dcbnl_exit
);