projects/linux·blob master · refs

2013 lines · 45.3 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * NETLINK Generic Netlink Family
4 *
5 * Authors: Jamal Hadi Salim
6 * Thomas Graf <[email protected]>
7 * Johannes Berg <[email protected]>
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_helpers.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#include "genetlink.h"
26
27static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
28static DECLARE_RWSEM(cb_lock);
29
30atomic_t genl_sk_destructing_cnt = ATOMIC_INIT(0);
31DECLARE_WAIT_QUEUE_HEAD(genl_sk_destructing_waitq);
32
33void genl_lock(void)
34{
35 mutex_lock(&genl_mutex);
36}
37EXPORT_SYMBOL(genl_lock);
38
39void genl_unlock(void)
40{
41 mutex_unlock(&genl_mutex);
42}
43EXPORT_SYMBOL(genl_unlock);
44
45static void genl_lock_all(void)
46{
47 down_write(&cb_lock);
48 genl_lock();
49}
50
51static void genl_unlock_all(void)
52{
53 genl_unlock();
54 up_write(&cb_lock);
55}
56
57static void genl_op_lock(const struct genl_family *family)
58{
59 if (!family->parallel_ops)
60 genl_lock();
61}
62
63static void genl_op_unlock(const struct genl_family *family)
64{
65 if (!family->parallel_ops)
66 genl_unlock();
67}
68
69static DEFINE_IDR(genl_fam_idr);
70
71/*
72 * Bitmap of multicast groups that are currently in use.
73 *
74 * To avoid an allocation at boot of just one unsigned long,
75 * declare it global instead.
76 * Bit 0 is marked as already used since group 0 is invalid.
77 * Bit 1 is marked as already used since the drop-monitor code
78 * abuses the API and thinks it can statically use group 1.
79 * That group will typically conflict with other groups that
80 * any proper users use.
81 * Bit 16 is marked as used since it's used for generic netlink
82 * and the code no longer marks pre-reserved IDs as used.
83 * Bit 17 is marked as already used since the VFS quota code
84 * also abused this API and relied on family == group ID, we
85 * cater to that by giving it a static family and group ID.
86 * Bit 18 is marked as already used since the PMCRAID driver
87 * did the same thing as the VFS quota code (maybe copied?)
88 */
89static unsigned long mc_group_start = 0x3 | BIT(GENL_ID_CTRL) |
90 BIT(GENL_ID_VFS_DQUOT) |
91 BIT(GENL_ID_PMCRAID);
92static unsigned long *mc_groups = &mc_group_start;
93static unsigned long mc_groups_longs = 1;
94
95static struct nla_policy genl_policy_reject_all[] = {
96 { .type = NLA_REJECT },
97};
98
99static int genl_ctrl_event(int event, const struct genl_family *family,
100 const struct genl_multicast_group *grp,
101 int grp_id);
102
103static void
104genl_op_fill_in_reject_policy(const struct genl_family *family,
105 struct genl_ops *op)
106{
107 if (op->policy || op->cmd < family->resv_start_op)
108 return;
109
110 op->policy = genl_policy_reject_all;
111}
112
113static void
114genl_op_fill_in_reject_policy_split(const struct genl_family *family,
115 struct genl_split_ops *op)
116{
117 if (op->policy)
118 return;
119
120 op->policy = genl_policy_reject_all;
121}
122
123static const struct genl_family *genl_family_find_byid(unsigned int id)
124{
125 return idr_find(&genl_fam_idr, id);
126}
127
128static const struct genl_family *genl_family_find_byname(char *name)
129{
130 const struct genl_family *family;
131 unsigned int id;
132
133 idr_for_each_entry(&genl_fam_idr, family, id)
134 if (strcmp(family->name, name) == 0)
135 return family;
136
137 return NULL;
138}
139
140struct genl_op_iter {
141 const struct genl_family *family;
142 struct genl_split_ops doit;
143 struct genl_split_ops dumpit;
144 int cmd_idx;
145 int entry_idx;
146 u32 cmd;
147 u8 flags;
148};
149
150static void genl_op_from_full(const struct genl_family *family,
151 unsigned int i, struct genl_ops *op)
152{
153 *op = family->ops[i];
154
155 if (!op->maxattr)
156 op->maxattr = family->maxattr;
157 if (!op->policy)
158 op->policy = family->policy;
159
160 genl_op_fill_in_reject_policy(family, op);
161}
162
163static int genl_get_cmd_full(u32 cmd, const struct genl_family *family,
164 struct genl_ops *op)
165{
166 int i;
167
168 for (i = 0; i < family->n_ops; i++)
169 if (family->ops[i].cmd == cmd) {
170 genl_op_from_full(family, i, op);
171 return 0;
172 }
173
174 return -ENOENT;
175}
176
177static void genl_op_from_small(const struct genl_family *family,
178 unsigned int i, struct genl_ops *op)
179{
180 memset(op, 0, sizeof(*op));
181 op->doit = family->small_ops[i].doit;
182 op->dumpit = family->small_ops[i].dumpit;
183 op->cmd = family->small_ops[i].cmd;
184 op->internal_flags = family->small_ops[i].internal_flags;
185 op->flags = family->small_ops[i].flags;
186 op->validate = family->small_ops[i].validate;
187
188 op->maxattr = family->maxattr;
189 op->policy = family->policy;
190
191 genl_op_fill_in_reject_policy(family, op);
192}
193
194static int genl_get_cmd_small(u32 cmd, const struct genl_family *family,
195 struct genl_ops *op)
196{
197 int i;
198
199 for (i = 0; i < family->n_small_ops; i++)
200 if (family->small_ops[i].cmd == cmd) {
201 genl_op_from_small(family, i, op);
202 return 0;
203 }
204
205 return -ENOENT;
206}
207
208static void genl_op_from_split(struct genl_op_iter *iter)
209{
210 const struct genl_family *family = iter->family;
211 int i, cnt = 0;
212
213 i = iter->entry_idx - family->n_ops - family->n_small_ops;
214
215 if (family->split_ops[i + cnt].flags & GENL_CMD_CAP_DO) {
216 iter->doit = family->split_ops[i + cnt];
217 genl_op_fill_in_reject_policy_split(family, &iter->doit);
218 cnt++;
219 } else {
220 memset(&iter->doit, 0, sizeof(iter->doit));
221 }
222
223 if (i + cnt < family->n_split_ops &&
224 family->split_ops[i + cnt].flags & GENL_CMD_CAP_DUMP &&
225 (!cnt || family->split_ops[i + cnt].cmd == iter->doit.cmd)) {
226 iter->dumpit = family->split_ops[i + cnt];
227 genl_op_fill_in_reject_policy_split(family, &iter->dumpit);
228 cnt++;
229 } else {
230 memset(&iter->dumpit, 0, sizeof(iter->dumpit));
231 }
232
233 WARN_ON(!cnt);
234 iter->entry_idx += cnt;
235}
236
237static int
238genl_get_cmd_split(u32 cmd, u8 flag, const struct genl_family *family,
239 struct genl_split_ops *op)
240{
241 int i;
242
243 for (i = 0; i < family->n_split_ops; i++)
244 if (family->split_ops[i].cmd == cmd &&
245 family->split_ops[i].flags & flag) {
246 *op = family->split_ops[i];
247 genl_op_fill_in_reject_policy_split(family, op);
248 return 0;
249 }
250
251 return -ENOENT;
252}
253
254static int
255genl_cmd_full_to_split(struct genl_split_ops *op,
256 const struct genl_family *family,
257 const struct genl_ops *full, u8 flags)
258{
259 if ((flags & GENL_CMD_CAP_DO && !full->doit) ||
260 (flags & GENL_CMD_CAP_DUMP && !full->dumpit)) {
261 memset(op, 0, sizeof(*op));
262 return -ENOENT;
263 }
264
265 if (flags & GENL_CMD_CAP_DUMP) {
266 op->start = full->start;
267 op->dumpit = full->dumpit;
268 op->done = full->done;
269 } else {
270 op->pre_doit = family->pre_doit;
271 op->doit = full->doit;
272 op->post_doit = family->post_doit;
273 }
274
275 if (flags & GENL_CMD_CAP_DUMP &&
276 full->validate & GENL_DONT_VALIDATE_DUMP) {
277 op->policy = NULL;
278 op->maxattr = 0;
279 } else {
280 op->policy = full->policy;
281 op->maxattr = full->maxattr;
282 }
283
284 op->cmd = full->cmd;
285 op->internal_flags = full->internal_flags;
286 op->flags = full->flags;
287 op->validate = full->validate;
288
289 /* Make sure flags include the GENL_CMD_CAP_DO / GENL_CMD_CAP_DUMP */
290 op->flags |= flags;
291
292 return 0;
293}
294
295/* Must make sure that op is initialized to 0 on failure */
296static int
297genl_get_cmd(u32 cmd, u8 flags, const struct genl_family *family,
298 struct genl_split_ops *op)
299{
300 struct genl_ops full;
301 int err;
302
303 err = genl_get_cmd_full(cmd, family, &full);
304 if (err == -ENOENT)
305 err = genl_get_cmd_small(cmd, family, &full);
306 /* Found one of legacy forms */
307 if (err == 0)
308 return genl_cmd_full_to_split(op, family, &full, flags);
309
310 err = genl_get_cmd_split(cmd, flags, family, op);
311 if (err)
312 memset(op, 0, sizeof(*op));
313 return err;
314}
315
316/* For policy dumping only, get ops of both do and dump.
317 * Fail if both are missing, genl_get_cmd() will zero-init in case of failure.
318 */
319static int
320genl_get_cmd_both(u32 cmd, const struct genl_family *family,
321 struct genl_split_ops *doit, struct genl_split_ops *dumpit)
322{
323 int err1, err2;
324
325 err1 = genl_get_cmd(cmd, GENL_CMD_CAP_DO, family, doit);
326 err2 = genl_get_cmd(cmd, GENL_CMD_CAP_DUMP, family, dumpit);
327
328 return err1 && err2 ? -ENOENT : 0;
329}
330
331static bool
332genl_op_iter_init(const struct genl_family *family, struct genl_op_iter *iter)
333{
334 iter->family = family;
335 iter->cmd_idx = 0;
336 iter->entry_idx = 0;
337
338 iter->flags = 0;
339
340 return iter->family->n_ops +
341 iter->family->n_small_ops +
342 iter->family->n_split_ops;
343}
344
345static bool genl_op_iter_next(struct genl_op_iter *iter)
346{
347 const struct genl_family *family = iter->family;
348 bool legacy_op = true;
349 struct genl_ops op;
350
351 if (iter->entry_idx < family->n_ops) {
352 genl_op_from_full(family, iter->entry_idx, &op);
353 } else if (iter->entry_idx < family->n_ops + family->n_small_ops) {
354 genl_op_from_small(family, iter->entry_idx - family->n_ops,
355 &op);
356 } else if (iter->entry_idx <
357 family->n_ops + family->n_small_ops + family->n_split_ops) {
358 legacy_op = false;
359 /* updates entry_idx */
360 genl_op_from_split(iter);
361 } else {
362 return false;
363 }
364
365 iter->cmd_idx++;
366
367 if (legacy_op) {
368 iter->entry_idx++;
369
370 genl_cmd_full_to_split(&iter->doit, family,
371 &op, GENL_CMD_CAP_DO);
372 genl_cmd_full_to_split(&iter->dumpit, family,
373 &op, GENL_CMD_CAP_DUMP);
374 }
375
376 iter->cmd = iter->doit.cmd | iter->dumpit.cmd;
377 iter->flags = iter->doit.flags | iter->dumpit.flags;
378
379 return true;
380}
381
382static void
383genl_op_iter_copy(struct genl_op_iter *dst, struct genl_op_iter *src)
384{
385 *dst = *src;
386}
387
388static unsigned int genl_op_iter_idx(struct genl_op_iter *iter)
389{
390 return iter->cmd_idx;
391}
392
393static int genl_allocate_reserve_groups(int n_groups, int *first_id)
394{
395 unsigned long *new_groups;
396 int start = 0;
397 int i;
398 int id;
399 bool fits;
400
401 do {
402 if (start == 0)
403 id = find_first_zero_bit(mc_groups,
404 mc_groups_longs *
405 BITS_PER_LONG);
406 else
407 id = find_next_zero_bit(mc_groups,
408 mc_groups_longs * BITS_PER_LONG,
409 start);
410
411 fits = true;
412 for (i = id;
413 i < min_t(int, id + n_groups,
414 mc_groups_longs * BITS_PER_LONG);
415 i++) {
416 if (test_bit(i, mc_groups)) {
417 start = i;
418 fits = false;
419 break;
420 }
421 }
422
423 if (id + n_groups > mc_groups_longs * BITS_PER_LONG) {
424 unsigned long new_longs = mc_groups_longs +
425 BITS_TO_LONGS(n_groups);
426 size_t nlen = new_longs * sizeof(unsigned long);
427
428 if (mc_groups == &mc_group_start) {
429 new_groups = kzalloc(nlen, GFP_KERNEL);
430 if (!new_groups)
431 return -ENOMEM;
432 mc_groups = new_groups;
433 *mc_groups = mc_group_start;
434 } else {
435 new_groups = krealloc(mc_groups, nlen,
436 GFP_KERNEL);
437 if (!new_groups)
438 return -ENOMEM;
439 mc_groups = new_groups;
440 for (i = 0; i < BITS_TO_LONGS(n_groups); i++)
441 mc_groups[mc_groups_longs + i] = 0;
442 }
443 mc_groups_longs = new_longs;
444 }
445 } while (!fits);
446
447 for (i = id; i < id + n_groups; i++)
448 set_bit(i, mc_groups);
449 *first_id = id;
450 return 0;
451}
452
453static struct genl_family genl_ctrl;
454
455static int genl_validate_assign_mc_groups(struct genl_family *family)
456{
457 int first_id;
458 int n_groups = family->n_mcgrps;
459 int err = 0, i;
460 bool groups_allocated = false;
461
462 if (!n_groups)
463 return 0;
464
465 for (i = 0; i < n_groups; i++) {
466 const struct genl_multicast_group *grp = &family->mcgrps[i];
467
468 if (WARN_ON(grp->name[0] == '\0'))
469 return -EINVAL;
470 if (WARN_ON(!string_is_terminated(grp->name, GENL_NAMSIZ)))
471 return -EINVAL;
472 }
473
474 /* special-case our own group and hacks */
475 if (family == &genl_ctrl) {
476 first_id = GENL_ID_CTRL;
477 BUG_ON(n_groups != 1);
478 } else if (strcmp(family->name, "NET_DM") == 0) {
479 first_id = 1;
480 BUG_ON(n_groups != 1);
481 } else if (family->id == GENL_ID_VFS_DQUOT) {
482 first_id = GENL_ID_VFS_DQUOT;
483 BUG_ON(n_groups != 1);
484 } else if (family->id == GENL_ID_PMCRAID) {
485 first_id = GENL_ID_PMCRAID;
486 BUG_ON(n_groups != 1);
487 } else {
488 groups_allocated = true;
489 err = genl_allocate_reserve_groups(n_groups, &first_id);
490 if (err)
491 return err;
492 }
493
494 family->mcgrp_offset = first_id;
495
496 /* if still initializing, can't and don't need to realloc bitmaps */
497 if (!init_net.genl_sock)
498 return 0;
499
500 if (family->netnsok) {
501 struct net *net;
502
503 netlink_table_grab();
504 rcu_read_lock();
505 for_each_net_rcu(net) {
506 err = __netlink_change_ngroups(net->genl_sock,
507 mc_groups_longs * BITS_PER_LONG);
508 if (err) {
509 /*
510 * No need to roll back, can only fail if
511 * memory allocation fails and then the
512 * number of _possible_ groups has been
513 * increased on some sockets which is ok.
514 */
515 break;
516 }
517 }
518 rcu_read_unlock();
519 netlink_table_ungrab();
520 } else {
521 err = netlink_change_ngroups(init_net.genl_sock,
522 mc_groups_longs * BITS_PER_LONG);
523 }
524
525 if (groups_allocated && err) {
526 for (i = 0; i < family->n_mcgrps; i++)
527 clear_bit(family->mcgrp_offset + i, mc_groups);
528 }
529
530 return err;
531}
532
533static void genl_unregister_mc_groups(const struct genl_family *family)
534{
535 struct net *net;
536 int i;
537
538 netlink_table_grab();
539 rcu_read_lock();
540 for_each_net_rcu(net) {
541 for (i = 0; i < family->n_mcgrps; i++)
542 __netlink_clear_multicast_users(
543 net->genl_sock, family->mcgrp_offset + i);
544 }
545 rcu_read_unlock();
546 netlink_table_ungrab();
547
548 for (i = 0; i < family->n_mcgrps; i++) {
549 int grp_id = family->mcgrp_offset + i;
550
551 if (grp_id != 1)
552 clear_bit(grp_id, mc_groups);
553 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, family,
554 &family->mcgrps[i], grp_id);
555 }
556}
557
558static bool genl_split_op_check(const struct genl_split_ops *op)
559{
560 if (WARN_ON(hweight8(op->flags & (GENL_CMD_CAP_DO |
561 GENL_CMD_CAP_DUMP)) != 1))
562 return true;
563 return false;
564}
565
566static int genl_validate_ops(const struct genl_family *family)
567{
568 struct genl_op_iter i, j;
569 unsigned int s;
570
571 if (WARN_ON(family->n_ops && !family->ops) ||
572 WARN_ON(family->n_small_ops && !family->small_ops) ||
573 WARN_ON(family->n_split_ops && !family->split_ops))
574 return -EINVAL;
575
576 for (genl_op_iter_init(family, &i); genl_op_iter_next(&i); ) {
577 if (!(i.flags & (GENL_CMD_CAP_DO | GENL_CMD_CAP_DUMP)))
578 return -EINVAL;
579
580 if (WARN_ON(i.cmd >= family->resv_start_op &&
581 (i.doit.validate || i.dumpit.validate)))
582 return -EINVAL;
583
584 genl_op_iter_copy(&j, &i);
585 while (genl_op_iter_next(&j)) {
586 if (i.cmd == j.cmd)
587 return -EINVAL;
588 }
589 }
590
591 if (family->n_split_ops) {
592 if (genl_split_op_check(&family->split_ops[0]))
593 return -EINVAL;
594 }
595
596 for (s = 1; s < family->n_split_ops; s++) {
597 const struct genl_split_ops *a, *b;
598
599 a = &family->split_ops[s - 1];
600 b = &family->split_ops[s];
601
602 if (genl_split_op_check(b))
603 return -EINVAL;
604
605 /* Check sort order */
606 if (a->cmd < b->cmd) {
607 continue;
608 } else if (a->cmd > b->cmd) {
609 WARN_ON(1);
610 return -EINVAL;
611 }
612
613 if (a->internal_flags != b->internal_flags ||
614 ((a->flags ^ b->flags) & ~(GENL_CMD_CAP_DO |
615 GENL_CMD_CAP_DUMP))) {
616 WARN_ON(1);
617 return -EINVAL;
618 }
619
620 if ((a->flags & GENL_CMD_CAP_DO) &&
621 (b->flags & GENL_CMD_CAP_DUMP))
622 continue;
623
624 WARN_ON(1);
625 return -EINVAL;
626 }
627
628 return 0;
629}
630
631static void *genl_sk_priv_alloc(struct genl_family *family)
632{
633 void *priv;
634
635 priv = kzalloc(family->sock_priv_size, GFP_KERNEL);
636 if (!priv)
637 return ERR_PTR(-ENOMEM);
638
639 if (family->sock_priv_init)
640 family->sock_priv_init(priv);
641
642 return priv;
643}
644
645static void genl_sk_priv_free(const struct genl_family *family, void *priv)
646{
647 if (family->sock_priv_destroy)
648 family->sock_priv_destroy(priv);
649 kfree(priv);
650}
651
652static int genl_sk_privs_alloc(struct genl_family *family)
653{
654 if (!family->sock_priv_size)
655 return 0;
656
657 family->sock_privs = kzalloc_obj(*family->sock_privs);
658 if (!family->sock_privs)
659 return -ENOMEM;
660 xa_init(family->sock_privs);
661 return 0;
662}
663
664static void genl_sk_privs_free(const struct genl_family *family)
665{
666 unsigned long id;
667 void *priv;
668
669 if (!family->sock_priv_size)
670 return;
671
672 xa_for_each(family->sock_privs, id, priv)
673 genl_sk_priv_free(family, priv);
674
675 xa_destroy(family->sock_privs);
676 kfree(family->sock_privs);
677}
678
679static void genl_sk_priv_free_by_sock(struct genl_family *family,
680 struct sock *sk)
681{
682 void *priv;
683
684 if (!family->sock_priv_size)
685 return;
686 priv = xa_erase(family->sock_privs, (unsigned long) sk);
687 if (!priv)
688 return;
689 genl_sk_priv_free(family, priv);
690}
691
692static void genl_release(struct sock *sk, unsigned long *groups)
693{
694 struct genl_family *family;
695 unsigned int id;
696
697 down_read(&cb_lock);
698
699 idr_for_each_entry(&genl_fam_idr, family, id)
700 genl_sk_priv_free_by_sock(family, sk);
701
702 up_read(&cb_lock);
703}
704
705/**
706 * __genl_sk_priv_get - Get family private pointer for socket, if exists
707 *
708 * @family: family
709 * @sk: socket
710 *
711 * Lookup a private memory for a Generic netlink family and specified socket.
712 *
713 * Caller should make sure this is called in RCU read locked section.
714 *
715 * Return: valid pointer on success, otherwise negative error value
716 * encoded by ERR_PTR(), NULL in case priv does not exist.
717 */
718void *__genl_sk_priv_get(struct genl_family *family, struct sock *sk)
719{
720 if (WARN_ON_ONCE(!family->sock_privs))
721 return ERR_PTR(-EINVAL);
722 return xa_load(family->sock_privs, (unsigned long) sk);
723}
724
725/**
726 * genl_sk_priv_get - Get family private pointer for socket
727 *
728 * @family: family
729 * @sk: socket
730 *
731 * Lookup a private memory for a Generic netlink family and specified socket.
732 * Allocate the private memory in case it was not already done.
733 *
734 * Return: valid pointer on success, otherwise negative error value
735 * encoded by ERR_PTR().
736 */
737void *genl_sk_priv_get(struct genl_family *family, struct sock *sk)
738{
739 void *priv, *old_priv;
740
741 priv = __genl_sk_priv_get(family, sk);
742 if (priv)
743 return priv;
744
745 /* priv for the family does not exist so far, create it. */
746
747 priv = genl_sk_priv_alloc(family);
748 if (IS_ERR(priv))
749 return ERR_CAST(priv);
750
751 old_priv = xa_cmpxchg(family->sock_privs, (unsigned long) sk, NULL,
752 priv, GFP_KERNEL);
753 if (old_priv) {
754 genl_sk_priv_free(family, priv);
755 if (xa_is_err(old_priv))
756 return ERR_PTR(xa_err(old_priv));
757 /* Race happened, priv for the socket was already inserted. */
758 return old_priv;
759 }
760 return priv;
761}
762
763/**
764 * genl_register_family - register a generic netlink family
765 * @family: generic netlink family
766 *
767 * Registers the specified family after validating it first. Only one
768 * family may be registered with the same family name or identifier.
769 *
770 * The family's ops, multicast groups and module pointer must already
771 * be assigned.
772 *
773 * Return 0 on success or a negative error code.
774 */
775int genl_register_family(struct genl_family *family)
776{
777 int err, i;
778 int start = GENL_START_ALLOC, end = GENL_MAX_ID;
779
780 err = genl_validate_ops(family);
781 if (err)
782 return err;
783
784 genl_lock_all();
785
786 if (genl_family_find_byname(family->name)) {
787 err = -EEXIST;
788 goto errout_locked;
789 }
790
791 err = genl_sk_privs_alloc(family);
792 if (err)
793 goto errout_locked;
794
795 /*
796 * Sadly, a few cases need to be special-cased
797 * due to them having previously abused the API
798 * and having used their family ID also as their
799 * multicast group ID, so we use reserved IDs
800 * for both to be sure we can do that mapping.
801 */
802 if (family == &genl_ctrl) {
803 /* and this needs to be special for initial family lookups */
804 start = end = GENL_ID_CTRL;
805 } else if (strcmp(family->name, "pmcraid") == 0) {
806 start = end = GENL_ID_PMCRAID;
807 } else if (strcmp(family->name, "VFS_DQUOT") == 0) {
808 start = end = GENL_ID_VFS_DQUOT;
809 }
810
811 family->id = idr_alloc_cyclic(&genl_fam_idr, family,
812 start, end + 1, GFP_KERNEL);
813 if (family->id < 0) {
814 err = family->id;
815 goto errout_sk_privs_free;
816 }
817
818 err = genl_validate_assign_mc_groups(family);
819 if (err)
820 goto errout_remove;
821
822 genl_unlock_all();
823
824 /* send all events */
825 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0);
826 for (i = 0; i < family->n_mcgrps; i++)
827 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family,
828 &family->mcgrps[i], family->mcgrp_offset + i);
829
830 return 0;
831
832errout_remove:
833 idr_remove(&genl_fam_idr, family->id);
834errout_sk_privs_free:
835 genl_sk_privs_free(family);
836errout_locked:
837 genl_unlock_all();
838 return err;
839}
840EXPORT_SYMBOL(genl_register_family);
841
842/**
843 * genl_unregister_family - unregister generic netlink family
844 * @family: generic netlink family
845 *
846 * Unregisters the specified family.
847 *
848 * Returns 0 on success or a negative error code.
849 */
850int genl_unregister_family(const struct genl_family *family)
851{
852 genl_lock_all();
853
854 if (!genl_family_find_byid(family->id)) {
855 genl_unlock_all();
856 return -ENOENT;
857 }
858
859 genl_unregister_mc_groups(family);
860
861 idr_remove(&genl_fam_idr, family->id);
862
863 up_write(&cb_lock);
864 wait_event(genl_sk_destructing_waitq,
865 atomic_read(&genl_sk_destructing_cnt) == 0);
866
867 genl_sk_privs_free(family);
868
869 genl_unlock();
870
871 genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0);
872
873 return 0;
874}
875EXPORT_SYMBOL(genl_unregister_family);
876
877/**
878 * genlmsg_put - Add generic netlink header to netlink message
879 * @skb: socket buffer holding the message
880 * @portid: netlink portid the message is addressed to
881 * @seq: sequence number (usually the one of the sender)
882 * @family: generic netlink family
883 * @flags: netlink message flags
884 * @cmd: generic netlink command
885 *
886 * Returns pointer to user specific header
887 */
888void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
889 const struct genl_family *family, int flags, u8 cmd)
890{
891 struct nlmsghdr *nlh;
892 struct genlmsghdr *hdr;
893
894 nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +
895 family->hdrsize, flags);
896 if (nlh == NULL)
897 return NULL;
898
899 hdr = nlmsg_data(nlh);
900 hdr->cmd = cmd;
901 hdr->version = family->version;
902 hdr->reserved = 0;
903
904 return (char *) hdr + GENL_HDRLEN;
905}
906EXPORT_SYMBOL(genlmsg_put);
907
908static struct genl_dumpit_info *genl_dumpit_info_alloc(void)
909{
910 return kmalloc_obj(struct genl_dumpit_info);
911}
912
913static void genl_dumpit_info_free(const struct genl_dumpit_info *info)
914{
915 kfree(info);
916}
917
918static struct nlattr **
919genl_family_rcv_msg_attrs_parse(const struct genl_family *family,
920 struct nlmsghdr *nlh,
921 struct netlink_ext_ack *extack,
922 const struct genl_split_ops *ops,
923 int hdrlen,
924 enum genl_validate_flags no_strict_flag)
925{
926 enum netlink_validation validate = ops->validate & no_strict_flag ?
927 NL_VALIDATE_LIBERAL :
928 NL_VALIDATE_STRICT;
929 struct nlattr **attrbuf;
930 int err;
931
932 if (!ops->policy)
933 return NULL;
934
935 if (ops->maxattr) {
936 attrbuf = kmalloc_objs(struct nlattr *, ops->maxattr + 1);
937 if (!attrbuf)
938 return ERR_PTR(-ENOMEM);
939 } else {
940 /* Reject all policy, __nlmsg_parse() will just validate */
941 attrbuf = NULL;
942 }
943
944 err = __nlmsg_parse(nlh, hdrlen, attrbuf, ops->maxattr, ops->policy,
945 validate, extack);
946 if (err) {
947 kfree(attrbuf);
948 return ERR_PTR(err);
949 }
950 return attrbuf;
951}
952
953static void genl_family_rcv_msg_attrs_free(struct nlattr **attrbuf)
954{
955 kfree(attrbuf);
956}
957
958struct genl_start_context {
959 const struct genl_family *family;
960 struct nlmsghdr *nlh;
961 struct netlink_ext_ack *extack;
962 const struct genl_split_ops *ops;
963 int hdrlen;
964};
965
966static int genl_start(struct netlink_callback *cb)
967{
968 struct genl_start_context *ctx = cb->data;
969 const struct genl_split_ops *ops;
970 struct genl_dumpit_info *info;
971 struct nlattr **attrs = NULL;
972 int rc = 0;
973
974 ops = ctx->ops;
975 if (!(ops->validate & GENL_DONT_VALIDATE_DUMP) &&
976 ctx->nlh->nlmsg_len < nlmsg_msg_size(ctx->hdrlen))
977 return -EINVAL;
978
979 attrs = genl_family_rcv_msg_attrs_parse(ctx->family, ctx->nlh, ctx->extack,
980 ops, ctx->hdrlen,
981 GENL_DONT_VALIDATE_DUMP_STRICT);
982 if (IS_ERR(attrs))
983 return PTR_ERR(attrs);
984
985 info = genl_dumpit_info_alloc();
986 if (!info) {
987 genl_family_rcv_msg_attrs_free(attrs);
988 return -ENOMEM;
989 }
990 info->op = *ops;
991 info->info.family = ctx->family;
992 info->info.snd_seq = cb->nlh->nlmsg_seq;
993 info->info.snd_portid = NETLINK_CB(cb->skb).portid;
994 info->info.nlhdr = cb->nlh;
995 info->info.genlhdr = nlmsg_data(cb->nlh);
996 info->info.attrs = attrs;
997 genl_info_net_set(&info->info, sock_net(cb->skb->sk));
998 info->info.extack = cb->extack;
999 memset(&info->info.ctx, 0, sizeof(info->info.ctx));
1000
1001 cb->data = info;
1002 if (ops->start) {
1003 genl_op_lock(ctx->family);
1004 rc = ops->start(cb);
1005 genl_op_unlock(ctx->family);
1006 }
1007
1008 if (rc) {
1009 genl_family_rcv_msg_attrs_free(info->info.attrs);
1010 genl_dumpit_info_free(info);
1011 cb->data = NULL;
1012 }
1013 return rc;
1014}
1015
1016static int genl_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
1017{
1018 struct genl_dumpit_info *dump_info = cb->data;
1019 const struct genl_split_ops *ops = &dump_info->op;
1020 struct genl_info *info = &dump_info->info;
1021 int rc;
1022
1023 info->extack = cb->extack;
1024
1025 genl_op_lock(info->family);
1026 rc = ops->dumpit(skb, cb);
1027 genl_op_unlock(info->family);
1028 return rc;
1029}
1030
1031static int genl_done(struct netlink_callback *cb)
1032{
1033 struct genl_dumpit_info *dump_info = cb->data;
1034 const struct genl_split_ops *ops = &dump_info->op;
1035 struct genl_info *info = &dump_info->info;
1036 int rc = 0;
1037
1038 info->extack = cb->extack;
1039
1040 if (ops->done) {
1041 genl_op_lock(info->family);
1042 rc = ops->done(cb);
1043 genl_op_unlock(info->family);
1044 }
1045 genl_family_rcv_msg_attrs_free(info->attrs);
1046 genl_dumpit_info_free(dump_info);
1047 return rc;
1048}
1049
1050static int genl_family_rcv_msg_dumpit(const struct genl_family *family,
1051 struct sk_buff *skb,
1052 struct nlmsghdr *nlh,
1053 struct netlink_ext_ack *extack,
1054 const struct genl_split_ops *ops,
1055 int hdrlen, struct net *net)
1056{
1057 struct genl_start_context ctx;
1058 struct netlink_dump_control c = {
1059 .module = family->module,
1060 .data = &ctx,
1061 .start = genl_start,
1062 .dump = genl_dumpit,
1063 .done = genl_done,
1064 .extack = extack,
1065 };
1066 int err;
1067
1068 ctx.family = family;
1069 ctx.nlh = nlh;
1070 ctx.extack = extack;
1071 ctx.ops = ops;
1072 ctx.hdrlen = hdrlen;
1073
1074 genl_op_unlock(family);
1075 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
1076 genl_op_lock(family);
1077
1078 return err;
1079}
1080
1081static int genl_family_rcv_msg_doit(const struct genl_family *family,
1082 struct sk_buff *skb,
1083 struct nlmsghdr *nlh,
1084 struct netlink_ext_ack *extack,
1085 const struct genl_split_ops *ops,
1086 int hdrlen, struct net *net)
1087{
1088 struct nlattr **attrbuf;
1089 struct genl_info info;
1090 int err;
1091
1092 attrbuf = genl_family_rcv_msg_attrs_parse(family, nlh, extack,
1093 ops, hdrlen,
1094 GENL_DONT_VALIDATE_STRICT);
1095 if (IS_ERR(attrbuf))
1096 return PTR_ERR(attrbuf);
1097
1098 info.snd_seq = nlh->nlmsg_seq;
1099 info.snd_portid = NETLINK_CB(skb).portid;
1100 info.family = family;
1101 info.nlhdr = nlh;
1102 info.genlhdr = nlmsg_data(nlh);
1103 info.attrs = attrbuf;
1104 info.extack = extack;
1105 genl_info_net_set(&info, net);
1106 memset(&info.ctx, 0, sizeof(info.ctx));
1107
1108 if (ops->pre_doit) {
1109 err = ops->pre_doit(ops, skb, &info);
1110 if (err)
1111 goto out;
1112 }
1113
1114 err = ops->doit(skb, &info);
1115
1116 if (ops->post_doit)
1117 ops->post_doit(ops, skb, &info);
1118
1119out:
1120 genl_family_rcv_msg_attrs_free(attrbuf);
1121
1122 return err;
1123}
1124
1125static int genl_header_check(const struct genl_family *family,
1126 struct nlmsghdr *nlh, struct genlmsghdr *hdr,
1127 struct netlink_ext_ack *extack)
1128{
1129 u16 flags;
1130
1131 /* Only for commands added after we started validating */
1132 if (hdr->cmd < family->resv_start_op)
1133 return 0;
1134
1135 if (hdr->reserved) {
1136 NL_SET_ERR_MSG(extack, "genlmsghdr.reserved field is not 0");
1137 return -EINVAL;
1138 }
1139
1140 /* Old netlink flags have pretty loose semantics, allow only the flags
1141 * consumed by the core where we can enforce the meaning.
1142 */
1143 flags = nlh->nlmsg_flags;
1144 if ((flags & NLM_F_DUMP) == NLM_F_DUMP) /* DUMP is 2 bits */
1145 flags &= ~NLM_F_DUMP;
1146 if (flags & ~(NLM_F_REQUEST | NLM_F_ACK | NLM_F_ECHO)) {
1147 NL_SET_ERR_MSG(extack,
1148 "ambiguous or reserved bits set in nlmsg_flags");
1149 return -EINVAL;
1150 }
1151
1152 return 0;
1153}
1154
1155static int genl_family_rcv_msg(const struct genl_family *family,
1156 struct sk_buff *skb,
1157 struct nlmsghdr *nlh,
1158 struct netlink_ext_ack *extack)
1159{
1160 struct net *net = sock_net(skb->sk);
1161 struct genlmsghdr *hdr = nlmsg_data(nlh);
1162 struct genl_split_ops op;
1163 int hdrlen;
1164 u8 flags;
1165
1166 /* this family doesn't exist in this netns */
1167 if (!family->netnsok && !net_eq(net, &init_net))
1168 return -ENOENT;
1169
1170 hdrlen = GENL_HDRLEN + family->hdrsize;
1171 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
1172 return -EINVAL;
1173
1174 if (genl_header_check(family, nlh, hdr, extack))
1175 return -EINVAL;
1176
1177 flags = (nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP ?
1178 GENL_CMD_CAP_DUMP : GENL_CMD_CAP_DO;
1179 if (genl_get_cmd(hdr->cmd, flags, family, &op))
1180 return -EOPNOTSUPP;
1181
1182 if ((op.flags & GENL_ADMIN_PERM) &&
1183 !netlink_capable(skb, CAP_NET_ADMIN))
1184 return -EPERM;
1185
1186 if ((op.flags & GENL_UNS_ADMIN_PERM) &&
1187 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
1188 return -EPERM;
1189
1190 if (flags & GENL_CMD_CAP_DUMP)
1191 return genl_family_rcv_msg_dumpit(family, skb, nlh, extack,
1192 &op, hdrlen, net);
1193 else
1194 return genl_family_rcv_msg_doit(family, skb, nlh, extack,
1195 &op, hdrlen, net);
1196}
1197
1198static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
1199 struct netlink_ext_ack *extack)
1200{
1201 const struct genl_family *family;
1202 int err;
1203
1204 family = genl_family_find_byid(nlh->nlmsg_type);
1205 if (family == NULL)
1206 return -ENOENT;
1207
1208 genl_op_lock(family);
1209 err = genl_family_rcv_msg(family, skb, nlh, extack);
1210 genl_op_unlock(family);
1211
1212 return err;
1213}
1214
1215static void genl_rcv(struct sk_buff *skb)
1216{
1217 down_read(&cb_lock);
1218 netlink_rcv_skb(skb, &genl_rcv_msg);
1219 up_read(&cb_lock);
1220}
1221
1222/**************************************************************************
1223 * Controller
1224 **************************************************************************/
1225
1226static struct genl_family genl_ctrl;
1227
1228static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq,
1229 u32 flags, struct sk_buff *skb, u8 cmd)
1230{
1231 struct genl_op_iter i;
1232 void *hdr;
1233
1234 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
1235 if (hdr == NULL)
1236 return -EMSGSIZE;
1237
1238 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
1239 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
1240 nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
1241 nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
1242 nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
1243 goto nla_put_failure;
1244
1245 if (genl_op_iter_init(family, &i)) {
1246 struct nlattr *nla_ops;
1247
1248 nla_ops = nla_nest_start_noflag(skb, CTRL_ATTR_OPS);
1249 if (nla_ops == NULL)
1250 goto nla_put_failure;
1251
1252 while (genl_op_iter_next(&i)) {
1253 struct nlattr *nest;
1254 u32 op_flags;
1255
1256 op_flags = i.flags;
1257 if (i.doit.policy || i.dumpit.policy)
1258 op_flags |= GENL_CMD_CAP_HASPOL;
1259
1260 nest = nla_nest_start_noflag(skb, genl_op_iter_idx(&i));
1261 if (nest == NULL)
1262 goto nla_put_failure;
1263
1264 if (nla_put_u32(skb, CTRL_ATTR_OP_ID, i.cmd) ||
1265 nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags))
1266 goto nla_put_failure;
1267
1268 nla_nest_end(skb, nest);
1269 }
1270
1271 nla_nest_end(skb, nla_ops);
1272 }
1273
1274 if (family->n_mcgrps) {
1275 struct nlattr *nla_grps;
1276 int i;
1277
1278 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
1279 if (nla_grps == NULL)
1280 goto nla_put_failure;
1281
1282 for (i = 0; i < family->n_mcgrps; i++) {
1283 struct nlattr *nest;
1284 const struct genl_multicast_group *grp;
1285
1286 grp = &family->mcgrps[i];
1287
1288 nest = nla_nest_start_noflag(skb, i + 1);
1289 if (nest == NULL)
1290 goto nla_put_failure;
1291
1292 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID,
1293 family->mcgrp_offset + i) ||
1294 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
1295 grp->name))
1296 goto nla_put_failure;
1297
1298 nla_nest_end(skb, nest);
1299 }
1300 nla_nest_end(skb, nla_grps);
1301 }
1302
1303 genlmsg_end(skb, hdr);
1304 return 0;
1305
1306nla_put_failure:
1307 genlmsg_cancel(skb, hdr);
1308 return -EMSGSIZE;
1309}
1310
1311static int ctrl_fill_mcgrp_info(const struct genl_family *family,
1312 const struct genl_multicast_group *grp,
1313 int grp_id, u32 portid, u32 seq, u32 flags,
1314 struct sk_buff *skb, u8 cmd)
1315{
1316 void *hdr;
1317 struct nlattr *nla_grps;
1318 struct nlattr *nest;
1319
1320 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
1321 if (hdr == NULL)
1322 return -1;
1323
1324 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
1325 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id))
1326 goto nla_put_failure;
1327
1328 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
1329 if (nla_grps == NULL)
1330 goto nla_put_failure;
1331
1332 nest = nla_nest_start_noflag(skb, 1);
1333 if (nest == NULL)
1334 goto nla_put_failure;
1335
1336 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) ||
1337 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
1338 grp->name))
1339 goto nla_put_failure;
1340
1341 nla_nest_end(skb, nest);
1342 nla_nest_end(skb, nla_grps);
1343
1344 genlmsg_end(skb, hdr);
1345 return 0;
1346
1347nla_put_failure:
1348 genlmsg_cancel(skb, hdr);
1349 return -EMSGSIZE;
1350}
1351
1352static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
1353{
1354 int n = 0;
1355 struct genl_family *rt;
1356 struct net *net = sock_net(skb->sk);
1357 int fams_to_skip = cb->args[0];
1358 unsigned int id;
1359 int err = 0;
1360
1361 idr_for_each_entry(&genl_fam_idr, rt, id) {
1362 if (!rt->netnsok && !net_eq(net, &init_net))
1363 continue;
1364
1365 if (n++ < fams_to_skip)
1366 continue;
1367
1368 err = ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
1369 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1370 skb, CTRL_CMD_NEWFAMILY);
1371 if (err) {
1372 n--;
1373 break;
1374 }
1375 }
1376
1377 cb->args[0] = n;
1378 return err;
1379}
1380
1381static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family,
1382 u32 portid, int seq, u8 cmd)
1383{
1384 struct sk_buff *skb;
1385 int err;
1386
1387 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1388 if (skb == NULL)
1389 return ERR_PTR(-ENOBUFS);
1390
1391 err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);
1392 if (err < 0) {
1393 nlmsg_free(skb);
1394 return ERR_PTR(err);
1395 }
1396
1397 return skb;
1398}
1399
1400static struct sk_buff *
1401ctrl_build_mcgrp_msg(const struct genl_family *family,
1402 const struct genl_multicast_group *grp,
1403 int grp_id, u32 portid, int seq, u8 cmd)
1404{
1405 struct sk_buff *skb;
1406 int err;
1407
1408 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1409 if (skb == NULL)
1410 return ERR_PTR(-ENOBUFS);
1411
1412 err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid,
1413 seq, 0, skb, cmd);
1414 if (err < 0) {
1415 nlmsg_free(skb);
1416 return ERR_PTR(err);
1417 }
1418
1419 return skb;
1420}
1421
1422static const struct nla_policy ctrl_policy_family[] = {
1423 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
1424 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
1425 .len = GENL_NAMSIZ - 1 },
1426};
1427
1428static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
1429{
1430 struct sk_buff *msg;
1431 const struct genl_family *res = NULL;
1432 int err = -EINVAL;
1433
1434 if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
1435 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
1436 res = genl_family_find_byid(id);
1437 err = -ENOENT;
1438 }
1439
1440 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
1441 char *name;
1442
1443 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
1444 res = genl_family_find_byname(name);
1445#ifdef CONFIG_MODULES
1446 if (res == NULL) {
1447 genl_unlock();
1448 up_read(&cb_lock);
1449 request_module("net-pf-%d-proto-%d-family-%s",
1450 PF_NETLINK, NETLINK_GENERIC, name);
1451 down_read(&cb_lock);
1452 genl_lock();
1453 res = genl_family_find_byname(name);
1454 }
1455#endif
1456 err = -ENOENT;
1457 }
1458
1459 if (res == NULL)
1460 return err;
1461
1462 if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) {
1463 /* family doesn't exist here */
1464 return -ENOENT;
1465 }
1466
1467 msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,
1468 CTRL_CMD_NEWFAMILY);
1469 if (IS_ERR(msg))
1470 return PTR_ERR(msg);
1471
1472 return genlmsg_reply(msg, info);
1473}
1474
1475static int genl_ctrl_event(int event, const struct genl_family *family,
1476 const struct genl_multicast_group *grp,
1477 int grp_id)
1478{
1479 struct sk_buff *msg;
1480
1481 /* genl is still initialising */
1482 if (!init_net.genl_sock)
1483 return 0;
1484
1485 switch (event) {
1486 case CTRL_CMD_NEWFAMILY:
1487 case CTRL_CMD_DELFAMILY:
1488 WARN_ON(grp);
1489 msg = ctrl_build_family_msg(family, 0, 0, event);
1490 break;
1491 case CTRL_CMD_NEWMCAST_GRP:
1492 case CTRL_CMD_DELMCAST_GRP:
1493 BUG_ON(!grp);
1494 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event);
1495 break;
1496 default:
1497 return -EINVAL;
1498 }
1499
1500 if (IS_ERR(msg))
1501 return PTR_ERR(msg);
1502
1503 if (!family->netnsok)
1504 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0,
1505 0, GFP_KERNEL);
1506 else
1507 genlmsg_multicast_allns(&genl_ctrl, msg, 0, 0);
1508
1509 return 0;
1510}
1511
1512struct ctrl_dump_policy_ctx {
1513 struct netlink_policy_dump_state *state;
1514 const struct genl_family *rt;
1515 struct genl_op_iter *op_iter;
1516 struct module *owner;
1517 u32 op;
1518 u16 fam_id;
1519 u8 dump_map:1,
1520 single_op:1;
1521};
1522
1523static const struct nla_policy ctrl_policy_policy[] = {
1524 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
1525 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
1526 .len = GENL_NAMSIZ - 1 },
1527 [CTRL_ATTR_OP] = { .type = NLA_U32 },
1528};
1529
1530static int ctrl_dumppolicy_start(struct netlink_callback *cb)
1531{
1532 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
1533 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1534 struct nlattr **tb = info->info.attrs;
1535 const struct genl_family *rt;
1536 struct genl_op_iter i;
1537 int err;
1538
1539 BUILD_BUG_ON(sizeof(*ctx) > sizeof(cb->ctx));
1540
1541 if (!tb[CTRL_ATTR_FAMILY_ID] && !tb[CTRL_ATTR_FAMILY_NAME])
1542 return -EINVAL;
1543
1544 if (tb[CTRL_ATTR_FAMILY_ID]) {
1545 ctx->fam_id = nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]);
1546 } else {
1547 rt = genl_family_find_byname(
1548 nla_data(tb[CTRL_ATTR_FAMILY_NAME]));
1549 if (!rt)
1550 return -ENOENT;
1551 ctx->fam_id = rt->id;
1552 }
1553
1554 rt = genl_family_find_byid(ctx->fam_id);
1555 if (!rt)
1556 return -ENOENT;
1557
1558 ctx->rt = rt;
1559 ctx->owner = rt->module;
1560 if (!try_module_get(ctx->owner))
1561 return -ENOENT;
1562
1563 if (tb[CTRL_ATTR_OP]) {
1564 struct genl_split_ops doit, dump;
1565
1566 ctx->single_op = true;
1567 ctx->op = nla_get_u32(tb[CTRL_ATTR_OP]);
1568
1569 err = genl_get_cmd_both(ctx->op, rt, &doit, &dump);
1570 if (err) {
1571 NL_SET_BAD_ATTR(cb->extack, tb[CTRL_ATTR_OP]);
1572 goto err_put_owner;
1573 }
1574
1575 if (doit.policy) {
1576 err = netlink_policy_dump_add_policy(&ctx->state,
1577 doit.policy,
1578 doit.maxattr);
1579 if (err)
1580 goto err_free_state;
1581 }
1582 if (dump.policy) {
1583 err = netlink_policy_dump_add_policy(&ctx->state,
1584 dump.policy,
1585 dump.maxattr);
1586 if (err)
1587 goto err_free_state;
1588 }
1589
1590 if (!ctx->state) {
1591 err = -ENODATA;
1592 goto err_put_owner;
1593 }
1594
1595 ctx->dump_map = 1;
1596 return 0;
1597 }
1598
1599 ctx->op_iter = kmalloc_obj(*ctx->op_iter);
1600 if (!ctx->op_iter) {
1601 err = -ENOMEM;
1602 goto err_put_owner;
1603 }
1604
1605 genl_op_iter_init(rt, ctx->op_iter);
1606 ctx->dump_map = genl_op_iter_next(ctx->op_iter);
1607
1608 for (genl_op_iter_init(rt, &i); genl_op_iter_next(&i); ) {
1609 if (i.doit.policy) {
1610 err = netlink_policy_dump_add_policy(&ctx->state,
1611 i.doit.policy,
1612 i.doit.maxattr);
1613 if (err)
1614 goto err_free_state;
1615 }
1616 if (i.dumpit.policy) {
1617 err = netlink_policy_dump_add_policy(&ctx->state,
1618 i.dumpit.policy,
1619 i.dumpit.maxattr);
1620 if (err)
1621 goto err_free_state;
1622 }
1623 }
1624
1625 if (!ctx->state) {
1626 err = -ENODATA;
1627 goto err_free_op_iter;
1628 }
1629 return 0;
1630
1631err_free_state:
1632 netlink_policy_dump_free(ctx->state);
1633err_free_op_iter:
1634 kfree(ctx->op_iter);
1635err_put_owner:
1636 module_put(ctx->owner);
1637 return err;
1638}
1639
1640static void *ctrl_dumppolicy_prep(struct sk_buff *skb,
1641 struct netlink_callback *cb)
1642{
1643 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1644 void *hdr;
1645
1646 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
1647 cb->nlh->nlmsg_seq, &genl_ctrl,
1648 NLM_F_MULTI, CTRL_CMD_GETPOLICY);
1649 if (!hdr)
1650 return NULL;
1651
1652 if (nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, ctx->fam_id))
1653 return NULL;
1654
1655 return hdr;
1656}
1657
1658static int ctrl_dumppolicy_put_op(struct sk_buff *skb,
1659 struct netlink_callback *cb, u32 cmd,
1660 struct genl_split_ops *doit,
1661 struct genl_split_ops *dumpit)
1662{
1663 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1664 struct nlattr *nest_pol, *nest_op;
1665 void *hdr;
1666 int idx;
1667
1668 /* skip if we have nothing to show */
1669 if (!doit->policy && !dumpit->policy)
1670 return 0;
1671
1672 hdr = ctrl_dumppolicy_prep(skb, cb);
1673 if (!hdr)
1674 return -ENOBUFS;
1675
1676 nest_pol = nla_nest_start(skb, CTRL_ATTR_OP_POLICY);
1677 if (!nest_pol)
1678 goto err;
1679
1680 nest_op = nla_nest_start(skb, cmd);
1681 if (!nest_op)
1682 goto err;
1683
1684 if (doit->policy) {
1685 idx = netlink_policy_dump_get_policy_idx(ctx->state,
1686 doit->policy,
1687 doit->maxattr);
1688
1689 if (nla_put_u32(skb, CTRL_ATTR_POLICY_DO, idx))
1690 goto err;
1691 }
1692 if (dumpit->policy) {
1693 idx = netlink_policy_dump_get_policy_idx(ctx->state,
1694 dumpit->policy,
1695 dumpit->maxattr);
1696
1697 if (nla_put_u32(skb, CTRL_ATTR_POLICY_DUMP, idx))
1698 goto err;
1699 }
1700
1701 nla_nest_end(skb, nest_op);
1702 nla_nest_end(skb, nest_pol);
1703 genlmsg_end(skb, hdr);
1704
1705 return 0;
1706err:
1707 genlmsg_cancel(skb, hdr);
1708 return -ENOBUFS;
1709}
1710
1711static int ctrl_dumppolicy(struct sk_buff *skb, struct netlink_callback *cb)
1712{
1713 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1714 void *hdr;
1715
1716 if (ctx->dump_map) {
1717 if (ctx->single_op) {
1718 struct genl_split_ops doit, dumpit;
1719
1720 if (WARN_ON(genl_get_cmd_both(ctx->op, ctx->rt,
1721 &doit, &dumpit)))
1722 return -ENOENT;
1723
1724 if (ctrl_dumppolicy_put_op(skb, cb, ctx->op,
1725 &doit, &dumpit))
1726 return skb->len;
1727
1728 /* done with the per-op policy index list */
1729 ctx->dump_map = 0;
1730 }
1731
1732 while (ctx->dump_map) {
1733 if (ctrl_dumppolicy_put_op(skb, cb,
1734 ctx->op_iter->cmd,
1735 &ctx->op_iter->doit,
1736 &ctx->op_iter->dumpit))
1737 return skb->len;
1738
1739 ctx->dump_map = genl_op_iter_next(ctx->op_iter);
1740 }
1741 }
1742
1743 while (netlink_policy_dump_loop(ctx->state)) {
1744 struct nlattr *nest;
1745
1746 hdr = ctrl_dumppolicy_prep(skb, cb);
1747 if (!hdr)
1748 goto nla_put_failure;
1749
1750 nest = nla_nest_start(skb, CTRL_ATTR_POLICY);
1751 if (!nest)
1752 goto nla_put_failure;
1753
1754 if (netlink_policy_dump_write(skb, ctx->state))
1755 goto nla_put_failure;
1756
1757 nla_nest_end(skb, nest);
1758
1759 genlmsg_end(skb, hdr);
1760 }
1761
1762 return skb->len;
1763
1764nla_put_failure:
1765 genlmsg_cancel(skb, hdr);
1766 return skb->len;
1767}
1768
1769static int ctrl_dumppolicy_done(struct netlink_callback *cb)
1770{
1771 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1772
1773 kfree(ctx->op_iter);
1774 netlink_policy_dump_free(ctx->state);
1775 module_put(ctx->owner);
1776 return 0;
1777}
1778
1779static const struct genl_split_ops genl_ctrl_ops[] = {
1780 {
1781 .cmd = CTRL_CMD_GETFAMILY,
1782 .validate = GENL_DONT_VALIDATE_STRICT,
1783 .policy = ctrl_policy_family,
1784 .maxattr = ARRAY_SIZE(ctrl_policy_family) - 1,
1785 .doit = ctrl_getfamily,
1786 .flags = GENL_CMD_CAP_DO,
1787 },
1788 {
1789 .cmd = CTRL_CMD_GETFAMILY,
1790 .validate = GENL_DONT_VALIDATE_DUMP,
1791 .policy = ctrl_policy_family,
1792 .maxattr = ARRAY_SIZE(ctrl_policy_family) - 1,
1793 .dumpit = ctrl_dumpfamily,
1794 .flags = GENL_CMD_CAP_DUMP,
1795 },
1796 {
1797 .cmd = CTRL_CMD_GETPOLICY,
1798 .policy = ctrl_policy_policy,
1799 .maxattr = ARRAY_SIZE(ctrl_policy_policy) - 1,
1800 .start = ctrl_dumppolicy_start,
1801 .dumpit = ctrl_dumppolicy,
1802 .done = ctrl_dumppolicy_done,
1803 .flags = GENL_CMD_CAP_DUMP,
1804 },
1805};
1806
1807static const struct genl_multicast_group genl_ctrl_groups[] = {
1808 { .name = "notify", },
1809};
1810
1811static struct genl_family genl_ctrl __ro_after_init = {
1812 .module = THIS_MODULE,
1813 .split_ops = genl_ctrl_ops,
1814 .n_split_ops = ARRAY_SIZE(genl_ctrl_ops),
1815 .resv_start_op = CTRL_CMD_GETPOLICY + 1,
1816 .mcgrps = genl_ctrl_groups,
1817 .n_mcgrps = ARRAY_SIZE(genl_ctrl_groups),
1818 .id = GENL_ID_CTRL,
1819 .name = "nlctrl",
1820 .version = 0x2,
1821 .netnsok = true,
1822};
1823
1824static int genl_bind(struct net *net, int group)
1825{
1826 const struct genl_family *family;
1827 unsigned int id;
1828 int ret = 0;
1829
1830 down_read(&cb_lock);
1831
1832 idr_for_each_entry(&genl_fam_idr, family, id) {
1833 const struct genl_multicast_group *grp;
1834 int i;
1835
1836 if (family->n_mcgrps == 0)
1837 continue;
1838
1839 i = group - family->mcgrp_offset;
1840 if (i < 0 || i >= family->n_mcgrps)
1841 continue;
1842
1843 grp = &family->mcgrps[i];
1844 if ((grp->flags & GENL_MCAST_CAP_NET_ADMIN) &&
1845 !ns_capable(net->user_ns, CAP_NET_ADMIN))
1846 ret = -EPERM;
1847 if ((grp->flags & GENL_MCAST_CAP_SYS_ADMIN) &&
1848 !ns_capable(net->user_ns, CAP_SYS_ADMIN))
1849 ret = -EPERM;
1850
1851 if (ret)
1852 break;
1853
1854 if (family->bind)
1855 family->bind(i);
1856
1857 break;
1858 }
1859
1860 up_read(&cb_lock);
1861 return ret;
1862}
1863
1864static void genl_unbind(struct net *net, int group)
1865{
1866 const struct genl_family *family;
1867 unsigned int id;
1868
1869 down_read(&cb_lock);
1870
1871 idr_for_each_entry(&genl_fam_idr, family, id) {
1872 int i;
1873
1874 if (family->n_mcgrps == 0)
1875 continue;
1876
1877 i = group - family->mcgrp_offset;
1878 if (i < 0 || i >= family->n_mcgrps)
1879 continue;
1880
1881 if (family->unbind)
1882 family->unbind(i);
1883
1884 break;
1885 }
1886
1887 up_read(&cb_lock);
1888}
1889
1890static int __net_init genl_pernet_init(struct net *net)
1891{
1892 struct netlink_kernel_cfg cfg = {
1893 .input = genl_rcv,
1894 .flags = NL_CFG_F_NONROOT_RECV,
1895 .bind = genl_bind,
1896 .unbind = genl_unbind,
1897 .release = genl_release,
1898 };
1899
1900 /* we'll bump the group number right afterwards */
1901 net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);
1902
1903 if (!net->genl_sock && net_eq(net, &init_net))
1904 panic("GENL: Cannot initialize generic netlink\n");
1905
1906 if (!net->genl_sock)
1907 return -ENOMEM;
1908
1909 return 0;
1910}
1911
1912static void __net_exit genl_pernet_exit(struct net *net)
1913{
1914 netlink_kernel_release(net->genl_sock);
1915 net->genl_sock = NULL;
1916}
1917
1918static struct pernet_operations genl_pernet_ops = {
1919 .init = genl_pernet_init,
1920 .exit = genl_pernet_exit,
1921};
1922
1923static int __init genl_init(void)
1924{
1925 int err;
1926
1927 err = genl_register_family(&genl_ctrl);
1928 if (err < 0)
1929 goto problem;
1930
1931 err = register_pernet_subsys(&genl_pernet_ops);
1932 if (err)
1933 goto problem;
1934
1935 return 0;
1936
1937problem:
1938 panic("GENL: Cannot register controller: %d\n", err);
1939}
1940
1941core_initcall(genl_init);
1942
1943static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group)
1944{
1945 struct sk_buff *tmp;
1946 struct net *net, *prev = NULL;
1947 bool delivered = false;
1948 int err;
1949
1950 rcu_read_lock();
1951 for_each_net_rcu(net) {
1952 if (prev) {
1953 tmp = skb_clone(skb, GFP_ATOMIC);
1954 if (!tmp) {
1955 err = -ENOMEM;
1956 goto error;
1957 }
1958 err = nlmsg_multicast(prev->genl_sock, tmp,
1959 portid, group, GFP_ATOMIC);
1960 if (!err)
1961 delivered = true;
1962 else if (err != -ESRCH)
1963 goto error;
1964 }
1965
1966 prev = net;
1967 }
1968 err = nlmsg_multicast(prev->genl_sock, skb, portid, group, GFP_ATOMIC);
1969
1970 rcu_read_unlock();
1971
1972 if (!err)
1973 delivered = true;
1974 else if (err != -ESRCH)
1975 return err;
1976 return delivered ? 0 : -ESRCH;
1977 error:
1978 rcu_read_unlock();
1979
1980 kfree_skb(skb);
1981 return err;
1982}
1983
1984int genlmsg_multicast_allns(const struct genl_family *family,
1985 struct sk_buff *skb, u32 portid,
1986 unsigned int group)
1987{
1988 if (WARN_ON_ONCE(group >= family->n_mcgrps)) {
1989 kfree_skb(skb);
1990 return -EINVAL;
1991 }
1992
1993 group = family->mcgrp_offset + group;
1994 return genlmsg_mcast(skb, portid, group);
1995}
1996EXPORT_SYMBOL(genlmsg_multicast_allns);
1997
1998void genl_notify(const struct genl_family *family, struct sk_buff *skb,
1999 struct genl_info *info, u32 group, gfp_t flags)
2000{
2001 struct net *net = genl_info_net(info);
2002 struct sock *sk = net->genl_sock;
2003
2004 if (WARN_ON_ONCE(group >= family->n_mcgrps)) {
2005 kfree_skb(skb);
2006 return;
2007 }
2008
2009 group = family->mcgrp_offset + group;
2010 nlmsg_notify(sk, skb, info->snd_portid, group,
2011 nlmsg_report(info->nlhdr), flags);
2012}
2013EXPORT_SYMBOL(genl_notify);