]> Git Repo - linux.git/blame - net/dcb/dcbnl.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ipv6: sr: fix BUG due to headroom too small after SRH push
[linux.git] / net / dcb / dcbnl.c
CommitLineData
2f90b865 1/*
698e1d23 2 * Copyright (c) 2008-2011, Intel Corporation.
2f90b865
AD		 3 *
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.
7 *
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
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
c057b190 14 * this program; if not, see <http://www.gnu.org/licenses/>.
2f90b865 15 *
36b9ad80 16 * Description: Data Center Bridging netlink interface
2f90b865
AD		 17 * Author: Lucy Liu <[email protected]>
18 */
19
20#include <linux/netdevice.h>
21#include <linux/netlink.h>
5a0e3ad6 22#include <linux/slab.h>
2f90b865
AD		 23#include <net/netlink.h>
24#include <net/rtnetlink.h>
25#include <linux/dcbnl.h>
96b99684 26#include <net/dcbevent.h>
2f90b865 27#include <linux/rtnetlink.h>
36b9ad80 28#include <linux/init.h>
2f90b865
AD		 29#include <net/sock.h>
30
ae86b9e3 31/* Data Center Bridging (DCB) is a collection of Ethernet enhancements
2f90b865
AD		 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:
35 *
36 * Enhanced Transmission Selection (aka Priority Grouping [PG]) - provides a
37 * framework for assigning bandwidth guarantees to traffic classes.
38 *
39 * Priority-based Flow Control (PFC) - provides a flow control mechanism which
40 * can work independently for each 802.1p priority.
41 *
42 * Congestion Notification - provides a mechanism for end-to-end congestion
43 * control for protocols which do not have built-in congestion management.
44 *
45 * More information about the emerging standards for these Ethernet features
46 * can be found at: http://www.ieee802.org/1/pages/dcbridges.html
47 *
48 * This file implements an rtnetlink interface to allow configuration of DCB
49 * features for capable devices.
50 */
51
2f90b865
AD		 52/**************** DCB attribute policies *************************************/
53
54/* DCB netlink attributes policy */
b54452b0 55static const struct nla_policy dcbnl_rtnl_policy[DCB_ATTR_MAX + 1] = {
859ee3c4
AD		 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},
2f90b865 61 [DCB_ATTR_PERM_HWADDR] = {.type = NLA_FLAG},
859ee3c4
AD		 62 [DCB_ATTR_CAP] = {.type = NLA_NESTED},
63 [DCB_ATTR_PFC_STATE] = {.type = NLA_U8},
64 [DCB_ATTR_BCN] = {.type = NLA_NESTED},
6fa382af 65 [DCB_ATTR_APP] = {.type = NLA_NESTED},
3e29027a 66 [DCB_ATTR_IEEE] = {.type = NLA_NESTED},
6241b625 67 [DCB_ATTR_DCBX] = {.type = NLA_U8},
ea45fe4e 68 [DCB_ATTR_FEATCFG] = {.type = NLA_NESTED},
2f90b865
AD		 69};
70
71/* DCB priority flow control to User Priority nested attributes */
b54452b0 72static const struct nla_policy dcbnl_pfc_up_nest[DCB_PFC_UP_ATTR_MAX + 1] = {
2f90b865
AD		 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},
82};
83
84/* DCB priority grouping nested attributes */
b54452b0 85static const struct nla_policy dcbnl_pg_nest[DCB_PG_ATTR_MAX + 1] = {
2f90b865
AD		 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},
104};
105
106/* DCB traffic class nested attributes. */
b54452b0 107static const struct nla_policy dcbnl_tc_param_nest[DCB_TC_ATTR_PARAM_MAX + 1] = {
2f90b865
AD		 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},
113};
114
46132188 115/* DCB capabilities nested attributes. */
b54452b0 116static const struct nla_policy dcbnl_cap_nest[DCB_CAP_ATTR_MAX + 1] = {
46132188
AD		 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},
6241b625 125 [DCB_CAP_ATTR_DCBX] = {.type = NLA_U8},
46132188 126};
2f90b865 127
33dbabc4 128/* DCB capabilities nested attributes. */
b54452b0 129static const struct nla_policy dcbnl_numtcs_nest[DCB_NUMTCS_ATTR_MAX + 1] = {
33dbabc4
AD		 130 [DCB_NUMTCS_ATTR_ALL] = {.type = NLA_FLAG},
131 [DCB_NUMTCS_ATTR_PG] = {.type = NLA_U8},
132 [DCB_NUMTCS_ATTR_PFC] = {.type = NLA_U8},
133};
134
859ee3c4 135/* DCB BCN nested attributes. */
b54452b0 136static const struct nla_policy dcbnl_bcn_nest[DCB_BCN_ATTR_MAX + 1] = {
859ee3c4
AD		 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},
f4314e81
DS		 146 [DCB_BCN_ATTR_BCNA_0] = {.type = NLA_U32},
147 [DCB_BCN_ATTR_BCNA_1] = {.type = NLA_U32},
859ee3c4
AD		 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},
162};
163
6fa382af 164/* DCB APP nested attributes. */
b54452b0 165static const struct nla_policy dcbnl_app_nest[DCB_APP_ATTR_MAX + 1] = {
6fa382af
YZ		 166 [DCB_APP_ATTR_IDTYPE] = {.type = NLA_U8},
167 [DCB_APP_ATTR_ID] = {.type = NLA_U16},
168 [DCB_APP_ATTR_PRIORITY] = {.type = NLA_U8},
169};
170
3e29027a
JF		 171/* IEEE 802.1Qaz nested attributes. */
172static 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},
08f10aff 176 [DCB_ATTR_IEEE_MAXRATE] = {.len = sizeof(struct ieee_maxrate)},
c9368247
SM		 177 [DCB_ATTR_IEEE_QCN] = {.len = sizeof(struct ieee_qcn)},
178 [DCB_ATTR_IEEE_QCN_STATS] = {.len = sizeof(struct ieee_qcn_stats)},
3e29027a
JF		 179};
180
181static const struct nla_policy dcbnl_ieee_app[DCB_ATTR_IEEE_APP_MAX + 1] = {
182 [DCB_ATTR_IEEE_APP] = {.len = sizeof(struct dcb_app)},
183};
184
ea45fe4e
SR		 185/* DCB number of traffic classes nested attributes. */
186static 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},
191};
192
9ab933ab
JF		 193static LIST_HEAD(dcb_app_list);
194static DEFINE_SPINLOCK(dcb_lock);
195
33a03aad
TG		 196static struct sk_buff *dcbnl_newmsg(int type, u8 cmd, u32 port, u32 seq,
197 u32 flags, struct nlmsghdr **nlhp)
198{
199 struct sk_buff *skb;
200 struct dcbmsg *dcb;
201 struct nlmsghdr *nlh;
202
203 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
204 if (!skb)
205 return NULL;
206
207 nlh = nlmsg_put(skb, port, seq, type, sizeof(*dcb), flags);
b3908e22 208 BUG_ON(!nlh);
33a03aad
TG		 209
210 dcb = nlmsg_data(nlh);
211 dcb->dcb_family = AF_UNSPEC;
212 dcb->cmd = cmd;
213 dcb->dcb_pad = 0;
214
215 if (nlhp)
216 *nlhp = nlh;
217
218 return skb;
219}
220
7be99413
TG		 221static int dcbnl_getstate(struct net_device *netdev, struct nlmsghdr *nlh,
222 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 223{
2f90b865
AD		 224 /* if (!tb[DCB_ATTR_STATE] || !netdev->dcbnl_ops->getstate) */
225 if (!netdev->dcbnl_ops->getstate)
3d1f4869 226 return -EOPNOTSUPP;
2f90b865 227
7be99413
TG		 228 return nla_put_u8(skb, DCB_ATTR_STATE,
229 netdev->dcbnl_ops->getstate(netdev));
2f90b865
AD		 230}
231
7be99413
TG		 232static int dcbnl_getpfccfg(struct net_device *netdev, struct nlmsghdr *nlh,
233 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 234{
2f90b865
AD		 235 struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1], *nest;
236 u8 value;
3d1f4869 237 int ret;
2f90b865
AD		 238 int i;
239 int getall = 0;
240
3d1f4869
TG		 241 if (!tb[DCB_ATTR_PFC_CFG])
242 return -EINVAL;
243
244 if (!netdev->dcbnl_ops->getpfccfg)
245 return -EOPNOTSUPP;
2f90b865
AD		 246
247 ret = nla_parse_nested(data, DCB_PFC_UP_ATTR_MAX,
fceb6435 248 tb[DCB_ATTR_PFC_CFG], dcbnl_pfc_up_nest, NULL);
2f90b865 249 if (ret)
3d1f4869 250 return ret;
2f90b865 251
7be99413 252 nest = nla_nest_start(skb, DCB_ATTR_PFC_CFG);
2f90b865 253 if (!nest)
3d1f4869 254 return -EMSGSIZE;
2f90b865
AD		 255
256 if (data[DCB_PFC_UP_ATTR_ALL])
257 getall = 1;
258
259 for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) {
260 if (!getall && !data[i])
261 continue;
262
263 netdev->dcbnl_ops->getpfccfg(netdev, i - DCB_PFC_UP_ATTR_0,
264 &value);
7be99413 265 ret = nla_put_u8(skb, i, value);
2f90b865 266 if (ret) {
7be99413 267 nla_nest_cancel(skb, nest);
3d1f4869 268 return ret;
2f90b865
AD		 269 }
270 }
7be99413 271 nla_nest_end(skb, nest);
2f90b865
AD		 272
273 return 0;
2f90b865
AD		 274}
275
7be99413
TG		 276static int dcbnl_getperm_hwaddr(struct net_device *netdev, struct nlmsghdr *nlh,
277 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 278{
2f90b865 279 u8 perm_addr[MAX_ADDR_LEN];
2f90b865
AD		 280
281 if (!netdev->dcbnl_ops->getpermhwaddr)
3d1f4869 282 return -EOPNOTSUPP;
2f90b865 283
29cd8ae0 284 memset(perm_addr, 0, sizeof(perm_addr));
2f90b865
AD		 285 netdev->dcbnl_ops->getpermhwaddr(netdev, perm_addr);
286
7be99413 287 return nla_put(skb, DCB_ATTR_PERM_HWADDR, sizeof(perm_addr), perm_addr);
2f90b865
AD		 288}
289
7be99413
TG		 290static int dcbnl_getcap(struct net_device *netdev, struct nlmsghdr *nlh,
291 u32 seq, struct nlattr **tb, struct sk_buff *skb)
46132188 292{
46132188
AD		 293 struct nlattr *data[DCB_CAP_ATTR_MAX + 1], *nest;
294 u8 value;
3d1f4869 295 int ret;
46132188
AD		 296 int i;
297 int getall = 0;
298
3d1f4869
TG		 299 if (!tb[DCB_ATTR_CAP])
300 return -EINVAL;
301
302 if (!netdev->dcbnl_ops->getcap)
303 return -EOPNOTSUPP;
46132188
AD		 304
305 ret = nla_parse_nested(data, DCB_CAP_ATTR_MAX, tb[DCB_ATTR_CAP],
fceb6435 306 dcbnl_cap_nest, NULL);
46132188 307 if (ret)
3d1f4869 308 return ret;
46132188 309
7be99413 310 nest = nla_nest_start(skb, DCB_ATTR_CAP);
46132188 311 if (!nest)
3d1f4869 312 return -EMSGSIZE;
46132188
AD		 313
314 if (data[DCB_CAP_ATTR_ALL])
315 getall = 1;
316
317 for (i = DCB_CAP_ATTR_ALL+1; i <= DCB_CAP_ATTR_MAX; i++) {
318 if (!getall && !data[i])
319 continue;
320
321 if (!netdev->dcbnl_ops->getcap(netdev, i, &value)) {
7be99413 322 ret = nla_put_u8(skb, i, value);
46132188 323 if (ret) {
7be99413 324 nla_nest_cancel(skb, nest);
3d1f4869 325 return ret;
46132188
AD		 326 }
327 }
328 }
7be99413 329 nla_nest_end(skb, nest);
46132188
AD		 330
331 return 0;
46132188
AD		 332}
333
7be99413
TG		 334static int dcbnl_getnumtcs(struct net_device *netdev, struct nlmsghdr *nlh,
335 u32 seq, struct nlattr **tb, struct sk_buff *skb)
33dbabc4 336{
33dbabc4
AD		 337 struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1], *nest;
338 u8 value;
3d1f4869 339 int ret;
33dbabc4
AD		 340 int i;
341 int getall = 0;
342
3d1f4869
TG		 343 if (!tb[DCB_ATTR_NUMTCS])
344 return -EINVAL;
345
346 if (!netdev->dcbnl_ops->getnumtcs)
347 return -EOPNOTSUPP;
33dbabc4
AD		 348
349 ret = nla_parse_nested(data, DCB_NUMTCS_ATTR_MAX, tb[DCB_ATTR_NUMTCS],
fceb6435 350 dcbnl_numtcs_nest, NULL);
3d1f4869
TG		 351 if (ret)
352 return ret;
33dbabc4 353
7be99413 354 nest = nla_nest_start(skb, DCB_ATTR_NUMTCS);
3d1f4869
TG		 355 if (!nest)
356 return -EMSGSIZE;
33dbabc4
AD		 357
358 if (data[DCB_NUMTCS_ATTR_ALL])
359 getall = 1;
360
361 for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) {
362 if (!getall && !data[i])
363 continue;
364
365 ret = netdev->dcbnl_ops->getnumtcs(netdev, i, &value);
366 if (!ret) {
7be99413 367 ret = nla_put_u8(skb, i, value);
33dbabc4 368 if (ret) {
7be99413 369 nla_nest_cancel(skb, nest);
3d1f4869 370 return ret;
33dbabc4 371 }
3d1f4869
TG		 372 } else
373 return -EINVAL;
33dbabc4 374 }
7be99413 375 nla_nest_end(skb, nest);
33dbabc4
AD		 376
377 return 0;
33dbabc4
AD		 378}
379
7be99413
TG		 380static int dcbnl_setnumtcs(struct net_device *netdev, struct nlmsghdr *nlh,
381 u32 seq, struct nlattr **tb, struct sk_buff *skb)
33dbabc4
AD		 382{
383 struct nlattr *data[DCB_NUMTCS_ATTR_MAX + 1];
3d1f4869 384 int ret;
33dbabc4
AD		 385 u8 value;
386 int i;
387
3d1f4869
TG		 388 if (!tb[DCB_ATTR_NUMTCS])
389 return -EINVAL;
390
391 if (!netdev->dcbnl_ops->setnumtcs)
392 return -EOPNOTSUPP;
33dbabc4
AD		 393
394 ret = nla_parse_nested(data, DCB_NUMTCS_ATTR_MAX, tb[DCB_ATTR_NUMTCS],
fceb6435 395 dcbnl_numtcs_nest, NULL);
7be99413 396 if (ret)
3d1f4869 397 return ret;
33dbabc4
AD		 398
399 for (i = DCB_NUMTCS_ATTR_ALL+1; i <= DCB_NUMTCS_ATTR_MAX; i++) {
400 if (data[i] == NULL)
401 continue;
402
403 value = nla_get_u8(data[i]);
404
405 ret = netdev->dcbnl_ops->setnumtcs(netdev, i, value);
33dbabc4 406 if (ret)
7be99413 407 break;
33dbabc4
AD		 408 }
409
7be99413 410 return nla_put_u8(skb, DCB_ATTR_NUMTCS, !!ret);
33dbabc4
AD		 411}
412
7be99413
TG		 413static int dcbnl_getpfcstate(struct net_device *netdev, struct nlmsghdr *nlh,
414 u32 seq, struct nlattr **tb, struct sk_buff *skb)
0eb3aa9b 415{
0eb3aa9b 416 if (!netdev->dcbnl_ops->getpfcstate)
3d1f4869 417 return -EOPNOTSUPP;
0eb3aa9b 418
7be99413
TG		 419 return nla_put_u8(skb, DCB_ATTR_PFC_STATE,
420 netdev->dcbnl_ops->getpfcstate(netdev));
0eb3aa9b
AD		 421}
422
7be99413
TG		 423static int dcbnl_setpfcstate(struct net_device *netdev, struct nlmsghdr *nlh,
424 u32 seq, struct nlattr **tb, struct sk_buff *skb)
0eb3aa9b 425{
0eb3aa9b
AD		 426 u8 value;
427
3d1f4869 428 if (!tb[DCB_ATTR_PFC_STATE])
7be99413 429 return -EINVAL;
0eb3aa9b 430
3d1f4869
TG		 431 if (!netdev->dcbnl_ops->setpfcstate)
432 return -EOPNOTSUPP;
433
0eb3aa9b
AD		 434 value = nla_get_u8(tb[DCB_ATTR_PFC_STATE]);
435
436 netdev->dcbnl_ops->setpfcstate(netdev, value);
437
7be99413 438 return nla_put_u8(skb, DCB_ATTR_PFC_STATE, 0);
0eb3aa9b
AD		 439}
440
7be99413
TG		 441static int dcbnl_getapp(struct net_device *netdev, struct nlmsghdr *nlh,
442 u32 seq, struct nlattr **tb, struct sk_buff *skb)
57949686 443{
57949686
YZ		 444 struct nlattr *app_nest;
445 struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1];
446 u16 id;
447 u8 up, idtype;
3d1f4869 448 int ret;
57949686 449
3dce38a0 450 if (!tb[DCB_ATTR_APP])
3d1f4869 451 return -EINVAL;
57949686
YZ		 452
453 ret = nla_parse_nested(app_tb, DCB_APP_ATTR_MAX, tb[DCB_ATTR_APP],
fceb6435 454 dcbnl_app_nest, NULL);
57949686 455 if (ret)
3d1f4869 456 return ret;
57949686 457
57949686
YZ		 458 /* all must be non-null */
459 if ((!app_tb[DCB_APP_ATTR_IDTYPE]) ||
460 (!app_tb[DCB_APP_ATTR_ID]))
3d1f4869 461 return -EINVAL;
57949686
YZ		 462
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))
3d1f4869 467 return -EINVAL;
57949686
YZ		 468
469 id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]);
3dce38a0
JF		 470
471 if (netdev->dcbnl_ops->getapp) {
c2659479
AB		 472 ret = netdev->dcbnl_ops->getapp(netdev, idtype, id);
473 if (ret < 0)
474 return ret;
475 else
476 up = ret;
3dce38a0
JF		 477 } else {
478 struct dcb_app app = {
479 .selector = idtype,
480 .protocol = id,
481 };
482 up = dcb_getapp(netdev, &app);
483 }
57949686 484
7be99413 485 app_nest = nla_nest_start(skb, DCB_ATTR_APP);
d3337de5 486 if (!app_nest)
3d1f4869 487 return -EMSGSIZE;
d3337de5 488
7be99413 489 ret = nla_put_u8(skb, DCB_APP_ATTR_IDTYPE, idtype);
57949686
YZ		 490 if (ret)
491 goto out_cancel;
492
7be99413 493 ret = nla_put_u16(skb, DCB_APP_ATTR_ID, id);
57949686
YZ		 494 if (ret)
495 goto out_cancel;
496
7be99413 497 ret = nla_put_u8(skb, DCB_APP_ATTR_PRIORITY, up);
57949686
YZ		 498 if (ret)
499 goto out_cancel;
500
7be99413 501 nla_nest_end(skb, app_nest);
57949686 502
3d1f4869 503 return 0;
57949686
YZ		 504
505out_cancel:
7be99413 506 nla_nest_cancel(skb, app_nest);
57949686
YZ		 507 return ret;
508}
509
7be99413
TG		 510static int dcbnl_setapp(struct net_device *netdev, struct nlmsghdr *nlh,
511 u32 seq, struct nlattr **tb, struct sk_buff *skb)
57949686 512{
3d1f4869 513 int ret;
57949686
YZ		 514 u16 id;
515 u8 up, idtype;
516 struct nlattr *app_tb[DCB_APP_ATTR_MAX + 1];
517
9ab933ab 518 if (!tb[DCB_ATTR_APP])
3d1f4869 519 return -EINVAL;
57949686
YZ		 520
521 ret = nla_parse_nested(app_tb, DCB_APP_ATTR_MAX, tb[DCB_ATTR_APP],
fceb6435 522 dcbnl_app_nest, NULL);
57949686 523 if (ret)
3d1f4869 524 return ret;
57949686 525
57949686
YZ		 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]))
3d1f4869 530 return -EINVAL;
57949686
YZ		 531
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))
3d1f4869 536 return -EINVAL;
57949686
YZ		 537
538 id = nla_get_u16(app_tb[DCB_APP_ATTR_ID]);
539 up = nla_get_u8(app_tb[DCB_APP_ATTR_PRIORITY]);
540
9ab933ab 541 if (netdev->dcbnl_ops->setapp) {
3d1f4869 542 ret = netdev->dcbnl_ops->setapp(netdev, idtype, id, up);
c2659479
AB		 543 if (ret < 0)
544 return ret;
9ab933ab
JF		 545 } else {
546 struct dcb_app app;
547 app.selector = idtype;
548 app.protocol = id;
549 app.priority = up;
3d1f4869 550 ret = dcb_setapp(netdev, &app);
9ab933ab
JF		 551 }
552
7be99413 553 ret = nla_put_u8(skb, DCB_ATTR_APP, ret);
08157984 554 dcbnl_cee_notify(netdev, RTM_SETDCB, DCB_CMD_SAPP, seq, 0);
3d1f4869 555
57949686
YZ		 556 return ret;
557}
558
7be99413
TG		 559static int __dcbnl_pg_getcfg(struct net_device *netdev, struct nlmsghdr *nlh,
560 struct nlattr **tb, struct sk_buff *skb, int dir)
2f90b865 561{
2f90b865
AD		 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;
3d1f4869 566 int ret;
2f90b865
AD		 567 int getall = 0;
568 int i;
569
3d1f4869
TG		 570 if (!tb[DCB_ATTR_PG_CFG])
571 return -EINVAL;
572
573 if (!netdev->dcbnl_ops->getpgtccfgtx ||
2f90b865
AD		 574 !netdev->dcbnl_ops->getpgtccfgrx ||
575 !netdev->dcbnl_ops->getpgbwgcfgtx ||
576 !netdev->dcbnl_ops->getpgbwgcfgrx)
3d1f4869 577 return -EOPNOTSUPP;
2f90b865 578
fceb6435
JB		 579 ret = nla_parse_nested(pg_tb, DCB_PG_ATTR_MAX, tb[DCB_ATTR_PG_CFG],
580 dcbnl_pg_nest, NULL);
2f90b865 581 if (ret)
3d1f4869 582 return ret;
2f90b865 583
7be99413 584 pg_nest = nla_nest_start(skb, DCB_ATTR_PG_CFG);
2f90b865 585 if (!pg_nest)
3d1f4869 586 return -EMSGSIZE;
2f90b865
AD		 587
588 if (pg_tb[DCB_PG_ATTR_TC_ALL])
589 getall = 1;
590
591 for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) {
592 if (!getall && !pg_tb[i])
593 continue;
594
595 if (pg_tb[DCB_PG_ATTR_TC_ALL])
596 data = pg_tb[DCB_PG_ATTR_TC_ALL];
597 else
598 data = pg_tb[i];
fceb6435
JB		 599 ret = nla_parse_nested(param_tb, DCB_TC_ATTR_PARAM_MAX, data,
600 dcbnl_tc_param_nest, NULL);
2f90b865
AD		 601 if (ret)
602 goto err_pg;
603
7be99413 604 param_nest = nla_nest_start(skb, i);
2f90b865
AD		 605 if (!param_nest)
606 goto err_pg;
607
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;
612
613 if (dir) {
614 /* Rx */
615 netdev->dcbnl_ops->getpgtccfgrx(netdev,
616 i - DCB_PG_ATTR_TC_0, &prio,
617 &pgid, &tc_pct, &up_map);
618 } else {
619 /* Tx */
620 netdev->dcbnl_ops->getpgtccfgtx(netdev,
621 i - DCB_PG_ATTR_TC_0, &prio,
622 &pgid, &tc_pct, &up_map);
623 }
624
625 if (param_tb[DCB_TC_ATTR_PARAM_PGID] ||
626 param_tb[DCB_TC_ATTR_PARAM_ALL]) {
7be99413 627 ret = nla_put_u8(skb,
2f90b865
AD		 628 DCB_TC_ATTR_PARAM_PGID, pgid);
629 if (ret)
630 goto err_param;
631 }
632 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING] ||
633 param_tb[DCB_TC_ATTR_PARAM_ALL]) {
7be99413 634 ret = nla_put_u8(skb,
2f90b865
AD		 635 DCB_TC_ATTR_PARAM_UP_MAPPING, up_map);
636 if (ret)
637 goto err_param;
638 }
639 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO] ||
640 param_tb[DCB_TC_ATTR_PARAM_ALL]) {
7be99413 641 ret = nla_put_u8(skb,
2f90b865
AD		 642 DCB_TC_ATTR_PARAM_STRICT_PRIO, prio);
643 if (ret)
644 goto err_param;
645 }
646 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT] ||
647 param_tb[DCB_TC_ATTR_PARAM_ALL]) {
7be99413 648 ret = nla_put_u8(skb, DCB_TC_ATTR_PARAM_BW_PCT,
2f90b865
AD		 649 tc_pct);
650 if (ret)
651 goto err_param;
652 }
7be99413 653 nla_nest_end(skb, param_nest);
2f90b865
AD		 654 }
655
656 if (pg_tb[DCB_PG_ATTR_BW_ID_ALL])
657 getall = 1;
658 else
659 getall = 0;
660
661 for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
662 if (!getall && !pg_tb[i])
663 continue;
664
665 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
666
667 if (dir) {
668 /* Rx */
669 netdev->dcbnl_ops->getpgbwgcfgrx(netdev,
670 i - DCB_PG_ATTR_BW_ID_0, &tc_pct);
671 } else {
672 /* Tx */
673 netdev->dcbnl_ops->getpgbwgcfgtx(netdev,
674 i - DCB_PG_ATTR_BW_ID_0, &tc_pct);
675 }
7be99413 676 ret = nla_put_u8(skb, i, tc_pct);
2f90b865
AD		 677 if (ret)
678 goto err_pg;
679 }
680
7be99413 681 nla_nest_end(skb, pg_nest);
2f90b865
AD		 682
683 return 0;
684
685err_param:
7be99413 686 nla_nest_cancel(skb, param_nest);
2f90b865 687err_pg:
7be99413 688 nla_nest_cancel(skb, pg_nest);
3d1f4869
TG		 689
690 return -EMSGSIZE;
2f90b865
AD		 691}
692
7be99413
TG		 693static int dcbnl_pgtx_getcfg(struct net_device *netdev, struct nlmsghdr *nlh,
694 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 695{
7be99413 696 return __dcbnl_pg_getcfg(netdev, nlh, tb, skb, 0);
2f90b865
AD		 697}
698
7be99413
TG		 699static int dcbnl_pgrx_getcfg(struct net_device *netdev, struct nlmsghdr *nlh,
700 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 701{
7be99413 702 return __dcbnl_pg_getcfg(netdev, nlh, tb, skb, 1);
2f90b865
AD		 703}
704
7be99413
TG		 705static int dcbnl_setstate(struct net_device *netdev, struct nlmsghdr *nlh,
706 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 707{
2f90b865
AD		 708 u8 value;
709
3d1f4869 710 if (!tb[DCB_ATTR_STATE])
7be99413 711 return -EINVAL;
2f90b865 712
3d1f4869
TG		 713 if (!netdev->dcbnl_ops->setstate)
714 return -EOPNOTSUPP;
715
2f90b865
AD		 716 value = nla_get_u8(tb[DCB_ATTR_STATE]);
717
7be99413
TG		 718 return nla_put_u8(skb, DCB_ATTR_STATE,
719 netdev->dcbnl_ops->setstate(netdev, value));
2f90b865
AD		 720}
721
7be99413
TG		 722static int dcbnl_setpfccfg(struct net_device *netdev, struct nlmsghdr *nlh,
723 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865
AD		 724{
725 struct nlattr *data[DCB_PFC_UP_ATTR_MAX + 1];
726 int i;
3d1f4869 727 int ret;
2f90b865
AD		 728 u8 value;
729
3d1f4869
TG		 730 if (!tb[DCB_ATTR_PFC_CFG])
731 return -EINVAL;
732
733 if (!netdev->dcbnl_ops->setpfccfg)
734 return -EOPNOTSUPP;
2f90b865
AD		 735
736 ret = nla_parse_nested(data, DCB_PFC_UP_ATTR_MAX,
fceb6435 737 tb[DCB_ATTR_PFC_CFG], dcbnl_pfc_up_nest, NULL);
2f90b865 738 if (ret)
3d1f4869 739 return ret;
2f90b865
AD		 740
741 for (i = DCB_PFC_UP_ATTR_0; i <= DCB_PFC_UP_ATTR_7; i++) {
742 if (data[i] == NULL)
743 continue;
744 value = nla_get_u8(data[i]);
745 netdev->dcbnl_ops->setpfccfg(netdev,
746 data[i]->nla_type - DCB_PFC_UP_ATTR_0, value);
747 }
748
7be99413 749 return nla_put_u8(skb, DCB_ATTR_PFC_CFG, 0);
2f90b865
AD		 750}
751
7be99413
TG		 752static int dcbnl_setall(struct net_device *netdev, struct nlmsghdr *nlh,
753 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 754{
3d1f4869 755 int ret;
2f90b865 756
3d1f4869
TG		 757 if (!tb[DCB_ATTR_SET_ALL])
758 return -EINVAL;
759
760 if (!netdev->dcbnl_ops->setall)
761 return -EOPNOTSUPP;
2f90b865 762
7be99413
TG		 763 ret = nla_put_u8(skb, DCB_ATTR_SET_ALL,
764 netdev->dcbnl_ops->setall(netdev));
08157984 765 dcbnl_cee_notify(netdev, RTM_SETDCB, DCB_CMD_SET_ALL, seq, 0);
2f90b865
AD		 766
767 return ret;
768}
769
7be99413
TG		 770static int __dcbnl_pg_setcfg(struct net_device *netdev, struct nlmsghdr *nlh,
771 u32 seq, struct nlattr **tb, struct sk_buff *skb,
772 int dir)
2f90b865
AD		 773{
774 struct nlattr *pg_tb[DCB_PG_ATTR_MAX + 1];
775 struct nlattr *param_tb[DCB_TC_ATTR_PARAM_MAX + 1];
3d1f4869 776 int ret;
2f90b865
AD		 777 int i;
778 u8 pgid;
779 u8 up_map;
780 u8 prio;
781 u8 tc_pct;
782
3d1f4869
TG		 783 if (!tb[DCB_ATTR_PG_CFG])
784 return -EINVAL;
785
786 if (!netdev->dcbnl_ops->setpgtccfgtx ||
2f90b865
AD		 787 !netdev->dcbnl_ops->setpgtccfgrx ||
788 !netdev->dcbnl_ops->setpgbwgcfgtx ||
789 !netdev->dcbnl_ops->setpgbwgcfgrx)
3d1f4869 790 return -EOPNOTSUPP;
2f90b865 791
fceb6435
JB		 792 ret = nla_parse_nested(pg_tb, DCB_PG_ATTR_MAX, tb[DCB_ATTR_PG_CFG],
793 dcbnl_pg_nest, NULL);
2f90b865 794 if (ret)
3d1f4869 795 return ret;
2f90b865
AD		 796
797 for (i = DCB_PG_ATTR_TC_0; i <= DCB_PG_ATTR_TC_7; i++) {
798 if (!pg_tb[i])
799 continue;
800
801 ret = nla_parse_nested(param_tb, DCB_TC_ATTR_PARAM_MAX,
fceb6435 802 pg_tb[i], dcbnl_tc_param_nest, NULL);
2f90b865 803 if (ret)
3d1f4869 804 return ret;
2f90b865
AD		 805
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;
810
811 if (param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO])
812 prio =
813 nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_STRICT_PRIO]);
814
815 if (param_tb[DCB_TC_ATTR_PARAM_PGID])
816 pgid = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_PGID]);
817
818 if (param_tb[DCB_TC_ATTR_PARAM_BW_PCT])
819 tc_pct = nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_BW_PCT]);
820
821 if (param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING])
822 up_map =
823 nla_get_u8(param_tb[DCB_TC_ATTR_PARAM_UP_MAPPING]);
824
825 /* dir: Tx = 0, Rx = 1 */
826 if (dir) {
827 /* Rx */
828 netdev->dcbnl_ops->setpgtccfgrx(netdev,
829 i - DCB_PG_ATTR_TC_0,
830 prio, pgid, tc_pct, up_map);
831 } else {
832 /* Tx */
833 netdev->dcbnl_ops->setpgtccfgtx(netdev,
834 i - DCB_PG_ATTR_TC_0,
835 prio, pgid, tc_pct, up_map);
836 }
837 }
838
839 for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
840 if (!pg_tb[i])
841 continue;
842
843 tc_pct = nla_get_u8(pg_tb[i]);
844
845 /* dir: Tx = 0, Rx = 1 */
846 if (dir) {
847 /* Rx */
848 netdev->dcbnl_ops->setpgbwgcfgrx(netdev,
849 i - DCB_PG_ATTR_BW_ID_0, tc_pct);
850 } else {
851 /* Tx */
852 netdev->dcbnl_ops->setpgbwgcfgtx(netdev,
853 i - DCB_PG_ATTR_BW_ID_0, tc_pct);
854 }
855 }
856
bb1dfefd 857 return nla_put_u8(skb, DCB_ATTR_PG_CFG, 0);
2f90b865
AD		 858}
859
7be99413
TG		 860static int dcbnl_pgtx_setcfg(struct net_device *netdev, struct nlmsghdr *nlh,
861 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 862{
7be99413 863 return __dcbnl_pg_setcfg(netdev, nlh, seq, tb, skb, 0);
2f90b865
AD		 864}
865
7be99413
TG		 866static int dcbnl_pgrx_setcfg(struct net_device *netdev, struct nlmsghdr *nlh,
867 u32 seq, struct nlattr **tb, struct sk_buff *skb)
2f90b865 868{
7be99413 869 return __dcbnl_pg_setcfg(netdev, nlh, seq, tb, skb, 1);
2f90b865
AD		 870}
871
7be99413
TG		 872static int dcbnl_bcn_getcfg(struct net_device *netdev, struct nlmsghdr *nlh,
873 u32 seq, struct nlattr **tb, struct sk_buff *skb)
859ee3c4 874{
859ee3c4
AD		 875 struct nlattr *bcn_nest;
876 struct nlattr *bcn_tb[DCB_BCN_ATTR_MAX + 1];
877 u8 value_byte;
878 u32 value_integer;
3d1f4869 879 int ret;
859ee3c4
AD		 880 bool getall = false;
881 int i;
882
3d1f4869
TG		 883 if (!tb[DCB_ATTR_BCN])
884 return -EINVAL;
885
886 if (!netdev->dcbnl_ops->getbcnrp ||
859ee3c4 887 !netdev->dcbnl_ops->getbcncfg)
3d1f4869 888 return -EOPNOTSUPP;
859ee3c4 889
fceb6435
JB		 890 ret = nla_parse_nested(bcn_tb, DCB_BCN_ATTR_MAX, tb[DCB_ATTR_BCN],
891 dcbnl_bcn_nest, NULL);
859ee3c4 892 if (ret)
3d1f4869 893 return ret;
859ee3c4 894
7be99413 895 bcn_nest = nla_nest_start(skb, DCB_ATTR_BCN);
859ee3c4 896 if (!bcn_nest)
3d1f4869 897 return -EMSGSIZE;
859ee3c4
AD		 898
899 if (bcn_tb[DCB_BCN_ATTR_ALL])
900 getall = true;
901
902 for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) {
903 if (!getall && !bcn_tb[i])
904 continue;
905
906 netdev->dcbnl_ops->getbcnrp(netdev, i - DCB_BCN_ATTR_RP_0,
907 &value_byte);
7be99413 908 ret = nla_put_u8(skb, i, value_byte);
859ee3c4
AD		 909 if (ret)
910 goto err_bcn;
911 }
912
f4314e81 913 for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) {
859ee3c4
AD		 914 if (!getall && !bcn_tb[i])
915 continue;
916
917 netdev->dcbnl_ops->getbcncfg(netdev, i,
918 &value_integer);
7be99413 919 ret = nla_put_u32(skb, i, value_integer);
859ee3c4
AD		 920 if (ret)
921 goto err_bcn;
922 }
923
7be99413 924 nla_nest_end(skb, bcn_nest);
859ee3c4
AD		 925
926 return 0;
927
928err_bcn:
7be99413 929 nla_nest_cancel(skb, bcn_nest);
859ee3c4
AD		 930 return ret;
931}
932
7be99413
TG		 933static int dcbnl_bcn_setcfg(struct net_device *netdev, struct nlmsghdr *nlh,
934 u32 seq, struct nlattr **tb, struct sk_buff *skb)
859ee3c4
AD		 935{
936 struct nlattr *data[DCB_BCN_ATTR_MAX + 1];
937 int i;
3d1f4869 938 int ret;
859ee3c4
AD		 939 u8 value_byte;
940 u32 value_int;
941
3d1f4869
TG		 942 if (!tb[DCB_ATTR_BCN])
943 return -EINVAL;
944
945 if (!netdev->dcbnl_ops->setbcncfg ||
f64f9e71 946 !netdev->dcbnl_ops->setbcnrp)
3d1f4869 947 return -EOPNOTSUPP;
859ee3c4 948
fceb6435
JB		 949 ret = nla_parse_nested(data, DCB_BCN_ATTR_MAX, tb[DCB_ATTR_BCN],
950 dcbnl_pfc_up_nest, NULL);
859ee3c4 951 if (ret)
3d1f4869 952 return ret;
859ee3c4
AD		 953
954 for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) {
955 if (data[i] == NULL)
956 continue;
957 value_byte = nla_get_u8(data[i]);
958 netdev->dcbnl_ops->setbcnrp(netdev,
959 data[i]->nla_type - DCB_BCN_ATTR_RP_0, value_byte);
960 }
961
f4314e81 962 for (i = DCB_BCN_ATTR_BCNA_0; i <= DCB_BCN_ATTR_RI; i++) {
859ee3c4
AD		 963 if (data[i] == NULL)
964 continue;
965 value_int = nla_get_u32(data[i]);
966 netdev->dcbnl_ops->setbcncfg(netdev,
967 i, value_int);
968 }
969
3d1f4869 970 return nla_put_u8(skb, DCB_ATTR_BCN, 0);
859ee3c4
AD		 971}
972
dc6ed1df
SR		 973static int dcbnl_build_peer_app(struct net_device *netdev, struct sk_buff* skb,
974 int app_nested_type, int app_info_type,
975 int app_entry_type)
eed84713
SR		 976{
977 struct dcb_peer_app_info info;
978 struct dcb_app *table = NULL;
979 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
980 u16 app_count;
981 int err;
982
983
984 /**
985 * retrieve the peer app configuration form the driver. If the driver
986 * handlers fail exit without doing anything
987 */
988 err = ops->peer_getappinfo(netdev, &info, &app_count);
989 if (!err && app_count) {
990 table = kmalloc(sizeof(struct dcb_app) * app_count, GFP_KERNEL);
991 if (!table)
992 return -ENOMEM;
993
994 err = ops->peer_getapptable(netdev, table);
995 }
996
997 if (!err) {
998 u16 i;
999 struct nlattr *app;
1000
1001 /**
1002 * build the message, from here on the only possible failure
1003 * is due to the skb size
1004 */
1005 err = -EMSGSIZE;
1006
dc6ed1df 1007 app = nla_nest_start(skb, app_nested_type);
eed84713
SR		 1008 if (!app)
1009 goto nla_put_failure;
1010
1eb4c977
DM		 1011 if (app_info_type &&
1012 nla_put(skb, app_info_type, sizeof(info), &info))
1013 goto nla_put_failure;
eed84713 1014
1eb4c977
DM		 1015 for (i = 0; i < app_count; i++) {
1016 if (nla_put(skb, app_entry_type, sizeof(struct dcb_app),
1017 &table[i]))
1018 goto nla_put_failure;
1019 }
eed84713
SR		 1020 nla_nest_end(skb, app);
1021 }
1022 err = 0;
1023
1024nla_put_failure:
1025 kfree(table);
1026 return err;
1027}
3e29027a 1028
c9368247 1029/* Handle IEEE 802.1Qaz/802.1Qau/802.1Qbb GET commands. */
314b4778 1030static int dcbnl_ieee_fill(struct sk_buff *skb, struct net_device *netdev)
3e29027a 1031{
9ab933ab
JF		 1032 struct nlattr *ieee, *app;
1033 struct dcb_app_type *itr;
3e29027a 1034 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
c7797baf 1035 int dcbx;
3d1f4869 1036 int err;
3e29027a 1037
1eb4c977 1038 if (nla_put_string(skb, DCB_ATTR_IFNAME, netdev->name))
3d1f4869
TG		 1039 return -EMSGSIZE;
1040
3e29027a
JF		 1041 ieee = nla_nest_start(skb, DCB_ATTR_IEEE);
1042 if (!ieee)
3d1f4869 1043 return -EMSGSIZE;
3e29027a
JF		 1044
1045 if (ops->ieee_getets) {
1046 struct ieee_ets ets;
29cd8ae0 1047 memset(&ets, 0, sizeof(ets));
3e29027a 1048 err = ops->ieee_getets(netdev, &ets);
1eb4c977
DM		 1049 if (!err &&
1050 nla_put(skb, DCB_ATTR_IEEE_ETS, sizeof(ets), &ets))
3d1f4869 1051 return -EMSGSIZE;
3e29027a
JF		 1052 }
1053
08f10aff
AV		 1054 if (ops->ieee_getmaxrate) {
1055 struct ieee_maxrate maxrate;
29cd8ae0 1056 memset(&maxrate, 0, sizeof(maxrate));
08f10aff
AV		 1057 err = ops->ieee_getmaxrate(netdev, &maxrate);
1058 if (!err) {
1059 err = nla_put(skb, DCB_ATTR_IEEE_MAXRATE,
1060 sizeof(maxrate), &maxrate);
1061 if (err)
3d1f4869 1062 return -EMSGSIZE;
08f10aff
AV		 1063 }
1064 }
1065
c9368247
SM		 1066 if (ops->ieee_getqcn) {
1067 struct ieee_qcn qcn;
1068
1069 memset(&qcn, 0, sizeof(qcn));
1070 err = ops->ieee_getqcn(netdev, &qcn);
1071 if (!err) {
1072 err = nla_put(skb, DCB_ATTR_IEEE_QCN,
1073 sizeof(qcn), &qcn);
1074 if (err)
1075 return -EMSGSIZE;
1076 }
1077 }
1078
1079 if (ops->ieee_getqcnstats) {
1080 struct ieee_qcn_stats qcn_stats;
1081
1082 memset(&qcn_stats, 0, sizeof(qcn_stats));
1083 err = ops->ieee_getqcnstats(netdev, &qcn_stats);
1084 if (!err) {
1085 err = nla_put(skb, DCB_ATTR_IEEE_QCN_STATS,
1086 sizeof(qcn_stats), &qcn_stats);
1087 if (err)
1088 return -EMSGSIZE;
1089 }
1090 }
1091
3e29027a
JF		 1092 if (ops->ieee_getpfc) {
1093 struct ieee_pfc pfc;
29cd8ae0 1094 memset(&pfc, 0, sizeof(pfc));
3e29027a 1095 err = ops->ieee_getpfc(netdev, &pfc);
1eb4c977
DM		 1096 if (!err &&
1097 nla_put(skb, DCB_ATTR_IEEE_PFC, sizeof(pfc), &pfc))
3d1f4869 1098 return -EMSGSIZE;
3e29027a
JF		 1099 }
1100
9ab933ab
JF		 1101 app = nla_nest_start(skb, DCB_ATTR_IEEE_APP_TABLE);
1102 if (!app)
3d1f4869 1103 return -EMSGSIZE;
9ab933ab 1104
52cff74e 1105 spin_lock_bh(&dcb_lock);
9ab933ab 1106 list_for_each_entry(itr, &dcb_app_list, list) {
e290ed81 1107 if (itr->ifindex == netdev->ifindex) {
70bfa2d2
DC		 1108 err = nla_put(skb, DCB_ATTR_IEEE_APP, sizeof(itr->app),
1109 &itr->app);
1110 if (err) {
52cff74e 1111 spin_unlock_bh(&dcb_lock);
3d1f4869 1112 return -EMSGSIZE;
70bfa2d2
DC		 1113 }
1114 }
9ab933ab 1115 }
c7797baf
JF		 1116
1117 if (netdev->dcbnl_ops->getdcbx)
1118 dcbx = netdev->dcbnl_ops->getdcbx(netdev);
1119 else
1120 dcbx = -EOPNOTSUPP;
1121
52cff74e 1122 spin_unlock_bh(&dcb_lock);
9ab933ab
JF		 1123 nla_nest_end(skb, app);
1124
eed84713
SR		 1125 /* get peer info if available */
1126 if (ops->ieee_peer_getets) {
1127 struct ieee_ets ets;
29cd8ae0 1128 memset(&ets, 0, sizeof(ets));
eed84713 1129 err = ops->ieee_peer_getets(netdev, &ets);
1eb4c977
DM		 1130 if (!err &&
1131 nla_put(skb, DCB_ATTR_IEEE_PEER_ETS, sizeof(ets), &ets))
3d1f4869 1132 return -EMSGSIZE;
eed84713
SR		 1133 }
1134
1135 if (ops->ieee_peer_getpfc) {
1136 struct ieee_pfc pfc;
29cd8ae0 1137 memset(&pfc, 0, sizeof(pfc));
eed84713 1138 err = ops->ieee_peer_getpfc(netdev, &pfc);
1eb4c977
DM		 1139 if (!err &&
1140 nla_put(skb, DCB_ATTR_IEEE_PEER_PFC, sizeof(pfc), &pfc))
3d1f4869 1141 return -EMSGSIZE;
eed84713
SR		 1142 }
1143
1144 if (ops->peer_getappinfo && ops->peer_getapptable) {
dc6ed1df
SR		 1145 err = dcbnl_build_peer_app(netdev, skb,
1146 DCB_ATTR_IEEE_PEER_APP,
1147 DCB_ATTR_IEEE_APP_UNSPEC,
1148 DCB_ATTR_IEEE_APP);
eed84713 1149 if (err)
3d1f4869 1150 return -EMSGSIZE;
eed84713
SR		 1151 }
1152
3e29027a 1153 nla_nest_end(skb, ieee);
c7797baf
JF		 1154 if (dcbx >= 0) {
1155 err = nla_put_u8(skb, DCB_ATTR_DCBX, dcbx);
1156 if (err)
3d1f4869 1157 return -EMSGSIZE;
c7797baf 1158 }
3e29027a 1159
314b4778 1160 return 0;
3e29027a
JF		 1161}
1162
5b7f7626
SR		 1163static int dcbnl_cee_pg_fill(struct sk_buff *skb, struct net_device *dev,
1164 int dir)
1165{
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);
1170
1171 if (!pg)
3d1f4869 1172 return -EMSGSIZE;
5b7f7626
SR		 1173
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);
1176
1177 if (!tc_nest)
3d1f4869 1178 return -EMSGSIZE;
5b7f7626
SR		 1179
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;
1184
1185 if (!dir)
1186 ops->getpgtccfgrx(dev, i - DCB_PG_ATTR_TC_0,
1187 &prio, &pgid, &tc_pct, &up_map);
1188 else
1189 ops->getpgtccfgtx(dev, i - DCB_PG_ATTR_TC_0,
1190 &prio, &pgid, &tc_pct, &up_map);
1191
1eb4c977
DM		 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))
3d1f4869 1196 return -EMSGSIZE;
5b7f7626
SR		 1197 nla_nest_end(skb, tc_nest);
1198 }
1199
1200 for (i = DCB_PG_ATTR_BW_ID_0; i <= DCB_PG_ATTR_BW_ID_7; i++) {
1201 tc_pct = DCB_ATTR_VALUE_UNDEFINED;
1202
1203 if (!dir)
1204 ops->getpgbwgcfgrx(dev, i - DCB_PG_ATTR_BW_ID_0,
1205 &tc_pct);
1206 else
1207 ops->getpgbwgcfgtx(dev, i - DCB_PG_ATTR_BW_ID_0,
1208 &tc_pct);
1eb4c977 1209 if (nla_put_u8(skb, i, tc_pct))
3d1f4869 1210 return -EMSGSIZE;
5b7f7626
SR		 1211 }
1212 nla_nest_end(skb, pg);
1213 return 0;
5b7f7626
SR		 1214}
1215
1216static int dcbnl_cee_fill(struct sk_buff *skb, struct net_device *netdev)
1217{
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;
1222 u8 value;
1223
1eb4c977
DM		 1224 if (nla_put_string(skb, DCB_ATTR_IFNAME, netdev->name))
1225 goto nla_put_failure;
5b7f7626
SR		 1226 cee = nla_nest_start(skb, DCB_ATTR_CEE);
1227 if (!cee)
1228 goto nla_put_failure;
1229
1230 /* local pg */
1231 if (ops->getpgtccfgtx && ops->getpgbwgcfgtx) {
1232 err = dcbnl_cee_pg_fill(skb, netdev, 1);
1233 if (err)
1234 goto nla_put_failure;
1235 }
1236
1237 if (ops->getpgtccfgrx && ops->getpgbwgcfgrx) {
1238 err = dcbnl_cee_pg_fill(skb, netdev, 0);
1239 if (err)
1240 goto nla_put_failure;
1241 }
1242
1243 /* local pfc */
1244 if (ops->getpfccfg) {
1245 struct nlattr *pfc_nest = nla_nest_start(skb, DCB_ATTR_CEE_PFC);
1246
1247 if (!pfc_nest)
1248 goto nla_put_failure;
1249
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);
1eb4c977
DM		 1252 if (nla_put_u8(skb, i, value))
1253 goto nla_put_failure;
5b7f7626
SR		 1254 }
1255 nla_nest_end(skb, pfc_nest);
1256 }
1257
1258 /* local app */
52cff74e 1259 spin_lock_bh(&dcb_lock);
5b7f7626
SR		 1260 app = nla_nest_start(skb, DCB_ATTR_CEE_APP_TABLE);
1261 if (!app)
40f5d72a 1262 goto dcb_unlock;
5b7f7626
SR		 1263
1264 list_for_each_entry(itr, &dcb_app_list, list) {
e290ed81 1265 if (itr->ifindex == netdev->ifindex) {
5b7f7626
SR		 1266 struct nlattr *app_nest = nla_nest_start(skb,
1267 DCB_ATTR_APP);
1268 if (!app_nest)
1269 goto dcb_unlock;
1270
1271 err = nla_put_u8(skb, DCB_APP_ATTR_IDTYPE,
1272 itr->app.selector);
1273 if (err)
1274 goto dcb_unlock;
1275
1276 err = nla_put_u16(skb, DCB_APP_ATTR_ID,
1277 itr->app.protocol);
1278 if (err)
1279 goto dcb_unlock;
1280
1281 err = nla_put_u8(skb, DCB_APP_ATTR_PRIORITY,
1282 itr->app.priority);
1283 if (err)
1284 goto dcb_unlock;
1285
1286 nla_nest_end(skb, app_nest);
1287 }
1288 }
1289 nla_nest_end(skb, app);
1290
1291 if (netdev->dcbnl_ops->getdcbx)
1292 dcbx = netdev->dcbnl_ops->getdcbx(netdev);
1293 else
1294 dcbx = -EOPNOTSUPP;
1295
52cff74e 1296 spin_unlock_bh(&dcb_lock);
5b7f7626
SR		 1297
1298 /* features flags */
1299 if (ops->getfeatcfg) {
1300 struct nlattr *feat = nla_nest_start(skb, DCB_ATTR_CEE_FEAT);
1301 if (!feat)
1302 goto nla_put_failure;
1303
1304 for (i = DCB_FEATCFG_ATTR_ALL + 1; i <= DCB_FEATCFG_ATTR_MAX;
1305 i++)
1eb4c977
DM		 1306 if (!ops->getfeatcfg(netdev, i, &value) &&
1307 nla_put_u8(skb, i, value))
1308 goto nla_put_failure;
5b7f7626
SR		 1309
1310 nla_nest_end(skb, feat);
1311 }
1312
1313 /* peer info if available */
1314 if (ops->cee_peer_getpg) {
1315 struct cee_pg pg;
29cd8ae0 1316 memset(&pg, 0, sizeof(pg));
5b7f7626 1317 err = ops->cee_peer_getpg(netdev, &pg);
1eb4c977
DM		 1318 if (!err &&
1319 nla_put(skb, DCB_ATTR_CEE_PEER_PG, sizeof(pg), &pg))
1320 goto nla_put_failure;
5b7f7626
SR		 1321 }
1322
1323 if (ops->cee_peer_getpfc) {
1324 struct cee_pfc pfc;
29cd8ae0 1325 memset(&pfc, 0, sizeof(pfc));
5b7f7626 1326 err = ops->cee_peer_getpfc(netdev, &pfc);
1eb4c977
DM		 1327 if (!err &&
1328 nla_put(skb, DCB_ATTR_CEE_PEER_PFC, sizeof(pfc), &pfc))
1329 goto nla_put_failure;
5b7f7626
SR		 1330 }
1331
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);
1337 if (err)
1338 goto nla_put_failure;
1339 }
1340 nla_nest_end(skb, cee);
1341
1342 /* DCBX state */
1343 if (dcbx >= 0) {
1344 err = nla_put_u8(skb, DCB_ATTR_DCBX, dcbx);
1345 if (err)
1346 goto nla_put_failure;
1347 }
1348 return 0;
1349
1350dcb_unlock:
52cff74e 1351 spin_unlock_bh(&dcb_lock);
5b7f7626 1352nla_put_failure:
c66ebf2d 1353 err = -EMSGSIZE;
5b7f7626
SR		 1354 return err;
1355}
1356
1357static int dcbnl_notify(struct net_device *dev, int event, int cmd,
15e47304 1358 u32 seq, u32 portid, int dcbx_ver)
314b4778
JF		 1359{
1360 struct net *net = dev_net(dev);
1361 struct sk_buff *skb;
1362 struct nlmsghdr *nlh;
314b4778
JF		 1363 const struct dcbnl_rtnl_ops *ops = dev->dcbnl_ops;
1364 int err;
1365
1366 if (!ops)
1367 return -EOPNOTSUPP;
1368
15e47304 1369 skb = dcbnl_newmsg(event, cmd, portid, seq, 0, &nlh);
314b4778
JF		 1370 if (!skb)
1371 return -ENOBUFS;
1372
5b7f7626
SR		 1373 if (dcbx_ver == DCB_CAP_DCBX_VER_IEEE)
1374 err = dcbnl_ieee_fill(skb, dev);
1375 else
1376 err = dcbnl_cee_fill(skb, dev);
1377
314b4778
JF		 1378 if (err < 0) {
1379 /* Report error to broadcast listeners */
ab6d4707 1380 nlmsg_free(skb);
314b4778
JF		 1381 rtnl_set_sk_err(net, RTNLGRP_DCB, err);
1382 } else {
1383 /* End nlmsg and notify broadcast listeners */
1384 nlmsg_end(skb, nlh);
1385 rtnl_notify(skb, net, 0, RTNLGRP_DCB, NULL, GFP_KERNEL);
1386 }
1387
1388 return err;
1389}
5b7f7626
SR		 1390
1391int dcbnl_ieee_notify(struct net_device *dev, int event, int cmd,
15e47304 1392 u32 seq, u32 portid)
5b7f7626 1393{
15e47304 1394 return dcbnl_notify(dev, event, cmd, seq, portid, DCB_CAP_DCBX_VER_IEEE);
5b7f7626
SR		 1395}
1396EXPORT_SYMBOL(dcbnl_ieee_notify);
1397
1398int dcbnl_cee_notify(struct net_device *dev, int event, int cmd,
15e47304 1399 u32 seq, u32 portid)
5b7f7626 1400{
15e47304 1401 return dcbnl_notify(dev, event, cmd, seq, portid, DCB_CAP_DCBX_VER_CEE);
5b7f7626
SR		 1402}
1403EXPORT_SYMBOL(dcbnl_cee_notify);
314b4778 1404
c9368247
SM		 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.
314b4778
JF		 1408 * No attempt is made to reconcile the case where only part of the
1409 * cmd can be completed.
1410 */
7be99413
TG		 1411static int dcbnl_ieee_set(struct net_device *netdev, struct nlmsghdr *nlh,
1412 u32 seq, struct nlattr **tb, struct sk_buff *skb)
314b4778
JF		 1413{
1414 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1415 struct nlattr *ieee[DCB_ATTR_IEEE_MAX + 1];
3d1f4869 1416 int err;
314b4778
JF		 1417
1418 if (!ops)
3d1f4869 1419 return -EOPNOTSUPP;
314b4778 1420
4003b658
JF		 1421 if (!tb[DCB_ATTR_IEEE])
1422 return -EINVAL;
1423
fceb6435
JB		 1424 err = nla_parse_nested(ieee, DCB_ATTR_IEEE_MAX, tb[DCB_ATTR_IEEE],
1425 dcbnl_ieee_policy, NULL);
314b4778
JF		 1426 if (err)
1427 return err;
1428
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);
1432 if (err)
1433 goto err;
1434 }
1435
08f10aff
AV		 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);
1440 if (err)
1441 goto err;
1442 }
1443
c9368247
SM		 1444 if (ieee[DCB_ATTR_IEEE_QCN] && ops->ieee_setqcn) {
1445 struct ieee_qcn *qcn =
1446 nla_data(ieee[DCB_ATTR_IEEE_QCN]);
1447
1448 err = ops->ieee_setqcn(netdev, qcn);
1449 if (err)
1450 goto err;
1451 }
1452
314b4778
JF		 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);
1456 if (err)
1457 goto err;
1458 }
1459
1460 if (ieee[DCB_ATTR_IEEE_APP_TABLE]) {
1461 struct nlattr *attr;
1462 int rem;
1463
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)
1467 continue;
1468 app_data = nla_data(attr);
1469 if (ops->ieee_setapp)
1470 err = ops->ieee_setapp(netdev, app_data);
1471 else
b6db2174 1472 err = dcb_ieee_setapp(netdev, app_data);
314b4778
JF		 1473 if (err)
1474 goto err;
1475 }
1476 }
1477
1478err:
7be99413 1479 err = nla_put_u8(skb, DCB_ATTR_IEEE, err);
5b7f7626 1480 dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_SET, seq, 0);
314b4778
JF		 1481 return err;
1482}
1483
7be99413
TG		 1484static int dcbnl_ieee_get(struct net_device *netdev, struct nlmsghdr *nlh,
1485 u32 seq, struct nlattr **tb, struct sk_buff *skb)
314b4778 1486{
314b4778 1487 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
314b4778
JF		 1488
1489 if (!ops)
1490 return -EOPNOTSUPP;
1491
7be99413 1492 return dcbnl_ieee_fill(skb, netdev);
314b4778 1493}
f9ae7e4b 1494
7be99413
TG		 1495static int dcbnl_ieee_del(struct net_device *netdev, struct nlmsghdr *nlh,
1496 u32 seq, struct nlattr **tb, struct sk_buff *skb)
f9ae7e4b
JF		 1497{
1498 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
1499 struct nlattr *ieee[DCB_ATTR_IEEE_MAX + 1];
3d1f4869 1500 int err;
f9ae7e4b
JF		 1501
1502 if (!ops)
1503 return -EOPNOTSUPP;
1504
1505 if (!tb[DCB_ATTR_IEEE])
1506 return -EINVAL;
1507
fceb6435
JB		 1508 err = nla_parse_nested(ieee, DCB_ATTR_IEEE_MAX, tb[DCB_ATTR_IEEE],
1509 dcbnl_ieee_policy, NULL);
f9ae7e4b
JF		 1510 if (err)
1511 return err;
1512
1513 if (ieee[DCB_ATTR_IEEE_APP_TABLE]) {
1514 struct nlattr *attr;
1515 int rem;
1516
1517 nla_for_each_nested(attr, ieee[DCB_ATTR_IEEE_APP_TABLE], rem) {
1518 struct dcb_app *app_data;
1519
1520 if (nla_type(attr) != DCB_ATTR_IEEE_APP)
1521 continue;
1522 app_data = nla_data(attr);
1523 if (ops->ieee_delapp)
1524 err = ops->ieee_delapp(netdev, app_data);
1525 else
1526 err = dcb_ieee_delapp(netdev, app_data);
1527 if (err)
1528 goto err;
1529 }
1530 }
1531
1532err:
7be99413 1533 err = nla_put_u8(skb, DCB_ATTR_IEEE, err);
5b7f7626 1534 dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_DEL, seq, 0);
f9ae7e4b
JF		 1535 return err;
1536}
1537
1538
6241b625 1539/* DCBX configuration */
7be99413
TG		 1540static int dcbnl_getdcbx(struct net_device *netdev, struct nlmsghdr *nlh,
1541 u32 seq, struct nlattr **tb, struct sk_buff *skb)
6241b625 1542{
6241b625 1543 if (!netdev->dcbnl_ops->getdcbx)
7f891cf1 1544 return -EOPNOTSUPP;
6241b625 1545
7be99413
TG		 1546 return nla_put_u8(skb, DCB_ATTR_DCBX,
1547 netdev->dcbnl_ops->getdcbx(netdev));
6241b625
SR		 1548}
1549
7be99413
TG		 1550static int dcbnl_setdcbx(struct net_device *netdev, struct nlmsghdr *nlh,
1551 u32 seq, struct nlattr **tb, struct sk_buff *skb)
6241b625 1552{
6241b625
SR		 1553 u8 value;
1554
7f891cf1
SR		 1555 if (!netdev->dcbnl_ops->setdcbx)
1556 return -EOPNOTSUPP;
1557
1558 if (!tb[DCB_ATTR_DCBX])
1559 return -EINVAL;
6241b625
SR		 1560
1561 value = nla_get_u8(tb[DCB_ATTR_DCBX]);
1562
7be99413
TG		 1563 return nla_put_u8(skb, DCB_ATTR_DCBX,
1564 netdev->dcbnl_ops->setdcbx(netdev, value));
6241b625
SR		 1565}
1566
7be99413
TG		 1567static int dcbnl_getfeatcfg(struct net_device *netdev, struct nlmsghdr *nlh,
1568 u32 seq, struct nlattr **tb, struct sk_buff *skb)
ea45fe4e 1569{
ea45fe4e
SR		 1570 struct nlattr *data[DCB_FEATCFG_ATTR_MAX + 1], *nest;
1571 u8 value;
7f891cf1 1572 int ret, i;
ea45fe4e
SR		 1573 int getall = 0;
1574
7f891cf1
SR		 1575 if (!netdev->dcbnl_ops->getfeatcfg)
1576 return -EOPNOTSUPP;
1577
1578 if (!tb[DCB_ATTR_FEATCFG])
1579 return -EINVAL;
ea45fe4e 1580
fceb6435
JB		 1581 ret = nla_parse_nested(data, DCB_FEATCFG_ATTR_MAX,
1582 tb[DCB_ATTR_FEATCFG], dcbnl_featcfg_nest, NULL);
7f891cf1 1583 if (ret)
7be99413 1584 return ret;
ea45fe4e 1585
7be99413
TG		 1586 nest = nla_nest_start(skb, DCB_ATTR_FEATCFG);
1587 if (!nest)
1588 return -EMSGSIZE;
ea45fe4e
SR		 1589
1590 if (data[DCB_FEATCFG_ATTR_ALL])
1591 getall = 1;
1592
1593 for (i = DCB_FEATCFG_ATTR_ALL+1; i <= DCB_FEATCFG_ATTR_MAX; i++) {
1594 if (!getall && !data[i])
1595 continue;
1596
1597 ret = netdev->dcbnl_ops->getfeatcfg(netdev, i, &value);
7f891cf1 1598 if (!ret)
7be99413 1599 ret = nla_put_u8(skb, i, value);
ea45fe4e 1600
7f891cf1 1601 if (ret) {
7be99413 1602 nla_nest_cancel(skb, nest);
7f891cf1
SR		 1603 goto nla_put_failure;
1604 }
ea45fe4e 1605 }
7be99413 1606 nla_nest_end(skb, nest);
ea45fe4e 1607
7f891cf1 1608nla_put_failure:
ea45fe4e
SR		 1609 return ret;
1610}
1611
7be99413
TG		 1612static int dcbnl_setfeatcfg(struct net_device *netdev, struct nlmsghdr *nlh,
1613 u32 seq, struct nlattr **tb, struct sk_buff *skb)
ea45fe4e
SR		 1614{
1615 struct nlattr *data[DCB_FEATCFG_ATTR_MAX + 1];
7f891cf1 1616 int ret, i;
ea45fe4e 1617 u8 value;
ea45fe4e 1618
7f891cf1
SR		 1619 if (!netdev->dcbnl_ops->setfeatcfg)
1620 return -ENOTSUPP;
1621
1622 if (!tb[DCB_ATTR_FEATCFG])
1623 return -EINVAL;
ea45fe4e 1624
fceb6435
JB		 1625 ret = nla_parse_nested(data, DCB_FEATCFG_ATTR_MAX,
1626 tb[DCB_ATTR_FEATCFG], dcbnl_featcfg_nest, NULL);
ea45fe4e 1627
7f891cf1 1628 if (ret)
ea45fe4e 1629 goto err;
ea45fe4e
SR		 1630
1631 for (i = DCB_FEATCFG_ATTR_ALL+1; i <= DCB_FEATCFG_ATTR_MAX; i++) {
1632 if (data[i] == NULL)
1633 continue;
1634
1635 value = nla_get_u8(data[i]);
1636
1637 ret = netdev->dcbnl_ops->setfeatcfg(netdev, i, value);
1638
1639 if (ret)
7f891cf1 1640 goto err;
ea45fe4e 1641 }
ea45fe4e 1642err:
7be99413 1643 ret = nla_put_u8(skb, DCB_ATTR_FEATCFG, ret);
7f891cf1 1644
ea45fe4e
SR		 1645 return ret;
1646}
1647
dc6ed1df 1648/* Handle CEE DCBX GET commands. */
7be99413
TG		 1649static int dcbnl_cee_get(struct net_device *netdev, struct nlmsghdr *nlh,
1650 u32 seq, struct nlattr **tb, struct sk_buff *skb)
dc6ed1df 1651{
dc6ed1df 1652 const struct dcbnl_rtnl_ops *ops = netdev->dcbnl_ops;
dc6ed1df
SR		 1653
1654 if (!ops)
1655 return -EOPNOTSUPP;
1656
7be99413 1657 return dcbnl_cee_fill(skb, netdev);
dc6ed1df
SR		 1658}
1659
33a03aad
TG		 1660struct reply_func {
1661 /* reply netlink message type */
1662 int type;
1663
1664 /* function to fill message contents */
1665 int (*cb)(struct net_device *, struct nlmsghdr *, u32,
1666 struct nlattr **, struct sk_buff *);
1667};
1668
1669static const struct reply_func reply_funcs[DCB_CMD_MAX+1] = {
7be99413
TG		 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 },
33a03aad
TG		 1697};
1698
661d2967 1699static int dcb_doit(struct sk_buff *skb, struct nlmsghdr *nlh)
2f90b865
AD		 1700{
1701 struct net *net = sock_net(skb->sk);
1702 struct net_device *netdev;
7a282bc3 1703 struct dcbmsg *dcb = nlmsg_data(nlh);
2f90b865 1704 struct nlattr *tb[DCB_ATTR_MAX + 1];
15e47304 1705 u32 portid = skb ? NETLINK_CB(skb).portid : 0;
2f90b865 1706 int ret = -EINVAL;
33a03aad 1707 struct sk_buff *reply_skb;
39912f9c 1708 struct nlmsghdr *reply_nlh = NULL;
33a03aad 1709 const struct reply_func *fn;
2f90b865 1710
90f62cf3 1711 if ((nlh->nlmsg_type == RTM_SETDCB) && !netlink_capable(skb, CAP_NET_ADMIN))
dfc47ef8
EB		 1712 return -EPERM;
1713
2f90b865 1714 ret = nlmsg_parse(nlh, sizeof(*dcb), tb, DCB_ATTR_MAX,
fceb6435 1715 dcbnl_rtnl_policy, NULL);
2f90b865
AD		 1716 if (ret < 0)
1717 return ret;
1718
33a03aad
TG		 1719 if (dcb->cmd > DCB_CMD_MAX)
1720 return -EINVAL;
1721
1722 /* check if a reply function has been defined for the command */
1723 fn = &reply_funcs[dcb->cmd];
1724 if (!fn->cb)
1725 return -EOPNOTSUPP;
1726
2f90b865
AD		 1727 if (!tb[DCB_ATTR_IFNAME])
1728 return -EINVAL;
1729
d9ac62be 1730 netdev = __dev_get_by_name(net, nla_data(tb[DCB_ATTR_IFNAME]));
2f90b865 1731 if (!netdev)
3d1f4869 1732 return -ENODEV;
2f90b865 1733
d9ac62be
YX		 1734 if (!netdev->dcbnl_ops)
1735 return -EOPNOTSUPP;
2f90b865 1736
15e47304 1737 reply_skb = dcbnl_newmsg(fn->type, dcb->cmd, portid, nlh->nlmsg_seq,
33a03aad 1738 nlh->nlmsg_flags, &reply_nlh);
d9ac62be
YX		 1739 if (!reply_skb)
1740 return -ENOBUFS;
33a03aad
TG		 1741
1742 ret = fn->cb(netdev, nlh, nlh->nlmsg_seq, tb, reply_skb);
1743 if (ret < 0) {
1744 nlmsg_free(reply_skb);
1745 goto out;
1746 }
1747
1748 nlmsg_end(reply_skb, reply_nlh);
1749
7c77ab24 1750 ret = rtnl_unicast(reply_skb, net, portid);
2f90b865 1751out:
2f90b865
AD		 1752 return ret;
1753}
1754
716b31ab
TG		 1755static struct dcb_app_type *dcb_app_lookup(const struct dcb_app *app,
1756 int ifindex, int prio)
1757{
1758 struct dcb_app_type *itr;
1759
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))
1765 return itr;
1766 }
1767
1768 return NULL;
1769}
1770
4e4f2f69
TG		 1771static int dcb_app_add(const struct dcb_app *app, int ifindex)
1772{
1773 struct dcb_app_type *entry;
1774
1775 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
1776 if (!entry)
1777 return -ENOMEM;
1778
1779 memcpy(&entry->app, app, sizeof(*app));
1780 entry->ifindex = ifindex;
1781 list_add(&entry->list, &dcb_app_list);
1782
1783 return 0;
1784}
1785
9ab933ab
JF		 1786/**
1787 * dcb_getapp - retrieve the DCBX application user priority
1788 *
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.
1792 */
1793u8 dcb_getapp(struct net_device *dev, struct dcb_app *app)
1794{
1795 struct dcb_app_type *itr;
1796 u8 prio = 0;
1797
52cff74e 1798 spin_lock_bh(&dcb_lock);
716b31ab
TG		 1799 if ((itr = dcb_app_lookup(app, dev->ifindex, 0)))
1800 prio = itr->app.priority;
52cff74e 1801 spin_unlock_bh(&dcb_lock);
9ab933ab
JF		 1802
1803 return prio;
1804}
1805EXPORT_SYMBOL(dcb_getapp);
1806
1807/**
b6db2174 1808 * dcb_setapp - add CEE dcb application data to app list
9ab933ab 1809 *
b6db2174
JF		 1810 * Priority 0 is an invalid priority in CEE spec. This routine
1811 * removes applications from the app list if the priority is
16eecd9b 1812 * set to zero. Priority is expected to be 8-bit 802.1p user priority bitmap
9ab933ab 1813 */
ab6baf98 1814int dcb_setapp(struct net_device *dev, struct dcb_app *new)
9ab933ab
JF		 1815{
1816 struct dcb_app_type *itr;
7ec79270 1817 struct dcb_app_type event;
4e4f2f69 1818 int err = 0;
7ec79270 1819
e290ed81 1820 event.ifindex = dev->ifindex;
7ec79270 1821 memcpy(&event.app, new, sizeof(event.app));
6bd0e1cb
JF		 1822 if (dev->dcbnl_ops->getdcbx)
1823 event.dcbx = dev->dcbnl_ops->getdcbx(dev);
9ab933ab 1824
52cff74e 1825 spin_lock_bh(&dcb_lock);
9ab933ab 1826 /* Search for existing match and replace */
716b31ab
TG		 1827 if ((itr = dcb_app_lookup(new, dev->ifindex, 0))) {
1828 if (new->priority)
1829 itr->app.priority = new->priority;
1830 else {
1831 list_del(&itr->list);
1832 kfree(itr);
9ab933ab 1833 }
716b31ab 1834 goto out;
9ab933ab
JF		 1835 }
1836 /* App type does not exist add new application type */
4e4f2f69
TG		 1837 if (new->priority)
1838 err = dcb_app_add(new, dev->ifindex);
9ab933ab 1839out:
52cff74e 1840 spin_unlock_bh(&dcb_lock);
4e4f2f69
TG		 1841 if (!err)
1842 call_dcbevent_notifiers(DCB_APP_EVENT, &event);
1843 return err;
9ab933ab
JF		 1844}
1845EXPORT_SYMBOL(dcb_setapp);
1846
a364c8cf
JF		 1847/**
1848 * dcb_ieee_getapp_mask - retrieve the IEEE DCB application priority
1849 *
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.
1853 */
1854u8 dcb_ieee_getapp_mask(struct net_device *dev, struct dcb_app *app)
1855{
1856 struct dcb_app_type *itr;
1857 u8 prio = 0;
1858
52cff74e 1859 spin_lock_bh(&dcb_lock);
716b31ab
TG		 1860 if ((itr = dcb_app_lookup(app, dev->ifindex, 0)))
1861 prio |= 1 << itr->app.priority;
52cff74e 1862 spin_unlock_bh(&dcb_lock);
a364c8cf
JF		 1863
1864 return prio;
1865}
1866EXPORT_SYMBOL(dcb_ieee_getapp_mask);
1867
b6db2174
JF		 1868/**
1869 * dcb_ieee_setapp - add IEEE dcb application data to app list
1870 *
1871 * This adds Application data to the list. Multiple application
1872 * entries may exists for the same selector and protocol as long
16eecd9b
AB		 1873 * as the priorities are different. Priority is expected to be a
1874 * 3-bit unsigned integer
b6db2174
JF		 1875 */
1876int dcb_ieee_setapp(struct net_device *dev, struct dcb_app *new)
1877{
b6db2174
JF		 1878 struct dcb_app_type event;
1879 int err = 0;
1880
e290ed81 1881 event.ifindex = dev->ifindex;
b6db2174 1882 memcpy(&event.app, new, sizeof(event.app));
6bd0e1cb
JF		 1883 if (dev->dcbnl_ops->getdcbx)
1884 event.dcbx = dev->dcbnl_ops->getdcbx(dev);
b6db2174 1885
52cff74e 1886 spin_lock_bh(&dcb_lock);
b6db2174 1887 /* Search for existing match and abort if found */
716b31ab
TG		 1888 if (dcb_app_lookup(new, dev->ifindex, new->priority)) {
1889 err = -EEXIST;
1890 goto out;
b6db2174
JF		 1891 }
1892
4e4f2f69 1893 err = dcb_app_add(new, dev->ifindex);
b6db2174 1894out:
52cff74e 1895 spin_unlock_bh(&dcb_lock);
b6db2174
JF		 1896 if (!err)
1897 call_dcbevent_notifiers(DCB_APP_EVENT, &event);
1898 return err;
1899}
1900EXPORT_SYMBOL(dcb_ieee_setapp);
1901
f9ae7e4b
JF		 1902/**
1903 * dcb_ieee_delapp - delete IEEE dcb application data from list
1904 *
1905 * This removes a matching APP data from the APP list
1906 */
1907int dcb_ieee_delapp(struct net_device *dev, struct dcb_app *del)
1908{
1909 struct dcb_app_type *itr;
1910 struct dcb_app_type event;
1911 int err = -ENOENT;
1912
e290ed81 1913 event.ifindex = dev->ifindex;
f9ae7e4b 1914 memcpy(&event.app, del, sizeof(event.app));
6bd0e1cb
JF		 1915 if (dev->dcbnl_ops->getdcbx)
1916 event.dcbx = dev->dcbnl_ops->getdcbx(dev);
f9ae7e4b 1917
52cff74e 1918 spin_lock_bh(&dcb_lock);
f9ae7e4b 1919 /* Search for existing match and remove it. */
716b31ab
TG		 1920 if ((itr = dcb_app_lookup(del, dev->ifindex, del->priority))) {
1921 list_del(&itr->list);
1922 kfree(itr);
1923 err = 0;
f9ae7e4b
JF		 1924 }
1925
52cff74e 1926 spin_unlock_bh(&dcb_lock);
f9ae7e4b
JF		 1927 if (!err)
1928 call_dcbevent_notifiers(DCB_APP_EVENT, &event);
1929 return err;
1930}
1931EXPORT_SYMBOL(dcb_ieee_delapp);
1932
2f90b865
AD		 1933static int __init dcbnl_init(void)
1934{
9ab933ab
JF		 1935 INIT_LIST_HEAD(&dcb_app_list);
1936
c7ac8679
GR		 1937 rtnl_register(PF_UNSPEC, RTM_GETDCB, dcb_doit, NULL, NULL);
1938 rtnl_register(PF_UNSPEC, RTM_SETDCB, dcb_doit, NULL, NULL);
2f90b865
AD		 1939
1940 return 0;
1941}
36b9ad80 1942device_initcall(dcbnl_init);
Empty description
This page took 0.960078 seconds and 4 git commands to generate.