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

TOMOYO Linux Cross Reference
Linux/net/netlink/genetlink.c

Version: ~ [ linux-5.8-rc5 ] ~ [ linux-5.7.8 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.51 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.132 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.188 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.230 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.230 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ 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
  2 /*
  3  * NETLINK      Generic Netlink Family
  4  *
  5  *              Authors:        Jamal Hadi Salim
  6  *                              Thomas Graf <tgraf@suug.ch>
  7  *                              Johannes Berg <johannes@sipsolutions.net>
  8  */
  9 
 10 #include <linux/module.h>
 11 #include <linux/kernel.h>
 12 #include <linux/slab.h>
 13 #include <linux/errno.h>
 14 #include <linux/types.h>
 15 #include <linux/socket.h>
 16 #include <linux/string.h>
 17 #include <linux/skbuff.h>
 18 #include <linux/mutex.h>
 19 #include <linux/bitmap.h>
 20 #include <linux/rwsem.h>
 21 #include <linux/idr.h>
 22 #include <net/sock.h>
 23 #include <net/genetlink.h>
 24 
 25 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
 26 static DECLARE_RWSEM(cb_lock);
 27 
 28 atomic_t genl_sk_destructing_cnt = ATOMIC_INIT(0);
 29 DECLARE_WAIT_QUEUE_HEAD(genl_sk_destructing_waitq);
 30 
 31 void genl_lock(void)
 32 {
 33         mutex_lock(&genl_mutex);
 34 }
 35 EXPORT_SYMBOL(genl_lock);
 36 
 37 void genl_unlock(void)
 38 {
 39         mutex_unlock(&genl_mutex);
 40 }
 41 EXPORT_SYMBOL(genl_unlock);
 42 
 43 #ifdef CONFIG_LOCKDEP
 44 bool lockdep_genl_is_held(void)
 45 {
 46         return lockdep_is_held(&genl_mutex);
 47 }
 48 EXPORT_SYMBOL(lockdep_genl_is_held);
 49 #endif
 50 
 51 static void genl_lock_all(void)
 52 {
 53         down_write(&cb_lock);
 54         genl_lock();
 55 }
 56 
 57 static void genl_unlock_all(void)
 58 {
 59         genl_unlock();
 60         up_write(&cb_lock);
 61 }
 62 
 63 static DEFINE_IDR(genl_fam_idr);
 64 
 65 /*
 66  * Bitmap of multicast groups that are currently in use.
 67  *
 68  * To avoid an allocation at boot of just one unsigned long,
 69  * declare it global instead.
 70  * Bit 0 is marked as already used since group 0 is invalid.
 71  * Bit 1 is marked as already used since the drop-monitor code
 72  * abuses the API and thinks it can statically use group 1.
 73  * That group will typically conflict with other groups that
 74  * any proper users use.
 75  * Bit 16 is marked as used since it's used for generic netlink
 76  * and the code no longer marks pre-reserved IDs as used.
 77  * Bit 17 is marked as already used since the VFS quota code
 78  * also abused this API and relied on family == group ID, we
 79  * cater to that by giving it a static family and group ID.
 80  * Bit 18 is marked as already used since the PMCRAID driver
 81  * did the same thing as the VFS quota code (maybe copied?)
 82  */
 83 static unsigned long mc_group_start = 0x3 | BIT(GENL_ID_CTRL) |
 84                                       BIT(GENL_ID_VFS_DQUOT) |
 85                                       BIT(GENL_ID_PMCRAID);
 86 static unsigned long *mc_groups = &mc_group_start;
 87 static unsigned long mc_groups_longs = 1;
 88 
 89 static int genl_ctrl_event(int event, const struct genl_family *family,
 90                            const struct genl_multicast_group *grp,
 91                            int grp_id);
 92 
 93 static const struct genl_family *genl_family_find_byid(unsigned int id)
 94 {
 95         return idr_find(&genl_fam_idr, id);
 96 }
 97 
 98 static const struct genl_family *genl_family_find_byname(char *name)
 99 {
100         const struct genl_family *family;
101         unsigned int id;
102 
103         idr_for_each_entry(&genl_fam_idr, family, id)
104                 if (strcmp(family->name, name) == 0)
105                         return family;
106 
107         return NULL;
108 }
109 
110 static const struct genl_ops *genl_get_cmd(u8 cmd,
111                                            const struct genl_family *family)
112 {
113         int i;
114 
115         for (i = 0; i < family->n_ops; i++)
116                 if (family->ops[i].cmd == cmd)
117                         return &family->ops[i];
118 
119         return NULL;
120 }
121 
122 static int genl_allocate_reserve_groups(int n_groups, int *first_id)
123 {
124         unsigned long *new_groups;
125         int start = 0;
126         int i;
127         int id;
128         bool fits;
129 
130         do {
131                 if (start == 0)
132                         id = find_first_zero_bit(mc_groups,
133                                                  mc_groups_longs *
134                                                  BITS_PER_LONG);
135                 else
136                         id = find_next_zero_bit(mc_groups,
137                                                 mc_groups_longs * BITS_PER_LONG,
138                                                 start);
139 
140                 fits = true;
141                 for (i = id;
142                      i < min_t(int, id + n_groups,
143                                mc_groups_longs * BITS_PER_LONG);
144                      i++) {
145                         if (test_bit(i, mc_groups)) {
146                                 start = i;
147                                 fits = false;
148                                 break;
149                         }
150                 }
151 
152                 if (id + n_groups > mc_groups_longs * BITS_PER_LONG) {
153                         unsigned long new_longs = mc_groups_longs +
154                                                   BITS_TO_LONGS(n_groups);
155                         size_t nlen = new_longs * sizeof(unsigned long);
156 
157                         if (mc_groups == &mc_group_start) {
158                                 new_groups = kzalloc(nlen, GFP_KERNEL);
159                                 if (!new_groups)
160                                         return -ENOMEM;
161                                 mc_groups = new_groups;
162                                 *mc_groups = mc_group_start;
163                         } else {
164                                 new_groups = krealloc(mc_groups, nlen,
165                                                       GFP_KERNEL);
166                                 if (!new_groups)
167                                         return -ENOMEM;
168                                 mc_groups = new_groups;
169                                 for (i = 0; i < BITS_TO_LONGS(n_groups); i++)
170                                         mc_groups[mc_groups_longs + i] = 0;
171                         }
172                         mc_groups_longs = new_longs;
173                 }
174         } while (!fits);
175 
176         for (i = id; i < id + n_groups; i++)
177                 set_bit(i, mc_groups);
178         *first_id = id;
179         return 0;
180 }
181 
182 static struct genl_family genl_ctrl;
183 
184 static int genl_validate_assign_mc_groups(struct genl_family *family)
185 {
186         int first_id;
187         int n_groups = family->n_mcgrps;
188         int err = 0, i;
189         bool groups_allocated = false;
190 
191         if (!n_groups)
192                 return 0;
193 
194         for (i = 0; i < n_groups; i++) {
195                 const struct genl_multicast_group *grp = &family->mcgrps[i];
196 
197                 if (WARN_ON(grp->name[0] == '\0'))
198                         return -EINVAL;
199                 if (WARN_ON(memchr(grp->name, '\0', GENL_NAMSIZ) == NULL))
200                         return -EINVAL;
201         }
202 
203         /* special-case our own group and hacks */
204         if (family == &genl_ctrl) {
205                 first_id = GENL_ID_CTRL;
206                 BUG_ON(n_groups != 1);
207         } else if (strcmp(family->name, "NET_DM") == 0) {
208                 first_id = 1;
209                 BUG_ON(n_groups != 1);
210         } else if (family->id == GENL_ID_VFS_DQUOT) {
211                 first_id = GENL_ID_VFS_DQUOT;
212                 BUG_ON(n_groups != 1);
213         } else if (family->id == GENL_ID_PMCRAID) {
214                 first_id = GENL_ID_PMCRAID;
215                 BUG_ON(n_groups != 1);
216         } else {
217                 groups_allocated = true;
218                 err = genl_allocate_reserve_groups(n_groups, &first_id);
219                 if (err)
220                         return err;
221         }
222 
223         family->mcgrp_offset = first_id;
224 
225         /* if still initializing, can't and don't need to to realloc bitmaps */
226         if (!init_net.genl_sock)
227                 return 0;
228 
229         if (family->netnsok) {
230                 struct net *net;
231 
232                 netlink_table_grab();
233                 rcu_read_lock();
234                 for_each_net_rcu(net) {
235                         err = __netlink_change_ngroups(net->genl_sock,
236                                         mc_groups_longs * BITS_PER_LONG);
237                         if (err) {
238                                 /*
239                                  * No need to roll back, can only fail if
240                                  * memory allocation fails and then the
241                                  * number of _possible_ groups has been
242                                  * increased on some sockets which is ok.
243                                  */
244                                 break;
245                         }
246                 }
247                 rcu_read_unlock();
248                 netlink_table_ungrab();
249         } else {
250                 err = netlink_change_ngroups(init_net.genl_sock,
251                                              mc_groups_longs * BITS_PER_LONG);
252         }
253 
254         if (groups_allocated && err) {
255                 for (i = 0; i < family->n_mcgrps; i++)
256                         clear_bit(family->mcgrp_offset + i, mc_groups);
257         }
258 
259         return err;
260 }
261 
262 static void genl_unregister_mc_groups(const struct genl_family *family)
263 {
264         struct net *net;
265         int i;
266 
267         netlink_table_grab();
268         rcu_read_lock();
269         for_each_net_rcu(net) {
270                 for (i = 0; i < family->n_mcgrps; i++)
271                         __netlink_clear_multicast_users(
272                                 net->genl_sock, family->mcgrp_offset + i);
273         }
274         rcu_read_unlock();
275         netlink_table_ungrab();
276 
277         for (i = 0; i < family->n_mcgrps; i++) {
278                 int grp_id = family->mcgrp_offset + i;
279 
280                 if (grp_id != 1)
281                         clear_bit(grp_id, mc_groups);
282                 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, family,
283                                 &family->mcgrps[i], grp_id);
284         }
285 }
286 
287 static int genl_validate_ops(const struct genl_family *family)
288 {
289         const struct genl_ops *ops = family->ops;
290         unsigned int n_ops = family->n_ops;
291         int i, j;
292 
293         if (WARN_ON(n_ops && !ops))
294                 return -EINVAL;
295 
296         if (!n_ops)
297                 return 0;
298 
299         for (i = 0; i < n_ops; i++) {
300                 if (ops[i].dumpit == NULL && ops[i].doit == NULL)
301                         return -EINVAL;
302                 for (j = i + 1; j < n_ops; j++)
303                         if (ops[i].cmd == ops[j].cmd)
304                                 return -EINVAL;
305         }
306 
307         return 0;
308 }
309 
310 /**
311  * genl_register_family - register a generic netlink family
312  * @family: generic netlink family
313  *
314  * Registers the specified family after validating it first. Only one
315  * family may be registered with the same family name or identifier.
316  *
317  * The family's ops, multicast groups and module pointer must already
318  * be assigned.
319  *
320  * Return 0 on success or a negative error code.
321  */
322 int genl_register_family(struct genl_family *family)
323 {
324         int err, i;
325         int start = GENL_START_ALLOC, end = GENL_MAX_ID;
326 
327         err = genl_validate_ops(family);
328         if (err)
329                 return err;
330 
331         genl_lock_all();
332 
333         if (genl_family_find_byname(family->name)) {
334                 err = -EEXIST;
335                 goto errout_locked;
336         }
337 
338         /*
339          * Sadly, a few cases need to be special-cased
340          * due to them having previously abused the API
341          * and having used their family ID also as their
342          * multicast group ID, so we use reserved IDs
343          * for both to be sure we can do that mapping.
344          */
345         if (family == &genl_ctrl) {
346                 /* and this needs to be special for initial family lookups */
347                 start = end = GENL_ID_CTRL;
348         } else if (strcmp(family->name, "pmcraid") == 0) {
349                 start = end = GENL_ID_PMCRAID;
350         } else if (strcmp(family->name, "VFS_DQUOT") == 0) {
351                 start = end = GENL_ID_VFS_DQUOT;
352         }
353 
354         if (family->maxattr && !family->parallel_ops) {
355                 family->attrbuf = kmalloc_array(family->maxattr + 1,
356                                                 sizeof(struct nlattr *),
357                                                 GFP_KERNEL);
358                 if (family->attrbuf == NULL) {
359                         err = -ENOMEM;
360                         goto errout_locked;
361                 }
362         } else
363                 family->attrbuf = NULL;
364 
365         family->id = idr_alloc(&genl_fam_idr, family,
366                                start, end + 1, GFP_KERNEL);
367         if (family->id < 0) {
368                 err = family->id;
369                 goto errout_locked;
370         }
371 
372         err = genl_validate_assign_mc_groups(family);
373         if (err)
374                 goto errout_remove;
375 
376         genl_unlock_all();
377 
378         /* send all events */
379         genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0);
380         for (i = 0; i < family->n_mcgrps; i++)
381                 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family,
382                                 &family->mcgrps[i], family->mcgrp_offset + i);
383 
384         return 0;
385 
386 errout_remove:
387         idr_remove(&genl_fam_idr, family->id);
388         kfree(family->attrbuf);
389 errout_locked:
390         genl_unlock_all();
391         return err;
392 }
393 EXPORT_SYMBOL(genl_register_family);
394 
395 /**
396  * genl_unregister_family - unregister generic netlink family
397  * @family: generic netlink family
398  *
399  * Unregisters the specified family.
400  *
401  * Returns 0 on success or a negative error code.
402  */
403 int genl_unregister_family(const struct genl_family *family)
404 {
405         genl_lock_all();
406 
407         if (!genl_family_find_byid(family->id)) {
408                 genl_unlock_all();
409                 return -ENOENT;
410         }
411 
412         genl_unregister_mc_groups(family);
413 
414         idr_remove(&genl_fam_idr, family->id);
415 
416         up_write(&cb_lock);
417         wait_event(genl_sk_destructing_waitq,
418                    atomic_read(&genl_sk_destructing_cnt) == 0);
419         genl_unlock();
420 
421         kfree(family->attrbuf);
422 
423         genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0);
424 
425         return 0;
426 }
427 EXPORT_SYMBOL(genl_unregister_family);
428 
429 /**
430  * genlmsg_put - Add generic netlink header to netlink message
431  * @skb: socket buffer holding the message
432  * @portid: netlink portid the message is addressed to
433  * @seq: sequence number (usually the one of the sender)
434  * @family: generic netlink family
435  * @flags: netlink message flags
436  * @cmd: generic netlink command
437  *
438  * Returns pointer to user specific header
439  */
440 void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
441                   const struct genl_family *family, int flags, u8 cmd)
442 {
443         struct nlmsghdr *nlh;
444         struct genlmsghdr *hdr;
445 
446         nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +
447                         family->hdrsize, flags);
448         if (nlh == NULL)
449                 return NULL;
450 
451         hdr = nlmsg_data(nlh);
452         hdr->cmd = cmd;
453         hdr->version = family->version;
454         hdr->reserved = 0;
455 
456         return (char *) hdr + GENL_HDRLEN;
457 }
458 EXPORT_SYMBOL(genlmsg_put);
459 
460 static int genl_lock_start(struct netlink_callback *cb)
461 {
462         /* our ops are always const - netlink API doesn't propagate that */
463         const struct genl_ops *ops = cb->data;
464         int rc = 0;
465 
466         if (ops->start) {
467                 genl_lock();
468                 rc = ops->start(cb);
469                 genl_unlock();
470         }
471         return rc;
472 }
473 
474 static int genl_lock_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
475 {
476         /* our ops are always const - netlink API doesn't propagate that */
477         const struct genl_ops *ops = cb->data;
478         int rc;
479 
480         genl_lock();
481         rc = ops->dumpit(skb, cb);
482         genl_unlock();
483         return rc;
484 }
485 
486 static int genl_lock_done(struct netlink_callback *cb)
487 {
488         /* our ops are always const - netlink API doesn't propagate that */
489         const struct genl_ops *ops = cb->data;
490         int rc = 0;
491 
492         if (ops->done) {
493                 genl_lock();
494                 rc = ops->done(cb);
495                 genl_unlock();
496         }
497         return rc;
498 }
499 
500 static int genl_family_rcv_msg(const struct genl_family *family,
501                                struct sk_buff *skb,
502                                struct nlmsghdr *nlh,
503                                struct netlink_ext_ack *extack)
504 {
505         const struct genl_ops *ops;
506         struct net *net = sock_net(skb->sk);
507         struct genl_info info;
508         struct genlmsghdr *hdr = nlmsg_data(nlh);
509         struct nlattr **attrbuf;
510         int hdrlen, err;
511 
512         /* this family doesn't exist in this netns */
513         if (!family->netnsok && !net_eq(net, &init_net))
514                 return -ENOENT;
515 
516         hdrlen = GENL_HDRLEN + family->hdrsize;
517         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
518                 return -EINVAL;
519 
520         ops = genl_get_cmd(hdr->cmd, family);
521         if (ops == NULL)
522                 return -EOPNOTSUPP;
523 
524         if ((ops->flags & GENL_ADMIN_PERM) &&
525             !netlink_capable(skb, CAP_NET_ADMIN))
526                 return -EPERM;
527 
528         if ((ops->flags & GENL_UNS_ADMIN_PERM) &&
529             !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
530                 return -EPERM;
531 
532         if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP) {
533                 int rc;
534 
535                 if (ops->dumpit == NULL)
536                         return -EOPNOTSUPP;
537 
538                 if (!family->parallel_ops) {
539                         struct netlink_dump_control c = {
540                                 .module = family->module,
541                                 /* we have const, but the netlink API doesn't */
542                                 .data = (void *)ops,
543                                 .start = genl_lock_start,
544                                 .dump = genl_lock_dumpit,
545                                 .done = genl_lock_done,
546                         };
547 
548                         genl_unlock();
549                         rc = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
550                         genl_lock();
551 
552                 } else {
553                         struct netlink_dump_control c = {
554                                 .module = family->module,
555                                 .start = ops->start,
556                                 .dump = ops->dumpit,
557                                 .done = ops->done,
558                         };
559 
560                         rc = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
561                 }
562 
563                 return rc;
564         }
565 
566         if (ops->doit == NULL)
567                 return -EOPNOTSUPP;
568 
569         if (family->maxattr && family->parallel_ops) {
570                 attrbuf = kmalloc_array(family->maxattr + 1,
571                                         sizeof(struct nlattr *),
572                                         GFP_KERNEL);
573                 if (attrbuf == NULL)
574                         return -ENOMEM;
575         } else
576                 attrbuf = family->attrbuf;
577 
578         if (attrbuf) {
579                 err = nlmsg_parse(nlh, hdrlen, attrbuf, family->maxattr,
580                                   ops->policy, extack);
581                 if (err < 0)
582                         goto out;
583         }
584 
585         info.snd_seq = nlh->nlmsg_seq;
586         info.snd_portid = NETLINK_CB(skb).portid;
587         info.nlhdr = nlh;
588         info.genlhdr = nlmsg_data(nlh);
589         info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
590         info.attrs = attrbuf;
591         info.extack = extack;
592         genl_info_net_set(&info, net);
593         memset(&info.user_ptr, 0, sizeof(info.user_ptr));
594 
595         if (family->pre_doit) {
596                 err = family->pre_doit(ops, skb, &info);
597                 if (err)
598                         goto out;
599         }
600 
601         err = ops->doit(skb, &info);
602 
603         if (family->post_doit)
604                 family->post_doit(ops, skb, &info);
605 
606 out:
607         if (family->parallel_ops)
608                 kfree(attrbuf);
609 
610         return err;
611 }
612 
613 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
614                         struct netlink_ext_ack *extack)
615 {
616         const struct genl_family *family;
617         int err;
618 
619         family = genl_family_find_byid(nlh->nlmsg_type);
620         if (family == NULL)
621                 return -ENOENT;
622 
623         if (!family->parallel_ops)
624                 genl_lock();
625 
626         err = genl_family_rcv_msg(family, skb, nlh, extack);
627 
628         if (!family->parallel_ops)
629                 genl_unlock();
630 
631         return err;
632 }
633 
634 static void genl_rcv(struct sk_buff *skb)
635 {
636         down_read(&cb_lock);
637         netlink_rcv_skb(skb, &genl_rcv_msg);
638         up_read(&cb_lock);
639 }
640 
641 /**************************************************************************
642  * Controller
643  **************************************************************************/
644 
645 static struct genl_family genl_ctrl;
646 
647 static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq,
648                           u32 flags, struct sk_buff *skb, u8 cmd)
649 {
650         void *hdr;
651 
652         hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
653         if (hdr == NULL)
654                 return -1;
655 
656         if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
657             nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
658             nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
659             nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
660             nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
661                 goto nla_put_failure;
662 
663         if (family->n_ops) {
664                 struct nlattr *nla_ops;
665                 int i;
666 
667                 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
668                 if (nla_ops == NULL)
669                         goto nla_put_failure;
670 
671                 for (i = 0; i < family->n_ops; i++) {
672                         struct nlattr *nest;
673                         const struct genl_ops *ops = &family->ops[i];
674                         u32 op_flags = ops->flags;
675 
676                         if (ops->dumpit)
677                                 op_flags |= GENL_CMD_CAP_DUMP;
678                         if (ops->doit)
679                                 op_flags |= GENL_CMD_CAP_DO;
680                         if (ops->policy)
681                                 op_flags |= GENL_CMD_CAP_HASPOL;
682 
683                         nest = nla_nest_start(skb, i + 1);
684                         if (nest == NULL)
685                                 goto nla_put_failure;
686 
687                         if (nla_put_u32(skb, CTRL_ATTR_OP_ID, ops->cmd) ||
688                             nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags))
689                                 goto nla_put_failure;
690 
691                         nla_nest_end(skb, nest);
692                 }
693 
694                 nla_nest_end(skb, nla_ops);
695         }
696 
697         if (family->n_mcgrps) {
698                 struct nlattr *nla_grps;
699                 int i;
700 
701                 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
702                 if (nla_grps == NULL)
703                         goto nla_put_failure;
704 
705                 for (i = 0; i < family->n_mcgrps; i++) {
706                         struct nlattr *nest;
707                         const struct genl_multicast_group *grp;
708 
709                         grp = &family->mcgrps[i];
710 
711                         nest = nla_nest_start(skb, i + 1);
712                         if (nest == NULL)
713                                 goto nla_put_failure;
714 
715                         if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID,
716                                         family->mcgrp_offset + i) ||
717                             nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
718                                            grp->name))
719                                 goto nla_put_failure;
720 
721                         nla_nest_end(skb, nest);
722                 }
723                 nla_nest_end(skb, nla_grps);
724         }
725 
726         genlmsg_end(skb, hdr);
727         return 0;
728 
729 nla_put_failure:
730         genlmsg_cancel(skb, hdr);
731         return -EMSGSIZE;
732 }
733 
734 static int ctrl_fill_mcgrp_info(const struct genl_family *family,
735                                 const struct genl_multicast_group *grp,
736                                 int grp_id, u32 portid, u32 seq, u32 flags,
737                                 struct sk_buff *skb, u8 cmd)
738 {
739         void *hdr;
740         struct nlattr *nla_grps;
741         struct nlattr *nest;
742 
743         hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
744         if (hdr == NULL)
745                 return -1;
746 
747         if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
748             nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id))
749                 goto nla_put_failure;
750 
751         nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
752         if (nla_grps == NULL)
753                 goto nla_put_failure;
754 
755         nest = nla_nest_start(skb, 1);
756         if (nest == NULL)
757                 goto nla_put_failure;
758 
759         if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) ||
760             nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
761                            grp->name))
762                 goto nla_put_failure;
763 
764         nla_nest_end(skb, nest);
765         nla_nest_end(skb, nla_grps);
766 
767         genlmsg_end(skb, hdr);
768         return 0;
769 
770 nla_put_failure:
771         genlmsg_cancel(skb, hdr);
772         return -EMSGSIZE;
773 }
774 
775 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
776 {
777         int n = 0;
778         struct genl_family *rt;
779         struct net *net = sock_net(skb->sk);
780         int fams_to_skip = cb->args[0];
781         unsigned int id;
782 
783         idr_for_each_entry(&genl_fam_idr, rt, id) {
784                 if (!rt->netnsok && !net_eq(net, &init_net))
785                         continue;
786 
787                 if (n++ < fams_to_skip)
788                         continue;
789 
790                 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
791                                    cb->nlh->nlmsg_seq, NLM_F_MULTI,
792                                    skb, CTRL_CMD_NEWFAMILY) < 0) {
793                         n--;
794                         break;
795                 }
796         }
797 
798         cb->args[0] = n;
799         return skb->len;
800 }
801 
802 static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family,
803                                              u32 portid, int seq, u8 cmd)
804 {
805         struct sk_buff *skb;
806         int err;
807 
808         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
809         if (skb == NULL)
810                 return ERR_PTR(-ENOBUFS);
811 
812         err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);
813         if (err < 0) {
814                 nlmsg_free(skb);
815                 return ERR_PTR(err);
816         }
817 
818         return skb;
819 }
820 
821 static struct sk_buff *
822 ctrl_build_mcgrp_msg(const struct genl_family *family,
823                      const struct genl_multicast_group *grp,
824                      int grp_id, u32 portid, int seq, u8 cmd)
825 {
826         struct sk_buff *skb;
827         int err;
828 
829         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
830         if (skb == NULL)
831                 return ERR_PTR(-ENOBUFS);
832 
833         err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid,
834                                    seq, 0, skb, cmd);
835         if (err < 0) {
836                 nlmsg_free(skb);
837                 return ERR_PTR(err);
838         }
839 
840         return skb;
841 }
842 
843 static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
844         [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
845         [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
846                                     .len = GENL_NAMSIZ - 1 },
847 };
848 
849 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
850 {
851         struct sk_buff *msg;
852         const struct genl_family *res = NULL;
853         int err = -EINVAL;
854 
855         if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
856                 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
857                 res = genl_family_find_byid(id);
858                 err = -ENOENT;
859         }
860 
861         if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
862                 char *name;
863 
864                 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
865                 res = genl_family_find_byname(name);
866 #ifdef CONFIG_MODULES
867                 if (res == NULL) {
868                         genl_unlock();
869                         up_read(&cb_lock);
870                         request_module("net-pf-%d-proto-%d-family-%s",
871                                        PF_NETLINK, NETLINK_GENERIC, name);
872                         down_read(&cb_lock);
873                         genl_lock();
874                         res = genl_family_find_byname(name);
875                 }
876 #endif
877                 err = -ENOENT;
878         }
879 
880         if (res == NULL)
881                 return err;
882 
883         if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) {
884                 /* family doesn't exist here */
885                 return -ENOENT;
886         }
887 
888         msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,
889                                     CTRL_CMD_NEWFAMILY);
890         if (IS_ERR(msg))
891                 return PTR_ERR(msg);
892 
893         return genlmsg_reply(msg, info);
894 }
895 
896 static int genl_ctrl_event(int event, const struct genl_family *family,
897                            const struct genl_multicast_group *grp,
898                            int grp_id)
899 {
900         struct sk_buff *msg;
901 
902         /* genl is still initialising */
903         if (!init_net.genl_sock)
904                 return 0;
905 
906         switch (event) {
907         case CTRL_CMD_NEWFAMILY:
908         case CTRL_CMD_DELFAMILY:
909                 WARN_ON(grp);
910                 msg = ctrl_build_family_msg(family, 0, 0, event);
911                 break;
912         case CTRL_CMD_NEWMCAST_GRP:
913         case CTRL_CMD_DELMCAST_GRP:
914                 BUG_ON(!grp);
915                 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event);
916                 break;
917         default:
918                 return -EINVAL;
919         }
920 
921         if (IS_ERR(msg))
922                 return PTR_ERR(msg);
923 
924         if (!family->netnsok) {
925                 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0,
926                                         0, GFP_KERNEL);
927         } else {
928                 rcu_read_lock();
929                 genlmsg_multicast_allns(&genl_ctrl, msg, 0,
930                                         0, GFP_ATOMIC);
931                 rcu_read_unlock();
932         }
933 
934         return 0;
935 }
936 
937 static const struct genl_ops genl_ctrl_ops[] = {
938         {
939                 .cmd            = CTRL_CMD_GETFAMILY,
940                 .doit           = ctrl_getfamily,
941                 .dumpit         = ctrl_dumpfamily,
942                 .policy         = ctrl_policy,
943         },
944 };
945 
946 static const struct genl_multicast_group genl_ctrl_groups[] = {
947         { .name = "notify", },
948 };
949 
950 static struct genl_family genl_ctrl __ro_after_init = {
951         .module = THIS_MODULE,
952         .ops = genl_ctrl_ops,
953         .n_ops = ARRAY_SIZE(genl_ctrl_ops),
954         .mcgrps = genl_ctrl_groups,
955         .n_mcgrps = ARRAY_SIZE(genl_ctrl_groups),
956         .id = GENL_ID_CTRL,
957         .name = "nlctrl",
958         .version = 0x2,
959         .maxattr = CTRL_ATTR_MAX,
960         .netnsok = true,
961 };
962 
963 static int genl_bind(struct net *net, int group)
964 {
965         struct genl_family *f;
966         int err = -ENOENT;
967         unsigned int id;
968 
969         down_read(&cb_lock);
970 
971         idr_for_each_entry(&genl_fam_idr, f, id) {
972                 if (group >= f->mcgrp_offset &&
973                     group < f->mcgrp_offset + f->n_mcgrps) {
974                         int fam_grp = group - f->mcgrp_offset;
975 
976                         if (!f->netnsok && net != &init_net)
977                                 err = -ENOENT;
978                         else if (f->mcast_bind)
979                                 err = f->mcast_bind(net, fam_grp);
980                         else
981                                 err = 0;
982                         break;
983                 }
984         }
985         up_read(&cb_lock);
986 
987         return err;
988 }
989 
990 static void genl_unbind(struct net *net, int group)
991 {
992         struct genl_family *f;
993         unsigned int id;
994 
995         down_read(&cb_lock);
996 
997         idr_for_each_entry(&genl_fam_idr, f, id) {
998                 if (group >= f->mcgrp_offset &&
999                     group < f->mcgrp_offset + f->n_mcgrps) {
1000                         int fam_grp = group - f->mcgrp_offset;
1001 
1002                         if (f->mcast_unbind)
1003                                 f->mcast_unbind(net, fam_grp);
1004                         break;
1005                 }
1006         }
1007         up_read(&cb_lock);
1008 }
1009 
1010 static int __net_init genl_pernet_init(struct net *net)
1011 {
1012         struct netlink_kernel_cfg cfg = {
1013                 .input          = genl_rcv,
1014                 .flags          = NL_CFG_F_NONROOT_RECV,
1015                 .bind           = genl_bind,
1016                 .unbind         = genl_unbind,
1017         };
1018 
1019         /* we'll bump the group number right afterwards */
1020         net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);
1021 
1022         if (!net->genl_sock && net_eq(net, &init_net))
1023                 panic("GENL: Cannot initialize generic netlink\n");
1024 
1025         if (!net->genl_sock)
1026                 return -ENOMEM;
1027 
1028         return 0;
1029 }
1030 
1031 static void __net_exit genl_pernet_exit(struct net *net)
1032 {
1033         netlink_kernel_release(net->genl_sock);
1034         net->genl_sock = NULL;
1035 }
1036 
1037 static struct pernet_operations genl_pernet_ops = {
1038         .init = genl_pernet_init,
1039         .exit = genl_pernet_exit,
1040 };
1041 
1042 static int __init genl_init(void)
1043 {
1044         int err;
1045 
1046         err = genl_register_family(&genl_ctrl);
1047         if (err < 0)
1048                 goto problem;
1049 
1050         err = register_pernet_subsys(&genl_pernet_ops);
1051         if (err)
1052                 goto problem;
1053 
1054         return 0;
1055 
1056 problem:
1057         panic("GENL: Cannot register controller: %d\n", err);
1058 }
1059 
1060 subsys_initcall(genl_init);
1061 
1062 /**
1063  * genl_family_attrbuf - return family's attrbuf
1064  * @family: the family
1065  *
1066  * Return the family's attrbuf, while validating that it's
1067  * actually valid to access it.
1068  *
1069  * You cannot use this function with a family that has parallel_ops
1070  * and you can only use it within (pre/post) doit/dumpit callbacks.
1071  */
1072 struct nlattr **genl_family_attrbuf(const struct genl_family *family)
1073 {
1074         if (!WARN_ON(family->parallel_ops))
1075                 lockdep_assert_held(&genl_mutex);
1076 
1077         return family->attrbuf;
1078 }
1079 EXPORT_SYMBOL(genl_family_attrbuf);
1080 
1081 static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
1082                          gfp_t flags)
1083 {
1084         struct sk_buff *tmp;
1085         struct net *net, *prev = NULL;
1086         bool delivered = false;
1087         int err;
1088 
1089         for_each_net_rcu(net) {
1090                 if (prev) {
1091                         tmp = skb_clone(skb, flags);
1092                         if (!tmp) {
1093                                 err = -ENOMEM;
1094                                 goto error;
1095                         }
1096                         err = nlmsg_multicast(prev->genl_sock, tmp,
1097                                               portid, group, flags);
1098                         if (!err)
1099                                 delivered = true;
1100                         else if (err != -ESRCH)
1101                                 goto error;
1102                 }
1103 
1104                 prev = net;
1105         }
1106 
1107         err = nlmsg_multicast(prev->genl_sock, skb, portid, group, flags);
1108         if (!err)
1109                 delivered = true;
1110         else if (err != -ESRCH)
1111                 return err;
1112         return delivered ? 0 : -ESRCH;
1113  error:
1114         kfree_skb(skb);
1115         return err;
1116 }
1117 
1118 int genlmsg_multicast_allns(const struct genl_family *family,
1119                             struct sk_buff *skb, u32 portid,
1120                             unsigned int group, gfp_t flags)
1121 {
1122         if (WARN_ON_ONCE(group >= family->n_mcgrps))
1123                 return -EINVAL;
1124         group = family->mcgrp_offset + group;
1125         return genlmsg_mcast(skb, portid, group, flags);
1126 }
1127 EXPORT_SYMBOL(genlmsg_multicast_allns);
1128 
1129 void genl_notify(const struct genl_family *family, struct sk_buff *skb,
1130                  struct genl_info *info, u32 group, gfp_t flags)
1131 {
1132         struct net *net = genl_info_net(info);
1133         struct sock *sk = net->genl_sock;
1134         int report = 0;
1135 
1136         if (info->nlhdr)
1137                 report = nlmsg_report(info->nlhdr);
1138 
1139         if (WARN_ON_ONCE(group >= family->n_mcgrps))
1140                 return;
1141         group = family->mcgrp_offset + group;
1142         nlmsg_notify(sk, skb, info->snd_portid, group, report, flags);
1143 }
1144 EXPORT_SYMBOL(genl_notify);
1145 

~ [ 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