1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
3 * Copyright (C) 2006 Andrey Volkov, Varma Electronics
4 * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
5 * Copyright (C) 2021 Vincent Mailhol <mailhol.vincent@wanadoo.fr>
6 */
7
8 #include <linux/can/dev.h>
9 #include <net/rtnetlink.h>
10
11 static const struct nla_policy can_policy[IFLA_CAN_MAX + 1] = {
12 [IFLA_CAN_STATE] = { .type = NLA_U32 },
13 [IFLA_CAN_CTRLMODE] = { .len = sizeof(struct can_ctrlmode) },
14 [IFLA_CAN_RESTART_MS] = { .type = NLA_U32 },
15 [IFLA_CAN_RESTART] = { .type = NLA_U32 },
16 [IFLA_CAN_BITTIMING] = { .len = sizeof(struct can_bittiming) },
17 [IFLA_CAN_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },
18 [IFLA_CAN_CLOCK] = { .len = sizeof(struct can_clock) },
19 [IFLA_CAN_BERR_COUNTER] = { .len = sizeof(struct can_berr_counter) },
20 [IFLA_CAN_DATA_BITTIMING] = { .len = sizeof(struct can_bittiming) },
21 [IFLA_CAN_DATA_BITTIMING_CONST] = { .len = sizeof(struct can_bittiming_const) },
22 [IFLA_CAN_TERMINATION] = { .type = NLA_U16 },
23 [IFLA_CAN_TDC] = { .type = NLA_NESTED },
24 };
25
26 static const struct nla_policy can_tdc_policy[IFLA_CAN_TDC_MAX + 1] = {
27 [IFLA_CAN_TDC_TDCV_MIN] = { .type = NLA_U32 },
28 [IFLA_CAN_TDC_TDCV_MAX] = { .type = NLA_U32 },
29 [IFLA_CAN_TDC_TDCO_MIN] = { .type = NLA_U32 },
30 [IFLA_CAN_TDC_TDCO_MAX] = { .type = NLA_U32 },
31 [IFLA_CAN_TDC_TDCF_MIN] = { .type = NLA_U32 },
32 [IFLA_CAN_TDC_TDCF_MAX] = { .type = NLA_U32 },
33 [IFLA_CAN_TDC_TDCV] = { .type = NLA_U32 },
34 [IFLA_CAN_TDC_TDCO] = { .type = NLA_U32 },
35 [IFLA_CAN_TDC_TDCF] = { .type = NLA_U32 },
36 };
37
can_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)38 static int can_validate(struct nlattr *tb[], struct nlattr *data[],
39 struct netlink_ext_ack *extack)
40 {
41 bool is_can_fd = false;
42
43 /* Make sure that valid CAN FD configurations always consist of
44 * - nominal/arbitration bittiming
45 * - data bittiming
46 * - control mode with CAN_CTRLMODE_FD set
47 * - TDC parameters are coherent (details below)
48 */
49
50 if (!data)
51 return 0;
52
53 if (data[IFLA_CAN_CTRLMODE]) {
54 struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
55 u32 tdc_flags = cm->flags & CAN_CTRLMODE_TDC_MASK;
56
57 is_can_fd = cm->flags & cm->mask & CAN_CTRLMODE_FD;
58
59 /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually exclusive */
60 if (tdc_flags == CAN_CTRLMODE_TDC_MASK)
61 return -EOPNOTSUPP;
62 /* If one of the CAN_CTRLMODE_TDC_* flag is set then
63 * TDC must be set and vice-versa
64 */
65 if (!!tdc_flags != !!data[IFLA_CAN_TDC])
66 return -EOPNOTSUPP;
67 /* If providing TDC parameters, at least TDCO is
68 * needed. TDCV is needed if and only if
69 * CAN_CTRLMODE_TDC_MANUAL is set
70 */
71 if (data[IFLA_CAN_TDC]) {
72 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
73 int err;
74
75 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX,
76 data[IFLA_CAN_TDC],
77 can_tdc_policy, extack);
78 if (err)
79 return err;
80
81 if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
82 if (tdc_flags & CAN_CTRLMODE_TDC_AUTO)
83 return -EOPNOTSUPP;
84 } else {
85 if (tdc_flags & CAN_CTRLMODE_TDC_MANUAL)
86 return -EOPNOTSUPP;
87 }
88
89 if (!tb_tdc[IFLA_CAN_TDC_TDCO])
90 return -EOPNOTSUPP;
91 }
92 }
93
94 if (is_can_fd) {
95 if (!data[IFLA_CAN_BITTIMING] || !data[IFLA_CAN_DATA_BITTIMING])
96 return -EOPNOTSUPP;
97 }
98
99 if (data[IFLA_CAN_DATA_BITTIMING] || data[IFLA_CAN_TDC]) {
100 if (!is_can_fd)
101 return -EOPNOTSUPP;
102 }
103
104 return 0;
105 }
106
can_tdc_changelink(struct can_priv * priv,const struct nlattr * nla,struct netlink_ext_ack * extack)107 static int can_tdc_changelink(struct can_priv *priv, const struct nlattr *nla,
108 struct netlink_ext_ack *extack)
109 {
110 struct nlattr *tb_tdc[IFLA_CAN_TDC_MAX + 1];
111 struct can_tdc tdc = { 0 };
112 const struct can_tdc_const *tdc_const = priv->tdc_const;
113 int err;
114
115 if (!tdc_const || !can_tdc_is_enabled(priv))
116 return -EOPNOTSUPP;
117
118 err = nla_parse_nested(tb_tdc, IFLA_CAN_TDC_MAX, nla,
119 can_tdc_policy, extack);
120 if (err)
121 return err;
122
123 if (tb_tdc[IFLA_CAN_TDC_TDCV]) {
124 u32 tdcv = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCV]);
125
126 if (tdcv < tdc_const->tdcv_min || tdcv > tdc_const->tdcv_max)
127 return -EINVAL;
128
129 tdc.tdcv = tdcv;
130 }
131
132 if (tb_tdc[IFLA_CAN_TDC_TDCO]) {
133 u32 tdco = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCO]);
134
135 if (tdco < tdc_const->tdco_min || tdco > tdc_const->tdco_max)
136 return -EINVAL;
137
138 tdc.tdco = tdco;
139 }
140
141 if (tb_tdc[IFLA_CAN_TDC_TDCF]) {
142 u32 tdcf = nla_get_u32(tb_tdc[IFLA_CAN_TDC_TDCF]);
143
144 if (tdcf < tdc_const->tdcf_min || tdcf > tdc_const->tdcf_max)
145 return -EINVAL;
146
147 tdc.tdcf = tdcf;
148 }
149
150 priv->tdc = tdc;
151
152 return 0;
153 }
154
can_changelink(struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)155 static int can_changelink(struct net_device *dev, struct nlattr *tb[],
156 struct nlattr *data[],
157 struct netlink_ext_ack *extack)
158 {
159 struct can_priv *priv = netdev_priv(dev);
160 u32 tdc_mask = 0;
161 int err;
162
163 /* We need synchronization with dev->stop() */
164 ASSERT_RTNL();
165
166 if (data[IFLA_CAN_BITTIMING]) {
167 struct can_bittiming bt;
168
169 /* Do not allow changing bittiming while running */
170 if (dev->flags & IFF_UP)
171 return -EBUSY;
172
173 /* Calculate bittiming parameters based on
174 * bittiming_const if set, otherwise pass bitrate
175 * directly via do_set_bitrate(). Bail out if neither
176 * is given.
177 */
178 if (!priv->bittiming_const && !priv->do_set_bittiming)
179 return -EOPNOTSUPP;
180
181 memcpy(&bt, nla_data(data[IFLA_CAN_BITTIMING]), sizeof(bt));
182 err = can_get_bittiming(dev, &bt,
183 priv->bittiming_const,
184 priv->bitrate_const,
185 priv->bitrate_const_cnt);
186 if (err)
187 return err;
188
189 if (priv->bitrate_max && bt.bitrate > priv->bitrate_max) {
190 netdev_err(dev, "arbitration bitrate surpasses transceiver capabilities of %d bps\n",
191 priv->bitrate_max);
192 return -EINVAL;
193 }
194
195 memcpy(&priv->bittiming, &bt, sizeof(bt));
196
197 if (priv->do_set_bittiming) {
198 /* Finally, set the bit-timing registers */
199 err = priv->do_set_bittiming(dev);
200 if (err)
201 return err;
202 }
203 }
204
205 if (data[IFLA_CAN_CTRLMODE]) {
206 struct can_ctrlmode *cm;
207 u32 ctrlstatic;
208 u32 maskedflags;
209
210 /* Do not allow changing controller mode while running */
211 if (dev->flags & IFF_UP)
212 return -EBUSY;
213 cm = nla_data(data[IFLA_CAN_CTRLMODE]);
214 ctrlstatic = priv->ctrlmode_static;
215 maskedflags = cm->flags & cm->mask;
216
217 /* check whether provided bits are allowed to be passed */
218 if (maskedflags & ~(priv->ctrlmode_supported | ctrlstatic))
219 return -EOPNOTSUPP;
220
221 /* do not check for static fd-non-iso if 'fd' is disabled */
222 if (!(maskedflags & CAN_CTRLMODE_FD))
223 ctrlstatic &= ~CAN_CTRLMODE_FD_NON_ISO;
224
225 /* make sure static options are provided by configuration */
226 if ((maskedflags & ctrlstatic) != ctrlstatic)
227 return -EOPNOTSUPP;
228
229 /* clear bits to be modified and copy the flag values */
230 priv->ctrlmode &= ~cm->mask;
231 priv->ctrlmode |= maskedflags;
232
233 /* CAN_CTRLMODE_FD can only be set when driver supports FD */
234 if (priv->ctrlmode & CAN_CTRLMODE_FD) {
235 dev->mtu = CANFD_MTU;
236 } else {
237 dev->mtu = CAN_MTU;
238 memset(&priv->data_bittiming, 0,
239 sizeof(priv->data_bittiming));
240 priv->ctrlmode &= ~CAN_CTRLMODE_TDC_MASK;
241 memset(&priv->tdc, 0, sizeof(priv->tdc));
242 }
243
244 tdc_mask = cm->mask & CAN_CTRLMODE_TDC_MASK;
245 /* CAN_CTRLMODE_TDC_{AUTO,MANUAL} are mutually
246 * exclusive: make sure to turn the other one off
247 */
248 if (tdc_mask)
249 priv->ctrlmode &= cm->flags | ~CAN_CTRLMODE_TDC_MASK;
250 }
251
252 if (data[IFLA_CAN_RESTART_MS]) {
253 /* Do not allow changing restart delay while running */
254 if (dev->flags & IFF_UP)
255 return -EBUSY;
256 priv->restart_ms = nla_get_u32(data[IFLA_CAN_RESTART_MS]);
257 }
258
259 if (data[IFLA_CAN_RESTART]) {
260 /* Do not allow a restart while not running */
261 if (!(dev->flags & IFF_UP))
262 return -EINVAL;
263 err = can_restart_now(dev);
264 if (err)
265 return err;
266 }
267
268 if (data[IFLA_CAN_DATA_BITTIMING]) {
269 struct can_bittiming dbt;
270
271 /* Do not allow changing bittiming while running */
272 if (dev->flags & IFF_UP)
273 return -EBUSY;
274
275 /* Calculate bittiming parameters based on
276 * data_bittiming_const if set, otherwise pass bitrate
277 * directly via do_set_bitrate(). Bail out if neither
278 * is given.
279 */
280 if (!priv->data_bittiming_const && !priv->do_set_data_bittiming)
281 return -EOPNOTSUPP;
282
283 memcpy(&dbt, nla_data(data[IFLA_CAN_DATA_BITTIMING]),
284 sizeof(dbt));
285 err = can_get_bittiming(dev, &dbt,
286 priv->data_bittiming_const,
287 priv->data_bitrate_const,
288 priv->data_bitrate_const_cnt);
289 if (err)
290 return err;
291
292 if (priv->bitrate_max && dbt.bitrate > priv->bitrate_max) {
293 netdev_err(dev, "canfd data bitrate surpasses transceiver capabilities of %d bps\n",
294 priv->bitrate_max);
295 return -EINVAL;
296 }
297
298 memset(&priv->tdc, 0, sizeof(priv->tdc));
299 if (data[IFLA_CAN_TDC]) {
300 /* TDC parameters are provided: use them */
301 err = can_tdc_changelink(priv, data[IFLA_CAN_TDC],
302 extack);
303 if (err) {
304 priv->ctrlmode &= ~CAN_CTRLMODE_TDC_MASK;
305 return err;
306 }
307 } else if (!tdc_mask) {
308 /* Neither of TDC parameters nor TDC flags are
309 * provided: do calculation
310 */
311 can_calc_tdco(&priv->tdc, priv->tdc_const, &priv->data_bittiming,
312 &priv->ctrlmode, priv->ctrlmode_supported);
313 } /* else: both CAN_CTRLMODE_TDC_{AUTO,MANUAL} are explicitly
314 * turned off. TDC is disabled: do nothing
315 */
316
317 memcpy(&priv->data_bittiming, &dbt, sizeof(dbt));
318
319 if (priv->do_set_data_bittiming) {
320 /* Finally, set the bit-timing registers */
321 err = priv->do_set_data_bittiming(dev);
322 if (err)
323 return err;
324 }
325 }
326
327 if (data[IFLA_CAN_TERMINATION]) {
328 const u16 termval = nla_get_u16(data[IFLA_CAN_TERMINATION]);
329 const unsigned int num_term = priv->termination_const_cnt;
330 unsigned int i;
331
332 if (!priv->do_set_termination)
333 return -EOPNOTSUPP;
334
335 /* check whether given value is supported by the interface */
336 for (i = 0; i < num_term; i++) {
337 if (termval == priv->termination_const[i])
338 break;
339 }
340 if (i >= num_term)
341 return -EINVAL;
342
343 /* Finally, set the termination value */
344 err = priv->do_set_termination(dev, termval);
345 if (err)
346 return err;
347
348 priv->termination = termval;
349 }
350
351 return 0;
352 }
353
can_tdc_get_size(const struct net_device * dev)354 static size_t can_tdc_get_size(const struct net_device *dev)
355 {
356 struct can_priv *priv = netdev_priv(dev);
357 size_t size;
358
359 if (!priv->tdc_const)
360 return 0;
361
362 size = nla_total_size(0); /* nest IFLA_CAN_TDC */
363 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL) {
364 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MIN */
365 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV_MAX */
366 }
367 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MIN */
368 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO_MAX */
369 if (priv->tdc_const->tdcf_max) {
370 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MIN */
371 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF_MAX */
372 }
373
374 if (can_tdc_is_enabled(priv)) {
375 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL ||
376 priv->do_get_auto_tdcv)
377 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCV */
378 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCO */
379 if (priv->tdc_const->tdcf_max)
380 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_TDCF */
381 }
382
383 return size;
384 }
385
can_get_size(const struct net_device * dev)386 static size_t can_get_size(const struct net_device *dev)
387 {
388 struct can_priv *priv = netdev_priv(dev);
389 size_t size = 0;
390
391 if (priv->bittiming.bitrate) /* IFLA_CAN_BITTIMING */
392 size += nla_total_size(sizeof(struct can_bittiming));
393 if (priv->bittiming_const) /* IFLA_CAN_BITTIMING_CONST */
394 size += nla_total_size(sizeof(struct can_bittiming_const));
395 size += nla_total_size(sizeof(struct can_clock)); /* IFLA_CAN_CLOCK */
396 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_STATE */
397 size += nla_total_size(sizeof(struct can_ctrlmode)); /* IFLA_CAN_CTRLMODE */
398 size += nla_total_size(sizeof(u32)); /* IFLA_CAN_RESTART_MS */
399 if (priv->do_get_berr_counter) /* IFLA_CAN_BERR_COUNTER */
400 size += nla_total_size(sizeof(struct can_berr_counter));
401 if (priv->data_bittiming.bitrate) /* IFLA_CAN_DATA_BITTIMING */
402 size += nla_total_size(sizeof(struct can_bittiming));
403 if (priv->data_bittiming_const) /* IFLA_CAN_DATA_BITTIMING_CONST */
404 size += nla_total_size(sizeof(struct can_bittiming_const));
405 if (priv->termination_const) {
406 size += nla_total_size(sizeof(priv->termination)); /* IFLA_CAN_TERMINATION */
407 size += nla_total_size(sizeof(*priv->termination_const) * /* IFLA_CAN_TERMINATION_CONST */
408 priv->termination_const_cnt);
409 }
410 if (priv->bitrate_const) /* IFLA_CAN_BITRATE_CONST */
411 size += nla_total_size(sizeof(*priv->bitrate_const) *
412 priv->bitrate_const_cnt);
413 if (priv->data_bitrate_const) /* IFLA_CAN_DATA_BITRATE_CONST */
414 size += nla_total_size(sizeof(*priv->data_bitrate_const) *
415 priv->data_bitrate_const_cnt);
416 size += sizeof(priv->bitrate_max); /* IFLA_CAN_BITRATE_MAX */
417 size += can_tdc_get_size(dev); /* IFLA_CAN_TDC */
418
419 return size;
420 }
421
can_tdc_fill_info(struct sk_buff * skb,const struct net_device * dev)422 static int can_tdc_fill_info(struct sk_buff *skb, const struct net_device *dev)
423 {
424 struct nlattr *nest;
425 struct can_priv *priv = netdev_priv(dev);
426 struct can_tdc *tdc = &priv->tdc;
427 const struct can_tdc_const *tdc_const = priv->tdc_const;
428
429 if (!tdc_const)
430 return 0;
431
432 nest = nla_nest_start(skb, IFLA_CAN_TDC);
433 if (!nest)
434 return -EMSGSIZE;
435
436 if (priv->ctrlmode_supported & CAN_CTRLMODE_TDC_MANUAL &&
437 (nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MIN, tdc_const->tdcv_min) ||
438 nla_put_u32(skb, IFLA_CAN_TDC_TDCV_MAX, tdc_const->tdcv_max)))
439 goto err_cancel;
440 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MIN, tdc_const->tdco_min) ||
441 nla_put_u32(skb, IFLA_CAN_TDC_TDCO_MAX, tdc_const->tdco_max))
442 goto err_cancel;
443 if (tdc_const->tdcf_max &&
444 (nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MIN, tdc_const->tdcf_min) ||
445 nla_put_u32(skb, IFLA_CAN_TDC_TDCF_MAX, tdc_const->tdcf_max)))
446 goto err_cancel;
447
448 if (can_tdc_is_enabled(priv)) {
449 u32 tdcv;
450 int err = -EINVAL;
451
452 if (priv->ctrlmode & CAN_CTRLMODE_TDC_MANUAL) {
453 tdcv = tdc->tdcv;
454 err = 0;
455 } else if (priv->do_get_auto_tdcv) {
456 err = priv->do_get_auto_tdcv(dev, &tdcv);
457 }
458 if (!err && nla_put_u32(skb, IFLA_CAN_TDC_TDCV, tdcv))
459 goto err_cancel;
460 if (nla_put_u32(skb, IFLA_CAN_TDC_TDCO, tdc->tdco))
461 goto err_cancel;
462 if (tdc_const->tdcf_max &&
463 nla_put_u32(skb, IFLA_CAN_TDC_TDCF, tdc->tdcf))
464 goto err_cancel;
465 }
466
467 nla_nest_end(skb, nest);
468 return 0;
469
470 err_cancel:
471 nla_nest_cancel(skb, nest);
472 return -EMSGSIZE;
473 }
474
can_fill_info(struct sk_buff * skb,const struct net_device * dev)475 static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)
476 {
477 struct can_priv *priv = netdev_priv(dev);
478 struct can_ctrlmode cm = {.flags = priv->ctrlmode};
479 struct can_berr_counter bec = { };
480 enum can_state state = priv->state;
481
482 if (priv->do_get_state)
483 priv->do_get_state(dev, &state);
484
485 if ((priv->bittiming.bitrate &&
486 nla_put(skb, IFLA_CAN_BITTIMING,
487 sizeof(priv->bittiming), &priv->bittiming)) ||
488
489 (priv->bittiming_const &&
490 nla_put(skb, IFLA_CAN_BITTIMING_CONST,
491 sizeof(*priv->bittiming_const), priv->bittiming_const)) ||
492
493 nla_put(skb, IFLA_CAN_CLOCK, sizeof(priv->clock), &priv->clock) ||
494 nla_put_u32(skb, IFLA_CAN_STATE, state) ||
495 nla_put(skb, IFLA_CAN_CTRLMODE, sizeof(cm), &cm) ||
496 nla_put_u32(skb, IFLA_CAN_RESTART_MS, priv->restart_ms) ||
497
498 (priv->do_get_berr_counter &&
499 !priv->do_get_berr_counter(dev, &bec) &&
500 nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
501
502 (priv->data_bittiming.bitrate &&
503 nla_put(skb, IFLA_CAN_DATA_BITTIMING,
504 sizeof(priv->data_bittiming), &priv->data_bittiming)) ||
505
506 (priv->data_bittiming_const &&
507 nla_put(skb, IFLA_CAN_DATA_BITTIMING_CONST,
508 sizeof(*priv->data_bittiming_const),
509 priv->data_bittiming_const)) ||
510
511 (priv->termination_const &&
512 (nla_put_u16(skb, IFLA_CAN_TERMINATION, priv->termination) ||
513 nla_put(skb, IFLA_CAN_TERMINATION_CONST,
514 sizeof(*priv->termination_const) *
515 priv->termination_const_cnt,
516 priv->termination_const))) ||
517
518 (priv->bitrate_const &&
519 nla_put(skb, IFLA_CAN_BITRATE_CONST,
520 sizeof(*priv->bitrate_const) *
521 priv->bitrate_const_cnt,
522 priv->bitrate_const)) ||
523
524 (priv->data_bitrate_const &&
525 nla_put(skb, IFLA_CAN_DATA_BITRATE_CONST,
526 sizeof(*priv->data_bitrate_const) *
527 priv->data_bitrate_const_cnt,
528 priv->data_bitrate_const)) ||
529
530 (nla_put(skb, IFLA_CAN_BITRATE_MAX,
531 sizeof(priv->bitrate_max),
532 &priv->bitrate_max)) ||
533
534 (can_tdc_fill_info(skb, dev))
535 )
536
537 return -EMSGSIZE;
538
539 return 0;
540 }
541
can_get_xstats_size(const struct net_device * dev)542 static size_t can_get_xstats_size(const struct net_device *dev)
543 {
544 return sizeof(struct can_device_stats);
545 }
546
can_fill_xstats(struct sk_buff * skb,const struct net_device * dev)547 static int can_fill_xstats(struct sk_buff *skb, const struct net_device *dev)
548 {
549 struct can_priv *priv = netdev_priv(dev);
550
551 if (nla_put(skb, IFLA_INFO_XSTATS,
552 sizeof(priv->can_stats), &priv->can_stats))
553 goto nla_put_failure;
554 return 0;
555
556 nla_put_failure:
557 return -EMSGSIZE;
558 }
559
can_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)560 static int can_newlink(struct net *src_net, struct net_device *dev,
561 struct nlattr *tb[], struct nlattr *data[],
562 struct netlink_ext_ack *extack)
563 {
564 return -EOPNOTSUPP;
565 }
566
can_dellink(struct net_device * dev,struct list_head * head)567 static void can_dellink(struct net_device *dev, struct list_head *head)
568 {
569 }
570
571 struct rtnl_link_ops can_link_ops __read_mostly = {
572 .kind = "can",
573 .netns_refund = true,
574 .maxtype = IFLA_CAN_MAX,
575 .policy = can_policy,
576 .setup = can_setup,
577 .validate = can_validate,
578 .newlink = can_newlink,
579 .changelink = can_changelink,
580 .dellink = can_dellink,
581 .get_size = can_get_size,
582 .fill_info = can_fill_info,
583 .get_xstats_size = can_get_xstats_size,
584 .fill_xstats = can_fill_xstats,
585 };
586
can_netlink_register(void)587 int can_netlink_register(void)
588 {
589 return rtnl_link_register(&can_link_ops);
590 }
591
can_netlink_unregister(void)592 void can_netlink_unregister(void)
593 {
594 rtnl_link_unregister(&can_link_ops);
595 }
596