2 * NETLINK Generic Netlink Family
4 * Authors: Jamal Hadi Salim
5 * Thomas Graf <tgraf@suug.ch>
6 * Johannes Berg <johannes@sipsolutions.net>
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 <asm/semaphore.h>
18 #include <net/genetlink.h>
22 struct sock *genl_sock = NULL;
24 static DECLARE_MUTEX(genl_mutex); /* serialization of message processing */
26 static void genl_lock(void)
31 static int genl_trylock(void)
33 return down_trylock(&genl_mutex);
36 static void genl_unlock(void)
40 if (genl_sock && genl_sock->receive_queue.qlen)
41 genl_sock->data_ready(genl_sock, 0);
44 #define GENL_FAM_TAB_SIZE 16
45 #define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1)
47 static struct list_head family_ht[GENL_FAM_TAB_SIZE];
49 * Bitmap of multicast groups that are currently in use.
51 * To avoid an allocation at boot of just one unsigned long,
52 * declare it global instead.
53 * Bit 0 is marked as already used since group 0 is invalid.
55 static unsigned long mc_group_start = 0x1;
56 static unsigned long *mc_groups = &mc_group_start;
57 static unsigned long mc_groups_longs = 1;
59 static int genl_ctrl_event(int event, void *data);
61 static inline unsigned int genl_family_hash(unsigned int id)
63 return id & GENL_FAM_TAB_MASK;
66 static inline struct list_head *genl_family_chain(unsigned int id)
68 return &family_ht[genl_family_hash(id)];
71 static struct genl_family *genl_family_find_byid(unsigned int id)
73 struct genl_family *f;
75 list_for_each_entry(f, genl_family_chain(id), family_list)
82 static struct genl_family *genl_family_find_byname(char *name)
84 struct genl_family *f;
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)
95 static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
99 list_for_each_entry(ops, &family->ops_list, ops_list)
106 /* Of course we are going to have problems once we hit
107 * 2^16 alive types, but that can only happen by year 2K
109 static inline u16 genl_generate_id(void)
111 static u16 id_gen_idx;
116 id_gen_idx = GENL_MIN_ID;
118 if (++id_gen_idx > GENL_MAX_ID) {
127 } while (genl_family_find_byid(id_gen_idx));
132 static struct genl_multicast_group notify_grp;
135 * genl_register_mc_group - register a multicast group
137 * Registers the specified multicast group and notifies userspace
138 * about the new group.
140 * Returns 0 on success or a negative error code.
142 * @family: The generic netlink family the group shall be registered for.
143 * @grp: The group to register, must have a name.
145 int genl_register_mc_group(struct genl_family *family,
146 struct genl_multicast_group *grp)
150 BUG_ON(grp->name[0] == '\0');
154 /* special-case our own group */
155 if (grp == ¬ify_grp)
158 id = find_first_zero_bit(mc_groups,
159 mc_groups_longs * BITS_PER_LONG);
162 if (id >= mc_groups_longs * BITS_PER_LONG) {
168 set_bit(id, mc_groups);
169 list_add_tail(&grp->list, &family->mcast_groups);
170 grp->family = family;
172 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, grp);
176 EXPORT_SYMBOL(genl_register_mc_group);
178 static void __genl_unregister_mc_group(struct genl_family *family,
179 struct genl_multicast_group *grp)
181 BUG_ON(grp->family != family);
183 /* We should clear this multicast group from any subscribers, but 2.4
184 * doesn't have the proper interface to do it, and we'd need a patch to
186 /*netlink_clear_multicast_users(genl_sock, grp->id);*/
187 clear_bit(grp->id, mc_groups);
188 list_del(&grp->list);
189 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp);
195 * genl_unregister_mc_group - unregister a multicast group
197 * Unregisters the specified multicast group and notifies userspace
198 * about it. All current listeners on the group are removed.
200 * Note: It is not necessary to unregister all multicast groups before
201 * unregistering the family, unregistering the family will cause
202 * all assigned multicast groups to be unregistered automatically.
204 * @family: Generic netlink family the group belongs to.
205 * @grp: The group to unregister, must have been registered successfully
208 void genl_unregister_mc_group(struct genl_family *family,
209 struct genl_multicast_group *grp)
212 __genl_unregister_mc_group(family, grp);
215 EXPORT_SYMBOL(genl_unregister_mc_group);
217 static void genl_unregister_mc_groups(struct genl_family *family)
219 struct genl_multicast_group *grp, *tmp;
222 list_for_each_entry_safe(grp, tmp, &family->mcast_groups, list)
223 __genl_unregister_mc_group(family, grp);
228 * genl_register_ops - register generic netlink operations
229 * @family: generic netlink family
230 * @ops: operations to be registered
232 * Registers the specified operations and assigns them to the specified
233 * family. Either a doit or dumpit callback must be specified or the
234 * operation will fail. Only one operation structure per command
235 * identifier may be registered.
237 * See include/net/genetlink.h for more documenation on the operations
240 * Returns 0 on success or a negative error code.
242 int genl_register_ops(struct genl_family *family, struct genl_ops *ops)
246 if (ops->dumpit == NULL && ops->doit == NULL)
249 if (genl_get_cmd(ops->cmd, family)) {
255 ops->flags |= GENL_CMD_CAP_DUMP;
257 ops->flags |= GENL_CMD_CAP_DO;
259 ops->flags |= GENL_CMD_CAP_HASPOL;
262 list_add_tail(&ops->ops_list, &family->ops_list);
265 genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
272 * genl_unregister_ops - unregister generic netlink operations
273 * @family: generic netlink family
274 * @ops: operations to be unregistered
276 * Unregisters the specified operations and unassigns them from the
277 * specified family. The operation blocks until the current message
278 * processing has finished and doesn't start again until the
279 * unregister process has finished.
281 * Note: It is not necessary to unregister all operations before
282 * unregistering the family, unregistering the family will cause
283 * all assigned operations to be unregistered automatically.
285 * Returns 0 on success or a negative error code.
287 int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops)
292 list_for_each_entry(rc, &family->ops_list, ops_list) {
294 list_del(&ops->ops_list);
296 genl_ctrl_event(CTRL_CMD_DELOPS, ops);
306 * genl_register_family - register a generic netlink family
307 * @family: generic netlink family
309 * Registers the specified family after validating it first. Only one
310 * family may be registered with the same family name or identifier.
311 * The family id may equal GENL_ID_GENERATE causing an unique id to
312 * be automatically generated and assigned.
314 * Return 0 on success or a negative error code.
316 int genl_register_family(struct genl_family *family)
320 if (family->id && family->id < GENL_MIN_ID)
323 if (family->id > GENL_MAX_ID)
326 INIT_LIST_HEAD(&family->ops_list);
327 INIT_LIST_HEAD(&family->mcast_groups);
331 if (genl_family_find_byname(family->name)) {
336 if (genl_family_find_byid(family->id)) {
341 if (family->id == GENL_ID_GENERATE) {
342 u16 newid = genl_generate_id();
352 if (family->maxattr) {
353 family->attrbuf = kmalloc((family->maxattr+1) *
354 sizeof(struct nlattr *), GFP_KERNEL);
355 if (family->attrbuf == NULL) {
360 family->attrbuf = NULL;
362 list_add_tail(&family->family_list, genl_family_chain(family->id));
366 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
377 * genl_unregister_family - unregister generic netlink family
378 * @family: generic netlink family
380 * Unregisters the specified family.
382 * Returns 0 on success or a negative error code.
384 int genl_unregister_family(struct genl_family *family)
386 struct genl_family *rc;
388 genl_unregister_mc_groups(family);
392 list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
393 if (family->id != rc->id || strcmp(rc->name, family->name))
396 list_del(&rc->family_list);
397 INIT_LIST_HEAD(&family->ops_list);
400 kfree(family->attrbuf);
401 genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
411 static int null_done_func(struct netlink_callback *cb)
416 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
418 struct genl_ops *ops;
419 struct genl_family *family;
420 struct genl_info info;
421 struct genlmsghdr *hdr = nlmsg_data(nlh);
424 family = genl_family_find_byid(nlh->nlmsg_type);
428 hdrlen = GENL_HDRLEN + family->hdrsize;
429 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
432 ops = genl_get_cmd(hdr->cmd, family);
436 if ((ops->flags & GENL_ADMIN_PERM) && !capable(CAP_NET_ADMIN))
439 if (nlh->nlmsg_flags & NLM_F_DUMP) {
440 if (ops->dumpit == NULL)
443 return netlink_dump_start(genl_sock, skb, nlh,
445 ops->done ?: null_done_func);
448 if (ops->doit == NULL)
451 if (family->attrbuf) {
452 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
458 info.snd_seq = nlh->nlmsg_seq;
459 info.snd_pid = NETLINK_CB(skb).pid;
461 info.genlhdr = nlmsg_data(nlh);
462 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
463 info.attrs = family->attrbuf;
465 return ops->doit(skb, &info);
468 static void genl_rcv(struct sock *sk, int len)
470 unsigned int qlen = 0;
475 netlink_run_queue(sk, &qlen, genl_rcv_msg);
477 } while (qlen && genl_sock && genl_sock->receive_queue.qlen);
480 /**************************************************************************
482 **************************************************************************/
484 static struct genl_family genl_ctrl = {
488 .maxattr = CTRL_ATTR_MAX,
491 static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
492 u32 flags, struct sk_buff *skb, u8 cmd)
496 hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
500 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
501 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
502 NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version);
503 NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize);
504 NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr);
506 if (!list_empty(&family->ops_list)) {
507 struct nlattr *nla_ops;
508 struct genl_ops *ops;
511 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
513 goto nla_put_failure;
515 list_for_each_entry(ops, &family->ops_list, ops_list) {
518 nest = nla_nest_start(skb, idx++);
520 goto nla_put_failure;
522 NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd);
523 NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags);
525 nla_nest_end(skb, nest);
528 nla_nest_end(skb, nla_ops);
531 if (!list_empty(&family->mcast_groups)) {
532 struct genl_multicast_group *grp;
533 struct nlattr *nla_grps;
536 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
537 if (nla_grps == NULL)
538 goto nla_put_failure;
540 list_for_each_entry(grp, &family->mcast_groups, list) {
543 nest = nla_nest_start(skb, idx++);
545 goto nla_put_failure;
547 NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
548 NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
551 nla_nest_end(skb, nest);
553 nla_nest_end(skb, nla_grps);
556 return genlmsg_end(skb, hdr);
559 return genlmsg_cancel(skb, hdr);
562 static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid,
563 u32 seq, u32 flags, struct sk_buff *skb,
567 struct nlattr *nla_grps;
570 hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
574 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name);
575 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id);
577 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
578 if (nla_grps == NULL)
579 goto nla_put_failure;
581 nest = nla_nest_start(skb, 1);
583 goto nla_put_failure;
585 NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
586 NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
589 nla_nest_end(skb, nest);
590 nla_nest_end(skb, nla_grps);
592 return genlmsg_end(skb, hdr);
595 return genlmsg_cancel(skb, hdr);
598 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
602 struct genl_family *rt;
603 int chains_to_skip = cb->args[0];
604 int fams_to_skip = cb->args[1];
606 if (chains_to_skip != 0)
609 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
610 if (i < chains_to_skip)
613 list_for_each_entry(rt, genl_family_chain(i), family_list) {
614 if (++n < fams_to_skip)
616 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
617 cb->nlh->nlmsg_seq, NLM_F_MULTI,
618 skb, CTRL_CMD_NEWFAMILY) < 0)
626 if (chains_to_skip != 0)
635 static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
636 u32 pid, int seq, u8 cmd)
641 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
643 return ERR_PTR(-ENOBUFS);
645 err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
654 static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp,
655 u32 pid, int seq, u8 cmd)
660 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
662 return ERR_PTR(-ENOBUFS);
664 err = ctrl_fill_mcgrp_info(grp, pid, seq, 0, skb, cmd);
673 static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
674 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
675 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
676 .len = GENL_NAMSIZ - 1 },
679 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
682 struct genl_family *res = NULL;
685 if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
686 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
687 res = genl_family_find_byid(id);
690 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
693 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
694 res = genl_family_find_byname(name);
702 msg = ctrl_build_family_msg(res, info->snd_pid, info->snd_seq,
709 err = genlmsg_reply(msg, info);
714 static int genl_ctrl_event(int event, void *data)
718 if (genl_sock == NULL)
722 case CTRL_CMD_NEWFAMILY:
723 case CTRL_CMD_DELFAMILY:
724 msg = ctrl_build_family_msg(data, 0, 0, event);
728 genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
730 case CTRL_CMD_NEWMCAST_GRP:
731 case CTRL_CMD_DELMCAST_GRP:
732 msg = ctrl_build_mcgrp_msg(data, 0, 0, event);
736 genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
743 static struct genl_ops genl_ctrl_ops = {
744 .cmd = CTRL_CMD_GETFAMILY,
745 .doit = ctrl_getfamily,
746 .dumpit = ctrl_dumpfamily,
747 .policy = ctrl_policy,
750 static struct genl_multicast_group notify_grp = {
754 int __init genl_init(void)
758 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
759 INIT_LIST_HEAD(&family_ht[i]);
761 err = genl_register_family(&genl_ctrl);
765 err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
767 goto errout_register;
769 netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
770 genl_sock = netlink_kernel_create(NETLINK_GENERIC, genl_rcv);
771 if (genl_sock == NULL)
772 panic("GENL: Cannot initialize generic netlink\n");
774 err = genl_register_mc_group(&genl_ctrl, ¬ify_grp);
776 goto errout_register;
781 genl_unregister_family(&genl_ctrl);
783 panic("GENL: Cannot register controller: %d\n", err);
786 void __exit genl_exit(void)
790 err = genl_unregister_ops(&genl_ctrl, &genl_ctrl_ops);
792 printk("GENL: cannot unregister ops (%d)\n", err);
796 err = genl_unregister_family(&genl_ctrl);
798 printk("GENL: cannot unregister family (%d)\n", err);
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);
810 MODULE_LICENSE("GPL");