can/dev/netlink.c

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