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/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 <linux/rwsem.h>
20 #include <linux/idr.h>
22 #include <net/genetlink.h>
24 static DEFINE_MUTEX(genl_mutex
); /* serialization of message processing */
25 static DECLARE_RWSEM(cb_lock
);
27 atomic_t genl_sk_destructing_cnt
= ATOMIC_INIT(0);
28 DECLARE_WAIT_QUEUE_HEAD(genl_sk_destructing_waitq
);
32 mutex_lock(&genl_mutex
);
34 EXPORT_SYMBOL(genl_lock
);
36 void genl_unlock(void)
38 mutex_unlock(&genl_mutex
);
40 EXPORT_SYMBOL(genl_unlock
);
43 bool lockdep_genl_is_held(void)
45 return lockdep_is_held(&genl_mutex
);
47 EXPORT_SYMBOL(lockdep_genl_is_held
);
50 static void genl_lock_all(void)
56 static void genl_unlock_all(void)
62 static DEFINE_IDR(genl_fam_idr
);
65 * Bitmap of multicast groups that are currently in use.
67 * To avoid an allocation at boot of just one unsigned long,
68 * declare it global instead.
69 * Bit 0 is marked as already used since group 0 is invalid.
70 * Bit 1 is marked as already used since the drop-monitor code
71 * abuses the API and thinks it can statically use group 1.
72 * That group will typically conflict with other groups that
73 * any proper users use.
74 * Bit 16 is marked as used since it's used for generic netlink
75 * and the code no longer marks pre-reserved IDs as used.
76 * Bit 17 is marked as already used since the VFS quota code
77 * also abused this API and relied on family == group ID, we
78 * cater to that by giving it a static family and group ID.
79 * Bit 18 is marked as already used since the PMCRAID driver
80 * did the same thing as the VFS quota code (maybe copied?)
82 static unsigned long mc_group_start
= 0x3 | BIT(GENL_ID_CTRL
) |
83 BIT(GENL_ID_VFS_DQUOT
) |
85 static unsigned long *mc_groups
= &mc_group_start
;
86 static unsigned long mc_groups_longs
= 1;
88 static int genl_ctrl_event(int event
, const struct genl_family
*family
,
89 const struct genl_multicast_group
*grp
,
92 static const struct genl_family
*genl_family_find_byid(unsigned int id
)
94 return idr_find(&genl_fam_idr
, id
);
97 static const struct genl_family
*genl_family_find_byname(char *name
)
99 const struct genl_family
*family
;
102 idr_for_each_entry(&genl_fam_idr
, family
, id
)
103 if (strcmp(family
->name
, name
) == 0)
109 static const struct genl_ops
*genl_get_cmd(u8 cmd
,
110 const struct genl_family
*family
)
114 for (i
= 0; i
< family
->n_ops
; i
++)
115 if (family
->ops
[i
].cmd
== cmd
)
116 return &family
->ops
[i
];
121 static int genl_allocate_reserve_groups(int n_groups
, int *first_id
)
123 unsigned long *new_groups
;
131 id
= find_first_zero_bit(mc_groups
,
135 id
= find_next_zero_bit(mc_groups
,
136 mc_groups_longs
* BITS_PER_LONG
,
141 i
< min_t(int, id
+ n_groups
,
142 mc_groups_longs
* BITS_PER_LONG
);
144 if (test_bit(i
, mc_groups
)) {
151 if (id
+ n_groups
> mc_groups_longs
* BITS_PER_LONG
) {
152 unsigned long new_longs
= mc_groups_longs
+
153 BITS_TO_LONGS(n_groups
);
154 size_t nlen
= new_longs
* sizeof(unsigned long);
156 if (mc_groups
== &mc_group_start
) {
157 new_groups
= kzalloc(nlen
, GFP_KERNEL
);
160 mc_groups
= new_groups
;
161 *mc_groups
= mc_group_start
;
163 new_groups
= krealloc(mc_groups
, nlen
,
167 mc_groups
= new_groups
;
168 for (i
= 0; i
< BITS_TO_LONGS(n_groups
); i
++)
169 mc_groups
[mc_groups_longs
+ i
] = 0;
171 mc_groups_longs
= new_longs
;
175 for (i
= id
; i
< id
+ n_groups
; i
++)
176 set_bit(i
, mc_groups
);
181 static struct genl_family genl_ctrl
;
183 static int genl_validate_assign_mc_groups(struct genl_family
*family
)
186 int n_groups
= family
->n_mcgrps
;
188 bool groups_allocated
= false;
193 for (i
= 0; i
< n_groups
; i
++) {
194 const struct genl_multicast_group
*grp
= &family
->mcgrps
[i
];
196 if (WARN_ON(grp
->name
[0] == '\0'))
198 if (WARN_ON(memchr(grp
->name
, '\0', GENL_NAMSIZ
) == NULL
))
202 /* special-case our own group and hacks */
203 if (family
== &genl_ctrl
) {
204 first_id
= GENL_ID_CTRL
;
205 BUG_ON(n_groups
!= 1);
206 } else if (strcmp(family
->name
, "NET_DM") == 0) {
208 BUG_ON(n_groups
!= 1);
209 } else if (family
->id
== GENL_ID_VFS_DQUOT
) {
210 first_id
= GENL_ID_VFS_DQUOT
;
211 BUG_ON(n_groups
!= 1);
212 } else if (family
->id
== GENL_ID_PMCRAID
) {
213 first_id
= GENL_ID_PMCRAID
;
214 BUG_ON(n_groups
!= 1);
216 groups_allocated
= true;
217 err
= genl_allocate_reserve_groups(n_groups
, &first_id
);
222 family
->mcgrp_offset
= first_id
;
224 /* if still initializing, can't and don't need to to realloc bitmaps */
225 if (!init_net
.genl_sock
)
228 if (family
->netnsok
) {
231 netlink_table_grab();
233 for_each_net_rcu(net
) {
234 err
= __netlink_change_ngroups(net
->genl_sock
,
235 mc_groups_longs
* BITS_PER_LONG
);
238 * No need to roll back, can only fail if
239 * memory allocation fails and then the
240 * number of _possible_ groups has been
241 * increased on some sockets which is ok.
247 netlink_table_ungrab();
249 err
= netlink_change_ngroups(init_net
.genl_sock
,
250 mc_groups_longs
* BITS_PER_LONG
);
253 if (groups_allocated
&& err
) {
254 for (i
= 0; i
< family
->n_mcgrps
; i
++)
255 clear_bit(family
->mcgrp_offset
+ i
, mc_groups
);
261 static void genl_unregister_mc_groups(const struct genl_family
*family
)
266 netlink_table_grab();
268 for_each_net_rcu(net
) {
269 for (i
= 0; i
< family
->n_mcgrps
; i
++)
270 __netlink_clear_multicast_users(
271 net
->genl_sock
, family
->mcgrp_offset
+ i
);
274 netlink_table_ungrab();
276 for (i
= 0; i
< family
->n_mcgrps
; i
++) {
277 int grp_id
= family
->mcgrp_offset
+ i
;
280 clear_bit(grp_id
, mc_groups
);
281 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP
, family
,
282 &family
->mcgrps
[i
], grp_id
);
286 static int genl_validate_ops(const struct genl_family
*family
)
288 const struct genl_ops
*ops
= family
->ops
;
289 unsigned int n_ops
= family
->n_ops
;
292 if (WARN_ON(n_ops
&& !ops
))
298 for (i
= 0; i
< n_ops
; i
++) {
299 if (ops
[i
].dumpit
== NULL
&& ops
[i
].doit
== NULL
)
301 for (j
= i
+ 1; j
< n_ops
; j
++)
302 if (ops
[i
].cmd
== ops
[j
].cmd
)
310 * genl_register_family - register a generic netlink family
311 * @family: generic netlink family
313 * Registers the specified family after validating it first. Only one
314 * family may be registered with the same family name or identifier.
316 * The family's ops, multicast groups and module pointer must already
319 * Return 0 on success or a negative error code.
321 int genl_register_family(struct genl_family
*family
)
324 int start
= GENL_START_ALLOC
, end
= GENL_MAX_ID
;
326 err
= genl_validate_ops(family
);
332 if (genl_family_find_byname(family
->name
)) {
338 * Sadly, a few cases need to be special-cased
339 * due to them having previously abused the API
340 * and having used their family ID also as their
341 * multicast group ID, so we use reserved IDs
342 * for both to be sure we can do that mapping.
344 if (family
== &genl_ctrl
) {
345 /* and this needs to be special for initial family lookups */
346 start
= end
= GENL_ID_CTRL
;
347 } else if (strcmp(family
->name
, "pmcraid") == 0) {
348 start
= end
= GENL_ID_PMCRAID
;
349 } else if (strcmp(family
->name
, "VFS_DQUOT") == 0) {
350 start
= end
= GENL_ID_VFS_DQUOT
;
353 if (family
->maxattr
&& !family
->parallel_ops
) {
354 family
->attrbuf
= kmalloc((family
->maxattr
+1) *
355 sizeof(struct nlattr
*), GFP_KERNEL
);
356 if (family
->attrbuf
== NULL
) {
361 family
->attrbuf
= NULL
;
363 family
->id
= idr_alloc(&genl_fam_idr
, family
,
364 start
, end
+ 1, GFP_KERNEL
);
365 if (family
->id
< 0) {
370 err
= genl_validate_assign_mc_groups(family
);
376 /* send all events */
377 genl_ctrl_event(CTRL_CMD_NEWFAMILY
, family
, NULL
, 0);
378 for (i
= 0; i
< family
->n_mcgrps
; i
++)
379 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP
, family
,
380 &family
->mcgrps
[i
], family
->mcgrp_offset
+ i
);
385 idr_remove(&genl_fam_idr
, family
->id
);
386 kfree(family
->attrbuf
);
391 EXPORT_SYMBOL(genl_register_family
);
394 * genl_unregister_family - unregister generic netlink family
395 * @family: generic netlink family
397 * Unregisters the specified family.
399 * Returns 0 on success or a negative error code.
401 int genl_unregister_family(const struct genl_family
*family
)
405 if (!genl_family_find_byid(family
->id
)) {
410 genl_unregister_mc_groups(family
);
412 idr_remove(&genl_fam_idr
, family
->id
);
415 wait_event(genl_sk_destructing_waitq
,
416 atomic_read(&genl_sk_destructing_cnt
) == 0);
419 kfree(family
->attrbuf
);
421 genl_ctrl_event(CTRL_CMD_DELFAMILY
, family
, NULL
, 0);
425 EXPORT_SYMBOL(genl_unregister_family
);
428 * genlmsg_put - Add generic netlink header to netlink message
429 * @skb: socket buffer holding the message
430 * @portid: netlink portid the message is addressed to
431 * @seq: sequence number (usually the one of the sender)
432 * @family: generic netlink family
433 * @flags: netlink message flags
434 * @cmd: generic netlink command
436 * Returns pointer to user specific header
438 void *genlmsg_put(struct sk_buff
*skb
, u32 portid
, u32 seq
,
439 const struct genl_family
*family
, int flags
, u8 cmd
)
441 struct nlmsghdr
*nlh
;
442 struct genlmsghdr
*hdr
;
444 nlh
= nlmsg_put(skb
, portid
, seq
, family
->id
, GENL_HDRLEN
+
445 family
->hdrsize
, flags
);
449 hdr
= nlmsg_data(nlh
);
451 hdr
->version
= family
->version
;
454 return (char *) hdr
+ GENL_HDRLEN
;
456 EXPORT_SYMBOL(genlmsg_put
);
458 static int genl_lock_start(struct netlink_callback
*cb
)
460 /* our ops are always const - netlink API doesn't propagate that */
461 const struct genl_ops
*ops
= cb
->data
;
472 static int genl_lock_dumpit(struct sk_buff
*skb
, struct netlink_callback
*cb
)
474 /* our ops are always const - netlink API doesn't propagate that */
475 const struct genl_ops
*ops
= cb
->data
;
479 rc
= ops
->dumpit(skb
, cb
);
484 static int genl_lock_done(struct netlink_callback
*cb
)
486 /* our ops are always const - netlink API doesn't propagate that */
487 const struct genl_ops
*ops
= cb
->data
;
498 static int genl_family_rcv_msg(const struct genl_family
*family
,
500 struct nlmsghdr
*nlh
,
501 struct netlink_ext_ack
*extack
)
503 const struct genl_ops
*ops
;
504 struct net
*net
= sock_net(skb
->sk
);
505 struct genl_info info
;
506 struct genlmsghdr
*hdr
= nlmsg_data(nlh
);
507 struct nlattr
**attrbuf
;
510 /* this family doesn't exist in this netns */
511 if (!family
->netnsok
&& !net_eq(net
, &init_net
))
514 hdrlen
= GENL_HDRLEN
+ family
->hdrsize
;
515 if (nlh
->nlmsg_len
< nlmsg_msg_size(hdrlen
))
518 ops
= genl_get_cmd(hdr
->cmd
, family
);
522 if ((ops
->flags
& GENL_ADMIN_PERM
) &&
523 !netlink_capable(skb
, CAP_NET_ADMIN
))
526 if ((ops
->flags
& GENL_UNS_ADMIN_PERM
) &&
527 !netlink_ns_capable(skb
, net
->user_ns
, CAP_NET_ADMIN
))
530 if ((nlh
->nlmsg_flags
& NLM_F_DUMP
) == NLM_F_DUMP
) {
533 if (ops
->dumpit
== NULL
)
536 if (!family
->parallel_ops
) {
537 struct netlink_dump_control c
= {
538 .module
= family
->module
,
539 /* we have const, but the netlink API doesn't */
541 .start
= genl_lock_start
,
542 .dump
= genl_lock_dumpit
,
543 .done
= genl_lock_done
,
547 rc
= __netlink_dump_start(net
->genl_sock
, skb
, nlh
, &c
);
551 struct netlink_dump_control c
= {
552 .module
= family
->module
,
558 rc
= __netlink_dump_start(net
->genl_sock
, skb
, nlh
, &c
);
564 if (ops
->doit
== NULL
)
567 if (family
->maxattr
&& family
->parallel_ops
) {
568 attrbuf
= kmalloc((family
->maxattr
+1) *
569 sizeof(struct nlattr
*), GFP_KERNEL
);
573 attrbuf
= family
->attrbuf
;
576 err
= nlmsg_parse(nlh
, hdrlen
, attrbuf
, family
->maxattr
,
577 ops
->policy
, extack
);
582 info
.snd_seq
= nlh
->nlmsg_seq
;
583 info
.snd_portid
= NETLINK_CB(skb
).portid
;
585 info
.genlhdr
= nlmsg_data(nlh
);
586 info
.userhdr
= nlmsg_data(nlh
) + GENL_HDRLEN
;
587 info
.attrs
= attrbuf
;
588 info
.extack
= extack
;
589 genl_info_net_set(&info
, net
);
590 memset(&info
.user_ptr
, 0, sizeof(info
.user_ptr
));
592 if (family
->pre_doit
) {
593 err
= family
->pre_doit(ops
, skb
, &info
);
598 err
= ops
->doit(skb
, &info
);
600 if (family
->post_doit
)
601 family
->post_doit(ops
, skb
, &info
);
604 if (family
->parallel_ops
)
610 static int genl_rcv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
611 struct netlink_ext_ack
*extack
)
613 const struct genl_family
*family
;
616 family
= genl_family_find_byid(nlh
->nlmsg_type
);
620 if (!family
->parallel_ops
)
623 err
= genl_family_rcv_msg(family
, skb
, nlh
, extack
);
625 if (!family
->parallel_ops
)
631 static void genl_rcv(struct sk_buff
*skb
)
634 netlink_rcv_skb(skb
, &genl_rcv_msg
);
638 /**************************************************************************
640 **************************************************************************/
642 static struct genl_family genl_ctrl
;
644 static int ctrl_fill_info(const struct genl_family
*family
, u32 portid
, u32 seq
,
645 u32 flags
, struct sk_buff
*skb
, u8 cmd
)
649 hdr
= genlmsg_put(skb
, portid
, seq
, &genl_ctrl
, flags
, cmd
);
653 if (nla_put_string(skb
, CTRL_ATTR_FAMILY_NAME
, family
->name
) ||
654 nla_put_u16(skb
, CTRL_ATTR_FAMILY_ID
, family
->id
) ||
655 nla_put_u32(skb
, CTRL_ATTR_VERSION
, family
->version
) ||
656 nla_put_u32(skb
, CTRL_ATTR_HDRSIZE
, family
->hdrsize
) ||
657 nla_put_u32(skb
, CTRL_ATTR_MAXATTR
, family
->maxattr
))
658 goto nla_put_failure
;
661 struct nlattr
*nla_ops
;
664 nla_ops
= nla_nest_start(skb
, CTRL_ATTR_OPS
);
666 goto nla_put_failure
;
668 for (i
= 0; i
< family
->n_ops
; i
++) {
670 const struct genl_ops
*ops
= &family
->ops
[i
];
671 u32 op_flags
= ops
->flags
;
674 op_flags
|= GENL_CMD_CAP_DUMP
;
676 op_flags
|= GENL_CMD_CAP_DO
;
678 op_flags
|= GENL_CMD_CAP_HASPOL
;
680 nest
= nla_nest_start(skb
, i
+ 1);
682 goto nla_put_failure
;
684 if (nla_put_u32(skb
, CTRL_ATTR_OP_ID
, ops
->cmd
) ||
685 nla_put_u32(skb
, CTRL_ATTR_OP_FLAGS
, op_flags
))
686 goto nla_put_failure
;
688 nla_nest_end(skb
, nest
);
691 nla_nest_end(skb
, nla_ops
);
694 if (family
->n_mcgrps
) {
695 struct nlattr
*nla_grps
;
698 nla_grps
= nla_nest_start(skb
, CTRL_ATTR_MCAST_GROUPS
);
699 if (nla_grps
== NULL
)
700 goto nla_put_failure
;
702 for (i
= 0; i
< family
->n_mcgrps
; i
++) {
704 const struct genl_multicast_group
*grp
;
706 grp
= &family
->mcgrps
[i
];
708 nest
= nla_nest_start(skb
, i
+ 1);
710 goto nla_put_failure
;
712 if (nla_put_u32(skb
, CTRL_ATTR_MCAST_GRP_ID
,
713 family
->mcgrp_offset
+ i
) ||
714 nla_put_string(skb
, CTRL_ATTR_MCAST_GRP_NAME
,
716 goto nla_put_failure
;
718 nla_nest_end(skb
, nest
);
720 nla_nest_end(skb
, nla_grps
);
723 genlmsg_end(skb
, hdr
);
727 genlmsg_cancel(skb
, hdr
);
731 static int ctrl_fill_mcgrp_info(const struct genl_family
*family
,
732 const struct genl_multicast_group
*grp
,
733 int grp_id
, u32 portid
, u32 seq
, u32 flags
,
734 struct sk_buff
*skb
, u8 cmd
)
737 struct nlattr
*nla_grps
;
740 hdr
= genlmsg_put(skb
, portid
, seq
, &genl_ctrl
, flags
, cmd
);
744 if (nla_put_string(skb
, CTRL_ATTR_FAMILY_NAME
, family
->name
) ||
745 nla_put_u16(skb
, CTRL_ATTR_FAMILY_ID
, family
->id
))
746 goto nla_put_failure
;
748 nla_grps
= nla_nest_start(skb
, CTRL_ATTR_MCAST_GROUPS
);
749 if (nla_grps
== NULL
)
750 goto nla_put_failure
;
752 nest
= nla_nest_start(skb
, 1);
754 goto nla_put_failure
;
756 if (nla_put_u32(skb
, CTRL_ATTR_MCAST_GRP_ID
, grp_id
) ||
757 nla_put_string(skb
, CTRL_ATTR_MCAST_GRP_NAME
,
759 goto nla_put_failure
;
761 nla_nest_end(skb
, nest
);
762 nla_nest_end(skb
, nla_grps
);
764 genlmsg_end(skb
, hdr
);
768 genlmsg_cancel(skb
, hdr
);
772 static int ctrl_dumpfamily(struct sk_buff
*skb
, struct netlink_callback
*cb
)
775 struct genl_family
*rt
;
776 struct net
*net
= sock_net(skb
->sk
);
777 int fams_to_skip
= cb
->args
[0];
780 idr_for_each_entry(&genl_fam_idr
, rt
, id
) {
781 if (!rt
->netnsok
&& !net_eq(net
, &init_net
))
784 if (n
++ < fams_to_skip
)
787 if (ctrl_fill_info(rt
, NETLINK_CB(cb
->skb
).portid
,
788 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
789 skb
, CTRL_CMD_NEWFAMILY
) < 0) {
799 static struct sk_buff
*ctrl_build_family_msg(const struct genl_family
*family
,
800 u32 portid
, int seq
, u8 cmd
)
805 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
807 return ERR_PTR(-ENOBUFS
);
809 err
= ctrl_fill_info(family
, portid
, seq
, 0, skb
, cmd
);
818 static struct sk_buff
*
819 ctrl_build_mcgrp_msg(const struct genl_family
*family
,
820 const struct genl_multicast_group
*grp
,
821 int grp_id
, u32 portid
, int seq
, u8 cmd
)
826 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
828 return ERR_PTR(-ENOBUFS
);
830 err
= ctrl_fill_mcgrp_info(family
, grp
, grp_id
, portid
,
840 static const struct nla_policy ctrl_policy
[CTRL_ATTR_MAX
+1] = {
841 [CTRL_ATTR_FAMILY_ID
] = { .type
= NLA_U16
},
842 [CTRL_ATTR_FAMILY_NAME
] = { .type
= NLA_NUL_STRING
,
843 .len
= GENL_NAMSIZ
- 1 },
846 static int ctrl_getfamily(struct sk_buff
*skb
, struct genl_info
*info
)
849 const struct genl_family
*res
= NULL
;
852 if (info
->attrs
[CTRL_ATTR_FAMILY_ID
]) {
853 u16 id
= nla_get_u16(info
->attrs
[CTRL_ATTR_FAMILY_ID
]);
854 res
= genl_family_find_byid(id
);
858 if (info
->attrs
[CTRL_ATTR_FAMILY_NAME
]) {
861 name
= nla_data(info
->attrs
[CTRL_ATTR_FAMILY_NAME
]);
862 res
= genl_family_find_byname(name
);
863 #ifdef CONFIG_MODULES
867 request_module("net-pf-%d-proto-%d-family-%s",
868 PF_NETLINK
, NETLINK_GENERIC
, name
);
871 res
= genl_family_find_byname(name
);
880 if (!res
->netnsok
&& !net_eq(genl_info_net(info
), &init_net
)) {
881 /* family doesn't exist here */
885 msg
= ctrl_build_family_msg(res
, info
->snd_portid
, info
->snd_seq
,
890 return genlmsg_reply(msg
, info
);
893 static int genl_ctrl_event(int event
, const struct genl_family
*family
,
894 const struct genl_multicast_group
*grp
,
899 /* genl is still initialising */
900 if (!init_net
.genl_sock
)
904 case CTRL_CMD_NEWFAMILY
:
905 case CTRL_CMD_DELFAMILY
:
907 msg
= ctrl_build_family_msg(family
, 0, 0, event
);
909 case CTRL_CMD_NEWMCAST_GRP
:
910 case CTRL_CMD_DELMCAST_GRP
:
912 msg
= ctrl_build_mcgrp_msg(family
, grp
, grp_id
, 0, 0, event
);
921 if (!family
->netnsok
) {
922 genlmsg_multicast_netns(&genl_ctrl
, &init_net
, msg
, 0,
926 genlmsg_multicast_allns(&genl_ctrl
, msg
, 0,
934 static const struct genl_ops genl_ctrl_ops
[] = {
936 .cmd
= CTRL_CMD_GETFAMILY
,
937 .doit
= ctrl_getfamily
,
938 .dumpit
= ctrl_dumpfamily
,
939 .policy
= ctrl_policy
,
943 static const struct genl_multicast_group genl_ctrl_groups
[] = {
944 { .name
= "notify", },
947 static struct genl_family genl_ctrl __ro_after_init
= {
948 .module
= THIS_MODULE
,
949 .ops
= genl_ctrl_ops
,
950 .n_ops
= ARRAY_SIZE(genl_ctrl_ops
),
951 .mcgrps
= genl_ctrl_groups
,
952 .n_mcgrps
= ARRAY_SIZE(genl_ctrl_groups
),
956 .maxattr
= CTRL_ATTR_MAX
,
960 static int genl_bind(struct net
*net
, int group
)
962 struct genl_family
*f
;
968 idr_for_each_entry(&genl_fam_idr
, f
, id
) {
969 if (group
>= f
->mcgrp_offset
&&
970 group
< f
->mcgrp_offset
+ f
->n_mcgrps
) {
971 int fam_grp
= group
- f
->mcgrp_offset
;
973 if (!f
->netnsok
&& net
!= &init_net
)
975 else if (f
->mcast_bind
)
976 err
= f
->mcast_bind(net
, fam_grp
);
987 static void genl_unbind(struct net
*net
, int group
)
989 struct genl_family
*f
;
994 idr_for_each_entry(&genl_fam_idr
, f
, id
) {
995 if (group
>= f
->mcgrp_offset
&&
996 group
< f
->mcgrp_offset
+ f
->n_mcgrps
) {
997 int fam_grp
= group
- f
->mcgrp_offset
;
1000 f
->mcast_unbind(net
, fam_grp
);
1007 static int __net_init
genl_pernet_init(struct net
*net
)
1009 struct netlink_kernel_cfg cfg
= {
1011 .flags
= NL_CFG_F_NONROOT_RECV
,
1013 .unbind
= genl_unbind
,
1016 /* we'll bump the group number right afterwards */
1017 net
->genl_sock
= netlink_kernel_create(net
, NETLINK_GENERIC
, &cfg
);
1019 if (!net
->genl_sock
&& net_eq(net
, &init_net
))
1020 panic("GENL: Cannot initialize generic netlink\n");
1022 if (!net
->genl_sock
)
1028 static void __net_exit
genl_pernet_exit(struct net
*net
)
1030 netlink_kernel_release(net
->genl_sock
);
1031 net
->genl_sock
= NULL
;
1034 static struct pernet_operations genl_pernet_ops
= {
1035 .init
= genl_pernet_init
,
1036 .exit
= genl_pernet_exit
,
1039 static int __init
genl_init(void)
1043 err
= genl_register_family(&genl_ctrl
);
1047 err
= register_pernet_subsys(&genl_pernet_ops
);
1054 panic("GENL: Cannot register controller: %d\n", err
);
1057 subsys_initcall(genl_init
);
1060 * genl_family_attrbuf - return family's attrbuf
1061 * @family: the family
1063 * Return the family's attrbuf, while validating that it's
1064 * actually valid to access it.
1066 * You cannot use this function with a family that has parallel_ops
1067 * and you can only use it within (pre/post) doit/dumpit callbacks.
1069 struct nlattr
**genl_family_attrbuf(const struct genl_family
*family
)
1071 if (!WARN_ON(family
->parallel_ops
))
1072 lockdep_assert_held(&genl_mutex
);
1074 return family
->attrbuf
;
1076 EXPORT_SYMBOL(genl_family_attrbuf
);
1078 static int genlmsg_mcast(struct sk_buff
*skb
, u32 portid
, unsigned long group
,
1081 struct sk_buff
*tmp
;
1082 struct net
*net
, *prev
= NULL
;
1085 for_each_net_rcu(net
) {
1087 tmp
= skb_clone(skb
, flags
);
1092 err
= nlmsg_multicast(prev
->genl_sock
, tmp
,
1093 portid
, group
, flags
);
1101 return nlmsg_multicast(prev
->genl_sock
, skb
, portid
, group
, flags
);
1107 int genlmsg_multicast_allns(const struct genl_family
*family
,
1108 struct sk_buff
*skb
, u32 portid
,
1109 unsigned int group
, gfp_t flags
)
1111 if (WARN_ON_ONCE(group
>= family
->n_mcgrps
))
1113 group
= family
->mcgrp_offset
+ group
;
1114 return genlmsg_mcast(skb
, portid
, group
, flags
);
1116 EXPORT_SYMBOL(genlmsg_multicast_allns
);
1118 void genl_notify(const struct genl_family
*family
, struct sk_buff
*skb
,
1119 struct genl_info
*info
, u32 group
, gfp_t flags
)
1121 struct net
*net
= genl_info_net(info
);
1122 struct sock
*sk
= net
->genl_sock
;
1126 report
= nlmsg_report(info
->nlhdr
);
1128 if (WARN_ON_ONCE(group
>= family
->n_mcgrps
))
1130 group
= family
->mcgrp_offset
+ group
;
1131 nlmsg_notify(sk
, skb
, info
->snd_portid
, group
, report
, flags
);
1133 EXPORT_SYMBOL(genl_notify
);