netlink.c 18 KB

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