[GENETLINK]: Dynamic multicast groups.

Introduce API to dynamically register and unregister multicast groups.

Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Patrick McHardy <kaber@trash.net>
Acked-by: Jamal Hadi Salim <hadi@cyberus.ca>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/linux/genetlink.h b/include/linux/genetlink.h
index f7a9377..7da02c9 100644 (file)
--- a/include/linux/genetlink.h
+++ b/include/linux/genetlink.h
@@ -39,6 +39,9 @@ enum {
        CTRL_CMD_NEWOPS,
        CTRL_CMD_DELOPS,
        CTRL_CMD_GETOPS,
+       CTRL_CMD_NEWMCAST_GRP,
+       CTRL_CMD_DELMCAST_GRP,
+       CTRL_CMD_GETMCAST_GRP, /* unused */
        __CTRL_CMD_MAX,
 };
 
@@ -52,6 +55,7 @@ enum {
        CTRL_ATTR_HDRSIZE,
        CTRL_ATTR_MAXATTR,
        CTRL_ATTR_OPS,
+       CTRL_ATTR_MCAST_GROUPS,
        __CTRL_ATTR_MAX,
 };
 
@@ -66,4 +70,13 @@ enum {
 
 #define CTRL_ATTR_OP_MAX (__CTRL_ATTR_OP_MAX - 1)
 
+enum {
+       CTRL_ATTR_MCAST_GRP_UNSPEC,
+       CTRL_ATTR_MCAST_GRP_NAME,
+       CTRL_ATTR_MCAST_GRP_ID,
+       __CTRL_ATTR_MCAST_GRP_MAX,
+};
+
+#define CTRL_ATTR_MCAST_GRP_MAX (__CTRL_ATTR_MCAST_GRP_MAX - 1)
+
 #endif /* __LINUX_GENERIC_NETLINK_H */

diff --git a/include/net/genetlink.h b/include/net/genetlink.h
index b6eaca1..decdda5 100644 (file)
--- a/include/net/genetlink.h
+++ b/include/net/genetlink.h
@@ -4,6 +4,22 @@
 #include <linux/genetlink.h>
 #include <net/netlink.h>
 
+/**
+ * struct genl_multicast_group - generic netlink multicast group
+ * @name: name of the multicast group, names are per-family
+ * @id: multicast group ID, assigned by the core, to use with
+ *      genlmsg_multicast().
+ * @list: list entry for linking
+ * @family: pointer to family, need not be set before registering
+ */
+struct genl_multicast_group
+{
+       struct genl_family      *family;        /* private */
+       struct list_head        list;           /* private */
+       char                    name[GENL_NAMSIZ];
+       u32                     id;
+};
+
 /**
  * struct genl_family - generic netlink family
  * @id: protocol family idenfitier
@@ -14,6 +30,7 @@
  * @attrbuf: buffer to store parsed attributes
  * @ops_list: list of all assigned operations
  * @family_list: family list
+ * @mcast_groups: multicast groups list
  */
 struct genl_family
 {
@@ -25,6 +42,7 @@ struct genl_family
        struct nlattr **        attrbuf;        /* private */
        struct list_head        ops_list;       /* private */
        struct list_head        family_list;    /* private */
+       struct list_head        mcast_groups;   /* private */
 };
 
 /**
@@ -73,6 +91,10 @@ extern int genl_register_family(struct genl_family *family);
 extern int genl_unregister_family(struct genl_family *family);
 extern int genl_register_ops(struct genl_family *, struct genl_ops *ops);
 extern int genl_unregister_ops(struct genl_family *, struct genl_ops *ops);
+extern int genl_register_mc_group(struct genl_family *family,
+                                 struct genl_multicast_group *grp);
+extern void genl_unregister_mc_group(struct genl_family *family,
+                                    struct genl_multicast_group *grp);
 
 extern struct sock *genl_sock;
 

diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index b9ab62f..e146531 100644 (file)
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -3,6 +3,7 @@
  *
  *             Authors:        Jamal Hadi Salim
  *                             Thomas Graf <tgraf@suug.ch>
+ *                             Johannes Berg <johannes@sipsolutions.net>
  */
 
 #include <linux/module.h>
@@ -13,6 +14,7 @@
 #include <linux/string.h>
 #include <linux/skbuff.h>
 #include <linux/mutex.h>
+#include <linux/bitmap.h>
 #include <net/sock.h>
 #include <net/genetlink.h>
 
@@ -42,6 +44,16 @@ static void genl_unlock(void)
 #define GENL_FAM_TAB_MASK      (GENL_FAM_TAB_SIZE - 1)
 
 static struct list_head family_ht[GENL_FAM_TAB_SIZE];
+/*
+ * Bitmap of multicast groups that are currently in use.
+ *
+ * To avoid an allocation at boot of just one unsigned long,
+ * declare it global instead.
+ * Bit 0 is marked as already used since group 0 is invalid.
+ */
+static unsigned long mc_group_start = 0x1;
+static unsigned long *mc_groups = &mc_group_start;
+static unsigned long mc_groups_longs = 1;
 
 static int genl_ctrl_event(int event, void *data);
 
@@ -116,6 +128,114 @@ static inline u16 genl_generate_id(void)
        return id_gen_idx;
 }
 
+static struct genl_multicast_group notify_grp;
+
+/**
+ * genl_register_mc_group - register a multicast group
+ *
+ * Registers the specified multicast group and notifies userspace
+ * about the new group.
+ *
+ * Returns 0 on success or a negative error code.
+ *
+ * @family: The generic netlink family the group shall be registered for.
+ * @grp: The group to register, must have a name.
+ */
+int genl_register_mc_group(struct genl_family *family,
+                          struct genl_multicast_group *grp)
+{
+       int id;
+       unsigned long *new_groups;
+       int err;
+
+       BUG_ON(grp->name[0] == '\0');
+
+       genl_lock();
+
+       /* special-case our own group */
+       if (grp == &notify_grp)
+               id = GENL_ID_CTRL;
+       else
+               id = find_first_zero_bit(mc_groups,
+                                        mc_groups_longs * BITS_PER_LONG);
+
+
+       if (id >= mc_groups_longs * BITS_PER_LONG) {
+               size_t nlen = (mc_groups_longs + 1) * sizeof(unsigned long);
+
+               if (mc_groups == &mc_group_start) {
+                       new_groups = kzalloc(nlen, GFP_KERNEL);
+                       if (!new_groups) {
+                               err = -ENOMEM;
+                               goto out;
+                       }
+                       mc_groups = new_groups;
+                       *mc_groups = mc_group_start;
+               } else {
+                       new_groups = krealloc(mc_groups, nlen, GFP_KERNEL);
+                       if (!new_groups) {
+                               err = -ENOMEM;
+                               goto out;
+                       }
+                       mc_groups = new_groups;
+                       mc_groups[mc_groups_longs] = 0;
+               }
+               mc_groups_longs++;
+       }
+
+       err = netlink_change_ngroups(genl_sock,
+                                    sizeof(unsigned long) * NETLINK_GENERIC);
+       if (err)
+               goto out;
+
+       grp->id = id;
+       set_bit(id, mc_groups);
+       list_add_tail(&grp->list, &family->mcast_groups);
+       grp->family = family;
+
+       genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, grp);
+ out:
+       genl_unlock();
+       return 0;
+}
+EXPORT_SYMBOL(genl_register_mc_group);
+
+/**
+ * genl_unregister_mc_group - unregister a multicast group
+ *
+ * Unregisters the specified multicast group and notifies userspace
+ * about it. All current listeners on the group are removed.
+ *
+ * Note: It is not necessary to unregister all multicast groups before
+ *       unregistering the family, unregistering the family will cause
+ *       all assigned multicast groups to be unregistered automatically.
+ *
+ * @family: Generic netlink family the group belongs to.
+ * @grp: The group to unregister, must have been registered successfully
+ *      previously.
+ */
+void genl_unregister_mc_group(struct genl_family *family,
+                             struct genl_multicast_group *grp)
+{
+       BUG_ON(grp->family != family);
+       genl_lock();
+       netlink_clear_multicast_users(genl_sock, grp->id);
+       clear_bit(grp->id, mc_groups);
+       list_del(&grp->list);
+       genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp);
+       grp->id = 0;
+       grp->family = NULL;
+       genl_unlock();
+}
+
+static void genl_unregister_mc_groups(struct genl_family *family)
+{
+       struct genl_multicast_group *grp, *tmp;
+
+       list_for_each_entry_safe(grp, tmp, &family->mcast_groups, list)
+               genl_unregister_mc_group(family, grp);
+}
+
 /**
  * genl_register_ops - register generic netlink operations
  * @family: generic netlink family
@@ -216,6 +336,7 @@ int genl_register_family(struct genl_family *family)
                goto errout;
 
        INIT_LIST_HEAD(&family->ops_list);
+       INIT_LIST_HEAD(&family->mcast_groups);
 
        genl_lock();
 
@@ -275,6 +396,8 @@ int genl_unregister_family(struct genl_family *family)
 {
        struct genl_family *rc;
 
+       genl_unregister_mc_groups(family);
+
        genl_lock();
 
        list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
@@ -410,6 +533,67 @@ static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
                nla_nest_end(skb, nla_ops);
        }
 
+       if (!list_empty(&family->mcast_groups)) {
+               struct genl_multicast_group *grp;
+               struct nlattr *nla_grps;
+               int idx = 1;
+
+               nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
+               if (nla_grps == NULL)
+                       goto nla_put_failure;
+
+               list_for_each_entry(grp, &family->mcast_groups, list) {
+                       struct nlattr *nest;
+
+                       nest = nla_nest_start(skb, idx++);
+                       if (nest == NULL)
+                               goto nla_put_failure;
+
+                       NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
+                       NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
+                                      grp->name);
+
+                       nla_nest_end(skb, nest);
+               }
+               nla_nest_end(skb, nla_grps);
+       }
+
+       return genlmsg_end(skb, hdr);
+
+nla_put_failure:
+       return genlmsg_cancel(skb, hdr);
+}
+
+static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid,
+                               u32 seq, u32 flags, struct sk_buff *skb,
+                               u8 cmd)
+{
+       void *hdr;
+       struct nlattr *nla_grps;
+       struct nlattr *nest;
+
+       hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
+       if (hdr == NULL)
+               return -1;
+
+       NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name);
+       NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id);
+
+       nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
+       if (nla_grps == NULL)
+               goto nla_put_failure;
+
+       nest = nla_nest_start(skb, 1);
+       if (nest == NULL)
+               goto nla_put_failure;
+
+       NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
+       NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
+                      grp->name);
+
+       nla_nest_end(skb, nest);
+       nla_nest_end(skb, nla_grps);
+
        return genlmsg_end(skb, hdr);
 
 nla_put_failure:
@@ -453,8 +637,8 @@ errout:
        return skb->len;
 }
 
-static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid,
-                                     int seq, u8 cmd)
+static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
+                                            u32 pid, int seq, u8 cmd)
 {
        struct sk_buff *skb;
        int err;
@@ -472,6 +656,25 @@ static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid,
        return skb;
 }
 
+static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp,
+                                           u32 pid, int seq, u8 cmd)
+{
+       struct sk_buff *skb;
+       int err;
+
+       skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
+       if (skb == NULL)
+               return ERR_PTR(-ENOBUFS);
+
+       err = ctrl_fill_mcgrp_info(grp, pid, seq, 0, skb, cmd);
+       if (err < 0) {
+               nlmsg_free(skb);
+               return ERR_PTR(err);
+       }
+
+       return skb;
+}
+
 static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
        [CTRL_ATTR_FAMILY_ID]   = { .type = NLA_U16 },
        [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
@@ -501,8 +704,8 @@ static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
                goto errout;
        }
 
-       msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq,
-                            CTRL_CMD_NEWFAMILY);
+       msg = ctrl_build_family_msg(res, info->snd_pid, info->snd_seq,
+                                   CTRL_CMD_NEWFAMILY);
        if (IS_ERR(msg)) {
                err = PTR_ERR(msg);
                goto errout;
@@ -523,7 +726,15 @@ static int genl_ctrl_event(int event, void *data)
        switch (event) {
        case CTRL_CMD_NEWFAMILY:
        case CTRL_CMD_DELFAMILY:
-               msg = ctrl_build_msg(data, 0, 0, event);
+               msg = ctrl_build_family_msg(data, 0, 0, event);
+               if (IS_ERR(msg))
+                       return PTR_ERR(msg);
+
+               genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
+               break;
+       case CTRL_CMD_NEWMCAST_GRP:
+       case CTRL_CMD_DELMCAST_GRP:
+               msg = ctrl_build_mcgrp_msg(data, 0, 0, event);
                if (IS_ERR(msg))
                        return PTR_ERR(msg);
 
@@ -541,6 +752,10 @@ static struct genl_ops genl_ctrl_ops = {
        .policy         = ctrl_policy,
 };
 
+static struct genl_multicast_group notify_grp = {
+       .name           = "notify",
+};
+
 static int __init genl_init(void)
 {
        int i, err;
@@ -557,11 +772,17 @@ static int __init genl_init(void)
                goto errout_register;
 
        netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
-       genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID,
-                                         genl_rcv, NULL, THIS_MODULE);
+
+       /* we'll bump the group number right afterwards */
+       genl_sock = netlink_kernel_create(NETLINK_GENERIC, 0, genl_rcv,
+                                         NULL, THIS_MODULE);
        if (genl_sock == NULL)
                panic("GENL: Cannot initialize generic netlink\n");
 
+       err = genl_register_mc_group(&genl_ctrl, &notify_grp);
+       if (err < 0)
+               goto errout_register;
+
        return 0;
 
 errout_register: