~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ncsi/ncsi-netlink.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp