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