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

TOMOYO Linux Cross Reference
Linux/include/net/netlink.h

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ 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.75 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /* SPDX-License-Identifier: GPL-2.0 */
  2 #ifndef __NET_NETLINK_H
  3 #define __NET_NETLINK_H
  4 
  5 #include <linux/types.h>
  6 #include <linux/netlink.h>
  7 #include <linux/jiffies.h>
  8 #include <linux/in6.h>
  9 
 10 /* ========================================================================
 11  *         Netlink Messages and Attributes Interface (As Seen On TV)
 12  * ------------------------------------------------------------------------
 13  *                          Messages Interface
 14  * ------------------------------------------------------------------------
 15  *
 16  * Message Format:
 17  *    <--- nlmsg_total_size(payload)  --->
 18  *    <-- nlmsg_msg_size(payload) ->
 19  *   +----------+- - -+-------------+- - -+-------- - -
 20  *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
 21  *   +----------+- - -+-------------+- - -+-------- - -
 22  *   nlmsg_data(nlh)---^                   ^
 23  *   nlmsg_next(nlh)-----------------------+
 24  *
 25  * Payload Format:
 26  *    <---------------------- nlmsg_len(nlh) --------------------->
 27  *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
 28  *   +----------------------+- - -+--------------------------------+
 29  *   |     Family Header    | Pad |           Attributes           |
 30  *   +----------------------+- - -+--------------------------------+
 31  *   nlmsg_attrdata(nlh, hdrlen)---^
 32  *
 33  * Data Structures:
 34  *   struct nlmsghdr                    netlink message header
 35  *
 36  * Message Construction:
 37  *   nlmsg_new()                        create a new netlink message
 38  *   nlmsg_put()                        add a netlink message to an skb
 39  *   nlmsg_put_answer()                 callback based nlmsg_put()
 40  *   nlmsg_end()                        finalize netlink message
 41  *   nlmsg_get_pos()                    return current position in message
 42  *   nlmsg_trim()                       trim part of message
 43  *   nlmsg_cancel()                     cancel message construction
 44  *   nlmsg_free()                       free a netlink message
 45  *
 46  * Message Sending:
 47  *   nlmsg_multicast()                  multicast message to several groups
 48  *   nlmsg_unicast()                    unicast a message to a single socket
 49  *   nlmsg_notify()                     send notification message
 50  *
 51  * Message Length Calculations:
 52  *   nlmsg_msg_size(payload)            length of message w/o padding
 53  *   nlmsg_total_size(payload)          length of message w/ padding
 54  *   nlmsg_padlen(payload)              length of padding at tail
 55  *
 56  * Message Payload Access:
 57  *   nlmsg_data(nlh)                    head of message payload
 58  *   nlmsg_len(nlh)                     length of message payload
 59  *   nlmsg_attrdata(nlh, hdrlen)        head of attributes data
 60  *   nlmsg_attrlen(nlh, hdrlen)         length of attributes data
 61  *
 62  * Message Parsing:
 63  *   nlmsg_ok(nlh, remaining)           does nlh fit into remaining bytes?
 64  *   nlmsg_next(nlh, remaining)         get next netlink message
 65  *   nlmsg_parse()                      parse attributes of a message
 66  *   nlmsg_find_attr()                  find an attribute in a message
 67  *   nlmsg_for_each_msg()               loop over all messages
 68  *   nlmsg_validate()                   validate netlink message incl. attrs
 69  *   nlmsg_for_each_attr()              loop over all attributes
 70  *
 71  * Misc:
 72  *   nlmsg_report()                     report back to application?
 73  *
 74  * ------------------------------------------------------------------------
 75  *                          Attributes Interface
 76  * ------------------------------------------------------------------------
 77  *
 78  * Attribute Format:
 79  *    <------- nla_total_size(payload) ------->
 80  *    <---- nla_attr_size(payload) ----->
 81  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
 82  *   |  Header  | Pad |     Payload      | Pad |  Header
 83  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
 84  *                     <- nla_len(nla) ->      ^
 85  *   nla_data(nla)----^                        |
 86  *   nla_next(nla)-----------------------------'
 87  *
 88  * Data Structures:
 89  *   struct nlattr                      netlink attribute header
 90  *
 91  * Attribute Construction:
 92  *   nla_reserve(skb, type, len)        reserve room for an attribute
 93  *   nla_reserve_nohdr(skb, len)        reserve room for an attribute w/o hdr
 94  *   nla_put(skb, type, len, data)      add attribute to skb
 95  *   nla_put_nohdr(skb, len, data)      add attribute w/o hdr
 96  *   nla_append(skb, len, data)         append data to skb
 97  *
 98  * Attribute Construction for Basic Types:
 99  *   nla_put_u8(skb, type, value)       add u8 attribute to skb
100  *   nla_put_u16(skb, type, value)      add u16 attribute to skb
101  *   nla_put_u32(skb, type, value)      add u32 attribute to skb
102  *   nla_put_u64_64bit(skb, type,
103  *                     value, padattr)  add u64 attribute to skb
104  *   nla_put_s8(skb, type, value)       add s8 attribute to skb
105  *   nla_put_s16(skb, type, value)      add s16 attribute to skb
106  *   nla_put_s32(skb, type, value)      add s32 attribute to skb
107  *   nla_put_s64(skb, type, value,
108  *               padattr)               add s64 attribute to skb
109  *   nla_put_string(skb, type, str)     add string attribute to skb
110  *   nla_put_flag(skb, type)            add flag attribute to skb
111  *   nla_put_msecs(skb, type, jiffies,
112  *                 padattr)             add msecs attribute to skb
113  *   nla_put_in_addr(skb, type, addr)   add IPv4 address attribute to skb
114  *   nla_put_in6_addr(skb, type, addr)  add IPv6 address attribute to skb
115  *
116  * Nested Attributes Construction:
117  *   nla_nest_start(skb, type)          start a nested attribute
118  *   nla_nest_end(skb, nla)             finalize a nested attribute
119  *   nla_nest_cancel(skb, nla)          cancel nested attribute construction
120  *
121  * Attribute Length Calculations:
122  *   nla_attr_size(payload)             length of attribute w/o padding
123  *   nla_total_size(payload)            length of attribute w/ padding
124  *   nla_padlen(payload)                length of padding
125  *
126  * Attribute Payload Access:
127  *   nla_data(nla)                      head of attribute payload
128  *   nla_len(nla)                       length of attribute payload
129  *
130  * Attribute Payload Access for Basic Types:
131  *   nla_get_u8(nla)                    get payload for a u8 attribute
132  *   nla_get_u16(nla)                   get payload for a u16 attribute
133  *   nla_get_u32(nla)                   get payload for a u32 attribute
134  *   nla_get_u64(nla)                   get payload for a u64 attribute
135  *   nla_get_s8(nla)                    get payload for a s8 attribute
136  *   nla_get_s16(nla)                   get payload for a s16 attribute
137  *   nla_get_s32(nla)                   get payload for a s32 attribute
138  *   nla_get_s64(nla)                   get payload for a s64 attribute
139  *   nla_get_flag(nla)                  return 1 if flag is true
140  *   nla_get_msecs(nla)                 get payload for a msecs attribute
141  *
142  * Attribute Misc:
143  *   nla_memcpy(dest, nla, count)       copy attribute into memory
144  *   nla_memcmp(nla, data, size)        compare attribute with memory area
145  *   nla_strlcpy(dst, nla, size)        copy attribute to a sized string
146  *   nla_strcmp(nla, str)               compare attribute with string
147  *
148  * Attribute Parsing:
149  *   nla_ok(nla, remaining)             does nla fit into remaining bytes?
150  *   nla_next(nla, remaining)           get next netlink attribute
151  *   nla_validate()                     validate a stream of attributes
152  *   nla_validate_nested()              validate a stream of nested attributes
153  *   nla_find()                         find attribute in stream of attributes
154  *   nla_find_nested()                  find attribute in nested attributes
155  *   nla_parse()                        parse and validate stream of attrs
156  *   nla_parse_nested()                 parse nested attribuets
157  *   nla_for_each_attr()                loop over all attributes
158  *   nla_for_each_nested()              loop over the nested attributes
159  *=========================================================================
160  */
161 
162  /**
163   * Standard attribute types to specify validation policy
164   */
165 enum {
166         NLA_UNSPEC,
167         NLA_U8,
168         NLA_U16,
169         NLA_U32,
170         NLA_U64,
171         NLA_STRING,
172         NLA_FLAG,
173         NLA_MSECS,
174         NLA_NESTED,
175         NLA_NESTED_COMPAT,
176         NLA_NUL_STRING,
177         NLA_BINARY,
178         NLA_S8,
179         NLA_S16,
180         NLA_S32,
181         NLA_S64,
182         NLA_BITFIELD32,
183         __NLA_TYPE_MAX,
184 };
185 
186 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
187 
188 /**
189  * struct nla_policy - attribute validation policy
190  * @type: Type of attribute or NLA_UNSPEC
191  * @len: Type specific length of payload
192  *
193  * Policies are defined as arrays of this struct, the array must be
194  * accessible by attribute type up to the highest identifier to be expected.
195  *
196  * Meaning of `len' field:
197  *    NLA_STRING           Maximum length of string
198  *    NLA_NUL_STRING       Maximum length of string (excluding NUL)
199  *    NLA_FLAG             Unused
200  *    NLA_BINARY           Maximum length of attribute payload
201  *    NLA_NESTED           Don't use `len' field -- length verification is
202  *                         done by checking len of nested header (or empty)
203  *    NLA_NESTED_COMPAT    Minimum length of structure payload
204  *    NLA_U8, NLA_U16,
205  *    NLA_U32, NLA_U64,
206  *    NLA_S8, NLA_S16,
207  *    NLA_S32, NLA_S64,
208  *    NLA_MSECS            Leaving the length field zero will verify the
209  *                         given type fits, using it verifies minimum length
210  *                         just like "All other"
211  *    NLA_BITFIELD32      A 32-bit bitmap/bitselector attribute
212  *    All other            Minimum length of attribute payload
213  *
214  * Example:
215  * static const struct nla_policy my_policy[ATTR_MAX+1] = {
216  *      [ATTR_FOO] = { .type = NLA_U16 },
217  *      [ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
218  *      [ATTR_BAZ] = { .len = sizeof(struct mystruct) },
219  *      [ATTR_GOO] = { .type = NLA_BITFIELD32, .validation_data = &myvalidflags },
220  * };
221  */
222 struct nla_policy {
223         u16             type;
224         u16             len;
225         void            *validation_data;
226 };
227 
228 /**
229  * struct nl_info - netlink source information
230  * @nlh: Netlink message header of original request
231  * @portid: Netlink PORTID of requesting application
232  */
233 struct nl_info {
234         struct nlmsghdr         *nlh;
235         struct net              *nl_net;
236         u32                     portid;
237         bool                    skip_notify;
238 };
239 
240 int netlink_rcv_skb(struct sk_buff *skb,
241                     int (*cb)(struct sk_buff *, struct nlmsghdr *,
242                               struct netlink_ext_ack *));
243 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
244                  unsigned int group, int report, gfp_t flags);
245 
246 int nla_validate(const struct nlattr *head, int len, int maxtype,
247                  const struct nla_policy *policy,
248                  struct netlink_ext_ack *extack);
249 int nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
250               int len, const struct nla_policy *policy,
251               struct netlink_ext_ack *extack);
252 int nla_policy_len(const struct nla_policy *, int);
253 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
254 size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize);
255 char *nla_strdup(const struct nlattr *nla, gfp_t flags);
256 int nla_memcpy(void *dest, const struct nlattr *src, int count);
257 int nla_memcmp(const struct nlattr *nla, const void *data, size_t size);
258 int nla_strcmp(const struct nlattr *nla, const char *str);
259 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
260 struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
261                                    int attrlen, int padattr);
262 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
263 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
264 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype,
265                                  int attrlen, int padattr);
266 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
267 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
268                const void *data);
269 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
270                      const void *data, int padattr);
271 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
272 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
273 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
274                   const void *data, int padattr);
275 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
276 int nla_append(struct sk_buff *skb, int attrlen, const void *data);
277 
278 /**************************************************************************
279  * Netlink Messages
280  **************************************************************************/
281 
282 /**
283  * nlmsg_msg_size - length of netlink message not including padding
284  * @payload: length of message payload
285  */
286 static inline int nlmsg_msg_size(int payload)
287 {
288         return NLMSG_HDRLEN + payload;
289 }
290 
291 /**
292  * nlmsg_total_size - length of netlink message including padding
293  * @payload: length of message payload
294  */
295 static inline int nlmsg_total_size(int payload)
296 {
297         return NLMSG_ALIGN(nlmsg_msg_size(payload));
298 }
299 
300 /**
301  * nlmsg_padlen - length of padding at the message's tail
302  * @payload: length of message payload
303  */
304 static inline int nlmsg_padlen(int payload)
305 {
306         return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
307 }
308 
309 /**
310  * nlmsg_data - head of message payload
311  * @nlh: netlink message header
312  */
313 static inline void *nlmsg_data(const struct nlmsghdr *nlh)
314 {
315         return (unsigned char *) nlh + NLMSG_HDRLEN;
316 }
317 
318 /**
319  * nlmsg_len - length of message payload
320  * @nlh: netlink message header
321  */
322 static inline int nlmsg_len(const struct nlmsghdr *nlh)
323 {
324         return nlh->nlmsg_len - NLMSG_HDRLEN;
325 }
326 
327 /**
328  * nlmsg_attrdata - head of attributes data
329  * @nlh: netlink message header
330  * @hdrlen: length of family specific header
331  */
332 static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
333                                             int hdrlen)
334 {
335         unsigned char *data = nlmsg_data(nlh);
336         return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
337 }
338 
339 /**
340  * nlmsg_attrlen - length of attributes data
341  * @nlh: netlink message header
342  * @hdrlen: length of family specific header
343  */
344 static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
345 {
346         return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
347 }
348 
349 /**
350  * nlmsg_ok - check if the netlink message fits into the remaining bytes
351  * @nlh: netlink message header
352  * @remaining: number of bytes remaining in message stream
353  */
354 static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
355 {
356         return (remaining >= (int) sizeof(struct nlmsghdr) &&
357                 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
358                 nlh->nlmsg_len <= remaining);
359 }
360 
361 /**
362  * nlmsg_next - next netlink message in message stream
363  * @nlh: netlink message header
364  * @remaining: number of bytes remaining in message stream
365  *
366  * Returns the next netlink message in the message stream and
367  * decrements remaining by the size of the current message.
368  */
369 static inline struct nlmsghdr *
370 nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
371 {
372         int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
373 
374         *remaining -= totlen;
375 
376         return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
377 }
378 
379 /**
380  * nlmsg_parse - parse attributes of a netlink message
381  * @nlh: netlink message header
382  * @hdrlen: length of family specific header
383  * @tb: destination array with maxtype+1 elements
384  * @maxtype: maximum attribute type to be expected
385  * @policy: validation policy
386  * @extack: extended ACK report struct
387  *
388  * See nla_parse()
389  */
390 static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
391                               struct nlattr *tb[], int maxtype,
392                               const struct nla_policy *policy,
393                               struct netlink_ext_ack *extack)
394 {
395         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
396                 return -EINVAL;
397 
398         return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
399                          nlmsg_attrlen(nlh, hdrlen), policy, extack);
400 }
401 
402 /**
403  * nlmsg_find_attr - find a specific attribute in a netlink message
404  * @nlh: netlink message header
405  * @hdrlen: length of familiy specific header
406  * @attrtype: type of attribute to look for
407  *
408  * Returns the first attribute which matches the specified type.
409  */
410 static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
411                                              int hdrlen, int attrtype)
412 {
413         return nla_find(nlmsg_attrdata(nlh, hdrlen),
414                         nlmsg_attrlen(nlh, hdrlen), attrtype);
415 }
416 
417 /**
418  * nlmsg_validate - validate a netlink message including attributes
419  * @nlh: netlinket message header
420  * @hdrlen: length of familiy specific header
421  * @maxtype: maximum attribute type to be expected
422  * @policy: validation policy
423  * @extack: extended ACK report struct
424  */
425 static inline int nlmsg_validate(const struct nlmsghdr *nlh,
426                                  int hdrlen, int maxtype,
427                                  const struct nla_policy *policy,
428                                  struct netlink_ext_ack *extack)
429 {
430         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
431                 return -EINVAL;
432 
433         return nla_validate(nlmsg_attrdata(nlh, hdrlen),
434                             nlmsg_attrlen(nlh, hdrlen), maxtype, policy,
435                             extack);
436 }
437 
438 /**
439  * nlmsg_report - need to report back to application?
440  * @nlh: netlink message header
441  *
442  * Returns 1 if a report back to the application is requested.
443  */
444 static inline int nlmsg_report(const struct nlmsghdr *nlh)
445 {
446         return !!(nlh->nlmsg_flags & NLM_F_ECHO);
447 }
448 
449 /**
450  * nlmsg_for_each_attr - iterate over a stream of attributes
451  * @pos: loop counter, set to current attribute
452  * @nlh: netlink message header
453  * @hdrlen: length of familiy specific header
454  * @rem: initialized to len, holds bytes currently remaining in stream
455  */
456 #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
457         nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
458                           nlmsg_attrlen(nlh, hdrlen), rem)
459 
460 /**
461  * nlmsg_put - Add a new netlink message to an skb
462  * @skb: socket buffer to store message in
463  * @portid: netlink PORTID of requesting application
464  * @seq: sequence number of message
465  * @type: message type
466  * @payload: length of message payload
467  * @flags: message flags
468  *
469  * Returns NULL if the tailroom of the skb is insufficient to store
470  * the message header and payload.
471  */
472 static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
473                                          int type, int payload, int flags)
474 {
475         if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
476                 return NULL;
477 
478         return __nlmsg_put(skb, portid, seq, type, payload, flags);
479 }
480 
481 /**
482  * nlmsg_put_answer - Add a new callback based netlink message to an skb
483  * @skb: socket buffer to store message in
484  * @cb: netlink callback
485  * @type: message type
486  * @payload: length of message payload
487  * @flags: message flags
488  *
489  * Returns NULL if the tailroom of the skb is insufficient to store
490  * the message header and payload.
491  */
492 static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
493                                                 struct netlink_callback *cb,
494                                                 int type, int payload,
495                                                 int flags)
496 {
497         return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
498                          type, payload, flags);
499 }
500 
501 /**
502  * nlmsg_new - Allocate a new netlink message
503  * @payload: size of the message payload
504  * @flags: the type of memory to allocate.
505  *
506  * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
507  * and a good default is needed.
508  */
509 static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
510 {
511         return alloc_skb(nlmsg_total_size(payload), flags);
512 }
513 
514 /**
515  * nlmsg_end - Finalize a netlink message
516  * @skb: socket buffer the message is stored in
517  * @nlh: netlink message header
518  *
519  * Corrects the netlink message header to include the appeneded
520  * attributes. Only necessary if attributes have been added to
521  * the message.
522  */
523 static inline void nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
524 {
525         nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
526 }
527 
528 /**
529  * nlmsg_get_pos - return current position in netlink message
530  * @skb: socket buffer the message is stored in
531  *
532  * Returns a pointer to the current tail of the message.
533  */
534 static inline void *nlmsg_get_pos(struct sk_buff *skb)
535 {
536         return skb_tail_pointer(skb);
537 }
538 
539 /**
540  * nlmsg_trim - Trim message to a mark
541  * @skb: socket buffer the message is stored in
542  * @mark: mark to trim to
543  *
544  * Trims the message to the provided mark.
545  */
546 static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
547 {
548         if (mark) {
549                 WARN_ON((unsigned char *) mark < skb->data);
550                 skb_trim(skb, (unsigned char *) mark - skb->data);
551         }
552 }
553 
554 /**
555  * nlmsg_cancel - Cancel construction of a netlink message
556  * @skb: socket buffer the message is stored in
557  * @nlh: netlink message header
558  *
559  * Removes the complete netlink message including all
560  * attributes from the socket buffer again.
561  */
562 static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
563 {
564         nlmsg_trim(skb, nlh);
565 }
566 
567 /**
568  * nlmsg_free - free a netlink message
569  * @skb: socket buffer of netlink message
570  */
571 static inline void nlmsg_free(struct sk_buff *skb)
572 {
573         kfree_skb(skb);
574 }
575 
576 /**
577  * nlmsg_multicast - multicast a netlink message
578  * @sk: netlink socket to spread messages to
579  * @skb: netlink message as socket buffer
580  * @portid: own netlink portid to avoid sending to yourself
581  * @group: multicast group id
582  * @flags: allocation flags
583  */
584 static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
585                                   u32 portid, unsigned int group, gfp_t flags)
586 {
587         int err;
588 
589         NETLINK_CB(skb).dst_group = group;
590 
591         err = netlink_broadcast(sk, skb, portid, group, flags);
592         if (err > 0)
593                 err = 0;
594 
595         return err;
596 }
597 
598 /**
599  * nlmsg_unicast - unicast a netlink message
600  * @sk: netlink socket to spread message to
601  * @skb: netlink message as socket buffer
602  * @portid: netlink portid of the destination socket
603  */
604 static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
605 {
606         int err;
607 
608         err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
609         if (err > 0)
610                 err = 0;
611 
612         return err;
613 }
614 
615 /**
616  * nlmsg_for_each_msg - iterate over a stream of messages
617  * @pos: loop counter, set to current message
618  * @head: head of message stream
619  * @len: length of message stream
620  * @rem: initialized to len, holds bytes currently remaining in stream
621  */
622 #define nlmsg_for_each_msg(pos, head, len, rem) \
623         for (pos = head, rem = len; \
624              nlmsg_ok(pos, rem); \
625              pos = nlmsg_next(pos, &(rem)))
626 
627 /**
628  * nl_dump_check_consistent - check if sequence is consistent and advertise if not
629  * @cb: netlink callback structure that stores the sequence number
630  * @nlh: netlink message header to write the flag to
631  *
632  * This function checks if the sequence (generation) number changed during dump
633  * and if it did, advertises it in the netlink message header.
634  *
635  * The correct way to use it is to set cb->seq to the generation counter when
636  * all locks for dumping have been acquired, and then call this function for
637  * each message that is generated.
638  *
639  * Note that due to initialisation concerns, 0 is an invalid sequence number
640  * and must not be used by code that uses this functionality.
641  */
642 static inline void
643 nl_dump_check_consistent(struct netlink_callback *cb,
644                          struct nlmsghdr *nlh)
645 {
646         if (cb->prev_seq && cb->seq != cb->prev_seq)
647                 nlh->nlmsg_flags |= NLM_F_DUMP_INTR;
648         cb->prev_seq = cb->seq;
649 }
650 
651 /**************************************************************************
652  * Netlink Attributes
653  **************************************************************************/
654 
655 /**
656  * nla_attr_size - length of attribute not including padding
657  * @payload: length of payload
658  */
659 static inline int nla_attr_size(int payload)
660 {
661         return NLA_HDRLEN + payload;
662 }
663 
664 /**
665  * nla_total_size - total length of attribute including padding
666  * @payload: length of payload
667  */
668 static inline int nla_total_size(int payload)
669 {
670         return NLA_ALIGN(nla_attr_size(payload));
671 }
672 
673 /**
674  * nla_padlen - length of padding at the tail of attribute
675  * @payload: length of payload
676  */
677 static inline int nla_padlen(int payload)
678 {
679         return nla_total_size(payload) - nla_attr_size(payload);
680 }
681 
682 /**
683  * nla_type - attribute type
684  * @nla: netlink attribute
685  */
686 static inline int nla_type(const struct nlattr *nla)
687 {
688         return nla->nla_type & NLA_TYPE_MASK;
689 }
690 
691 /**
692  * nla_data - head of payload
693  * @nla: netlink attribute
694  */
695 static inline void *nla_data(const struct nlattr *nla)
696 {
697         return (char *) nla + NLA_HDRLEN;
698 }
699 
700 /**
701  * nla_len - length of payload
702  * @nla: netlink attribute
703  */
704 static inline int nla_len(const struct nlattr *nla)
705 {
706         return nla->nla_len - NLA_HDRLEN;
707 }
708 
709 /**
710  * nla_ok - check if the netlink attribute fits into the remaining bytes
711  * @nla: netlink attribute
712  * @remaining: number of bytes remaining in attribute stream
713  */
714 static inline int nla_ok(const struct nlattr *nla, int remaining)
715 {
716         return remaining >= (int) sizeof(*nla) &&
717                nla->nla_len >= sizeof(*nla) &&
718                nla->nla_len <= remaining;
719 }
720 
721 /**
722  * nla_next - next netlink attribute in attribute stream
723  * @nla: netlink attribute
724  * @remaining: number of bytes remaining in attribute stream
725  *
726  * Returns the next netlink attribute in the attribute stream and
727  * decrements remaining by the size of the current attribute.
728  */
729 static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
730 {
731         unsigned int totlen = NLA_ALIGN(nla->nla_len);
732 
733         *remaining -= totlen;
734         return (struct nlattr *) ((char *) nla + totlen);
735 }
736 
737 /**
738  * nla_find_nested - find attribute in a set of nested attributes
739  * @nla: attribute containing the nested attributes
740  * @attrtype: type of attribute to look for
741  *
742  * Returns the first attribute which matches the specified type.
743  */
744 static inline struct nlattr *
745 nla_find_nested(const struct nlattr *nla, int attrtype)
746 {
747         return nla_find(nla_data(nla), nla_len(nla), attrtype);
748 }
749 
750 /**
751  * nla_parse_nested - parse nested attributes
752  * @tb: destination array with maxtype+1 elements
753  * @maxtype: maximum attribute type to be expected
754  * @nla: attribute containing the nested attributes
755  * @policy: validation policy
756  * @extack: extended ACK report struct
757  *
758  * See nla_parse()
759  */
760 static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
761                                    const struct nlattr *nla,
762                                    const struct nla_policy *policy,
763                                    struct netlink_ext_ack *extack)
764 {
765         return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
766                          extack);
767 }
768 
769 /**
770  * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
771  * @skb: socket buffer to add attribute to
772  * @attrtype: attribute type
773  * @value: numeric value
774  */
775 static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
776 {
777         /* temporary variables to work around GCC PR81715 with asan-stack=1 */
778         u8 tmp = value;
779 
780         return nla_put(skb, attrtype, sizeof(u8), &tmp);
781 }
782 
783 /**
784  * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
785  * @skb: socket buffer to add attribute to
786  * @attrtype: attribute type
787  * @value: numeric value
788  */
789 static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
790 {
791         u16 tmp = value;
792 
793         return nla_put(skb, attrtype, sizeof(u16), &tmp);
794 }
795 
796 /**
797  * nla_put_be16 - Add a __be16 netlink attribute to a socket buffer
798  * @skb: socket buffer to add attribute to
799  * @attrtype: attribute type
800  * @value: numeric value
801  */
802 static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
803 {
804         __be16 tmp = value;
805 
806         return nla_put(skb, attrtype, sizeof(__be16), &tmp);
807 }
808 
809 /**
810  * nla_put_net16 - Add 16-bit network byte order netlink attribute to a socket buffer
811  * @skb: socket buffer to add attribute to
812  * @attrtype: attribute type
813  * @value: numeric value
814  */
815 static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
816 {
817         __be16 tmp = value;
818 
819         return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
820 }
821 
822 /**
823  * nla_put_le16 - Add a __le16 netlink attribute to a socket buffer
824  * @skb: socket buffer to add attribute to
825  * @attrtype: attribute type
826  * @value: numeric value
827  */
828 static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
829 {
830         __le16 tmp = value;
831 
832         return nla_put(skb, attrtype, sizeof(__le16), &tmp);
833 }
834 
835 /**
836  * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
837  * @skb: socket buffer to add attribute to
838  * @attrtype: attribute type
839  * @value: numeric value
840  */
841 static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
842 {
843         u32 tmp = value;
844 
845         return nla_put(skb, attrtype, sizeof(u32), &tmp);
846 }
847 
848 /**
849  * nla_put_be32 - Add a __be32 netlink attribute to a socket buffer
850  * @skb: socket buffer to add attribute to
851  * @attrtype: attribute type
852  * @value: numeric value
853  */
854 static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
855 {
856         __be32 tmp = value;
857 
858         return nla_put(skb, attrtype, sizeof(__be32), &tmp);
859 }
860 
861 /**
862  * nla_put_net32 - Add 32-bit network byte order netlink attribute to a socket buffer
863  * @skb: socket buffer to add attribute to
864  * @attrtype: attribute type
865  * @value: numeric value
866  */
867 static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
868 {
869         __be32 tmp = value;
870 
871         return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
872 }
873 
874 /**
875  * nla_put_le32 - Add a __le32 netlink attribute to a socket buffer
876  * @skb: socket buffer to add attribute to
877  * @attrtype: attribute type
878  * @value: numeric value
879  */
880 static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
881 {
882         __le32 tmp = value;
883 
884         return nla_put(skb, attrtype, sizeof(__le32), &tmp);
885 }
886 
887 /**
888  * nla_put_u64_64bit - Add a u64 netlink attribute to a skb and align it
889  * @skb: socket buffer to add attribute to
890  * @attrtype: attribute type
891  * @value: numeric value
892  * @padattr: attribute type for the padding
893  */
894 static inline int nla_put_u64_64bit(struct sk_buff *skb, int attrtype,
895                                     u64 value, int padattr)
896 {
897         u64 tmp = value;
898 
899         return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
900 }
901 
902 /**
903  * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer and align it
904  * @skb: socket buffer to add attribute to
905  * @attrtype: attribute type
906  * @value: numeric value
907  * @padattr: attribute type for the padding
908  */
909 static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value,
910                                int padattr)
911 {
912         __be64 tmp = value;
913 
914         return nla_put_64bit(skb, attrtype, sizeof(__be64), &tmp, padattr);
915 }
916 
917 /**
918  * nla_put_net64 - Add 64-bit network byte order nlattr to a skb and align it
919  * @skb: socket buffer to add attribute to
920  * @attrtype: attribute type
921  * @value: numeric value
922  * @padattr: attribute type for the padding
923  */
924 static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value,
925                                 int padattr)
926 {
927         __be64 tmp = value;
928 
929         return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, tmp,
930                             padattr);
931 }
932 
933 /**
934  * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer and align it
935  * @skb: socket buffer to add attribute to
936  * @attrtype: attribute type
937  * @value: numeric value
938  * @padattr: attribute type for the padding
939  */
940 static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value,
941                                int padattr)
942 {
943         __le64 tmp = value;
944 
945         return nla_put_64bit(skb, attrtype, sizeof(__le64), &tmp, padattr);
946 }
947 
948 /**
949  * nla_put_s8 - Add a s8 netlink attribute to a socket buffer
950  * @skb: socket buffer to add attribute to
951  * @attrtype: attribute type
952  * @value: numeric value
953  */
954 static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
955 {
956         s8 tmp = value;
957 
958         return nla_put(skb, attrtype, sizeof(s8), &tmp);
959 }
960 
961 /**
962  * nla_put_s16 - Add a s16 netlink attribute to a socket buffer
963  * @skb: socket buffer to add attribute to
964  * @attrtype: attribute type
965  * @value: numeric value
966  */
967 static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
968 {
969         s16 tmp = value;
970 
971         return nla_put(skb, attrtype, sizeof(s16), &tmp);
972 }
973 
974 /**
975  * nla_put_s32 - Add a s32 netlink attribute to a socket buffer
976  * @skb: socket buffer to add attribute to
977  * @attrtype: attribute type
978  * @value: numeric value
979  */
980 static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
981 {
982         s32 tmp = value;
983 
984         return nla_put(skb, attrtype, sizeof(s32), &tmp);
985 }
986 
987 /**
988  * nla_put_s64 - Add a s64 netlink attribute to a socket buffer and align it
989  * @skb: socket buffer to add attribute to
990  * @attrtype: attribute type
991  * @value: numeric value
992  * @padattr: attribute type for the padding
993  */
994 static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value,
995                               int padattr)
996 {
997         s64 tmp = value;
998 
999         return nla_put_64bit(skb, attrtype, sizeof(s64), &tmp, padattr);
1000 }
1001 
1002 /**
1003  * nla_put_string - Add a string netlink attribute to a socket buffer
1004  * @skb: socket buffer to add attribute to
1005  * @attrtype: attribute type
1006  * @str: NUL terminated string
1007  */
1008 static inline int nla_put_string(struct sk_buff *skb, int attrtype,
1009                                  const char *str)
1010 {
1011         return nla_put(skb, attrtype, strlen(str) + 1, str);
1012 }
1013 
1014 /**
1015  * nla_put_flag - Add a flag netlink attribute to a socket buffer
1016  * @skb: socket buffer to add attribute to
1017  * @attrtype: attribute type
1018  */
1019 static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
1020 {
1021         return nla_put(skb, attrtype, 0, NULL);
1022 }
1023 
1024 /**
1025  * nla_put_msecs - Add a msecs netlink attribute to a skb and align it
1026  * @skb: socket buffer to add attribute to
1027  * @attrtype: attribute type
1028  * @njiffies: number of jiffies to convert to msecs
1029  * @padattr: attribute type for the padding
1030  */
1031 static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
1032                                 unsigned long njiffies, int padattr)
1033 {
1034         u64 tmp = jiffies_to_msecs(njiffies);
1035 
1036         return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
1037 }
1038 
1039 /**
1040  * nla_put_in_addr - Add an IPv4 address netlink attribute to a socket
1041  * buffer
1042  * @skb: socket buffer to add attribute to
1043  * @attrtype: attribute type
1044  * @addr: IPv4 address
1045  */
1046 static inline int nla_put_in_addr(struct sk_buff *skb, int attrtype,
1047                                   __be32 addr)
1048 {
1049         __be32 tmp = addr;
1050 
1051         return nla_put_be32(skb, attrtype, tmp);
1052 }
1053 
1054 /**
1055  * nla_put_in6_addr - Add an IPv6 address netlink attribute to a socket
1056  * buffer
1057  * @skb: socket buffer to add attribute to
1058  * @attrtype: attribute type
1059  * @addr: IPv6 address
1060  */
1061 static inline int nla_put_in6_addr(struct sk_buff *skb, int attrtype,
1062                                    const struct in6_addr *addr)
1063 {
1064         return nla_put(skb, attrtype, sizeof(*addr), addr);
1065 }
1066 
1067 /**
1068  * nla_get_u32 - return payload of u32 attribute
1069  * @nla: u32 netlink attribute
1070  */
1071 static inline u32 nla_get_u32(const struct nlattr *nla)
1072 {
1073         return *(u32 *) nla_data(nla);
1074 }
1075 
1076 /**
1077  * nla_get_be32 - return payload of __be32 attribute
1078  * @nla: __be32 netlink attribute
1079  */
1080 static inline __be32 nla_get_be32(const struct nlattr *nla)
1081 {
1082         return *(__be32 *) nla_data(nla);
1083 }
1084 
1085 /**
1086  * nla_get_le32 - return payload of __le32 attribute
1087  * @nla: __le32 netlink attribute
1088  */
1089 static inline __le32 nla_get_le32(const struct nlattr *nla)
1090 {
1091         return *(__le32 *) nla_data(nla);
1092 }
1093 
1094 /**
1095  * nla_get_u16 - return payload of u16 attribute
1096  * @nla: u16 netlink attribute
1097  */
1098 static inline u16 nla_get_u16(const struct nlattr *nla)
1099 {
1100         return *(u16 *) nla_data(nla);
1101 }
1102 
1103 /**
1104  * nla_get_be16 - return payload of __be16 attribute
1105  * @nla: __be16 netlink attribute
1106  */
1107 static inline __be16 nla_get_be16(const struct nlattr *nla)
1108 {
1109         return *(__be16 *) nla_data(nla);
1110 }
1111 
1112 /**
1113  * nla_get_le16 - return payload of __le16 attribute
1114  * @nla: __le16 netlink attribute
1115  */
1116 static inline __le16 nla_get_le16(const struct nlattr *nla)
1117 {
1118         return *(__le16 *) nla_data(nla);
1119 }
1120 
1121 /**
1122  * nla_get_u8 - return payload of u8 attribute
1123  * @nla: u8 netlink attribute
1124  */
1125 static inline u8 nla_get_u8(const struct nlattr *nla)
1126 {
1127         return *(u8 *) nla_data(nla);
1128 }
1129 
1130 /**
1131  * nla_get_u64 - return payload of u64 attribute
1132  * @nla: u64 netlink attribute
1133  */
1134 static inline u64 nla_get_u64(const struct nlattr *nla)
1135 {
1136         u64 tmp;
1137 
1138         nla_memcpy(&tmp, nla, sizeof(tmp));
1139 
1140         return tmp;
1141 }
1142 
1143 /**
1144  * nla_get_be64 - return payload of __be64 attribute
1145  * @nla: __be64 netlink attribute
1146  */
1147 static inline __be64 nla_get_be64(const struct nlattr *nla)
1148 {
1149         __be64 tmp;
1150 
1151         nla_memcpy(&tmp, nla, sizeof(tmp));
1152 
1153         return tmp;
1154 }
1155 
1156 /**
1157  * nla_get_le64 - return payload of __le64 attribute
1158  * @nla: __le64 netlink attribute
1159  */
1160 static inline __le64 nla_get_le64(const struct nlattr *nla)
1161 {
1162         return *(__le64 *) nla_data(nla);
1163 }
1164 
1165 /**
1166  * nla_get_s32 - return payload of s32 attribute
1167  * @nla: s32 netlink attribute
1168  */
1169 static inline s32 nla_get_s32(const struct nlattr *nla)
1170 {
1171         return *(s32 *) nla_data(nla);
1172 }
1173 
1174 /**
1175  * nla_get_s16 - return payload of s16 attribute
1176  * @nla: s16 netlink attribute
1177  */
1178 static inline s16 nla_get_s16(const struct nlattr *nla)
1179 {
1180         return *(s16 *) nla_data(nla);
1181 }
1182 
1183 /**
1184  * nla_get_s8 - return payload of s8 attribute
1185  * @nla: s8 netlink attribute
1186  */
1187 static inline s8 nla_get_s8(const struct nlattr *nla)
1188 {
1189         return *(s8 *) nla_data(nla);
1190 }
1191 
1192 /**
1193  * nla_get_s64 - return payload of s64 attribute
1194  * @nla: s64 netlink attribute
1195  */
1196 static inline s64 nla_get_s64(const struct nlattr *nla)
1197 {
1198         s64 tmp;
1199 
1200         nla_memcpy(&tmp, nla, sizeof(tmp));
1201 
1202         return tmp;
1203 }
1204 
1205 /**
1206  * nla_get_flag - return payload of flag attribute
1207  * @nla: flag netlink attribute
1208  */
1209 static inline int nla_get_flag(const struct nlattr *nla)
1210 {
1211         return !!nla;
1212 }
1213 
1214 /**
1215  * nla_get_msecs - return payload of msecs attribute
1216  * @nla: msecs netlink attribute
1217  *
1218  * Returns the number of milliseconds in jiffies.
1219  */
1220 static inline unsigned long nla_get_msecs(const struct nlattr *nla)
1221 {
1222         u64 msecs = nla_get_u64(nla);
1223 
1224         return msecs_to_jiffies((unsigned long) msecs);
1225 }
1226 
1227 /**
1228  * nla_get_in_addr - return payload of IPv4 address attribute
1229  * @nla: IPv4 address netlink attribute
1230  */
1231 static inline __be32 nla_get_in_addr(const struct nlattr *nla)
1232 {
1233         return *(__be32 *) nla_data(nla);
1234 }
1235 
1236 /**
1237  * nla_get_in6_addr - return payload of IPv6 address attribute
1238  * @nla: IPv6 address netlink attribute
1239  */
1240 static inline struct in6_addr nla_get_in6_addr(const struct nlattr *nla)
1241 {
1242         struct in6_addr tmp;
1243 
1244         nla_memcpy(&tmp, nla, sizeof(tmp));
1245         return tmp;
1246 }
1247 
1248 /**
1249  * nla_get_bitfield32 - return payload of 32 bitfield attribute
1250  * @nla: nla_bitfield32 attribute
1251  */
1252 static inline struct nla_bitfield32 nla_get_bitfield32(const struct nlattr *nla)
1253 {
1254         struct nla_bitfield32 tmp;
1255 
1256         nla_memcpy(&tmp, nla, sizeof(tmp));
1257         return tmp;
1258 }
1259 
1260 /**
1261  * nla_memdup - duplicate attribute memory (kmemdup)
1262  * @src: netlink attribute to duplicate from
1263  * @gfp: GFP mask
1264  */
1265 static inline void *nla_memdup(const struct nlattr *src, gfp_t gfp)
1266 {
1267         return kmemdup(nla_data(src), nla_len(src), gfp);
1268 }
1269 
1270 /**
1271  * nla_nest_start - Start a new level of nested attributes
1272  * @skb: socket buffer to add attributes to
1273  * @attrtype: attribute type of container
1274  *
1275  * Returns the container attribute
1276  */
1277 static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
1278 {
1279         struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
1280 
1281         if (nla_put(skb, attrtype, 0, NULL) < 0)
1282                 return NULL;
1283 
1284         return start;
1285 }
1286 
1287 /**
1288  * nla_nest_end - Finalize nesting of attributes
1289  * @skb: socket buffer the attributes are stored in
1290  * @start: container attribute
1291  *
1292  * Corrects the container attribute header to include the all
1293  * appeneded attributes.
1294  *
1295  * Returns the total data length of the skb.
1296  */
1297 static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
1298 {
1299         start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
1300         return skb->len;
1301 }
1302 
1303 /**
1304  * nla_nest_cancel - Cancel nesting of attributes
1305  * @skb: socket buffer the message is stored in
1306  * @start: container attribute
1307  *
1308  * Removes the container attribute and including all nested
1309  * attributes. Returns -EMSGSIZE
1310  */
1311 static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
1312 {
1313         nlmsg_trim(skb, start);
1314 }
1315 
1316 /**
1317  * nla_validate_nested - Validate a stream of nested attributes
1318  * @start: container attribute
1319  * @maxtype: maximum attribute type to be expected
1320  * @policy: validation policy
1321  * @extack: extended ACK report struct
1322  *
1323  * Validates all attributes in the nested attribute stream against the
1324  * specified policy. Attributes with a type exceeding maxtype will be
1325  * ignored. See documenation of struct nla_policy for more details.
1326  *
1327  * Returns 0 on success or a negative error code.
1328  */
1329 static inline int nla_validate_nested(const struct nlattr *start, int maxtype,
1330                                       const struct nla_policy *policy,
1331                                       struct netlink_ext_ack *extack)
1332 {
1333         return nla_validate(nla_data(start), nla_len(start), maxtype, policy,
1334                             extack);
1335 }
1336 
1337 /**
1338  * nla_need_padding_for_64bit - test 64-bit alignment of the next attribute
1339  * @skb: socket buffer the message is stored in
1340  *
1341  * Return true if padding is needed to align the next attribute (nla_data()) to
1342  * a 64-bit aligned area.
1343  */
1344 static inline bool nla_need_padding_for_64bit(struct sk_buff *skb)
1345 {
1346 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1347         /* The nlattr header is 4 bytes in size, that's why we test
1348          * if the skb->data _is_ aligned.  A NOP attribute, plus
1349          * nlattr header for next attribute, will make nla_data()
1350          * 8-byte aligned.
1351          */
1352         if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
1353                 return true;
1354 #endif
1355         return false;
1356 }
1357 
1358 /**
1359  * nla_align_64bit - 64-bit align the nla_data() of next attribute
1360  * @skb: socket buffer the message is stored in
1361  * @padattr: attribute type for the padding
1362  *
1363  * Conditionally emit a padding netlink attribute in order to make
1364  * the next attribute we emit have a 64-bit aligned nla_data() area.
1365  * This will only be done in architectures which do not have
1366  * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS defined.
1367  *
1368  * Returns zero on success or a negative error code.
1369  */
1370 static inline int nla_align_64bit(struct sk_buff *skb, int padattr)
1371 {
1372         if (nla_need_padding_for_64bit(skb) &&
1373             !nla_reserve(skb, padattr, 0))
1374                 return -EMSGSIZE;
1375 
1376         return 0;
1377 }
1378 
1379 /**
1380  * nla_total_size_64bit - total length of attribute including padding
1381  * @payload: length of payload
1382  */
1383 static inline int nla_total_size_64bit(int payload)
1384 {
1385         return NLA_ALIGN(nla_attr_size(payload))
1386 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
1387                 + NLA_ALIGN(nla_attr_size(0))
1388 #endif
1389                 ;
1390 }
1391 
1392 /**
1393  * nla_for_each_attr - iterate over a stream of attributes
1394  * @pos: loop counter, set to current attribute
1395  * @head: head of attribute stream
1396  * @len: length of attribute stream
1397  * @rem: initialized to len, holds bytes currently remaining in stream
1398  */
1399 #define nla_for_each_attr(pos, head, len, rem) \
1400         for (pos = head, rem = len; \
1401              nla_ok(pos, rem); \
1402              pos = nla_next(pos, &(rem)))
1403 
1404 /**
1405  * nla_for_each_nested - iterate over nested attributes
1406  * @pos: loop counter, set to current attribute
1407  * @nla: attribute containing the nested attributes
1408  * @rem: initialized to len, holds bytes currently remaining in stream
1409  */
1410 #define nla_for_each_nested(pos, nla, rem) \
1411         nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1412 
1413 /**
1414  * nla_is_last - Test if attribute is last in stream
1415  * @nla: attribute to test
1416  * @rem: bytes remaining in stream
1417  */
1418 static inline bool nla_is_last(const struct nlattr *nla, int rem)
1419 {
1420         return nla->nla_len == rem;
1421 }
1422 
1423 #endif
1424 

~ [ 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