ncsi-netlink.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright Samuel Mendoza-Jonas, IBM Corporation 2018.
  4. */
  5. #include <linux/module.h>
  6. #include <linux/kernel.h>
  7. #include <linux/if_arp.h>
  8. #include <linux/rtnetlink.h>
  9. #include <linux/etherdevice.h>
  10. #include <net/genetlink.h>
  11. #include <net/ncsi.h>
  12. #include <linux/skbuff.h>
  13. #include <net/sock.h>
  14. #include <uapi/linux/ncsi.h>
  15. #include "internal.h"
  16. #include "ncsi-pkt.h"
  17. #include "ncsi-netlink.h"
  18. static struct genl_family ncsi_genl_family;
  19. static const struct nla_policy ncsi_genl_policy[NCSI_ATTR_MAX + 1] = {
  20. [NCSI_ATTR_IFINDEX] = { .type = NLA_U32 },
  21. [NCSI_ATTR_PACKAGE_LIST] = { .type = NLA_NESTED },
  22. [NCSI_ATTR_PACKAGE_ID] = { .type = NLA_U32 },
  23. [NCSI_ATTR_CHANNEL_ID] = { .type = NLA_U32 },
  24. [NCSI_ATTR_DATA] = { .type = NLA_BINARY, .len = 2048 },
  25. [NCSI_ATTR_MULTI_FLAG] = { .type = NLA_FLAG },
  26. [NCSI_ATTR_PACKAGE_MASK] = { .type = NLA_U32 },
  27. [NCSI_ATTR_CHANNEL_MASK] = { .type = NLA_U32 },
  28. };
  29. static struct ncsi_dev_priv *ndp_from_ifindex(struct net *net, u32 ifindex)
  30. {
  31. struct ncsi_dev_priv *ndp;
  32. struct net_device *dev;
  33. struct ncsi_dev *nd;
  34. struct ncsi_dev;
  35. if (!net)
  36. return NULL;
  37. dev = dev_get_by_index(net, ifindex);
  38. if (!dev) {
  39. pr_err("NCSI netlink: No device for ifindex %u\n", ifindex);
  40. return NULL;
  41. }
  42. nd = ncsi_find_dev(dev);
  43. ndp = nd ? TO_NCSI_DEV_PRIV(nd) : NULL;
  44. dev_put(dev);
  45. return ndp;
  46. }
  47. static int ncsi_write_channel_info(struct sk_buff *skb,
  48. struct ncsi_dev_priv *ndp,
  49. struct ncsi_channel *nc)
  50. {
  51. struct ncsi_channel_vlan_filter *ncf;
  52. struct ncsi_channel_mode *m;
  53. struct nlattr *vid_nest;
  54. int i;
  55. nla_put_u32(skb, NCSI_CHANNEL_ATTR_ID, nc->id);
  56. m = &nc->modes[NCSI_MODE_LINK];
  57. nla_put_u32(skb, NCSI_CHANNEL_ATTR_LINK_STATE, m->data[2]);
  58. if (nc->state == NCSI_CHANNEL_ACTIVE)
  59. nla_put_flag(skb, NCSI_CHANNEL_ATTR_ACTIVE);
  60. if (nc == nc->package->preferred_channel)
  61. nla_put_flag(skb, NCSI_CHANNEL_ATTR_FORCED);
  62. nla_put_u32(skb, NCSI_CHANNEL_ATTR_VERSION_MAJOR, nc->version.version);
  63. nla_put_u32(skb, NCSI_CHANNEL_ATTR_VERSION_MINOR, nc->version.alpha2);
  64. nla_put_string(skb, NCSI_CHANNEL_ATTR_VERSION_STR, nc->version.fw_name);
  65. vid_nest = nla_nest_start_noflag(skb, NCSI_CHANNEL_ATTR_VLAN_LIST);
  66. if (!vid_nest)
  67. return -ENOMEM;
  68. ncf = &nc->vlan_filter;
  69. i = -1;
  70. while ((i = find_next_bit((void *)&ncf->bitmap, ncf->n_vids,
  71. i + 1)) < ncf->n_vids) {
  72. if (ncf->vids[i])
  73. nla_put_u16(skb, NCSI_CHANNEL_ATTR_VLAN_ID,
  74. ncf->vids[i]);
  75. }
  76. nla_nest_end(skb, vid_nest);
  77. return 0;
  78. }
  79. static int ncsi_write_package_info(struct sk_buff *skb,
  80. struct ncsi_dev_priv *ndp, unsigned int id)
  81. {
  82. struct nlattr *pnest, *cnest, *nest;
  83. struct ncsi_package *np;
  84. struct ncsi_channel *nc;
  85. bool found;
  86. int rc;
  87. if (id > ndp->package_num - 1) {
  88. netdev_info(ndp->ndev.dev, "NCSI: No package with id %u\n", id);
  89. return -ENODEV;
  90. }
  91. found = false;
  92. NCSI_FOR_EACH_PACKAGE(ndp, np) {
  93. if (np->id != id)
  94. continue;
  95. pnest = nla_nest_start_noflag(skb, NCSI_PKG_ATTR);
  96. if (!pnest)
  97. return -ENOMEM;
  98. rc = nla_put_u32(skb, NCSI_PKG_ATTR_ID, np->id);
  99. if (rc) {
  100. nla_nest_cancel(skb, pnest);
  101. return rc;
  102. }
  103. if ((0x1 << np->id) == ndp->package_whitelist)
  104. nla_put_flag(skb, NCSI_PKG_ATTR_FORCED);
  105. cnest = nla_nest_start_noflag(skb, NCSI_PKG_ATTR_CHANNEL_LIST);
  106. if (!cnest) {
  107. nla_nest_cancel(skb, pnest);
  108. return -ENOMEM;
  109. }
  110. NCSI_FOR_EACH_CHANNEL(np, nc) {
  111. nest = nla_nest_start_noflag(skb, NCSI_CHANNEL_ATTR);
  112. if (!nest) {
  113. nla_nest_cancel(skb, cnest);
  114. nla_nest_cancel(skb, pnest);
  115. return -ENOMEM;
  116. }
  117. rc = ncsi_write_channel_info(skb, ndp, nc);
  118. if (rc) {
  119. nla_nest_cancel(skb, nest);
  120. nla_nest_cancel(skb, cnest);
  121. nla_nest_cancel(skb, pnest);
  122. return rc;
  123. }
  124. nla_nest_end(skb, nest);
  125. }
  126. nla_nest_end(skb, cnest);
  127. nla_nest_end(skb, pnest);
  128. found = true;
  129. }
  130. if (!found)
  131. return -ENODEV;
  132. return 0;
  133. }
  134. static int ncsi_pkg_info_nl(struct sk_buff *msg, struct genl_info *info)
  135. {
  136. struct ncsi_dev_priv *ndp;
  137. unsigned int package_id;
  138. struct sk_buff *skb;
  139. struct nlattr *attr;
  140. void *hdr;
  141. int rc;
  142. if (!info || !info->attrs)
  143. return -EINVAL;
  144. if (!info->attrs[NCSI_ATTR_IFINDEX])
  145. return -EINVAL;
  146. if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
  147. return -EINVAL;
  148. ndp = ndp_from_ifindex(genl_info_net(info),
  149. nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
  150. if (!ndp)
  151. return -ENODEV;
  152. skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  153. if (!skb)
  154. return -ENOMEM;
  155. hdr = genlmsg_put(skb, info->snd_portid, info->snd_seq,
  156. &ncsi_genl_family, 0, NCSI_CMD_PKG_INFO);
  157. if (!hdr) {
  158. kfree_skb(skb);
  159. return -EMSGSIZE;
  160. }
  161. package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
  162. attr = nla_nest_start_noflag(skb, NCSI_ATTR_PACKAGE_LIST);
  163. if (!attr) {
  164. kfree_skb(skb);
  165. return -EMSGSIZE;
  166. }
  167. rc = ncsi_write_package_info(skb, ndp, package_id);
  168. if (rc) {
  169. nla_nest_cancel(skb, attr);
  170. goto err;
  171. }
  172. nla_nest_end(skb, attr);
  173. genlmsg_end(skb, hdr);
  174. return genlmsg_reply(skb, info);
  175. err:
  176. kfree_skb(skb);
  177. return rc;
  178. }
  179. static int ncsi_pkg_info_all_nl(struct sk_buff *skb,
  180. struct netlink_callback *cb)
  181. {
  182. struct nlattr *attrs[NCSI_ATTR_MAX + 1];
  183. struct ncsi_package *np, *package;
  184. struct ncsi_dev_priv *ndp;
  185. unsigned int package_id;
  186. struct nlattr *attr;
  187. void *hdr;
  188. int rc;
  189. rc = genlmsg_parse_deprecated(cb->nlh, &ncsi_genl_family, attrs, NCSI_ATTR_MAX,
  190. ncsi_genl_policy, NULL);
  191. if (rc)
  192. return rc;
  193. if (!attrs[NCSI_ATTR_IFINDEX])
  194. return -EINVAL;
  195. ndp = ndp_from_ifindex(get_net(sock_net(skb->sk)),
  196. nla_get_u32(attrs[NCSI_ATTR_IFINDEX]));
  197. if (!ndp)
  198. return -ENODEV;
  199. package_id = cb->args[0];
  200. package = NULL;
  201. NCSI_FOR_EACH_PACKAGE(ndp, np)
  202. if (np->id == package_id)
  203. package = np;
  204. if (!package)
  205. return 0; /* done */
  206. hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  207. &ncsi_genl_family, NLM_F_MULTI, NCSI_CMD_PKG_INFO);
  208. if (!hdr) {
  209. rc = -EMSGSIZE;
  210. goto err;
  211. }
  212. attr = nla_nest_start_noflag(skb, NCSI_ATTR_PACKAGE_LIST);
  213. if (!attr) {
  214. rc = -EMSGSIZE;
  215. goto err;
  216. }
  217. rc = ncsi_write_package_info(skb, ndp, package->id);
  218. if (rc) {
  219. nla_nest_cancel(skb, attr);
  220. goto err;
  221. }
  222. nla_nest_end(skb, attr);
  223. genlmsg_end(skb, hdr);
  224. cb->args[0] = package_id + 1;
  225. return skb->len;
  226. err:
  227. genlmsg_cancel(skb, hdr);
  228. return rc;
  229. }
  230. static int ncsi_set_interface_nl(struct sk_buff *msg, struct genl_info *info)
  231. {
  232. struct ncsi_package *np, *package;
  233. struct ncsi_channel *nc, *channel;
  234. u32 package_id, channel_id;
  235. struct ncsi_dev_priv *ndp;
  236. unsigned long flags;
  237. if (!info || !info->attrs)
  238. return -EINVAL;
  239. if (!info->attrs[NCSI_ATTR_IFINDEX])
  240. return -EINVAL;
  241. if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
  242. return -EINVAL;
  243. ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
  244. nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
  245. if (!ndp)
  246. return -ENODEV;
  247. package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
  248. package = NULL;
  249. NCSI_FOR_EACH_PACKAGE(ndp, np)
  250. if (np->id == package_id)
  251. package = np;
  252. if (!package) {
  253. /* The user has set a package that does not exist */
  254. return -ERANGE;
  255. }
  256. channel = NULL;
  257. if (info->attrs[NCSI_ATTR_CHANNEL_ID]) {
  258. channel_id = nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_ID]);
  259. NCSI_FOR_EACH_CHANNEL(package, nc)
  260. if (nc->id == channel_id) {
  261. channel = nc;
  262. break;
  263. }
  264. if (!channel) {
  265. netdev_info(ndp->ndev.dev,
  266. "NCSI: Channel %u does not exist!\n",
  267. channel_id);
  268. return -ERANGE;
  269. }
  270. }
  271. spin_lock_irqsave(&ndp->lock, flags);
  272. ndp->package_whitelist = 0x1 << package->id;
  273. ndp->multi_package = false;
  274. spin_unlock_irqrestore(&ndp->lock, flags);
  275. spin_lock_irqsave(&package->lock, flags);
  276. package->multi_channel = false;
  277. if (channel) {
  278. package->channel_whitelist = 0x1 << channel->id;
  279. package->preferred_channel = channel;
  280. } else {
  281. /* Allow any channel */
  282. package->channel_whitelist = UINT_MAX;
  283. package->preferred_channel = NULL;
  284. }
  285. spin_unlock_irqrestore(&package->lock, flags);
  286. if (channel)
  287. netdev_info(ndp->ndev.dev,
  288. "Set package 0x%x, channel 0x%x as preferred\n",
  289. package_id, channel_id);
  290. else
  291. netdev_info(ndp->ndev.dev, "Set package 0x%x as preferred\n",
  292. package_id);
  293. /* Update channel configuration */
  294. if (!(ndp->flags & NCSI_DEV_RESET))
  295. ncsi_reset_dev(&ndp->ndev);
  296. return 0;
  297. }
  298. static int ncsi_clear_interface_nl(struct sk_buff *msg, struct genl_info *info)
  299. {
  300. struct ncsi_dev_priv *ndp;
  301. struct ncsi_package *np;
  302. unsigned long flags;
  303. if (!info || !info->attrs)
  304. return -EINVAL;
  305. if (!info->attrs[NCSI_ATTR_IFINDEX])
  306. return -EINVAL;
  307. ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
  308. nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
  309. if (!ndp)
  310. return -ENODEV;
  311. /* Reset any whitelists and disable multi mode */
  312. spin_lock_irqsave(&ndp->lock, flags);
  313. ndp->package_whitelist = UINT_MAX;
  314. ndp->multi_package = false;
  315. spin_unlock_irqrestore(&ndp->lock, flags);
  316. NCSI_FOR_EACH_PACKAGE(ndp, np) {
  317. spin_lock_irqsave(&np->lock, flags);
  318. np->multi_channel = false;
  319. np->channel_whitelist = UINT_MAX;
  320. np->preferred_channel = NULL;
  321. spin_unlock_irqrestore(&np->lock, flags);
  322. }
  323. netdev_info(ndp->ndev.dev, "NCSI: Cleared preferred package/channel\n");
  324. /* Update channel configuration */
  325. if (!(ndp->flags & NCSI_DEV_RESET))
  326. ncsi_reset_dev(&ndp->ndev);
  327. return 0;
  328. }
  329. static int ncsi_send_cmd_nl(struct sk_buff *msg, struct genl_info *info)
  330. {
  331. struct ncsi_dev_priv *ndp;
  332. struct ncsi_pkt_hdr *hdr;
  333. struct ncsi_cmd_arg nca;
  334. unsigned char *data;
  335. u32 package_id;
  336. u32 channel_id;
  337. int len, ret;
  338. if (!info || !info->attrs) {
  339. ret = -EINVAL;
  340. goto out;
  341. }
  342. if (!info->attrs[NCSI_ATTR_IFINDEX]) {
  343. ret = -EINVAL;
  344. goto out;
  345. }
  346. if (!info->attrs[NCSI_ATTR_PACKAGE_ID]) {
  347. ret = -EINVAL;
  348. goto out;
  349. }
  350. if (!info->attrs[NCSI_ATTR_CHANNEL_ID]) {
  351. ret = -EINVAL;
  352. goto out;
  353. }
  354. if (!info->attrs[NCSI_ATTR_DATA]) {
  355. ret = -EINVAL;
  356. goto out;
  357. }
  358. ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
  359. nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
  360. if (!ndp) {
  361. ret = -ENODEV;
  362. goto out;
  363. }
  364. package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
  365. channel_id = nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_ID]);
  366. if (package_id >= NCSI_MAX_PACKAGE || channel_id >= NCSI_MAX_CHANNEL) {
  367. ret = -ERANGE;
  368. goto out_netlink;
  369. }
  370. len = nla_len(info->attrs[NCSI_ATTR_DATA]);
  371. if (len < sizeof(struct ncsi_pkt_hdr)) {
  372. netdev_info(ndp->ndev.dev, "NCSI: no command to send %u\n",
  373. package_id);
  374. ret = -EINVAL;
  375. goto out_netlink;
  376. } else {
  377. data = (unsigned char *)nla_data(info->attrs[NCSI_ATTR_DATA]);
  378. }
  379. hdr = (struct ncsi_pkt_hdr *)data;
  380. nca.ndp = ndp;
  381. nca.package = (unsigned char)package_id;
  382. nca.channel = (unsigned char)channel_id;
  383. nca.type = hdr->type;
  384. nca.req_flags = NCSI_REQ_FLAG_NETLINK_DRIVEN;
  385. nca.info = info;
  386. nca.payload = ntohs(hdr->length);
  387. nca.data = data + sizeof(*hdr);
  388. ret = ncsi_xmit_cmd(&nca);
  389. out_netlink:
  390. if (ret != 0) {
  391. netdev_err(ndp->ndev.dev,
  392. "NCSI: Error %d sending command\n",
  393. ret);
  394. ncsi_send_netlink_err(ndp->ndev.dev,
  395. info->snd_seq,
  396. info->snd_portid,
  397. info->nlhdr,
  398. ret);
  399. }
  400. out:
  401. return ret;
  402. }
  403. int ncsi_send_netlink_rsp(struct ncsi_request *nr,
  404. struct ncsi_package *np,
  405. struct ncsi_channel *nc)
  406. {
  407. struct sk_buff *skb;
  408. struct net *net;
  409. void *hdr;
  410. int rc;
  411. net = dev_net(nr->rsp->dev);
  412. skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
  413. if (!skb)
  414. return -ENOMEM;
  415. hdr = genlmsg_put(skb, nr->snd_portid, nr->snd_seq,
  416. &ncsi_genl_family, 0, NCSI_CMD_SEND_CMD);
  417. if (!hdr) {
  418. kfree_skb(skb);
  419. return -EMSGSIZE;
  420. }
  421. nla_put_u32(skb, NCSI_ATTR_IFINDEX, nr->rsp->dev->ifindex);
  422. if (np)
  423. nla_put_u32(skb, NCSI_ATTR_PACKAGE_ID, np->id);
  424. if (nc)
  425. nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, nc->id);
  426. else
  427. nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, NCSI_RESERVED_CHANNEL);
  428. rc = nla_put(skb, NCSI_ATTR_DATA, nr->rsp->len, (void *)nr->rsp->data);
  429. if (rc)
  430. goto err;
  431. genlmsg_end(skb, hdr);
  432. return genlmsg_unicast(net, skb, nr->snd_portid);
  433. err:
  434. kfree_skb(skb);
  435. return rc;
  436. }
  437. int ncsi_send_netlink_timeout(struct ncsi_request *nr,
  438. struct ncsi_package *np,
  439. struct ncsi_channel *nc)
  440. {
  441. struct sk_buff *skb;
  442. struct net *net;
  443. void *hdr;
  444. skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
  445. if (!skb)
  446. return -ENOMEM;
  447. hdr = genlmsg_put(skb, nr->snd_portid, nr->snd_seq,
  448. &ncsi_genl_family, 0, NCSI_CMD_SEND_CMD);
  449. if (!hdr) {
  450. kfree_skb(skb);
  451. return -EMSGSIZE;
  452. }
  453. net = dev_net(nr->cmd->dev);
  454. nla_put_u32(skb, NCSI_ATTR_IFINDEX, nr->cmd->dev->ifindex);
  455. if (np)
  456. nla_put_u32(skb, NCSI_ATTR_PACKAGE_ID, np->id);
  457. else
  458. nla_put_u32(skb, NCSI_ATTR_PACKAGE_ID,
  459. NCSI_PACKAGE_INDEX((((struct ncsi_pkt_hdr *)
  460. nr->cmd->data)->channel)));
  461. if (nc)
  462. nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, nc->id);
  463. else
  464. nla_put_u32(skb, NCSI_ATTR_CHANNEL_ID, NCSI_RESERVED_CHANNEL);
  465. genlmsg_end(skb, hdr);
  466. return genlmsg_unicast(net, skb, nr->snd_portid);
  467. }
  468. int ncsi_send_netlink_err(struct net_device *dev,
  469. u32 snd_seq,
  470. u32 snd_portid,
  471. struct nlmsghdr *nlhdr,
  472. int err)
  473. {
  474. struct nlmsghdr *nlh;
  475. struct nlmsgerr *nle;
  476. struct sk_buff *skb;
  477. struct net *net;
  478. skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
  479. if (!skb)
  480. return -ENOMEM;
  481. net = dev_net(dev);
  482. nlh = nlmsg_put(skb, snd_portid, snd_seq,
  483. NLMSG_ERROR, sizeof(*nle), 0);
  484. nle = (struct nlmsgerr *)nlmsg_data(nlh);
  485. nle->error = err;
  486. memcpy(&nle->msg, nlhdr, sizeof(*nlh));
  487. nlmsg_end(skb, nlh);
  488. return nlmsg_unicast(net->genl_sock, skb, snd_portid);
  489. }
  490. static int ncsi_set_package_mask_nl(struct sk_buff *msg,
  491. struct genl_info *info)
  492. {
  493. struct ncsi_dev_priv *ndp;
  494. unsigned long flags;
  495. int rc;
  496. if (!info || !info->attrs)
  497. return -EINVAL;
  498. if (!info->attrs[NCSI_ATTR_IFINDEX])
  499. return -EINVAL;
  500. if (!info->attrs[NCSI_ATTR_PACKAGE_MASK])
  501. return -EINVAL;
  502. ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
  503. nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
  504. if (!ndp)
  505. return -ENODEV;
  506. spin_lock_irqsave(&ndp->lock, flags);
  507. if (nla_get_flag(info->attrs[NCSI_ATTR_MULTI_FLAG])) {
  508. if (ndp->flags & NCSI_DEV_HWA) {
  509. ndp->multi_package = true;
  510. rc = 0;
  511. } else {
  512. netdev_err(ndp->ndev.dev,
  513. "NCSI: Can't use multiple packages without HWA\n");
  514. rc = -EPERM;
  515. }
  516. } else {
  517. ndp->multi_package = false;
  518. rc = 0;
  519. }
  520. if (!rc)
  521. ndp->package_whitelist =
  522. nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_MASK]);
  523. spin_unlock_irqrestore(&ndp->lock, flags);
  524. if (!rc) {
  525. /* Update channel configuration */
  526. if (!(ndp->flags & NCSI_DEV_RESET))
  527. ncsi_reset_dev(&ndp->ndev);
  528. }
  529. return rc;
  530. }
  531. static int ncsi_set_channel_mask_nl(struct sk_buff *msg,
  532. struct genl_info *info)
  533. {
  534. struct ncsi_package *np, *package;
  535. struct ncsi_channel *nc, *channel;
  536. u32 package_id, channel_id;
  537. struct ncsi_dev_priv *ndp;
  538. unsigned long flags;
  539. if (!info || !info->attrs)
  540. return -EINVAL;
  541. if (!info->attrs[NCSI_ATTR_IFINDEX])
  542. return -EINVAL;
  543. if (!info->attrs[NCSI_ATTR_PACKAGE_ID])
  544. return -EINVAL;
  545. if (!info->attrs[NCSI_ATTR_CHANNEL_MASK])
  546. return -EINVAL;
  547. ndp = ndp_from_ifindex(get_net(sock_net(msg->sk)),
  548. nla_get_u32(info->attrs[NCSI_ATTR_IFINDEX]));
  549. if (!ndp)
  550. return -ENODEV;
  551. package_id = nla_get_u32(info->attrs[NCSI_ATTR_PACKAGE_ID]);
  552. package = NULL;
  553. NCSI_FOR_EACH_PACKAGE(ndp, np)
  554. if (np->id == package_id) {
  555. package = np;
  556. break;
  557. }
  558. if (!package)
  559. return -ERANGE;
  560. spin_lock_irqsave(&package->lock, flags);
  561. channel = NULL;
  562. if (info->attrs[NCSI_ATTR_CHANNEL_ID]) {
  563. channel_id = nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_ID]);
  564. NCSI_FOR_EACH_CHANNEL(np, nc)
  565. if (nc->id == channel_id) {
  566. channel = nc;
  567. break;
  568. }
  569. if (!channel) {
  570. spin_unlock_irqrestore(&package->lock, flags);
  571. return -ERANGE;
  572. }
  573. netdev_dbg(ndp->ndev.dev,
  574. "NCSI: Channel %u set as preferred channel\n",
  575. channel->id);
  576. }
  577. package->channel_whitelist =
  578. nla_get_u32(info->attrs[NCSI_ATTR_CHANNEL_MASK]);
  579. if (package->channel_whitelist == 0)
  580. netdev_dbg(ndp->ndev.dev,
  581. "NCSI: Package %u set to all channels disabled\n",
  582. package->id);
  583. package->preferred_channel = channel;
  584. if (nla_get_flag(info->attrs[NCSI_ATTR_MULTI_FLAG])) {
  585. package->multi_channel = true;
  586. netdev_info(ndp->ndev.dev,
  587. "NCSI: Multi-channel enabled on package %u\n",
  588. package_id);
  589. } else {
  590. package->multi_channel = false;
  591. }
  592. spin_unlock_irqrestore(&package->lock, flags);
  593. /* Update channel configuration */
  594. if (!(ndp->flags & NCSI_DEV_RESET))
  595. ncsi_reset_dev(&ndp->ndev);
  596. return 0;
  597. }
  598. static const struct genl_small_ops ncsi_ops[] = {
  599. {
  600. .cmd = NCSI_CMD_PKG_INFO,
  601. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  602. .doit = ncsi_pkg_info_nl,
  603. .dumpit = ncsi_pkg_info_all_nl,
  604. .flags = 0,
  605. },
  606. {
  607. .cmd = NCSI_CMD_SET_INTERFACE,
  608. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  609. .doit = ncsi_set_interface_nl,
  610. .flags = GENL_ADMIN_PERM,
  611. },
  612. {
  613. .cmd = NCSI_CMD_CLEAR_INTERFACE,
  614. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  615. .doit = ncsi_clear_interface_nl,
  616. .flags = GENL_ADMIN_PERM,
  617. },
  618. {
  619. .cmd = NCSI_CMD_SEND_CMD,
  620. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  621. .doit = ncsi_send_cmd_nl,
  622. .flags = GENL_ADMIN_PERM,
  623. },
  624. {
  625. .cmd = NCSI_CMD_SET_PACKAGE_MASK,
  626. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  627. .doit = ncsi_set_package_mask_nl,
  628. .flags = GENL_ADMIN_PERM,
  629. },
  630. {
  631. .cmd = NCSI_CMD_SET_CHANNEL_MASK,
  632. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  633. .doit = ncsi_set_channel_mask_nl,
  634. .flags = GENL_ADMIN_PERM,
  635. },
  636. };
  637. static struct genl_family ncsi_genl_family __ro_after_init = {
  638. .name = "NCSI",
  639. .version = 0,
  640. .maxattr = NCSI_ATTR_MAX,
  641. .policy = ncsi_genl_policy,
  642. .module = THIS_MODULE,
  643. .small_ops = ncsi_ops,
  644. .n_small_ops = ARRAY_SIZE(ncsi_ops),
  645. };
  646. static int __init ncsi_init_netlink(void)
  647. {
  648. return genl_register_family(&ncsi_genl_family);
  649. }
  650. subsys_initcall(ncsi_init_netlink);