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