1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef GENL_MAGIC_FUNC_H
3#define GENL_MAGIC_FUNC_H
4
5#include <linux/args.h>
6#include <linux/build_bug.h>
7#include <linux/genl_magic_struct.h>
8
9/*
10 * Magic: declare tla policy						{{{1
11 * Magic: declare nested policies
12 *									{{{2
13 */
14#undef GENL_mc_group
15#define GENL_mc_group(group)
16
17#undef GENL_notification
18#define GENL_notification(op_name, op_num, mcast_group, tla_list)
19
20#undef GENL_op
21#define GENL_op(op_name, op_num, handler, tla_list)
22
23#undef GENL_struct
24#define GENL_struct(tag_name, tag_number, s_name, s_fields)		\
25	[tag_name] = { .type = NLA_NESTED },
26
27static struct nla_policy CONCATENATE(GENL_MAGIC_FAMILY, _tla_nl_policy)[] = {
28#include GENL_MAGIC_INCLUDE_FILE
29};
30
31#undef GENL_struct
32#define GENL_struct(tag_name, tag_number, s_name, s_fields)		\
33static struct nla_policy s_name ## _nl_policy[] __read_mostly =		\
34{ s_fields };
35
36#undef __field
37#define __field(attr_nr, attr_flag, name, nla_type, _type, __get,	\
38		 __put, __is_signed)					\
39	[attr_nr] = { .type = nla_type },
40
41#undef __array
42#define __array(attr_nr, attr_flag, name, nla_type, _type, maxlen,	\
43		__get, __put, __is_signed)				\
44	[attr_nr] = { .type = nla_type,					\
45		      .len = maxlen - (nla_type == NLA_NUL_STRING) },
46
47#include GENL_MAGIC_INCLUDE_FILE
48
49#ifndef __KERNEL__
50#ifndef pr_info
51#define pr_info(args...)	fprintf(stderr, args);
52#endif
53#endif
54
55#ifdef GENL_MAGIC_DEBUG
56static void dprint_field(const char *dir, int nla_type,
57		const char *name, void *valp)
58{
59	__u64 val = valp ? *(__u32 *)valp : 1;
60	switch (nla_type) {
61	case NLA_U8:  val = (__u8)val;
62	case NLA_U16: val = (__u16)val;
63	case NLA_U32: val = (__u32)val;
64		pr_info("%s attr %s: %d 0x%08x\n", dir,
65			name, (int)val, (unsigned)val);
66		break;
67	case NLA_U64:
68		val = *(__u64*)valp;
69		pr_info("%s attr %s: %lld 0x%08llx\n", dir,
70			name, (long long)val, (unsigned long long)val);
71		break;
72	case NLA_FLAG:
73		if (val)
74			pr_info("%s attr %s: set\n", dir, name);
75		break;
76	}
77}
78
79static void dprint_array(const char *dir, int nla_type,
80		const char *name, const char *val, unsigned len)
81{
82	switch (nla_type) {
83	case NLA_NUL_STRING:
84		if (len && val[len-1] == '\0')
85			len--;
86		pr_info("%s attr %s: [len:%u] '%s'\n", dir, name, len, val);
87		break;
88	default:
89		/* we can always show 4 byte,
90		 * thats what nlattr are aligned to. */
91		pr_info("%s attr %s: [len:%u] %02x%02x%02x%02x ...\n",
92			dir, name, len, val[0], val[1], val[2], val[3]);
93	}
94}
95
96#define DPRINT_TLA(a, op, b) pr_info("%s %s %s\n", a, op, b);
97
98/* Name is a member field name of the struct s.
99 * If s is NULL (only parsing, no copy requested in *_from_attrs()),
100 * nla is supposed to point to the attribute containing the information
101 * corresponding to that struct member. */
102#define DPRINT_FIELD(dir, nla_type, name, s, nla)			\
103	do {								\
104		if (s)							\
105			dprint_field(dir, nla_type, #name, &s->name);	\
106		else if (nla)						\
107			dprint_field(dir, nla_type, #name,		\
108				(nla_type == NLA_FLAG) ? NULL		\
109						: nla_data(nla));	\
110	} while (0)
111
112#define	DPRINT_ARRAY(dir, nla_type, name, s, nla)			\
113	do {								\
114		if (s)							\
115			dprint_array(dir, nla_type, #name,		\
116					s->name, s->name ## _len);	\
117		else if (nla)						\
118			dprint_array(dir, nla_type, #name,		\
119					nla_data(nla), nla_len(nla));	\
120	} while (0)
121#else
122#define DPRINT_TLA(a, op, b) do {} while (0)
123#define DPRINT_FIELD(dir, nla_type, name, s, nla) do {} while (0)
124#define	DPRINT_ARRAY(dir, nla_type, name, s, nla) do {} while (0)
125#endif
126
127/*
128 * Magic: provide conversion functions					{{{1
129 * populate struct from attribute table:
130 *									{{{2
131 */
132
133/* processing of generic netlink messages is serialized.
134 * use one static buffer for parsing of nested attributes */
135static struct nlattr *nested_attr_tb[128];
136
137#undef GENL_struct
138#define GENL_struct(tag_name, tag_number, s_name, s_fields)		\
139/* *_from_attrs functions are static, but potentially unused */		\
140static int __ ## s_name ## _from_attrs(struct s_name *s,		\
141		struct genl_info *info, bool exclude_invariants)	\
142{									\
143	const int maxtype = ARRAY_SIZE(s_name ## _nl_policy)-1;		\
144	struct nlattr *tla = info->attrs[tag_number];			\
145	struct nlattr **ntb = nested_attr_tb;				\
146	struct nlattr *nla;						\
147	int err;							\
148	BUILD_BUG_ON(ARRAY_SIZE(s_name ## _nl_policy) > ARRAY_SIZE(nested_attr_tb));	\
149	if (!tla)							\
150		return -ENOMSG;						\
151	DPRINT_TLA(#s_name, "<=-", #tag_name);				\
152	err = drbd_nla_parse_nested(ntb, maxtype, tla, s_name ## _nl_policy);	\
153	if (err)							\
154		return err;						\
155									\
156	s_fields							\
157	return 0;							\
158}					__attribute__((unused))		\
159static int s_name ## _from_attrs(struct s_name *s,			\
160						struct genl_info *info)	\
161{									\
162	return __ ## s_name ## _from_attrs(s, info, false);		\
163}					__attribute__((unused))		\
164static int s_name ## _from_attrs_for_change(struct s_name *s,		\
165						struct genl_info *info)	\
166{									\
167	return __ ## s_name ## _from_attrs(s, info, true);		\
168}					__attribute__((unused))		\
169
170#define __assign(attr_nr, attr_flag, name, nla_type, type, assignment...)	\
171		nla = ntb[attr_nr];						\
172		if (nla) {						\
173			if (exclude_invariants && !!((attr_flag) & DRBD_F_INVARIANT)) {		\
174				pr_info("<< must not change invariant attr: %s\n", #name);	\
175				return -EEXIST;				\
176			}						\
177			assignment;					\
178		} else if (exclude_invariants && !!((attr_flag) & DRBD_F_INVARIANT)) {		\
179			/* attribute missing from payload, */		\
180			/* which was expected */			\
181		} else if ((attr_flag) & DRBD_F_REQUIRED) {		\
182			pr_info("<< missing attr: %s\n", #name);	\
183			return -ENOMSG;					\
184		}
185
186#undef __field
187#define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put,	\
188		__is_signed)						\
189	__assign(attr_nr, attr_flag, name, nla_type, type,		\
190			if (s)						\
191				s->name = __get(nla);			\
192			DPRINT_FIELD("<<", nla_type, name, s, nla))
193
194/* validate_nla() already checked nla_len <= maxlen appropriately. */
195#undef __array
196#define __array(attr_nr, attr_flag, name, nla_type, type, maxlen,	\
197		__get, __put, __is_signed)				\
198	__assign(attr_nr, attr_flag, name, nla_type, type,		\
199			if (s)						\
200				s->name ## _len =			\
201					__get(s->name, nla, maxlen);	\
202			DPRINT_ARRAY("<<", nla_type, name, s, nla))
203
204#include GENL_MAGIC_INCLUDE_FILE
205
206#undef GENL_struct
207#define GENL_struct(tag_name, tag_number, s_name, s_fields)
208
209/*
210 * Magic: define op number to op name mapping				{{{1
211 *									{{{2
212 */
213static const char *CONCATENATE(GENL_MAGIC_FAMILY, _genl_cmd_to_str)(__u8 cmd)
214{
215	switch (cmd) {
216#undef GENL_op
217#define GENL_op(op_name, op_num, handler, tla_list)		\
218	case op_num: return #op_name;
219#include GENL_MAGIC_INCLUDE_FILE
220	default:
221		     return "unknown";
222	}
223}
224
225#ifdef __KERNEL__
226#include <linux/stringify.h>
227/*
228 * Magic: define genl_ops						{{{1
229 *									{{{2
230 */
231
232#undef GENL_op
233#define GENL_op(op_name, op_num, handler, tla_list)		\
234{								\
235	handler							\
236	.cmd = op_name,						\
237},
238
239#define ZZZ_genl_ops		CONCATENATE(GENL_MAGIC_FAMILY, _genl_ops)
240static struct genl_ops ZZZ_genl_ops[] __read_mostly = {
241#include GENL_MAGIC_INCLUDE_FILE
242};
243
244#undef GENL_op
245#define GENL_op(op_name, op_num, handler, tla_list)
246
247/*
248 * Define the genl_family, multicast groups,				{{{1
249 * and provide register/unregister functions.
250 *									{{{2
251 */
252#define ZZZ_genl_family		CONCATENATE(GENL_MAGIC_FAMILY, _genl_family)
253static struct genl_family ZZZ_genl_family;
254/*
255 * Magic: define multicast groups
256 * Magic: define multicast group registration helper
257 */
258#define ZZZ_genl_mcgrps		CONCATENATE(GENL_MAGIC_FAMILY, _genl_mcgrps)
259static const struct genl_multicast_group ZZZ_genl_mcgrps[] = {
260#undef GENL_mc_group
261#define GENL_mc_group(group) { .name = #group, },
262#include GENL_MAGIC_INCLUDE_FILE
263};
264
265enum CONCATENATE(GENL_MAGIC_FAMILY, group_ids) {
266#undef GENL_mc_group
267#define GENL_mc_group(group) CONCATENATE(GENL_MAGIC_FAMILY, _group_ ## group),
268#include GENL_MAGIC_INCLUDE_FILE
269};
270
271#undef GENL_mc_group
272#define GENL_mc_group(group)						\
273static int CONCATENATE(GENL_MAGIC_FAMILY, _genl_multicast_ ## group)(	\
274	struct sk_buff *skb, gfp_t flags)				\
275{									\
276	unsigned int group_id =						\
277		CONCATENATE(GENL_MAGIC_FAMILY, _group_ ## group);		\
278	return genlmsg_multicast(&ZZZ_genl_family, skb, 0,		\
279				 group_id, flags);			\
280}
281
282#include GENL_MAGIC_INCLUDE_FILE
283
284#undef GENL_mc_group
285#define GENL_mc_group(group)
286
287static struct genl_family ZZZ_genl_family __ro_after_init = {
288	.name = __stringify(GENL_MAGIC_FAMILY),
289	.version = GENL_MAGIC_VERSION,
290#ifdef GENL_MAGIC_FAMILY_HDRSZ
291	.hdrsize = NLA_ALIGN(GENL_MAGIC_FAMILY_HDRSZ),
292#endif
293	.maxattr = ARRAY_SIZE(CONCATENATE(GENL_MAGIC_FAMILY, _tla_nl_policy))-1,
294	.policy	= CONCATENATE(GENL_MAGIC_FAMILY, _tla_nl_policy),
295	.ops = ZZZ_genl_ops,
296	.n_ops = ARRAY_SIZE(ZZZ_genl_ops),
297	.mcgrps = ZZZ_genl_mcgrps,
298	.resv_start_op = 42, /* drbd is currently the only user */
299	.n_mcgrps = ARRAY_SIZE(ZZZ_genl_mcgrps),
300	.module = THIS_MODULE,
301};
302
303int CONCATENATE(GENL_MAGIC_FAMILY, _genl_register)(void)
304{
305	return genl_register_family(&ZZZ_genl_family);
306}
307
308void CONCATENATE(GENL_MAGIC_FAMILY, _genl_unregister)(void)
309{
310	genl_unregister_family(&ZZZ_genl_family);
311}
312
313/*
314 * Magic: provide conversion functions					{{{1
315 * populate skb from struct.
316 *									{{{2
317 */
318
319#undef GENL_op
320#define GENL_op(op_name, op_num, handler, tla_list)
321
322#undef GENL_struct
323#define GENL_struct(tag_name, tag_number, s_name, s_fields)		\
324static int s_name ## _to_skb(struct sk_buff *skb, struct s_name *s,	\
325		const bool exclude_sensitive)				\
326{									\
327	struct nlattr *tla = nla_nest_start(skb, tag_number);		\
328	if (!tla)							\
329		goto nla_put_failure;					\
330	DPRINT_TLA(#s_name, "-=>", #tag_name);				\
331	s_fields							\
332	nla_nest_end(skb, tla);						\
333	return 0;							\
334									\
335nla_put_failure:							\
336	if (tla)							\
337		nla_nest_cancel(skb, tla);				\
338        return -EMSGSIZE;						\
339}									\
340static inline int s_name ## _to_priv_skb(struct sk_buff *skb,		\
341		struct s_name *s)					\
342{									\
343	return s_name ## _to_skb(skb, s, 0);				\
344}									\
345static inline int s_name ## _to_unpriv_skb(struct sk_buff *skb,		\
346		struct s_name *s)					\
347{									\
348	return s_name ## _to_skb(skb, s, 1);				\
349}
350
351
352#undef __field
353#define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put,	\
354		__is_signed)						\
355	if (!exclude_sensitive || !((attr_flag) & DRBD_F_SENSITIVE)) {	\
356		DPRINT_FIELD(">>", nla_type, name, s, NULL);		\
357		if (__put(skb, attr_nr, s->name))			\
358			goto nla_put_failure;				\
359	}
360
361#undef __array
362#define __array(attr_nr, attr_flag, name, nla_type, type, maxlen,	\
363		__get, __put, __is_signed)				\
364	if (!exclude_sensitive || !((attr_flag) & DRBD_F_SENSITIVE)) {	\
365		DPRINT_ARRAY(">>",nla_type, name, s, NULL);		\
366		if (__put(skb, attr_nr, min_t(int, maxlen,		\
367			s->name ## _len + (nla_type == NLA_NUL_STRING)),\
368						s->name))		\
369			goto nla_put_failure;				\
370	}
371
372#include GENL_MAGIC_INCLUDE_FILE
373
374
375/* Functions for initializing structs to default values.  */
376
377#undef __field
378#define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put,	\
379		__is_signed)
380#undef __array
381#define __array(attr_nr, attr_flag, name, nla_type, type, maxlen,	\
382		__get, __put, __is_signed)
383#undef __u32_field_def
384#define __u32_field_def(attr_nr, attr_flag, name, default)		\
385	x->name = default;
386#undef __s32_field_def
387#define __s32_field_def(attr_nr, attr_flag, name, default)		\
388	x->name = default;
389#undef __flg_field_def
390#define __flg_field_def(attr_nr, attr_flag, name, default)		\
391	x->name = default;
392#undef __str_field_def
393#define __str_field_def(attr_nr, attr_flag, name, maxlen)		\
394	memset(x->name, 0, sizeof(x->name));				\
395	x->name ## _len = 0;
396#undef GENL_struct
397#define GENL_struct(tag_name, tag_number, s_name, s_fields)		\
398static void set_ ## s_name ## _defaults(struct s_name *x) __attribute__((unused)); \
399static void set_ ## s_name ## _defaults(struct s_name *x) {	\
400s_fields								\
401}
402
403#include GENL_MAGIC_INCLUDE_FILE
404
405#endif /* __KERNEL__ */
406
407/* }}}1 */
408#endif /* GENL_MAGIC_FUNC_H */
409