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

TOMOYO Linux Cross Reference
Linux/net/netlink/genetlink.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
  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         family->id = idr_alloc_cyclic(&genl_fam_idr, family,
355                                       start, end + 1, GFP_KERNEL);
356         if (family->id < 0) {
357                 err = family->id;
358                 goto errout_locked;
359         }
360 
361         err = genl_validate_assign_mc_groups(family);
362         if (err)
363                 goto errout_remove;
364 
365         genl_unlock_all();
366 
367         /* send all events */
368         genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0);
369         for (i = 0; i < family->n_mcgrps; i++)
370                 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family,
371                                 &family->mcgrps[i], family->mcgrp_offset + i);
372 
373         return 0;
374 
375 errout_remove:
376         idr_remove(&genl_fam_idr, family->id);
377 errout_locked:
378         genl_unlock_all();
379         return err;
380 }
381 EXPORT_SYMBOL(genl_register_family);
382 
383 /**
384  * genl_unregister_family - unregister generic netlink family
385  * @family: generic netlink family
386  *
387  * Unregisters the specified family.
388  *
389  * Returns 0 on success or a negative error code.
390  */
391 int genl_unregister_family(const struct genl_family *family)
392 {
393         genl_lock_all();
394 
395         if (!genl_family_find_byid(family->id)) {
396                 genl_unlock_all();
397                 return -ENOENT;
398         }
399 
400         genl_unregister_mc_groups(family);
401 
402         idr_remove(&genl_fam_idr, family->id);
403 
404         up_write(&cb_lock);
405         wait_event(genl_sk_destructing_waitq,
406                    atomic_read(&genl_sk_destructing_cnt) == 0);
407         genl_unlock();
408 
409         genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0);
410 
411         return 0;
412 }
413 EXPORT_SYMBOL(genl_unregister_family);
414 
415 /**
416  * genlmsg_put - Add generic netlink header to netlink message
417  * @skb: socket buffer holding the message
418  * @portid: netlink portid the message is addressed to
419  * @seq: sequence number (usually the one of the sender)
420  * @family: generic netlink family
421  * @flags: netlink message flags
422  * @cmd: generic netlink command
423  *
424  * Returns pointer to user specific header
425  */
426 void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
427                   const struct genl_family *family, int flags, u8 cmd)
428 {
429         struct nlmsghdr *nlh;
430         struct genlmsghdr *hdr;
431 
432         nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +
433                         family->hdrsize, flags);
434         if (nlh == NULL)
435                 return NULL;
436 
437         hdr = nlmsg_data(nlh);
438         hdr->cmd = cmd;
439         hdr->version = family->version;
440         hdr->reserved = 0;
441 
442         return (char *) hdr + GENL_HDRLEN;
443 }
444 EXPORT_SYMBOL(genlmsg_put);
445 
446 static struct genl_dumpit_info *genl_dumpit_info_alloc(void)
447 {
448         return kmalloc(sizeof(struct genl_dumpit_info), GFP_KERNEL);
449 }
450 
451 static void genl_dumpit_info_free(const struct genl_dumpit_info *info)
452 {
453         kfree(info);
454 }
455 
456 static struct nlattr **
457 genl_family_rcv_msg_attrs_parse(const struct genl_family *family,
458                                 struct nlmsghdr *nlh,
459                                 struct netlink_ext_ack *extack,
460                                 const struct genl_ops *ops,
461                                 int hdrlen,
462                                 enum genl_validate_flags no_strict_flag)
463 {
464         enum netlink_validation validate = ops->validate & no_strict_flag ?
465                                            NL_VALIDATE_LIBERAL :
466                                            NL_VALIDATE_STRICT;
467         struct nlattr **attrbuf;
468         int err;
469 
470         if (!family->maxattr)
471                 return NULL;
472 
473         attrbuf = kmalloc_array(family->maxattr + 1,
474                                 sizeof(struct nlattr *), GFP_KERNEL);
475         if (!attrbuf)
476                 return ERR_PTR(-ENOMEM);
477 
478         err = __nlmsg_parse(nlh, hdrlen, attrbuf, family->maxattr,
479                             family->policy, validate, extack);
480         if (err) {
481                 kfree(attrbuf);
482                 return ERR_PTR(err);
483         }
484         return attrbuf;
485 }
486 
487 static void genl_family_rcv_msg_attrs_free(struct nlattr **attrbuf)
488 {
489         kfree(attrbuf);
490 }
491 
492 struct genl_start_context {
493         const struct genl_family *family;
494         struct nlmsghdr *nlh;
495         struct netlink_ext_ack *extack;
496         const struct genl_ops *ops;
497         int hdrlen;
498 };
499 
500 static int genl_start(struct netlink_callback *cb)
501 {
502         struct genl_start_context *ctx = cb->data;
503         const struct genl_ops *ops = ctx->ops;
504         struct genl_dumpit_info *info;
505         struct nlattr **attrs = NULL;
506         int rc = 0;
507 
508         if (ops->validate & GENL_DONT_VALIDATE_DUMP)
509                 goto no_attrs;
510 
511         if (ctx->nlh->nlmsg_len < nlmsg_msg_size(ctx->hdrlen))
512                 return -EINVAL;
513 
514         attrs = genl_family_rcv_msg_attrs_parse(ctx->family, ctx->nlh, ctx->extack,
515                                                 ops, ctx->hdrlen,
516                                                 GENL_DONT_VALIDATE_DUMP_STRICT);
517         if (IS_ERR(attrs))
518                 return PTR_ERR(attrs);
519 
520 no_attrs:
521         info = genl_dumpit_info_alloc();
522         if (!info) {
523                 genl_family_rcv_msg_attrs_free(attrs);
524                 return -ENOMEM;
525         }
526         info->family = ctx->family;
527         info->ops = ops;
528         info->attrs = attrs;
529 
530         cb->data = info;
531         if (ops->start) {
532                 if (!ctx->family->parallel_ops)
533                         genl_lock();
534                 rc = ops->start(cb);
535                 if (!ctx->family->parallel_ops)
536                         genl_unlock();
537         }
538 
539         if (rc) {
540                 genl_family_rcv_msg_attrs_free(info->attrs);
541                 genl_dumpit_info_free(info);
542                 cb->data = NULL;
543         }
544         return rc;
545 }
546 
547 static int genl_lock_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
548 {
549         const struct genl_ops *ops = genl_dumpit_info(cb)->ops;
550         int rc;
551 
552         genl_lock();
553         rc = ops->dumpit(skb, cb);
554         genl_unlock();
555         return rc;
556 }
557 
558 static int genl_lock_done(struct netlink_callback *cb)
559 {
560         const struct genl_dumpit_info *info = genl_dumpit_info(cb);
561         const struct genl_ops *ops = info->ops;
562         int rc = 0;
563 
564         if (ops->done) {
565                 genl_lock();
566                 rc = ops->done(cb);
567                 genl_unlock();
568         }
569         genl_family_rcv_msg_attrs_free(info->attrs);
570         genl_dumpit_info_free(info);
571         return rc;
572 }
573 
574 static int genl_parallel_done(struct netlink_callback *cb)
575 {
576         const struct genl_dumpit_info *info = genl_dumpit_info(cb);
577         const struct genl_ops *ops = info->ops;
578         int rc = 0;
579 
580         if (ops->done)
581                 rc = ops->done(cb);
582         genl_family_rcv_msg_attrs_free(info->attrs);
583         genl_dumpit_info_free(info);
584         return rc;
585 }
586 
587 static int genl_family_rcv_msg_dumpit(const struct genl_family *family,
588                                       struct sk_buff *skb,
589                                       struct nlmsghdr *nlh,
590                                       struct netlink_ext_ack *extack,
591                                       const struct genl_ops *ops,
592                                       int hdrlen, struct net *net)
593 {
594         struct genl_start_context ctx;
595         int err;
596 
597         if (!ops->dumpit)
598                 return -EOPNOTSUPP;
599 
600         ctx.family = family;
601         ctx.nlh = nlh;
602         ctx.extack = extack;
603         ctx.ops = ops;
604         ctx.hdrlen = hdrlen;
605 
606         if (!family->parallel_ops) {
607                 struct netlink_dump_control c = {
608                         .module = family->module,
609                         .data = &ctx,
610                         .start = genl_start,
611                         .dump = genl_lock_dumpit,
612                         .done = genl_lock_done,
613                 };
614 
615                 genl_unlock();
616                 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
617                 genl_lock();
618         } else {
619                 struct netlink_dump_control c = {
620                         .module = family->module,
621                         .data = &ctx,
622                         .start = genl_start,
623                         .dump = ops->dumpit,
624                         .done = genl_parallel_done,
625                 };
626 
627                 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
628         }
629 
630         return err;
631 }
632 
633 static int genl_family_rcv_msg_doit(const struct genl_family *family,
634                                     struct sk_buff *skb,
635                                     struct nlmsghdr *nlh,
636                                     struct netlink_ext_ack *extack,
637                                     const struct genl_ops *ops,
638                                     int hdrlen, struct net *net)
639 {
640         struct nlattr **attrbuf;
641         struct genl_info info;
642         int err;
643 
644         if (!ops->doit)
645                 return -EOPNOTSUPP;
646 
647         attrbuf = genl_family_rcv_msg_attrs_parse(family, nlh, extack,
648                                                   ops, hdrlen,
649                                                   GENL_DONT_VALIDATE_STRICT);
650         if (IS_ERR(attrbuf))
651                 return PTR_ERR(attrbuf);
652 
653         info.snd_seq = nlh->nlmsg_seq;
654         info.snd_portid = NETLINK_CB(skb).portid;
655         info.nlhdr = nlh;
656         info.genlhdr = nlmsg_data(nlh);
657         info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
658         info.attrs = attrbuf;
659         info.extack = extack;
660         genl_info_net_set(&info, net);
661         memset(&info.user_ptr, 0, sizeof(info.user_ptr));
662 
663         if (family->pre_doit) {
664                 err = family->pre_doit(ops, skb, &info);
665                 if (err)
666                         goto out;
667         }
668 
669         err = ops->doit(skb, &info);
670 
671         if (family->post_doit)
672                 family->post_doit(ops, skb, &info);
673 
674 out:
675         genl_family_rcv_msg_attrs_free(attrbuf);
676 
677         return err;
678 }
679 
680 static int genl_family_rcv_msg(const struct genl_family *family,
681                                struct sk_buff *skb,
682                                struct nlmsghdr *nlh,
683                                struct netlink_ext_ack *extack)
684 {
685         const struct genl_ops *ops;
686         struct net *net = sock_net(skb->sk);
687         struct genlmsghdr *hdr = nlmsg_data(nlh);
688         int hdrlen;
689 
690         /* this family doesn't exist in this netns */
691         if (!family->netnsok && !net_eq(net, &init_net))
692                 return -ENOENT;
693 
694         hdrlen = GENL_HDRLEN + family->hdrsize;
695         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
696                 return -EINVAL;
697 
698         ops = genl_get_cmd(hdr->cmd, family);
699         if (ops == NULL)
700                 return -EOPNOTSUPP;
701 
702         if ((ops->flags & GENL_ADMIN_PERM) &&
703             !netlink_capable(skb, CAP_NET_ADMIN))
704                 return -EPERM;
705 
706         if ((ops->flags & GENL_UNS_ADMIN_PERM) &&
707             !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
708                 return -EPERM;
709 
710         if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP)
711                 return genl_family_rcv_msg_dumpit(family, skb, nlh, extack,
712                                                   ops, hdrlen, net);
713         else
714                 return genl_family_rcv_msg_doit(family, skb, nlh, extack,
715                                                 ops, hdrlen, net);
716 }
717 
718 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
719                         struct netlink_ext_ack *extack)
720 {
721         const struct genl_family *family;
722         int err;
723 
724         family = genl_family_find_byid(nlh->nlmsg_type);
725         if (family == NULL)
726                 return -ENOENT;
727 
728         if (!family->parallel_ops)
729                 genl_lock();
730 
731         err = genl_family_rcv_msg(family, skb, nlh, extack);
732 
733         if (!family->parallel_ops)
734                 genl_unlock();
735 
736         return err;
737 }
738 
739 static void genl_rcv(struct sk_buff *skb)
740 {
741         down_read(&cb_lock);
742         netlink_rcv_skb(skb, &genl_rcv_msg);
743         up_read(&cb_lock);
744 }
745 
746 /**************************************************************************
747  * Controller
748  **************************************************************************/
749 
750 static struct genl_family genl_ctrl;
751 
752 static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq,
753                           u32 flags, struct sk_buff *skb, u8 cmd)
754 {
755         void *hdr;
756 
757         hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
758         if (hdr == NULL)
759                 return -1;
760 
761         if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
762             nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
763             nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
764             nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
765             nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
766                 goto nla_put_failure;
767 
768         if (family->n_ops) {
769                 struct nlattr *nla_ops;
770                 int i;
771 
772                 nla_ops = nla_nest_start_noflag(skb, CTRL_ATTR_OPS);
773                 if (nla_ops == NULL)
774                         goto nla_put_failure;
775 
776                 for (i = 0; i < family->n_ops; i++) {
777                         struct nlattr *nest;
778                         const struct genl_ops *ops = &family->ops[i];
779                         u32 op_flags = ops->flags;
780 
781                         if (ops->dumpit)
782                                 op_flags |= GENL_CMD_CAP_DUMP;
783                         if (ops->doit)
784                                 op_flags |= GENL_CMD_CAP_DO;
785                         if (family->policy)
786                                 op_flags |= GENL_CMD_CAP_HASPOL;
787 
788                         nest = nla_nest_start_noflag(skb, i + 1);
789                         if (nest == NULL)
790                                 goto nla_put_failure;
791 
792                         if (nla_put_u32(skb, CTRL_ATTR_OP_ID, ops->cmd) ||
793                             nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags))
794                                 goto nla_put_failure;
795 
796                         nla_nest_end(skb, nest);
797                 }
798 
799                 nla_nest_end(skb, nla_ops);
800         }
801 
802         if (family->n_mcgrps) {
803                 struct nlattr *nla_grps;
804                 int i;
805 
806                 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
807                 if (nla_grps == NULL)
808                         goto nla_put_failure;
809 
810                 for (i = 0; i < family->n_mcgrps; i++) {
811                         struct nlattr *nest;
812                         const struct genl_multicast_group *grp;
813 
814                         grp = &family->mcgrps[i];
815 
816                         nest = nla_nest_start_noflag(skb, i + 1);
817                         if (nest == NULL)
818                                 goto nla_put_failure;
819 
820                         if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID,
821                                         family->mcgrp_offset + i) ||
822                             nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
823                                            grp->name))
824                                 goto nla_put_failure;
825 
826                         nla_nest_end(skb, nest);
827                 }
828                 nla_nest_end(skb, nla_grps);
829         }
830 
831         genlmsg_end(skb, hdr);
832         return 0;
833 
834 nla_put_failure:
835         genlmsg_cancel(skb, hdr);
836         return -EMSGSIZE;
837 }
838 
839 static int ctrl_fill_mcgrp_info(const struct genl_family *family,
840                                 const struct genl_multicast_group *grp,
841                                 int grp_id, u32 portid, u32 seq, u32 flags,
842                                 struct sk_buff *skb, u8 cmd)
843 {
844         void *hdr;
845         struct nlattr *nla_grps;
846         struct nlattr *nest;
847 
848         hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
849         if (hdr == NULL)
850                 return -1;
851 
852         if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
853             nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id))
854                 goto nla_put_failure;
855 
856         nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
857         if (nla_grps == NULL)
858                 goto nla_put_failure;
859 
860         nest = nla_nest_start_noflag(skb, 1);
861         if (nest == NULL)
862                 goto nla_put_failure;
863 
864         if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) ||
865             nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
866                            grp->name))
867                 goto nla_put_failure;
868 
869         nla_nest_end(skb, nest);
870         nla_nest_end(skb, nla_grps);
871 
872         genlmsg_end(skb, hdr);
873         return 0;
874 
875 nla_put_failure:
876         genlmsg_cancel(skb, hdr);
877         return -EMSGSIZE;
878 }
879 
880 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
881 {
882         int n = 0;
883         struct genl_family *rt;
884         struct net *net = sock_net(skb->sk);
885         int fams_to_skip = cb->args[0];
886         unsigned int id;
887 
888         idr_for_each_entry(&genl_fam_idr, rt, id) {
889                 if (!rt->netnsok && !net_eq(net, &init_net))
890                         continue;
891 
892                 if (n++ < fams_to_skip)
893                         continue;
894 
895                 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
896                                    cb->nlh->nlmsg_seq, NLM_F_MULTI,
897                                    skb, CTRL_CMD_NEWFAMILY) < 0) {
898                         n--;
899                         break;
900                 }
901         }
902 
903         cb->args[0] = n;
904         return skb->len;
905 }
906 
907 static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family,
908                                              u32 portid, int seq, u8 cmd)
909 {
910         struct sk_buff *skb;
911         int err;
912 
913         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
914         if (skb == NULL)
915                 return ERR_PTR(-ENOBUFS);
916 
917         err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);
918         if (err < 0) {
919                 nlmsg_free(skb);
920                 return ERR_PTR(err);
921         }
922 
923         return skb;
924 }
925 
926 static struct sk_buff *
927 ctrl_build_mcgrp_msg(const struct genl_family *family,
928                      const struct genl_multicast_group *grp,
929                      int grp_id, u32 portid, int seq, u8 cmd)
930 {
931         struct sk_buff *skb;
932         int err;
933 
934         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
935         if (skb == NULL)
936                 return ERR_PTR(-ENOBUFS);
937 
938         err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid,
939                                    seq, 0, skb, cmd);
940         if (err < 0) {
941                 nlmsg_free(skb);
942                 return ERR_PTR(err);
943         }
944 
945         return skb;
946 }
947 
948 static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
949         [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
950         [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
951                                     .len = GENL_NAMSIZ - 1 },
952 };
953 
954 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
955 {
956         struct sk_buff *msg;
957         const struct genl_family *res = NULL;
958         int err = -EINVAL;
959 
960         if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
961                 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
962                 res = genl_family_find_byid(id);
963                 err = -ENOENT;
964         }
965 
966         if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
967                 char *name;
968 
969                 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
970                 res = genl_family_find_byname(name);
971 #ifdef CONFIG_MODULES
972                 if (res == NULL) {
973                         genl_unlock();
974                         up_read(&cb_lock);
975                         request_module("net-pf-%d-proto-%d-family-%s",
976                                        PF_NETLINK, NETLINK_GENERIC, name);
977                         down_read(&cb_lock);
978                         genl_lock();
979                         res = genl_family_find_byname(name);
980                 }
981 #endif
982                 err = -ENOENT;
983         }
984 
985         if (res == NULL)
986                 return err;
987 
988         if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) {
989                 /* family doesn't exist here */
990                 return -ENOENT;
991         }
992 
993         msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,
994                                     CTRL_CMD_NEWFAMILY);
995         if (IS_ERR(msg))
996                 return PTR_ERR(msg);
997 
998         return genlmsg_reply(msg, info);
999 }
1000 
1001 static int genl_ctrl_event(int event, const struct genl_family *family,
1002                            const struct genl_multicast_group *grp,
1003                            int grp_id)
1004 {
1005         struct sk_buff *msg;
1006 
1007         /* genl is still initialising */
1008         if (!init_net.genl_sock)
1009                 return 0;
1010 
1011         switch (event) {
1012         case CTRL_CMD_NEWFAMILY:
1013         case CTRL_CMD_DELFAMILY:
1014                 WARN_ON(grp);
1015                 msg = ctrl_build_family_msg(family, 0, 0, event);
1016                 break;
1017         case CTRL_CMD_NEWMCAST_GRP:
1018         case CTRL_CMD_DELMCAST_GRP:
1019                 BUG_ON(!grp);
1020                 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event);
1021                 break;
1022         default:
1023                 return -EINVAL;
1024         }
1025 
1026         if (IS_ERR(msg))
1027                 return PTR_ERR(msg);
1028 
1029         if (!family->netnsok) {
1030                 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0,
1031                                         0, GFP_KERNEL);
1032         } else {
1033                 rcu_read_lock();
1034                 genlmsg_multicast_allns(&genl_ctrl, msg, 0,
1035                                         0, GFP_ATOMIC);
1036                 rcu_read_unlock();
1037         }
1038 
1039         return 0;
1040 }
1041 
1042 static int ctrl_dumppolicy(struct sk_buff *skb, struct netlink_callback *cb)
1043 {
1044         const struct genl_family *rt;
1045         unsigned int fam_id = cb->args[0];
1046         int err;
1047 
1048         if (!fam_id) {
1049                 struct nlattr *tb[CTRL_ATTR_MAX + 1];
1050 
1051                 err = genlmsg_parse(cb->nlh, &genl_ctrl, tb,
1052                                     genl_ctrl.maxattr,
1053                                     genl_ctrl.policy, cb->extack);
1054                 if (err)
1055                         return err;
1056 
1057                 if (!tb[CTRL_ATTR_FAMILY_ID] && !tb[CTRL_ATTR_FAMILY_NAME])
1058                         return -EINVAL;
1059 
1060                 if (tb[CTRL_ATTR_FAMILY_ID]) {
1061                         fam_id = nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]);
1062                 } else {
1063                         rt = genl_family_find_byname(
1064                                 nla_data(tb[CTRL_ATTR_FAMILY_NAME]));
1065                         if (!rt)
1066                                 return -ENOENT;
1067                         fam_id = rt->id;
1068                 }
1069         }
1070 
1071         rt = genl_family_find_byid(fam_id);
1072         if (!rt)
1073                 return -ENOENT;
1074 
1075         if (!rt->policy)
1076                 return -ENODATA;
1077 
1078         err = netlink_policy_dump_start(rt->policy, rt->maxattr, &cb->args[1]);
1079         if (err)
1080                 return err;
1081 
1082         while (netlink_policy_dump_loop(cb->args[1])) {
1083                 void *hdr;
1084                 struct nlattr *nest;
1085 
1086                 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
1087                                   cb->nlh->nlmsg_seq, &genl_ctrl,
1088                                   NLM_F_MULTI, CTRL_CMD_GETPOLICY);
1089                 if (!hdr)
1090                         goto nla_put_failure;
1091 
1092                 if (nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, rt->id))
1093                         goto nla_put_failure;
1094 
1095                 nest = nla_nest_start(skb, CTRL_ATTR_POLICY);
1096                 if (!nest)
1097                         goto nla_put_failure;
1098 
1099                 if (netlink_policy_dump_write(skb, cb->args[1]))
1100                         goto nla_put_failure;
1101 
1102                 nla_nest_end(skb, nest);
1103 
1104                 genlmsg_end(skb, hdr);
1105                 continue;
1106 
1107 nla_put_failure:
1108                 genlmsg_cancel(skb, hdr);
1109                 break;
1110         }
1111 
1112         cb->args[0] = fam_id;
1113         return skb->len;
1114 }
1115 
1116 static int ctrl_dumppolicy_done(struct netlink_callback *cb)
1117 {
1118         netlink_policy_dump_free(cb->args[1]);
1119         return 0;
1120 }
1121 
1122 static const struct genl_ops genl_ctrl_ops[] = {
1123         {
1124                 .cmd            = CTRL_CMD_GETFAMILY,
1125                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1126                 .doit           = ctrl_getfamily,
1127                 .dumpit         = ctrl_dumpfamily,
1128         },
1129         {
1130                 .cmd            = CTRL_CMD_GETPOLICY,
1131                 .dumpit         = ctrl_dumppolicy,
1132                 .done           = ctrl_dumppolicy_done,
1133         },
1134 };
1135 
1136 static const struct genl_multicast_group genl_ctrl_groups[] = {
1137         { .name = "notify", },
1138 };
1139 
1140 static struct genl_family genl_ctrl __ro_after_init = {
1141         .module = THIS_MODULE,
1142         .ops = genl_ctrl_ops,
1143         .n_ops = ARRAY_SIZE(genl_ctrl_ops),
1144         .mcgrps = genl_ctrl_groups,
1145         .n_mcgrps = ARRAY_SIZE(genl_ctrl_groups),
1146         .id = GENL_ID_CTRL,
1147         .name = "nlctrl",
1148         .version = 0x2,
1149         .maxattr = CTRL_ATTR_MAX,
1150         .policy = ctrl_policy,
1151         .netnsok = true,
1152 };
1153 
1154 static int __net_init genl_pernet_init(struct net *net)
1155 {
1156         struct netlink_kernel_cfg cfg = {
1157                 .input          = genl_rcv,
1158                 .flags          = NL_CFG_F_NONROOT_RECV,
1159         };
1160 
1161         /* we'll bump the group number right afterwards */
1162         net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);
1163 
1164         if (!net->genl_sock && net_eq(net, &init_net))
1165                 panic("GENL: Cannot initialize generic netlink\n");
1166 
1167         if (!net->genl_sock)
1168                 return -ENOMEM;
1169 
1170         return 0;
1171 }
1172 
1173 static void __net_exit genl_pernet_exit(struct net *net)
1174 {
1175         netlink_kernel_release(net->genl_sock);
1176         net->genl_sock = NULL;
1177 }
1178 
1179 static struct pernet_operations genl_pernet_ops = {
1180         .init = genl_pernet_init,
1181         .exit = genl_pernet_exit,
1182 };
1183 
1184 static int __init genl_init(void)
1185 {
1186         int err;
1187 
1188         err = genl_register_family(&genl_ctrl);
1189         if (err < 0)
1190                 goto problem;
1191 
1192         err = register_pernet_subsys(&genl_pernet_ops);
1193         if (err)
1194                 goto problem;
1195 
1196         return 0;
1197 
1198 problem:
1199         panic("GENL: Cannot register controller: %d\n", err);
1200 }
1201 
1202 core_initcall(genl_init);
1203 
1204 static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
1205                          gfp_t flags)
1206 {
1207         struct sk_buff *tmp;
1208         struct net *net, *prev = NULL;
1209         bool delivered = false;
1210         int err;
1211 
1212         for_each_net_rcu(net) {
1213                 if (prev) {
1214                         tmp = skb_clone(skb, flags);
1215                         if (!tmp) {
1216                                 err = -ENOMEM;
1217                                 goto error;
1218                         }
1219                         err = nlmsg_multicast(prev->genl_sock, tmp,
1220                                               portid, group, flags);
1221                         if (!err)
1222                                 delivered = true;
1223                         else if (err != -ESRCH)
1224                                 goto error;
1225                 }
1226 
1227                 prev = net;
1228         }
1229 
1230         err = nlmsg_multicast(prev->genl_sock, skb, portid, group, flags);
1231         if (!err)
1232                 delivered = true;
1233         else if (err != -ESRCH)
1234                 return err;
1235         return delivered ? 0 : -ESRCH;
1236  error:
1237         kfree_skb(skb);
1238         return err;
1239 }
1240 
1241 int genlmsg_multicast_allns(const struct genl_family *family,
1242                             struct sk_buff *skb, u32 portid,
1243                             unsigned int group, gfp_t flags)
1244 {
1245         if (WARN_ON_ONCE(group >= family->n_mcgrps))
1246                 return -EINVAL;
1247         group = family->mcgrp_offset + group;
1248         return genlmsg_mcast(skb, portid, group, flags);
1249 }
1250 EXPORT_SYMBOL(genlmsg_multicast_allns);
1251 
1252 void genl_notify(const struct genl_family *family, struct sk_buff *skb,
1253                  struct genl_info *info, u32 group, gfp_t flags)
1254 {
1255         struct net *net = genl_info_net(info);
1256         struct sock *sk = net->genl_sock;
1257         int report = 0;
1258 
1259         if (info->nlhdr)
1260                 report = nlmsg_report(info->nlhdr);
1261 
1262         if (WARN_ON_ONCE(group >= family->n_mcgrps))
1263                 return;
1264         group = family->mcgrp_offset + group;
1265         nlmsg_notify(sk, skb, info->snd_portid, group, report, flags);
1266 }
1267 EXPORT_SYMBOL(genl_notify);
1268 

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