1
2
3
4
5
6
7
8
9#include <linux/module.h>
10#include <linux/kernel.h>
11#include <linux/slab.h>
12#include <linux/errno.h>
13#include <linux/types.h>
14#include <linux/socket.h>
15#include <linux/string.h>
16#include <linux/skbuff.h>
17#include <linux/mutex.h>
18#include <linux/bitmap.h>
19#include <net/sock.h>
20#include <net/genetlink.h>
21
22static DEFINE_MUTEX(genl_mutex);
23
24void genl_lock(void)
25{
26 mutex_lock(&genl_mutex);
27}
28EXPORT_SYMBOL(genl_lock);
29
30void genl_unlock(void)
31{
32 mutex_unlock(&genl_mutex);
33}
34EXPORT_SYMBOL(genl_unlock);
35
36#ifdef CONFIG_LOCKDEP
37int lockdep_genl_is_held(void)
38{
39 return lockdep_is_held(&genl_mutex);
40}
41EXPORT_SYMBOL(lockdep_genl_is_held);
42#endif
43
44#define GENL_FAM_TAB_SIZE 16
45#define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1)
46
47static struct list_head family_ht[GENL_FAM_TAB_SIZE];
48
49
50
51
52
53
54
55static unsigned long mc_group_start = 0x1;
56static unsigned long *mc_groups = &mc_group_start;
57static unsigned long mc_groups_longs = 1;
58
59static int genl_ctrl_event(int event, void *data);
60
61static inline unsigned int genl_family_hash(unsigned int id)
62{
63 return id & GENL_FAM_TAB_MASK;
64}
65
66static inline struct list_head *genl_family_chain(unsigned int id)
67{
68 return &family_ht[genl_family_hash(id)];
69}
70
71static struct genl_family *genl_family_find_byid(unsigned int id)
72{
73 struct genl_family *f;
74
75 list_for_each_entry(f, genl_family_chain(id), family_list)
76 if (f->id == id)
77 return f;
78
79 return NULL;
80}
81
82static struct genl_family *genl_family_find_byname(char *name)
83{
84 struct genl_family *f;
85 int i;
86
87 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
88 list_for_each_entry(f, genl_family_chain(i), family_list)
89 if (strcmp(f->name, name) == 0)
90 return f;
91
92 return NULL;
93}
94
95static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
96{
97 struct genl_ops *ops;
98
99 list_for_each_entry(ops, &family->ops_list, ops_list)
100 if (ops->cmd == cmd)
101 return ops;
102
103 return NULL;
104}
105
106
107
108
109static u16 genl_generate_id(void)
110{
111 static u16 id_gen_idx = GENL_MIN_ID;
112 int i;
113
114 for (i = 0; i <= GENL_MAX_ID - GENL_MIN_ID; i++) {
115 if (!genl_family_find_byid(id_gen_idx))
116 return id_gen_idx;
117 if (++id_gen_idx > GENL_MAX_ID)
118 id_gen_idx = GENL_MIN_ID;
119 }
120
121 return 0;
122}
123
124static struct genl_multicast_group notify_grp;
125
126
127
128
129
130
131
132
133
134
135
136
137int genl_register_mc_group(struct genl_family *family,
138 struct genl_multicast_group *grp)
139{
140 int id;
141 unsigned long *new_groups;
142 int err = 0;
143
144 BUG_ON(grp->name[0] == '\0');
145 BUG_ON(memchr(grp->name, '\0', GENL_NAMSIZ) == NULL);
146
147 genl_lock();
148
149
150 if (grp == ¬ify_grp)
151 id = GENL_ID_CTRL;
152 else
153 id = find_first_zero_bit(mc_groups,
154 mc_groups_longs * BITS_PER_LONG);
155
156
157 if (id >= mc_groups_longs * BITS_PER_LONG) {
158 size_t nlen = (mc_groups_longs + 1) * sizeof(unsigned long);
159
160 if (mc_groups == &mc_group_start) {
161 new_groups = kzalloc(nlen, GFP_KERNEL);
162 if (!new_groups) {
163 err = -ENOMEM;
164 goto out;
165 }
166 mc_groups = new_groups;
167 *mc_groups = mc_group_start;
168 } else {
169 new_groups = krealloc(mc_groups, nlen, GFP_KERNEL);
170 if (!new_groups) {
171 err = -ENOMEM;
172 goto out;
173 }
174 mc_groups = new_groups;
175 mc_groups[mc_groups_longs] = 0;
176 }
177 mc_groups_longs++;
178 }
179
180 if (family->netnsok) {
181 struct net *net;
182
183 netlink_table_grab();
184 rcu_read_lock();
185 for_each_net_rcu(net) {
186 err = __netlink_change_ngroups(net->genl_sock,
187 mc_groups_longs * BITS_PER_LONG);
188 if (err) {
189
190
191
192
193
194
195 rcu_read_unlock();
196 netlink_table_ungrab();
197 goto out;
198 }
199 }
200 rcu_read_unlock();
201 netlink_table_ungrab();
202 } else {
203 err = netlink_change_ngroups(init_net.genl_sock,
204 mc_groups_longs * BITS_PER_LONG);
205 if (err)
206 goto out;
207 }
208
209 grp->id = id;
210 set_bit(id, mc_groups);
211 list_add_tail(&grp->list, &family->mcast_groups);
212 grp->family = family;
213
214 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, grp);
215 out:
216 genl_unlock();
217 return err;
218}
219EXPORT_SYMBOL(genl_register_mc_group);
220
221static void __genl_unregister_mc_group(struct genl_family *family,
222 struct genl_multicast_group *grp)
223{
224 struct net *net;
225 BUG_ON(grp->family != family);
226
227 netlink_table_grab();
228 rcu_read_lock();
229 for_each_net_rcu(net)
230 __netlink_clear_multicast_users(net->genl_sock, grp->id);
231 rcu_read_unlock();
232 netlink_table_ungrab();
233
234 clear_bit(grp->id, mc_groups);
235 list_del(&grp->list);
236 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp);
237 grp->id = 0;
238 grp->family = NULL;
239}
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255void genl_unregister_mc_group(struct genl_family *family,
256 struct genl_multicast_group *grp)
257{
258 genl_lock();
259 __genl_unregister_mc_group(family, grp);
260 genl_unlock();
261}
262EXPORT_SYMBOL(genl_unregister_mc_group);
263
264static void genl_unregister_mc_groups(struct genl_family *family)
265{
266 struct genl_multicast_group *grp, *tmp;
267
268 list_for_each_entry_safe(grp, tmp, &family->mcast_groups, list)
269 __genl_unregister_mc_group(family, grp);
270}
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287int genl_register_ops(struct genl_family *family, struct genl_ops *ops)
288{
289 int err = -EINVAL;
290
291 if (ops->dumpit == NULL && ops->doit == NULL)
292 goto errout;
293
294 if (genl_get_cmd(ops->cmd, family)) {
295 err = -EEXIST;
296 goto errout;
297 }
298
299 if (ops->dumpit)
300 ops->flags |= GENL_CMD_CAP_DUMP;
301 if (ops->doit)
302 ops->flags |= GENL_CMD_CAP_DO;
303 if (ops->policy)
304 ops->flags |= GENL_CMD_CAP_HASPOL;
305
306 genl_lock();
307 list_add_tail(&ops->ops_list, &family->ops_list);
308 genl_unlock();
309
310 genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
311 err = 0;
312errout:
313 return err;
314}
315EXPORT_SYMBOL(genl_register_ops);
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops)
334{
335 struct genl_ops *rc;
336
337 genl_lock();
338 list_for_each_entry(rc, &family->ops_list, ops_list) {
339 if (rc == ops) {
340 list_del(&ops->ops_list);
341 genl_unlock();
342 genl_ctrl_event(CTRL_CMD_DELOPS, ops);
343 return 0;
344 }
345 }
346 genl_unlock();
347
348 return -ENOENT;
349}
350EXPORT_SYMBOL(genl_unregister_ops);
351
352
353
354
355
356
357
358
359
360
361
362
363int genl_register_family(struct genl_family *family)
364{
365 int err = -EINVAL;
366
367 if (family->id && family->id < GENL_MIN_ID)
368 goto errout;
369
370 if (family->id > GENL_MAX_ID)
371 goto errout;
372
373 INIT_LIST_HEAD(&family->ops_list);
374 INIT_LIST_HEAD(&family->mcast_groups);
375
376 genl_lock();
377
378 if (genl_family_find_byname(family->name)) {
379 err = -EEXIST;
380 goto errout_locked;
381 }
382
383 if (family->id == GENL_ID_GENERATE) {
384 u16 newid = genl_generate_id();
385
386 if (!newid) {
387 err = -ENOMEM;
388 goto errout_locked;
389 }
390
391 family->id = newid;
392 } else if (genl_family_find_byid(family->id)) {
393 err = -EEXIST;
394 goto errout_locked;
395 }
396
397 if (family->maxattr) {
398 family->attrbuf = kmalloc((family->maxattr+1) *
399 sizeof(struct nlattr *), GFP_KERNEL);
400 if (family->attrbuf == NULL) {
401 err = -ENOMEM;
402 goto errout_locked;
403 }
404 } else
405 family->attrbuf = NULL;
406
407 list_add_tail(&family->family_list, genl_family_chain(family->id));
408 genl_unlock();
409
410 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
411
412 return 0;
413
414errout_locked:
415 genl_unlock();
416errout:
417 return err;
418}
419EXPORT_SYMBOL(genl_register_family);
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446int genl_register_family_with_ops(struct genl_family *family,
447 struct genl_ops *ops, size_t n_ops)
448{
449 int err, i;
450
451 err = genl_register_family(family);
452 if (err)
453 return err;
454
455 for (i = 0; i < n_ops; ++i, ++ops) {
456 err = genl_register_ops(family, ops);
457 if (err)
458 goto err_out;
459 }
460 return 0;
461err_out:
462 genl_unregister_family(family);
463 return err;
464}
465EXPORT_SYMBOL(genl_register_family_with_ops);
466
467
468
469
470
471
472
473
474
475int genl_unregister_family(struct genl_family *family)
476{
477 struct genl_family *rc;
478
479 genl_lock();
480
481 genl_unregister_mc_groups(family);
482
483 list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
484 if (family->id != rc->id || strcmp(rc->name, family->name))
485 continue;
486
487 list_del(&rc->family_list);
488 INIT_LIST_HEAD(&family->ops_list);
489 genl_unlock();
490
491 kfree(family->attrbuf);
492 genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
493 return 0;
494 }
495
496 genl_unlock();
497
498 return -ENOENT;
499}
500EXPORT_SYMBOL(genl_unregister_family);
501
502
503
504
505
506
507
508
509
510
511
512
513void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
514 struct genl_family *family, int flags, u8 cmd)
515{
516 struct nlmsghdr *nlh;
517 struct genlmsghdr *hdr;
518
519 nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +
520 family->hdrsize, flags);
521 if (nlh == NULL)
522 return NULL;
523
524 hdr = nlmsg_data(nlh);
525 hdr->cmd = cmd;
526 hdr->version = family->version;
527 hdr->reserved = 0;
528
529 return (char *) hdr + GENL_HDRLEN;
530}
531EXPORT_SYMBOL(genlmsg_put);
532
533static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
534{
535 struct genl_ops *ops;
536 struct genl_family *family;
537 struct net *net = sock_net(skb->sk);
538 struct genl_info info;
539 struct genlmsghdr *hdr = nlmsg_data(nlh);
540 int hdrlen, err;
541
542 family = genl_family_find_byid(nlh->nlmsg_type);
543 if (family == NULL)
544 return -ENOENT;
545
546
547 if (!family->netnsok && !net_eq(net, &init_net))
548 return -ENOENT;
549
550 hdrlen = GENL_HDRLEN + family->hdrsize;
551 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
552 return -EINVAL;
553
554 ops = genl_get_cmd(hdr->cmd, family);
555 if (ops == NULL)
556 return -EOPNOTSUPP;
557
558 if ((ops->flags & GENL_ADMIN_PERM) &&
559 !capable(CAP_NET_ADMIN))
560 return -EPERM;
561
562 if (nlh->nlmsg_flags & NLM_F_DUMP) {
563 if (ops->dumpit == NULL)
564 return -EOPNOTSUPP;
565
566 genl_unlock();
567 {
568 struct netlink_dump_control c = {
569 .dump = ops->dumpit,
570 .done = ops->done,
571 };
572 err = netlink_dump_start(net->genl_sock, skb, nlh, &c);
573 }
574 genl_lock();
575 return err;
576 }
577
578 if (ops->doit == NULL)
579 return -EOPNOTSUPP;
580
581 if (family->attrbuf) {
582 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
583 ops->policy);
584 if (err < 0)
585 return err;
586 }
587
588 info.snd_seq = nlh->nlmsg_seq;
589 info.snd_portid = NETLINK_CB(skb).portid;
590 info.nlhdr = nlh;
591 info.genlhdr = nlmsg_data(nlh);
592 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
593 info.attrs = family->attrbuf;
594 genl_info_net_set(&info, net);
595 memset(&info.user_ptr, 0, sizeof(info.user_ptr));
596
597 if (family->pre_doit) {
598 err = family->pre_doit(ops, skb, &info);
599 if (err)
600 return err;
601 }
602
603 err = ops->doit(skb, &info);
604
605 if (family->post_doit)
606 family->post_doit(ops, skb, &info);
607
608 return err;
609}
610
611static void genl_rcv(struct sk_buff *skb)
612{
613 genl_lock();
614 netlink_rcv_skb(skb, &genl_rcv_msg);
615 genl_unlock();
616}
617
618
619
620
621
622static struct genl_family genl_ctrl = {
623 .id = GENL_ID_CTRL,
624 .name = "nlctrl",
625 .version = 0x2,
626 .maxattr = CTRL_ATTR_MAX,
627 .netnsok = true,
628};
629
630static int ctrl_fill_info(struct genl_family *family, u32 portid, u32 seq,
631 u32 flags, struct sk_buff *skb, u8 cmd)
632{
633 void *hdr;
634
635 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
636 if (hdr == NULL)
637 return -1;
638
639 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
640 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
641 nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
642 nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
643 nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
644 goto nla_put_failure;
645
646 if (!list_empty(&family->ops_list)) {
647 struct nlattr *nla_ops;
648 struct genl_ops *ops;
649 int idx = 1;
650
651 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
652 if (nla_ops == NULL)
653 goto nla_put_failure;
654
655 list_for_each_entry(ops, &family->ops_list, ops_list) {
656 struct nlattr *nest;
657
658 nest = nla_nest_start(skb, idx++);
659 if (nest == NULL)
660 goto nla_put_failure;
661
662 if (nla_put_u32(skb, CTRL_ATTR_OP_ID, ops->cmd) ||
663 nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, ops->flags))
664 goto nla_put_failure;
665
666 nla_nest_end(skb, nest);
667 }
668
669 nla_nest_end(skb, nla_ops);
670 }
671
672 if (!list_empty(&family->mcast_groups)) {
673 struct genl_multicast_group *grp;
674 struct nlattr *nla_grps;
675 int idx = 1;
676
677 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
678 if (nla_grps == NULL)
679 goto nla_put_failure;
680
681 list_for_each_entry(grp, &family->mcast_groups, list) {
682 struct nlattr *nest;
683
684 nest = nla_nest_start(skb, idx++);
685 if (nest == NULL)
686 goto nla_put_failure;
687
688 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id) ||
689 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
690 grp->name))
691 goto nla_put_failure;
692
693 nla_nest_end(skb, nest);
694 }
695 nla_nest_end(skb, nla_grps);
696 }
697
698 return genlmsg_end(skb, hdr);
699
700nla_put_failure:
701 genlmsg_cancel(skb, hdr);
702 return -EMSGSIZE;
703}
704
705static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 portid,
706 u32 seq, u32 flags, struct sk_buff *skb,
707 u8 cmd)
708{
709 void *hdr;
710 struct nlattr *nla_grps;
711 struct nlattr *nest;
712
713 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
714 if (hdr == NULL)
715 return -1;
716
717 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name) ||
718 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id))
719 goto nla_put_failure;
720
721 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
722 if (nla_grps == NULL)
723 goto nla_put_failure;
724
725 nest = nla_nest_start(skb, 1);
726 if (nest == NULL)
727 goto nla_put_failure;
728
729 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id) ||
730 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
731 grp->name))
732 goto nla_put_failure;
733
734 nla_nest_end(skb, nest);
735 nla_nest_end(skb, nla_grps);
736
737 return genlmsg_end(skb, hdr);
738
739nla_put_failure:
740 genlmsg_cancel(skb, hdr);
741 return -EMSGSIZE;
742}
743
744static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
745{
746
747 int i, n = 0;
748 struct genl_family *rt;
749 struct net *net = sock_net(skb->sk);
750 int chains_to_skip = cb->args[0];
751 int fams_to_skip = cb->args[1];
752
753 for (i = chains_to_skip; i < GENL_FAM_TAB_SIZE; i++) {
754 n = 0;
755 list_for_each_entry(rt, genl_family_chain(i), family_list) {
756 if (!rt->netnsok && !net_eq(net, &init_net))
757 continue;
758 if (++n < fams_to_skip)
759 continue;
760 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
761 cb->nlh->nlmsg_seq, NLM_F_MULTI,
762 skb, CTRL_CMD_NEWFAMILY) < 0)
763 goto errout;
764 }
765
766 fams_to_skip = 0;
767 }
768
769errout:
770 cb->args[0] = i;
771 cb->args[1] = n;
772
773 return skb->len;
774}
775
776static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
777 u32 portid, int seq, u8 cmd)
778{
779 struct sk_buff *skb;
780 int err;
781
782 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
783 if (skb == NULL)
784 return ERR_PTR(-ENOBUFS);
785
786 err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);
787 if (err < 0) {
788 nlmsg_free(skb);
789 return ERR_PTR(err);
790 }
791
792 return skb;
793}
794
795static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp,
796 u32 portid, int seq, u8 cmd)
797{
798 struct sk_buff *skb;
799 int err;
800
801 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
802 if (skb == NULL)
803 return ERR_PTR(-ENOBUFS);
804
805 err = ctrl_fill_mcgrp_info(grp, portid, seq, 0, skb, cmd);
806 if (err < 0) {
807 nlmsg_free(skb);
808 return ERR_PTR(err);
809 }
810
811 return skb;
812}
813
814static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
815 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
816 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
817 .len = GENL_NAMSIZ - 1 },
818};
819
820static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
821{
822 struct sk_buff *msg;
823 struct genl_family *res = NULL;
824 int err = -EINVAL;
825
826 if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
827 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
828 res = genl_family_find_byid(id);
829 err = -ENOENT;
830 }
831
832 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
833 char *name;
834
835 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
836 res = genl_family_find_byname(name);
837#ifdef CONFIG_MODULES
838 if (res == NULL) {
839 genl_unlock();
840 request_module("net-pf-%d-proto-%d-family-%s",
841 PF_NETLINK, NETLINK_GENERIC, name);
842 genl_lock();
843 res = genl_family_find_byname(name);
844 }
845#endif
846 err = -ENOENT;
847 }
848
849 if (res == NULL)
850 return err;
851
852 if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) {
853
854 return -ENOENT;
855 }
856
857 msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,
858 CTRL_CMD_NEWFAMILY);
859 if (IS_ERR(msg))
860 return PTR_ERR(msg);
861
862 return genlmsg_reply(msg, info);
863}
864
865static int genl_ctrl_event(int event, void *data)
866{
867 struct sk_buff *msg;
868 struct genl_family *family;
869 struct genl_multicast_group *grp;
870
871
872 if (!init_net.genl_sock)
873 return 0;
874
875 switch (event) {
876 case CTRL_CMD_NEWFAMILY:
877 case CTRL_CMD_DELFAMILY:
878 family = data;
879 msg = ctrl_build_family_msg(family, 0, 0, event);
880 break;
881 case CTRL_CMD_NEWMCAST_GRP:
882 case CTRL_CMD_DELMCAST_GRP:
883 grp = data;
884 family = grp->family;
885 msg = ctrl_build_mcgrp_msg(data, 0, 0, event);
886 break;
887 default:
888 return -EINVAL;
889 }
890
891 if (IS_ERR(msg))
892 return PTR_ERR(msg);
893
894 if (!family->netnsok) {
895 genlmsg_multicast_netns(&init_net, msg, 0,
896 GENL_ID_CTRL, GFP_KERNEL);
897 } else {
898 rcu_read_lock();
899 genlmsg_multicast_allns(msg, 0, GENL_ID_CTRL, GFP_ATOMIC);
900 rcu_read_unlock();
901 }
902
903 return 0;
904}
905
906static struct genl_ops genl_ctrl_ops = {
907 .cmd = CTRL_CMD_GETFAMILY,
908 .doit = ctrl_getfamily,
909 .dumpit = ctrl_dumpfamily,
910 .policy = ctrl_policy,
911};
912
913static struct genl_multicast_group notify_grp = {
914 .name = "notify",
915};
916
917static int __net_init genl_pernet_init(struct net *net)
918{
919 struct netlink_kernel_cfg cfg = {
920 .input = genl_rcv,
921 .cb_mutex = &genl_mutex,
922 .flags = NL_CFG_F_NONROOT_RECV,
923 };
924
925
926 net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);
927
928 if (!net->genl_sock && net_eq(net, &init_net))
929 panic("GENL: Cannot initialize generic netlink\n");
930
931 if (!net->genl_sock)
932 return -ENOMEM;
933
934 return 0;
935}
936
937static void __net_exit genl_pernet_exit(struct net *net)
938{
939 netlink_kernel_release(net->genl_sock);
940 net->genl_sock = NULL;
941}
942
943static struct pernet_operations genl_pernet_ops = {
944 .init = genl_pernet_init,
945 .exit = genl_pernet_exit,
946};
947
948static int __init genl_init(void)
949{
950 int i, err;
951
952 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
953 INIT_LIST_HEAD(&family_ht[i]);
954
955 err = genl_register_family_with_ops(&genl_ctrl, &genl_ctrl_ops, 1);
956 if (err < 0)
957 goto problem;
958
959 err = register_pernet_subsys(&genl_pernet_ops);
960 if (err)
961 goto problem;
962
963 err = genl_register_mc_group(&genl_ctrl, ¬ify_grp);
964 if (err < 0)
965 goto problem;
966
967 return 0;
968
969problem:
970 panic("GENL: Cannot register controller: %d\n", err);
971}
972
973subsys_initcall(genl_init);
974
975static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
976 gfp_t flags)
977{
978 struct sk_buff *tmp;
979 struct net *net, *prev = NULL;
980 int err;
981
982 for_each_net_rcu(net) {
983 if (prev) {
984 tmp = skb_clone(skb, flags);
985 if (!tmp) {
986 err = -ENOMEM;
987 goto error;
988 }
989 err = nlmsg_multicast(prev->genl_sock, tmp,
990 portid, group, flags);
991 if (err)
992 goto error;
993 }
994
995 prev = net;
996 }
997
998 return nlmsg_multicast(prev->genl_sock, skb, portid, group, flags);
999 error:
1000 kfree_skb(skb);
1001 return err;
1002}
1003
1004int genlmsg_multicast_allns(struct sk_buff *skb, u32 portid, unsigned int group,
1005 gfp_t flags)
1006{
1007 return genlmsg_mcast(skb, portid, group, flags);
1008}
1009EXPORT_SYMBOL(genlmsg_multicast_allns);
1010
1011void genl_notify(struct sk_buff *skb, struct net *net, u32 portid, u32 group,
1012 struct nlmsghdr *nlh, gfp_t flags)
1013{
1014 struct sock *sk = net->genl_sock;
1015 int report = 0;
1016
1017 if (nlh)
1018 report = nlmsg_report(nlh);
1019
1020 nlmsg_notify(sk, skb, portid, group, report, flags);
1021}
1022EXPORT_SYMBOL(genl_notify);
1023