Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[pandora-kernel.git] / net / netlink / genetlink.c
1 /*
2  * NETLINK      Generic Netlink Family
3  *
4  *              Authors:        Jamal Hadi Salim
5  *                              Thomas Graf <tgraf@suug.ch>
6  *                              Johannes Berg <johannes@sipsolutions.net>
7  */
8
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/errno.h>
12 #include <linux/types.h>
13 #include <linux/socket.h>
14 #include <linux/string.h>
15 #include <linux/skbuff.h>
16 #include <linux/mutex.h>
17 #include <linux/bitmap.h>
18 #include <net/sock.h>
19 #include <net/genetlink.h>
20
21 struct sock *genl_sock = NULL;
22
23 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
24
25 static void genl_lock(void)
26 {
27         mutex_lock(&genl_mutex);
28 }
29
30 static int genl_trylock(void)
31 {
32         return !mutex_trylock(&genl_mutex);
33 }
34
35 static void genl_unlock(void)
36 {
37         mutex_unlock(&genl_mutex);
38
39         if (genl_sock && genl_sock->sk_receive_queue.qlen)
40                 genl_sock->sk_data_ready(genl_sock, 0);
41 }
42
43 #define GENL_FAM_TAB_SIZE       16
44 #define GENL_FAM_TAB_MASK       (GENL_FAM_TAB_SIZE - 1)
45
46 static struct list_head family_ht[GENL_FAM_TAB_SIZE];
47 /*
48  * Bitmap of multicast groups that are currently in use.
49  *
50  * To avoid an allocation at boot of just one unsigned long,
51  * declare it global instead.
52  * Bit 0 is marked as already used since group 0 is invalid.
53  */
54 static unsigned long mc_group_start = 0x1;
55 static unsigned long *mc_groups = &mc_group_start;
56 static unsigned long mc_groups_longs = 1;
57
58 static int genl_ctrl_event(int event, void *data);
59
60 static inline unsigned int genl_family_hash(unsigned int id)
61 {
62         return id & GENL_FAM_TAB_MASK;
63 }
64
65 static inline struct list_head *genl_family_chain(unsigned int id)
66 {
67         return &family_ht[genl_family_hash(id)];
68 }
69
70 static struct genl_family *genl_family_find_byid(unsigned int id)
71 {
72         struct genl_family *f;
73
74         list_for_each_entry(f, genl_family_chain(id), family_list)
75                 if (f->id == id)
76                         return f;
77
78         return NULL;
79 }
80
81 static struct genl_family *genl_family_find_byname(char *name)
82 {
83         struct genl_family *f;
84         int i;
85
86         for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
87                 list_for_each_entry(f, genl_family_chain(i), family_list)
88                         if (strcmp(f->name, name) == 0)
89                                 return f;
90
91         return NULL;
92 }
93
94 static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
95 {
96         struct genl_ops *ops;
97
98         list_for_each_entry(ops, &family->ops_list, ops_list)
99                 if (ops->cmd == cmd)
100                         return ops;
101
102         return NULL;
103 }
104
105 /* Of course we are going to have problems once we hit
106  * 2^16 alive types, but that can only happen by year 2K
107 */
108 static inline u16 genl_generate_id(void)
109 {
110         static u16 id_gen_idx;
111         int overflowed = 0;
112
113         do {
114                 if (id_gen_idx == 0)
115                         id_gen_idx = GENL_MIN_ID;
116
117                 if (++id_gen_idx > GENL_MAX_ID) {
118                         if (!overflowed) {
119                                 overflowed = 1;
120                                 id_gen_idx = 0;
121                                 continue;
122                         } else
123                                 return 0;
124                 }
125
126         } while (genl_family_find_byid(id_gen_idx));
127
128         return id_gen_idx;
129 }
130
131 static struct genl_multicast_group notify_grp;
132
133 /**
134  * genl_register_mc_group - register a multicast group
135  *
136  * Registers the specified multicast group and notifies userspace
137  * about the new group.
138  *
139  * Returns 0 on success or a negative error code.
140  *
141  * @family: The generic netlink family the group shall be registered for.
142  * @grp: The group to register, must have a name.
143  */
144 int genl_register_mc_group(struct genl_family *family,
145                            struct genl_multicast_group *grp)
146 {
147         int id;
148         unsigned long *new_groups;
149         int err;
150
151         BUG_ON(grp->name[0] == '\0');
152
153         genl_lock();
154
155         /* special-case our own group */
156         if (grp == &notify_grp)
157                 id = GENL_ID_CTRL;
158         else
159                 id = find_first_zero_bit(mc_groups,
160                                          mc_groups_longs * BITS_PER_LONG);
161
162
163         if (id >= mc_groups_longs * BITS_PER_LONG) {
164                 size_t nlen = (mc_groups_longs + 1) * sizeof(unsigned long);
165
166                 if (mc_groups == &mc_group_start) {
167                         new_groups = kzalloc(nlen, GFP_KERNEL);
168                         if (!new_groups) {
169                                 err = -ENOMEM;
170                                 goto out;
171                         }
172                         mc_groups = new_groups;
173                         *mc_groups = mc_group_start;
174                 } else {
175                         new_groups = krealloc(mc_groups, nlen, GFP_KERNEL);
176                         if (!new_groups) {
177                                 err = -ENOMEM;
178                                 goto out;
179                         }
180                         mc_groups = new_groups;
181                         mc_groups[mc_groups_longs] = 0;
182                 }
183                 mc_groups_longs++;
184         }
185
186         err = netlink_change_ngroups(genl_sock,
187                                      mc_groups_longs * BITS_PER_LONG);
188         if (err)
189                 goto out;
190
191         grp->id = id;
192         set_bit(id, mc_groups);
193         list_add_tail(&grp->list, &family->mcast_groups);
194         grp->family = family;
195
196         genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, grp);
197  out:
198         genl_unlock();
199         return err;
200 }
201 EXPORT_SYMBOL(genl_register_mc_group);
202
203 static void __genl_unregister_mc_group(struct genl_family *family,
204                                        struct genl_multicast_group *grp)
205 {
206         BUG_ON(grp->family != family);
207         netlink_clear_multicast_users(genl_sock, grp->id);
208         clear_bit(grp->id, mc_groups);
209         list_del(&grp->list);
210         genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp);
211         grp->id = 0;
212         grp->family = NULL;
213 }
214
215 /**
216  * genl_unregister_mc_group - unregister a multicast group
217  *
218  * Unregisters the specified multicast group and notifies userspace
219  * about it. All current listeners on the group are removed.
220  *
221  * Note: It is not necessary to unregister all multicast groups before
222  *       unregistering the family, unregistering the family will cause
223  *       all assigned multicast groups to be unregistered automatically.
224  *
225  * @family: Generic netlink family the group belongs to.
226  * @grp: The group to unregister, must have been registered successfully
227  *       previously.
228  */
229 void genl_unregister_mc_group(struct genl_family *family,
230                               struct genl_multicast_group *grp)
231 {
232         genl_lock();
233         __genl_unregister_mc_group(family, grp);
234         genl_unlock();
235 }
236
237 static void genl_unregister_mc_groups(struct genl_family *family)
238 {
239         struct genl_multicast_group *grp, *tmp;
240
241         genl_lock();
242         list_for_each_entry_safe(grp, tmp, &family->mcast_groups, list)
243                 __genl_unregister_mc_group(family, grp);
244         genl_unlock();
245 }
246
247 /**
248  * genl_register_ops - register generic netlink operations
249  * @family: generic netlink family
250  * @ops: operations to be registered
251  *
252  * Registers the specified operations and assigns them to the specified
253  * family. Either a doit or dumpit callback must be specified or the
254  * operation will fail. Only one operation structure per command
255  * identifier may be registered.
256  *
257  * See include/net/genetlink.h for more documenation on the operations
258  * structure.
259  *
260  * Returns 0 on success or a negative error code.
261  */
262 int genl_register_ops(struct genl_family *family, struct genl_ops *ops)
263 {
264         int err = -EINVAL;
265
266         if (ops->dumpit == NULL && ops->doit == NULL)
267                 goto errout;
268
269         if (genl_get_cmd(ops->cmd, family)) {
270                 err = -EEXIST;
271                 goto errout;
272         }
273
274         if (ops->dumpit)
275                 ops->flags |= GENL_CMD_CAP_DUMP;
276         if (ops->doit)
277                 ops->flags |= GENL_CMD_CAP_DO;
278         if (ops->policy)
279                 ops->flags |= GENL_CMD_CAP_HASPOL;
280
281         genl_lock();
282         list_add_tail(&ops->ops_list, &family->ops_list);
283         genl_unlock();
284
285         genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
286         err = 0;
287 errout:
288         return err;
289 }
290
291 /**
292  * genl_unregister_ops - unregister generic netlink operations
293  * @family: generic netlink family
294  * @ops: operations to be unregistered
295  *
296  * Unregisters the specified operations and unassigns them from the
297  * specified family. The operation blocks until the current message
298  * processing has finished and doesn't start again until the
299  * unregister process has finished.
300  *
301  * Note: It is not necessary to unregister all operations before
302  *       unregistering the family, unregistering the family will cause
303  *       all assigned operations to be unregistered automatically.
304  *
305  * Returns 0 on success or a negative error code.
306  */
307 int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops)
308 {
309         struct genl_ops *rc;
310
311         genl_lock();
312         list_for_each_entry(rc, &family->ops_list, ops_list) {
313                 if (rc == ops) {
314                         list_del(&ops->ops_list);
315                         genl_unlock();
316                         genl_ctrl_event(CTRL_CMD_DELOPS, ops);
317                         return 0;
318                 }
319         }
320         genl_unlock();
321
322         return -ENOENT;
323 }
324
325 /**
326  * genl_register_family - register a generic netlink family
327  * @family: generic netlink family
328  *
329  * Registers the specified family after validating it first. Only one
330  * family may be registered with the same family name or identifier.
331  * The family id may equal GENL_ID_GENERATE causing an unique id to
332  * be automatically generated and assigned.
333  *
334  * Return 0 on success or a negative error code.
335  */
336 int genl_register_family(struct genl_family *family)
337 {
338         int err = -EINVAL;
339
340         if (family->id && family->id < GENL_MIN_ID)
341                 goto errout;
342
343         if (family->id > GENL_MAX_ID)
344                 goto errout;
345
346         INIT_LIST_HEAD(&family->ops_list);
347         INIT_LIST_HEAD(&family->mcast_groups);
348
349         genl_lock();
350
351         if (genl_family_find_byname(family->name)) {
352                 err = -EEXIST;
353                 goto errout_locked;
354         }
355
356         if (genl_family_find_byid(family->id)) {
357                 err = -EEXIST;
358                 goto errout_locked;
359         }
360
361         if (family->id == GENL_ID_GENERATE) {
362                 u16 newid = genl_generate_id();
363
364                 if (!newid) {
365                         err = -ENOMEM;
366                         goto errout_locked;
367                 }
368
369                 family->id = newid;
370         }
371
372         if (family->maxattr) {
373                 family->attrbuf = kmalloc((family->maxattr+1) *
374                                         sizeof(struct nlattr *), GFP_KERNEL);
375                 if (family->attrbuf == NULL) {
376                         err = -ENOMEM;
377                         goto errout_locked;
378                 }
379         } else
380                 family->attrbuf = NULL;
381
382         list_add_tail(&family->family_list, genl_family_chain(family->id));
383         genl_unlock();
384
385         genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
386
387         return 0;
388
389 errout_locked:
390         genl_unlock();
391 errout:
392         return err;
393 }
394
395 /**
396  * genl_unregister_family - unregister generic netlink family
397  * @family: generic netlink family
398  *
399  * Unregisters the specified family.
400  *
401  * Returns 0 on success or a negative error code.
402  */
403 int genl_unregister_family(struct genl_family *family)
404 {
405         struct genl_family *rc;
406
407         genl_unregister_mc_groups(family);
408
409         genl_lock();
410
411         list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
412                 if (family->id != rc->id || strcmp(rc->name, family->name))
413                         continue;
414
415                 list_del(&rc->family_list);
416                 INIT_LIST_HEAD(&family->ops_list);
417                 genl_unlock();
418
419                 kfree(family->attrbuf);
420                 genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
421                 return 0;
422         }
423
424         genl_unlock();
425
426         return -ENOENT;
427 }
428
429 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
430 {
431         struct genl_ops *ops;
432         struct genl_family *family;
433         struct genl_info info;
434         struct genlmsghdr *hdr = nlmsg_data(nlh);
435         int hdrlen, err;
436
437         family = genl_family_find_byid(nlh->nlmsg_type);
438         if (family == NULL)
439                 return -ENOENT;
440
441         hdrlen = GENL_HDRLEN + family->hdrsize;
442         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
443                 return -EINVAL;
444
445         ops = genl_get_cmd(hdr->cmd, family);
446         if (ops == NULL)
447                 return -EOPNOTSUPP;
448
449         if ((ops->flags & GENL_ADMIN_PERM) &&
450             security_netlink_recv(skb, CAP_NET_ADMIN))
451                 return -EPERM;
452
453         if (nlh->nlmsg_flags & NLM_F_DUMP) {
454                 if (ops->dumpit == NULL)
455                         return -EOPNOTSUPP;
456
457                 return netlink_dump_start(genl_sock, skb, nlh,
458                                           ops->dumpit, ops->done);
459         }
460
461         if (ops->doit == NULL)
462                 return -EOPNOTSUPP;
463
464         if (family->attrbuf) {
465                 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
466                                   ops->policy);
467                 if (err < 0)
468                         return err;
469         }
470
471         info.snd_seq = nlh->nlmsg_seq;
472         info.snd_pid = NETLINK_CB(skb).pid;
473         info.nlhdr = nlh;
474         info.genlhdr = nlmsg_data(nlh);
475         info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
476         info.attrs = family->attrbuf;
477
478         return ops->doit(skb, &info);
479 }
480
481 static void genl_rcv(struct sock *sk, int len)
482 {
483         unsigned int qlen = 0;
484
485         do {
486                 if (genl_trylock())
487                         return;
488                 netlink_run_queue(sk, &qlen, genl_rcv_msg);
489                 genl_unlock();
490         } while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
491 }
492
493 /**************************************************************************
494  * Controller
495  **************************************************************************/
496
497 static struct genl_family genl_ctrl = {
498         .id = GENL_ID_CTRL,
499         .name = "nlctrl",
500         .version = 0x2,
501         .maxattr = CTRL_ATTR_MAX,
502 };
503
504 static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
505                           u32 flags, struct sk_buff *skb, u8 cmd)
506 {
507         void *hdr;
508
509         hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
510         if (hdr == NULL)
511                 return -1;
512
513         NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
514         NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
515         NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version);
516         NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize);
517         NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr);
518
519         if (!list_empty(&family->ops_list)) {
520                 struct nlattr *nla_ops;
521                 struct genl_ops *ops;
522                 int idx = 1;
523
524                 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
525                 if (nla_ops == NULL)
526                         goto nla_put_failure;
527
528                 list_for_each_entry(ops, &family->ops_list, ops_list) {
529                         struct nlattr *nest;
530
531                         nest = nla_nest_start(skb, idx++);
532                         if (nest == NULL)
533                                 goto nla_put_failure;
534
535                         NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd);
536                         NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags);
537
538                         nla_nest_end(skb, nest);
539                 }
540
541                 nla_nest_end(skb, nla_ops);
542         }
543
544         if (!list_empty(&family->mcast_groups)) {
545                 struct genl_multicast_group *grp;
546                 struct nlattr *nla_grps;
547                 int idx = 1;
548
549                 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
550                 if (nla_grps == NULL)
551                         goto nla_put_failure;
552
553                 list_for_each_entry(grp, &family->mcast_groups, list) {
554                         struct nlattr *nest;
555
556                         nest = nla_nest_start(skb, idx++);
557                         if (nest == NULL)
558                                 goto nla_put_failure;
559
560                         NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
561                         NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
562                                        grp->name);
563
564                         nla_nest_end(skb, nest);
565                 }
566                 nla_nest_end(skb, nla_grps);
567         }
568
569         return genlmsg_end(skb, hdr);
570
571 nla_put_failure:
572         return genlmsg_cancel(skb, hdr);
573 }
574
575 static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid,
576                                 u32 seq, u32 flags, struct sk_buff *skb,
577                                 u8 cmd)
578 {
579         void *hdr;
580         struct nlattr *nla_grps;
581         struct nlattr *nest;
582
583         hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
584         if (hdr == NULL)
585                 return -1;
586
587         NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name);
588         NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id);
589
590         nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
591         if (nla_grps == NULL)
592                 goto nla_put_failure;
593
594         nest = nla_nest_start(skb, 1);
595         if (nest == NULL)
596                 goto nla_put_failure;
597
598         NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
599         NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
600                        grp->name);
601
602         nla_nest_end(skb, nest);
603         nla_nest_end(skb, nla_grps);
604
605         return genlmsg_end(skb, hdr);
606
607 nla_put_failure:
608         return genlmsg_cancel(skb, hdr);
609 }
610
611 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
612 {
613
614         int i, n = 0;
615         struct genl_family *rt;
616         int chains_to_skip = cb->args[0];
617         int fams_to_skip = cb->args[1];
618
619         if (chains_to_skip != 0)
620                 genl_lock();
621
622         for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
623                 if (i < chains_to_skip)
624                         continue;
625                 n = 0;
626                 list_for_each_entry(rt, genl_family_chain(i), family_list) {
627                         if (++n < fams_to_skip)
628                                 continue;
629                         if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
630                                            cb->nlh->nlmsg_seq, NLM_F_MULTI,
631                                            skb, CTRL_CMD_NEWFAMILY) < 0)
632                                 goto errout;
633                 }
634
635                 fams_to_skip = 0;
636         }
637
638 errout:
639         if (chains_to_skip != 0)
640                 genl_unlock();
641
642         cb->args[0] = i;
643         cb->args[1] = n;
644
645         return skb->len;
646 }
647
648 static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
649                                              u32 pid, int seq, u8 cmd)
650 {
651         struct sk_buff *skb;
652         int err;
653
654         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
655         if (skb == NULL)
656                 return ERR_PTR(-ENOBUFS);
657
658         err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
659         if (err < 0) {
660                 nlmsg_free(skb);
661                 return ERR_PTR(err);
662         }
663
664         return skb;
665 }
666
667 static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp,
668                                             u32 pid, int seq, u8 cmd)
669 {
670         struct sk_buff *skb;
671         int err;
672
673         skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
674         if (skb == NULL)
675                 return ERR_PTR(-ENOBUFS);
676
677         err = ctrl_fill_mcgrp_info(grp, pid, seq, 0, skb, cmd);
678         if (err < 0) {
679                 nlmsg_free(skb);
680                 return ERR_PTR(err);
681         }
682
683         return skb;
684 }
685
686 static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
687         [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
688         [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
689                                     .len = GENL_NAMSIZ - 1 },
690 };
691
692 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
693 {
694         struct sk_buff *msg;
695         struct genl_family *res = NULL;
696         int err = -EINVAL;
697
698         if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
699                 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
700                 res = genl_family_find_byid(id);
701         }
702
703         if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
704                 char *name;
705
706                 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
707                 res = genl_family_find_byname(name);
708         }
709
710         if (res == NULL) {
711                 err = -ENOENT;
712                 goto errout;
713         }
714
715         msg = ctrl_build_family_msg(res, info->snd_pid, info->snd_seq,
716                                     CTRL_CMD_NEWFAMILY);
717         if (IS_ERR(msg)) {
718                 err = PTR_ERR(msg);
719                 goto errout;
720         }
721
722         err = genlmsg_reply(msg, info);
723 errout:
724         return err;
725 }
726
727 static int genl_ctrl_event(int event, void *data)
728 {
729         struct sk_buff *msg;
730
731         if (genl_sock == NULL)
732                 return 0;
733
734         switch (event) {
735         case CTRL_CMD_NEWFAMILY:
736         case CTRL_CMD_DELFAMILY:
737                 msg = ctrl_build_family_msg(data, 0, 0, event);
738                 if (IS_ERR(msg))
739                         return PTR_ERR(msg);
740
741                 genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
742                 break;
743         case CTRL_CMD_NEWMCAST_GRP:
744         case CTRL_CMD_DELMCAST_GRP:
745                 msg = ctrl_build_mcgrp_msg(data, 0, 0, event);
746                 if (IS_ERR(msg))
747                         return PTR_ERR(msg);
748
749                 genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
750                 break;
751         }
752
753         return 0;
754 }
755
756 static struct genl_ops genl_ctrl_ops = {
757         .cmd            = CTRL_CMD_GETFAMILY,
758         .doit           = ctrl_getfamily,
759         .dumpit         = ctrl_dumpfamily,
760         .policy         = ctrl_policy,
761 };
762
763 static struct genl_multicast_group notify_grp = {
764         .name           = "notify",
765 };
766
767 static int __init genl_init(void)
768 {
769         int i, err;
770
771         for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
772                 INIT_LIST_HEAD(&family_ht[i]);
773
774         err = genl_register_family(&genl_ctrl);
775         if (err < 0)
776                 goto errout;
777
778         err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
779         if (err < 0)
780                 goto errout_register;
781
782         netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
783
784         /* we'll bump the group number right afterwards */
785         genl_sock = netlink_kernel_create(NETLINK_GENERIC, 0, genl_rcv,
786                                           NULL, THIS_MODULE);
787         if (genl_sock == NULL)
788                 panic("GENL: Cannot initialize generic netlink\n");
789
790         err = genl_register_mc_group(&genl_ctrl, &notify_grp);
791         if (err < 0)
792                 goto errout_register;
793
794         return 0;
795
796 errout_register:
797         genl_unregister_family(&genl_ctrl);
798 errout:
799         panic("GENL: Cannot register controller: %d\n", err);
800 }
801
802 subsys_initcall(genl_init);
803
804 EXPORT_SYMBOL(genl_sock);
805 EXPORT_SYMBOL(genl_register_ops);
806 EXPORT_SYMBOL(genl_unregister_ops);
807 EXPORT_SYMBOL(genl_register_family);
808 EXPORT_SYMBOL(genl_unregister_family);