2 * NETLINK Generic Netlink Family
4 * Authors: Jamal Hadi Salim
5 * Thomas Graf <tgraf@suug.ch>
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/errno.h>
11 #include <linux/types.h>
12 #include <linux/socket.h>
13 #include <linux/string.h>
14 #include <linux/skbuff.h>
15 #include <linux/mutex.h>
17 #include <net/genetlink.h>
19 struct sock *genl_sock = NULL;
21 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
23 static void genl_lock(void)
25 mutex_lock(&genl_mutex);
28 static int genl_trylock(void)
30 return !mutex_trylock(&genl_mutex);
33 static void genl_unlock(void)
35 mutex_unlock(&genl_mutex);
37 if (genl_sock && genl_sock->sk_receive_queue.qlen)
38 genl_sock->sk_data_ready(genl_sock, 0);
41 #define GENL_FAM_TAB_SIZE 16
42 #define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1)
44 static struct list_head family_ht[GENL_FAM_TAB_SIZE];
46 static int genl_ctrl_event(int event, void *data);
48 static inline unsigned int genl_family_hash(unsigned int id)
50 return id & GENL_FAM_TAB_MASK;
53 static inline struct list_head *genl_family_chain(unsigned int id)
55 return &family_ht[genl_family_hash(id)];
58 static struct genl_family *genl_family_find_byid(unsigned int id)
60 struct genl_family *f;
62 list_for_each_entry(f, genl_family_chain(id), family_list)
69 static struct genl_family *genl_family_find_byname(char *name)
71 struct genl_family *f;
74 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
75 list_for_each_entry(f, genl_family_chain(i), family_list)
76 if (strcmp(f->name, name) == 0)
82 static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
86 list_for_each_entry(ops, &family->ops_list, ops_list)
93 /* Of course we are going to have problems once we hit
94 * 2^16 alive types, but that can only happen by year 2K
96 static inline u16 genl_generate_id(void)
98 static u16 id_gen_idx;
103 id_gen_idx = GENL_MIN_ID;
105 if (++id_gen_idx > GENL_MAX_ID) {
114 } while (genl_family_find_byid(id_gen_idx));
120 * genl_register_ops - register generic netlink operations
121 * @family: generic netlink family
122 * @ops: operations to be registered
124 * Registers the specified operations and assigns them to the specified
125 * family. Either a doit or dumpit callback must be specified or the
126 * operation will fail. Only one operation structure per command
127 * identifier may be registered.
129 * See include/net/genetlink.h for more documenation on the operations
132 * Returns 0 on success or a negative error code.
134 int genl_register_ops(struct genl_family *family, struct genl_ops *ops)
138 if (ops->dumpit == NULL && ops->doit == NULL)
141 if (genl_get_cmd(ops->cmd, family)) {
147 ops->flags |= GENL_CMD_CAP_DUMP;
149 ops->flags |= GENL_CMD_CAP_DO;
151 ops->flags |= GENL_CMD_CAP_HASPOL;
154 list_add_tail(&ops->ops_list, &family->ops_list);
157 genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
164 * genl_unregister_ops - unregister generic netlink operations
165 * @family: generic netlink family
166 * @ops: operations to be unregistered
168 * Unregisters the specified operations and unassigns them from the
169 * specified family. The operation blocks until the current message
170 * processing has finished and doesn't start again until the
171 * unregister process has finished.
173 * Note: It is not necessary to unregister all operations before
174 * unregistering the family, unregistering the family will cause
175 * all assigned operations to be unregistered automatically.
177 * Returns 0 on success or a negative error code.
179 int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops)
184 list_for_each_entry(rc, &family->ops_list, ops_list) {
186 list_del(&ops->ops_list);
188 genl_ctrl_event(CTRL_CMD_DELOPS, ops);
198 * genl_register_family - register a generic netlink family
199 * @family: generic netlink family
201 * Registers the specified family after validating it first. Only one
202 * family may be registered with the same family name or identifier.
203 * The family id may equal GENL_ID_GENERATE causing an unique id to
204 * be automatically generated and assigned.
206 * Return 0 on success or a negative error code.
208 int genl_register_family(struct genl_family *family)
212 if (family->id && family->id < GENL_MIN_ID)
215 if (family->id > GENL_MAX_ID)
218 INIT_LIST_HEAD(&family->ops_list);
222 if (genl_family_find_byname(family->name)) {
227 if (genl_family_find_byid(family->id)) {
232 if (family->id == GENL_ID_GENERATE) {
233 u16 newid = genl_generate_id();
243 if (family->maxattr) {
244 family->attrbuf = kmalloc((family->maxattr+1) *
245 sizeof(struct nlattr *), GFP_KERNEL);
246 if (family->attrbuf == NULL) {
251 family->attrbuf = NULL;
253 list_add_tail(&family->family_list, genl_family_chain(family->id));
256 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
267 * genl_unregister_family - unregister generic netlink family
268 * @family: generic netlink family
270 * Unregisters the specified family.
272 * Returns 0 on success or a negative error code.
274 int genl_unregister_family(struct genl_family *family)
276 struct genl_family *rc;
280 list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
281 if (family->id != rc->id || strcmp(rc->name, family->name))
284 list_del(&rc->family_list);
285 INIT_LIST_HEAD(&family->ops_list);
288 kfree(family->attrbuf);
289 genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
298 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
301 struct genl_ops *ops;
302 struct genl_family *family;
303 struct genl_info info;
304 struct genlmsghdr *hdr = nlmsg_data(nlh);
305 int hdrlen, err = -EINVAL;
307 if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
310 family = genl_family_find_byid(nlh->nlmsg_type);
311 if (family == NULL) {
316 hdrlen = GENL_HDRLEN + family->hdrsize;
317 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
320 ops = genl_get_cmd(hdr->cmd, family);
326 if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb, CAP_NET_ADMIN)) {
331 if (nlh->nlmsg_flags & NLM_F_DUMP) {
332 if (ops->dumpit == NULL) {
337 *errp = err = netlink_dump_start(genl_sock, skb, nlh,
338 ops->dumpit, ops->done);
340 skb_pull(skb, min(NLMSG_ALIGN(nlh->nlmsg_len),
345 if (ops->doit == NULL) {
350 if (family->attrbuf) {
351 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
357 info.snd_seq = nlh->nlmsg_seq;
358 info.snd_pid = NETLINK_CB(skb).pid;
360 info.genlhdr = nlmsg_data(nlh);
361 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
362 info.attrs = family->attrbuf;
364 *errp = err = ops->doit(skb, &info);
375 static void genl_rcv(struct sock *sk, int len)
377 unsigned int qlen = 0;
382 netlink_run_queue(sk, &qlen, genl_rcv_msg);
384 } while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
387 /**************************************************************************
389 **************************************************************************/
391 static struct genl_family genl_ctrl = {
395 .maxattr = CTRL_ATTR_MAX,
398 static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
399 u32 flags, struct sk_buff *skb, u8 cmd)
403 hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
407 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
408 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
409 NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version);
410 NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize);
411 NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr);
413 if (!list_empty(&family->ops_list)) {
414 struct nlattr *nla_ops;
415 struct genl_ops *ops;
418 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
420 goto nla_put_failure;
422 list_for_each_entry(ops, &family->ops_list, ops_list) {
425 nest = nla_nest_start(skb, idx++);
427 goto nla_put_failure;
429 NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd);
430 NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags);
432 nla_nest_end(skb, nest);
435 nla_nest_end(skb, nla_ops);
438 return genlmsg_end(skb, hdr);
441 return genlmsg_cancel(skb, hdr);
444 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
448 struct genl_family *rt;
449 int chains_to_skip = cb->args[0];
450 int fams_to_skip = cb->args[1];
452 if (chains_to_skip != 0)
455 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
456 if (i < chains_to_skip)
459 list_for_each_entry(rt, genl_family_chain(i), family_list) {
460 if (++n < fams_to_skip)
462 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
463 cb->nlh->nlmsg_seq, NLM_F_MULTI,
464 skb, CTRL_CMD_NEWFAMILY) < 0)
472 if (chains_to_skip != 0)
481 static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid,
487 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
489 return ERR_PTR(-ENOBUFS);
491 err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
500 static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] __read_mostly = {
501 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
502 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
503 .len = GENL_NAMSIZ - 1 },
506 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
509 struct genl_family *res = NULL;
512 if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
513 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
514 res = genl_family_find_byid(id);
517 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
520 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
521 res = genl_family_find_byname(name);
529 msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq,
536 err = genlmsg_reply(msg, info);
541 static int genl_ctrl_event(int event, void *data)
545 if (genl_sock == NULL)
549 case CTRL_CMD_NEWFAMILY:
550 case CTRL_CMD_DELFAMILY:
551 msg = ctrl_build_msg(data, 0, 0, event);
555 genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
562 static struct genl_ops genl_ctrl_ops = {
563 .cmd = CTRL_CMD_GETFAMILY,
564 .doit = ctrl_getfamily,
565 .dumpit = ctrl_dumpfamily,
566 .policy = ctrl_policy,
569 static int __init genl_init(void)
573 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
574 INIT_LIST_HEAD(&family_ht[i]);
576 err = genl_register_family(&genl_ctrl);
580 err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
582 goto errout_register;
584 netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
585 genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID,
586 genl_rcv, THIS_MODULE);
587 if (genl_sock == NULL)
588 panic("GENL: Cannot initialize generic netlink\n");
593 genl_unregister_family(&genl_ctrl);
595 panic("GENL: Cannot register controller: %d\n", err);
598 subsys_initcall(genl_init);
600 EXPORT_SYMBOL(genl_sock);
601 EXPORT_SYMBOL(genl_register_ops);
602 EXPORT_SYMBOL(genl_unregister_ops);
603 EXPORT_SYMBOL(genl_register_family);
604 EXPORT_SYMBOL(genl_unregister_family);