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  */
 165enum {
 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 */
 222struct 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 */
 233struct nl_info {
 234	struct nlmsghdr		*nlh;
 235	struct net		*nl_net;
 236	u32			portid;
 237	bool			skip_notify;
 238};
 239
 240int netlink_rcv_skb(struct sk_buff *skb,
 241		    int (*cb)(struct sk_buff *, struct nlmsghdr *,
 242			      struct netlink_ext_ack *));
 243int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
 244		 unsigned int group, int report, gfp_t flags);
 245
 246int nla_validate(const struct nlattr *head, int len, int maxtype,
 247		 const struct nla_policy *policy,
 248		 struct netlink_ext_ack *extack);
 249int 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);
 252int nla_policy_len(const struct nla_policy *, int);
 253struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
 254size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize);
 255char *nla_strdup(const struct nlattr *nla, gfp_t flags);
 256int nla_memcpy(void *dest, const struct nlattr *src, int count);
 257int nla_memcmp(const struct nlattr *nla, const void *data, size_t size);
 258int nla_strcmp(const struct nlattr *nla, const char *str);
 259struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
 260struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
 261				   int attrlen, int padattr);
 262void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
 263struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
 264struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype,
 265				 int attrlen, int padattr);
 266void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
 267void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
 268	       const void *data);
 269void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
 270		     const void *data, int padattr);
 271void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
 272int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
 273int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
 274		  const void *data, int padattr);
 275int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
 276int 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 */
 286static 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 */
 295static 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 */
 304static 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 */
 313static 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 */
 322static 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 */
 332static 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 */
 344static 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 */
 354static 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 */
 369static inline struct nlmsghdr *
 370nlmsg_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 */
 390static 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 */
 410static 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 */
 425static 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 */
 444static 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 */
 472static 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 */
 492static 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 */
 509static 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 */
 523static 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 */
 534static 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 */
 546static 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 */
 562static 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 */
 571static 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 */
 584static 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 */
 604static 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 */
 642static inline void
 643nl_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 */
 659static 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 */
 668static 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 */
 677static 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 */
 686static 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 */
 695static 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 */
 704static 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 */
 714static 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 */
 729static 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 */
 744static inline struct nlattr *
 745nla_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 */
 760static 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 */
 775static 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 */
 789static 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 */
 802static 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 */
 815static 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 */
 828static 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 */
 841static 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 */
 854static 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 */
 867static 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 */
 880static 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 */
 894static 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 */
 909static 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 */
 924static 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 */
 940static 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 */
 954static 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 */
 967static 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 */
 980static 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 */
 994static 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 */
1008static 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 */
1019static 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 */
1031static 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 */
1046static 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 */
1061static 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 */
1071static 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 */
1080static 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 */
1089static 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 */
1098static 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 */
1107static 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 */
1116static 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 */
1125static 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 */
1134static 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 */
1147static 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 */
1160static 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 */
1169static 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 */
1178static 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 */
1187static 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 */
1196static 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 */
1209static 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 */
1220static 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 */
1231static 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 */
1240static 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 */
1252static 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 */
1265static 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 */
1277static 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 */
1297static 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 */
1311static 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 */
1329static 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 */
1344static 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 */
1370static 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 */
1383static 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 */
1418static inline bool nla_is_last(const struct nlattr *nla, int rem)
1419{
1420	return nla->nla_len == rem;
1421}
1422
1423#endif