~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/genl_magic_func.h

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifndef GENL_MAGIC_FUNC_H
  2 #define GENL_MAGIC_FUNC_H
  3 
  4 #include <linux/genl_magic_struct.h>
  5 
  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
 34 #define __field(attr_nr, attr_flag, name, nla_type, _type, __get,       \
 35                  __put, __is_signed)                                    \
 36         [attr_nr] = { .type = nla_type },
 37 
 38 #undef __array
 39 #define __array(attr_nr, attr_flag, name, nla_type, _type, maxlen,      \
 40                 __get, __put, __is_signed)                              \
 41         [attr_nr] = { .type = nla_type,                                 \
 42                       .len = maxlen - (nla_type == NLA_NUL_STRING) },
 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 
 52 #ifdef GENL_MAGIC_DEBUG
 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)             \
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)        \
150 {                                                                       \
151         const int maxtype = ARRAY_SIZE(s_name ## _nl_policy)-1;         \
152         struct nlattr *tla = info->attrs[tag_number];                   \
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);                          \
160         err = drbd_nla_parse_nested(ntb, maxtype, tla, s_name ## _nl_policy);   \
161         if (err)                                                        \
162                 return err;                                             \
163                                                                         \
164         s_fields                                                        \
165         return 0;                                                       \
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))         \
177 
178 #define __assign(attr_nr, attr_flag, name, nla_type, type, assignment...)       \
179                 nla = ntb[attr_nr];                                             \
180                 if (nla) {                                              \
181                         if (exclude_invariants && ((attr_flag) & DRBD_F_INVARIANT)) {           \
182                                 pr_info("<< must not change invariant attr: %s\n", #name);      \
183                                 return -EEXIST;                         \
184                         }                                               \
185                         assignment;                                     \
186                 } else if (exclude_invariants && ((attr_flag) & DRBD_F_INVARIANT)) {            \
187                         /* attribute missing from payload, */           \
188                         /* which was expected */                        \
189                 } else if ((attr_flag) & DRBD_F_REQUIRED) {             \
190                         pr_info("<< missing attr: %s\n", #name);        \
191                         return -ENOMSG;                                 \
192                 }
193 
194 #undef __field
195 #define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put, \
196                 __is_signed)                                            \
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 
202 /* validate_nla() already checked nla_len <= maxlen appropriately. */
203 #undef __array
204 #define __array(attr_nr, attr_flag, name, nla_type, type, maxlen,       \
205                 __get, __put, __is_signed)                              \
206         __assign(attr_nr, attr_flag, name, nla_type, type,              \
207                         if (s)                                          \
208                                 s->name ## _len =                       \
209                                         __get(s->name, nla, maxlen);    \
210                         DPRINT_ARRAY("<<", nla_type, name, s, nla))
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
366 #define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put, \
367                 __is_signed)                                            \
368         if (!exclude_sensitive || !((attr_flag) & DRBD_F_SENSITIVE)) {  \
369                 DPRINT_FIELD(">>", nla_type, name, s, NULL);            \
370                 if (__put(skb, attr_nr, s->name))                       \
371                         goto nla_put_failure;                           \
372         }
373 
374 #undef __array
375 #define __array(attr_nr, attr_flag, name, nla_type, type, maxlen,       \
376                 __get, __put, __is_signed)                              \
377         if (!exclude_sensitive || !((attr_flag) & DRBD_F_SENSITIVE)) {  \
378                 DPRINT_ARRAY(">>",nla_type, name, s, NULL);             \
379                 if (__put(skb, attr_nr, min_t(int, maxlen,              \
380                         s->name ## _len + (nla_type == NLA_NUL_STRING)),\
381                                                 s->name))               \
382                         goto nla_put_failure;                           \
383         }
384 
385 #include GENL_MAGIC_INCLUDE_FILE
386 
387 
388 /* Functions for initializing structs to default values.  */
389 
390 #undef __field
391 #define __field(attr_nr, attr_flag, name, nla_type, type, __get, __put, \
392                 __is_signed)
393 #undef __array
394 #define __array(attr_nr, attr_flag, name, nla_type, type, maxlen,       \
395                 __get, __put, __is_signed)
396 #undef __u32_field_def
397 #define __u32_field_def(attr_nr, attr_flag, name, default)              \
398         x->name = default;
399 #undef __s32_field_def
400 #define __s32_field_def(attr_nr, attr_flag, name, default)              \
401         x->name = default;
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 
418 #endif /* __KERNEL__ */
419 
420 /* }}}1 */
421 #endif /* GENL_MAGIC_FUNC_H */
422 /* vim: set foldmethod=marker foldlevel=1 nofoldenable : */
423 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp