All new accounts created on Gitlab now require administrator approval. If you invite any collaborators, please let Flux staff know so they can approve the accounts.

genetlink.h 13.2 KB
Newer Older
1 2 3 4 5
#ifndef __NET_GENERIC_NETLINK_H
#define __NET_GENERIC_NETLINK_H

#include <linux/genetlink.h>
#include <net/netlink.h>
Johannes Berg's avatar
Johannes Berg committed
6
#include <net/net_namespace.h>
7

8 9
#define GENLMSG_DEFAULT_SIZE (NLMSG_DEFAULT_SIZE - GENL_HDRLEN)

10 11 12 13
/**
 * struct genl_multicast_group - generic netlink multicast group
 * @name: name of the multicast group, names are per-family
 */
Eric Dumazet's avatar
Eric Dumazet committed
14
struct genl_multicast_group {
15 16 17
	char			name[GENL_NAMSIZ];
};

18 19 20
struct genl_ops;
struct genl_info;

21 22 23 24 25 26 27
/**
 * struct genl_family - generic netlink family
 * @id: protocol family idenfitier
 * @hdrsize: length of user specific header in bytes
 * @name: name of family
 * @version: protocol version
 * @maxattr: maximum number of attributes supported
Johannes Berg's avatar
Johannes Berg committed
28 29
 * @netnsok: set to true if the family can handle network
 *	namespaces and should be presented in all of them
30 31
 * @parallel_ops: operations can be called in parallel and aren't
 *	synchronized by the core genetlink code
32 33 34 35
 * @pre_doit: called before an operation's doit callback, it may
 *	do additional, common, filtering and return an error
 * @post_doit: called after an operation's doit callback, it may
 *	undo operations done by pre_doit, for example release locks
36 37
 * @mcast_bind: a socket bound to the given multicast group (which
 *	is given as the offset into the groups array)
38 39 40 41
 * @mcast_unbind: a socket was unbound from the given multicast group.
 *	Note that unbind() will not be called symmetrically if the
 *	generic netlink family is removed while there are still open
 *	sockets.
42 43
 * @attrbuf: buffer to store parsed attributes
 * @family_list: family list
44 45 46
 * @mcgrps: multicast groups used by this family (private)
 * @n_mcgrps: number of multicast groups (private)
 * @mcgrp_offset: starting number of multicast group IDs in this family
47 48
 * @ops: the operations supported by this family (private)
 * @n_ops: number of operations supported by this family (private)
49
 */
Eric Dumazet's avatar
Eric Dumazet committed
50
struct genl_family {
51 52 53 54 55
	unsigned int		id;
	unsigned int		hdrsize;
	char			name[GENL_NAMSIZ];
	unsigned int		version;
	unsigned int		maxattr;
Johannes Berg's avatar
Johannes Berg committed
56
	bool			netnsok;
57
	bool			parallel_ops;
58
	int			(*pre_doit)(const struct genl_ops *ops,
59 60
					    struct sk_buff *skb,
					    struct genl_info *info);
61
	void			(*post_doit)(const struct genl_ops *ops,
62 63
					     struct sk_buff *skb,
					     struct genl_info *info);
64 65
	int			(*mcast_bind)(struct net *net, int group);
	void			(*mcast_unbind)(struct net *net, int group);
66
	struct nlattr **	attrbuf;	/* private */
67
	const struct genl_ops *	ops;		/* private */
68
	const struct genl_multicast_group *mcgrps; /* private */
69
	unsigned int		n_ops;		/* private */
70 71
	unsigned int		n_mcgrps;	/* private */
	unsigned int		mcgrp_offset;	/* private */
72
	struct list_head	family_list;	/* private */
73
	struct module		*module;
74 75 76 77 78
};

/**
 * struct genl_info - receiving information
 * @snd_seq: sending sequence number
79
 * @snd_portid: netlink portid of sender
80 81 82 83
 * @nlhdr: netlink message header
 * @genlhdr: generic netlink message header
 * @userhdr: user specific header
 * @attrs: netlink attributes
84 85
 * @_net: network namespace
 * @user_ptr: user pointers
86
 */
Eric Dumazet's avatar
Eric Dumazet committed
87
struct genl_info {
88
	u32			snd_seq;
89
	u32			snd_portid;
90 91 92 93
	struct nlmsghdr *	nlhdr;
	struct genlmsghdr *	genlhdr;
	void *			userhdr;
	struct nlattr **	attrs;
94
	possible_net_t		_net;
95
	void *			user_ptr[2];
96 97
};

Johannes Berg's avatar
Johannes Berg committed
98 99
static inline struct net *genl_info_net(struct genl_info *info)
{
Eric Dumazet's avatar
Eric Dumazet committed
100
	return read_pnet(&info->_net);
Johannes Berg's avatar
Johannes Berg committed
101 102 103 104
}

static inline void genl_info_net_set(struct genl_info *info, struct net *net)
{
Eric Dumazet's avatar
Eric Dumazet committed
105
	write_pnet(&info->_net, net);
Johannes Berg's avatar
Johannes Berg committed
106 107
}

108 109 110
/**
 * struct genl_ops - generic netlink operations
 * @cmd: command identifier
111
 * @internal_flags: flags used by the family
112 113 114
 * @flags: flags
 * @policy: attribute validation policy
 * @doit: standard command callback
115
 * @start: start callback for dumps
116
 * @dumpit: callback for dumpers
117
 * @done: completion callback for dumps
118 119
 * @ops_list: operations list
 */
Eric Dumazet's avatar
Eric Dumazet committed
120
struct genl_ops {
121
	const struct nla_policy	*policy;
122 123
	int		       (*doit)(struct sk_buff *skb,
				       struct genl_info *info);
124
	int		       (*start)(struct netlink_callback *cb);
125 126
	int		       (*dumpit)(struct sk_buff *skb,
					 struct netlink_callback *cb);
127
	int		       (*done)(struct netlink_callback *cb);
128 129 130
	u8			cmd;
	u8			internal_flags;
	u8			flags;
131 132
};

133
int __genl_register_family(struct genl_family *family);
134 135 136 137 138 139 140

static inline int genl_register_family(struct genl_family *family)
{
	family->module = THIS_MODULE;
	return __genl_register_family(family);
}

141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
/**
 * genl_register_family_with_ops - register a generic netlink family with ops
 * @family: generic netlink family
 * @ops: operations to be registered
 * @n_ops: number of elements to register
 *
 * Registers the specified family and operations from the specified table.
 * Only one family may be registered with the same family name or identifier.
 *
 * The family id may equal GENL_ID_GENERATE causing an unique id to
 * be automatically generated and assigned.
 *
 * Either a doit or dumpit callback must be specified for every registered
 * operation or the function will fail. Only one operation structure per
 * command identifier may be registered.
 *
 * See include/net/genetlink.h for more documenation on the operations
 * structure.
 *
 * Return 0 on success or a negative error code.
 */
162 163 164 165 166
static inline int
_genl_register_family_with_ops_grps(struct genl_family *family,
				    const struct genl_ops *ops, size_t n_ops,
				    const struct genl_multicast_group *mcgrps,
				    size_t n_mcgrps)
167 168
{
	family->module = THIS_MODULE;
169 170
	family->ops = ops;
	family->n_ops = n_ops;
171 172
	family->mcgrps = mcgrps;
	family->n_mcgrps = n_mcgrps;
173
	return __genl_register_family(family);
174 175
}

176 177 178 179 180 181 182 183
#define genl_register_family_with_ops(family, ops)			\
	_genl_register_family_with_ops_grps((family),			\
					    (ops), ARRAY_SIZE(ops),	\
					    NULL, 0)
#define genl_register_family_with_ops_groups(family, ops, grps)	\
	_genl_register_family_with_ops_grps((family),			\
					    (ops), ARRAY_SIZE(ops),	\
					    (grps), ARRAY_SIZE(grps))
184

185
int genl_unregister_family(struct genl_family *family);
Jiri Benc's avatar
Jiri Benc committed
186 187
void genl_notify(struct genl_family *family, struct sk_buff *skb,
		 struct genl_info *info, u32 group, gfp_t flags);
188

189
void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
190
		  struct genl_family *family, int flags, u8 cmd);
191

192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
/**
 * genlmsg_nlhdr - Obtain netlink header from user specified header
 * @user_hdr: user header as returned from genlmsg_put()
 * @family: generic netlink family
 *
 * Returns pointer to netlink header.
 */
static inline struct nlmsghdr *genlmsg_nlhdr(void *user_hdr,
					     struct genl_family *family)
{
	return (struct nlmsghdr *)((char *)user_hdr -
				   family->hdrsize -
				   GENL_HDRLEN -
				   NLMSG_HDRLEN);
}

208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
/**
 * genlmsg_parse - parse attributes of a genetlink message
 * @nlh: netlink message header
 * @family: genetlink message family
 * @tb: destination array with maxtype+1 elements
 * @maxtype: maximum attribute type to be expected
 * @policy: validation policy
 * */
static inline int genlmsg_parse(const struct nlmsghdr *nlh,
				const struct genl_family *family,
				struct nlattr *tb[], int maxtype,
				const struct nla_policy *policy)
{
	return nlmsg_parse(nlh, family->hdrsize + GENL_HDRLEN, tb, maxtype,
			   policy);
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
/**
 * genl_dump_check_consistent - check if sequence is consistent and advertise if not
 * @cb: netlink callback structure that stores the sequence number
 * @user_hdr: user header as returned from genlmsg_put()
 * @family: generic netlink family
 *
 * Cf. nl_dump_check_consistent(), this just provides a wrapper to make it
 * simpler to use with generic netlink.
 */
static inline void genl_dump_check_consistent(struct netlink_callback *cb,
					      void *user_hdr,
					      struct genl_family *family)
{
	nl_dump_check_consistent(cb, genlmsg_nlhdr(user_hdr, family));
}

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
/**
 * genlmsg_put_reply - Add generic netlink header to a reply message
 * @skb: socket buffer holding the message
 * @info: receiver info
 * @family: generic netlink family
 * @flags: netlink message flags
 * @cmd: generic netlink command
 *
 * Returns pointer to user specific header
 */
static inline void *genlmsg_put_reply(struct sk_buff *skb,
				      struct genl_info *info,
				      struct genl_family *family,
				      int flags, u8 cmd)
{
256
	return genlmsg_put(skb, info->snd_portid, info->snd_seq, family,
257 258 259
			   flags, cmd);
}

260 261 262 263 264
/**
 * genlmsg_end - Finalize a generic netlink message
 * @skb: socket buffer the message is stored in
 * @hdr: user specific header
 */
265
static inline void genlmsg_end(struct sk_buff *skb, void *hdr)
266
{
267
	nlmsg_end(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN);
268 269 270 271 272 273 274
}

/**
 * genlmsg_cancel - Cancel construction of a generic netlink message
 * @skb: socket buffer the message is stored in
 * @hdr: generic netlink message header
 */
275
static inline void genlmsg_cancel(struct sk_buff *skb, void *hdr)
276
{
277 278
	if (hdr)
		nlmsg_cancel(skb, hdr - GENL_HDRLEN - NLMSG_HDRLEN);
279 280 281
}

/**
Johannes Berg's avatar
Johannes Berg committed
282
 * genlmsg_multicast_netns - multicast a netlink message to a specific netns
283
 * @family: the generic netlink family
Johannes Berg's avatar
Johannes Berg committed
284 285
 * @net: the net namespace
 * @skb: netlink message as socket buffer
286
 * @portid: own netlink portid to avoid sending to yourself
287
 * @group: offset of multicast group in groups array
Johannes Berg's avatar
Johannes Berg committed
288 289
 * @flags: allocation flags
 */
290 291
static inline int genlmsg_multicast_netns(struct genl_family *family,
					  struct net *net, struct sk_buff *skb,
292
					  u32 portid, unsigned int group, gfp_t flags)
Johannes Berg's avatar
Johannes Berg committed
293
{
294
	if (WARN_ON_ONCE(group >= family->n_mcgrps))
295 296
		return -EINVAL;
	group = family->mcgrp_offset + group;
297
	return nlmsg_multicast(net->genl_sock, skb, portid, group, flags);
Johannes Berg's avatar
Johannes Berg committed
298 299 300 301
}

/**
 * genlmsg_multicast - multicast a netlink message to the default netns
302
 * @family: the generic netlink family
303
 * @skb: netlink message as socket buffer
304
 * @portid: own netlink portid to avoid sending to yourself
305
 * @group: offset of multicast group in groups array
306
 * @flags: allocation flags
307
 */
308 309
static inline int genlmsg_multicast(struct genl_family *family,
				    struct sk_buff *skb, u32 portid,
310
				    unsigned int group, gfp_t flags)
311
{
312 313
	return genlmsg_multicast_netns(family, &init_net, skb,
				       portid, group, flags);
314 315
}

Johannes Berg's avatar
Johannes Berg committed
316 317
/**
 * genlmsg_multicast_allns - multicast a netlink message to all net namespaces
318
 * @family: the generic netlink family
Johannes Berg's avatar
Johannes Berg committed
319
 * @skb: netlink message as socket buffer
320
 * @portid: own netlink portid to avoid sending to yourself
321
 * @group: offset of multicast group in groups array
Johannes Berg's avatar
Johannes Berg committed
322 323 324 325
 * @flags: allocation flags
 *
 * This function must hold the RTNL or rcu_read_lock().
 */
326 327
int genlmsg_multicast_allns(struct genl_family *family,
			    struct sk_buff *skb, u32 portid,
Johannes Berg's avatar
Johannes Berg committed
328 329
			    unsigned int group, gfp_t flags);

330 331 332
/**
 * genlmsg_unicast - unicast a netlink message
 * @skb: netlink message as socket buffer
333
 * @portid: netlink portid of the destination socket
334
 */
335
static inline int genlmsg_unicast(struct net *net, struct sk_buff *skb, u32 portid)
336
{
337
	return nlmsg_unicast(net->genl_sock, skb, portid);
338 339
}

340 341 342 343 344 345 346
/**
 * genlmsg_reply - reply to a request
 * @skb: netlink message to be sent back
 * @info: receiver information
 */
static inline int genlmsg_reply(struct sk_buff *skb, struct genl_info *info)
{
347
	return genlmsg_unicast(genl_info_net(info), skb, info->snd_portid);
348 349
}

350 351
/**
 * gennlmsg_data - head of message payload
352
 * @gnlh: genetlink message header
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
 */
static inline void *genlmsg_data(const struct genlmsghdr *gnlh)
{
	return ((unsigned char *) gnlh + GENL_HDRLEN);
}

/**
 * genlmsg_len - length of message payload
 * @gnlh: genetlink message header
 */
static inline int genlmsg_len(const struct genlmsghdr *gnlh)
{
	struct nlmsghdr *nlh = (struct nlmsghdr *)((unsigned char *)gnlh -
							NLMSG_HDRLEN);
	return (nlh->nlmsg_len - GENL_HDRLEN - NLMSG_HDRLEN);
}

370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
/**
 * genlmsg_msg_size - length of genetlink message not including padding
 * @payload: length of message payload
 */
static inline int genlmsg_msg_size(int payload)
{
	return GENL_HDRLEN + payload;
}

/**
 * genlmsg_total_size - length of genetlink message including padding
 * @payload: length of message payload
 */
static inline int genlmsg_total_size(int payload)
{
	return NLMSG_ALIGN(genlmsg_msg_size(payload));
}

388 389 390 391 392 393 394 395 396 397
/**
 * genlmsg_new - Allocate a new generic netlink message
 * @payload: size of the message payload
 * @flags: the type of memory to allocate.
 */
static inline struct sk_buff *genlmsg_new(size_t payload, gfp_t flags)
{
	return nlmsg_new(genlmsg_total_size(payload), flags);
}

398 399
/**
 * genl_set_err - report error to genetlink broadcast listeners
400
 * @family: the generic netlink family
401 402 403
 * @net: the network namespace to report the error to
 * @portid: the PORTID of a process that we want to skip (if any)
 * @group: the broadcast group that will notice the error
404
 * 	(this is the offset of the multicast group in the groups array)
405 406 407 408 409
 * @code: error code, must be negative (as usual in kernelspace)
 *
 * This function returns the number of broadcast listeners that have set the
 * NETLINK_RECV_NO_ENOBUFS socket option.
 */
410 411
static inline int genl_set_err(struct genl_family *family, struct net *net,
			       u32 portid, u32 group, int code)
412
{
413 414 415
	if (WARN_ON_ONCE(group >= family->n_mcgrps))
		return -EINVAL;
	group = family->mcgrp_offset + group;
416 417
	return netlink_set_err(net->genl_sock, portid, group, code);
}
418

419
static inline int genl_has_listeners(struct genl_family *family,
420
				     struct net *net, unsigned int group)
421 422 423 424
{
	if (WARN_ON_ONCE(group >= family->n_mcgrps))
		return -EINVAL;
	group = family->mcgrp_offset + group;
425
	return netlink_has_listeners(net->genl_sock, group);
426
}
427
#endif	/* __NET_GENERIC_NETLINK_H */