net/netlink/policy.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * NETLINK      Policy advertisement to userspace
   4  *
   5  *              Authors:        Johannes Berg <johannes@sipsolutions.net>
   6  *
   7  * Copyright 2019 Intel Corporation
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/errno.h>
  12 #include <linux/types.h>
  13 #include <net/netlink.h>
  14
  15 #define INITIAL_POLICIES_ALLOC  10
  16
  17 struct netlink_policy_dump_state {
  18         unsigned int policy_idx;
  19         unsigned int attr_idx;
  20         unsigned int n_alloc;
  21         struct {
  22                 const struct nla_policy *policy;
  23                 unsigned int maxtype;
  24         } policies[];
  25 };
  26
  27 static int add_policy(struct netlink_policy_dump_state **statep,
  28                       const struct nla_policy *policy,
  29                       unsigned int maxtype)
  30 {
  31         struct netlink_policy_dump_state *state = *statep;
  32         unsigned int n_alloc, i;
  33
  34         if (!policy || !maxtype)
  35                 return 0;
  36
  37         for (i = 0; i < state->n_alloc; i++) {
  38                 if (state->policies[i].policy == policy &&
  39                     state->policies[i].maxtype == maxtype)
  40                         return 0;
  41
  42                 if (!state->policies[i].policy) {
  43                         state->policies[i].policy = policy;
  44                         state->policies[i].maxtype = maxtype;
  45                         return 0;
  46                 }
  47         }
  48
  49         n_alloc = state->n_alloc + INITIAL_POLICIES_ALLOC;
  50         state = krealloc(state, struct_size(state, policies, n_alloc),
  51                          GFP_KERNEL);
  52         if (!state)
  53                 return -ENOMEM;
  54
  55         memset(&state->policies[state->n_alloc], 0,
  56                flex_array_size(state, policies, n_alloc - state->n_alloc));
  57
  58         state->policies[state->n_alloc].policy = policy;
  59         state->policies[state->n_alloc].maxtype = maxtype;
  60         state->n_alloc = n_alloc;
  61         *statep = state;
  62
  63         return 0;
  64 }
  65
  66 /**
  67  * netlink_policy_dump_get_policy_idx - retrieve policy index
  68  * @state: the policy dump state
  69  * @policy: the policy to find
  70  * @maxtype: the policy's maxattr
  71  *
  72  * Returns: the index of the given policy in the dump state
  73  *
  74  * Call this to find a policy index when you've added multiple and e.g.
  75  * need to tell userspace which command has which policy (by index).
  76  *
  77  * Note: this will WARN and return 0 if the policy isn't found, which
  78  *       means it wasn't added in the first place, which would be an
  79  *       internal consistency bug.
  80  */
  81 int netlink_policy_dump_get_policy_idx(struct netlink_policy_dump_state *state,
  82                                        const struct nla_policy *policy,
  83                                        unsigned int maxtype)
  84 {
  85         unsigned int i;
  86
  87         if (WARN_ON(!policy || !maxtype))
  88                 return 0;
  89
  90         for (i = 0; i < state->n_alloc; i++) {
  91                 if (state->policies[i].policy == policy &&
  92                     state->policies[i].maxtype == maxtype)
  93                         return i;
  94         }
  95
  96         WARN_ON(1);
  97         return 0;
  98 }
  99
 100 static struct netlink_policy_dump_state *alloc_state(void)
 101 {
 102         struct netlink_policy_dump_state *state;
 103
 104         state = kzalloc(struct_size(state, policies, INITIAL_POLICIES_ALLOC),
 105                         GFP_KERNEL);
 106         if (!state)
 107                 return ERR_PTR(-ENOMEM);
 108         state->n_alloc = INITIAL_POLICIES_ALLOC;
 109
 110         return state;
 111 }
 112
 113 /**
 114  * netlink_policy_dump_add_policy - add a policy to the dump
 115  * @pstate: state to add to, may be reallocated, must be %NULL the first time
 116  * @policy: the new policy to add to the dump
 117  * @maxtype: the new policy's max attr type
 118  *
 119  * Returns: 0 on success, a negative error code otherwise.
 120  *
 121  * Call this to allocate a policy dump state, and to add policies to it. This
 122  * should be called from the dump start() callback.
 123  *
 124  * Note: on failures, any previously allocated state is freed.
 125  */
 126 int netlink_policy_dump_add_policy(struct netlink_policy_dump_state **pstate,
 127                                    const struct nla_policy *policy,
 128                                    unsigned int maxtype)
 129 {
 130         struct netlink_policy_dump_state *state = *pstate;
 131         unsigned int policy_idx;
 132         int err;
 133
 134         if (!state) {
 135                 state = alloc_state();
 136                 if (IS_ERR(state))
 137                         return PTR_ERR(state);
 138         }
 139
 140         /*
 141          * walk the policies and nested ones first, and build
 142          * a linear list of them.
 143          */
 144
 145         err = add_policy(&state, policy, maxtype);
 146         if (err)
 147                 return err;
 148
 149         for (policy_idx = 0;
 150              policy_idx < state->n_alloc && state->policies[policy_idx].policy;
 151              policy_idx++) {
 152                 const struct nla_policy *policy;
 153                 unsigned int type;
 154
 155                 policy = state->policies[policy_idx].policy;
 156
 157                 for (type = 0;
 158                      type <= state->policies[policy_idx].maxtype;
 159                      type++) {
 160                         switch (policy[type].type) {
 161                         case NLA_NESTED:
 162                         case NLA_NESTED_ARRAY:
 163                                 err = add_policy(&state,
 164                                                  policy[type].nested_policy,
 165                                                  policy[type].len);
 166                                 if (err)
 167                                         return err;
 168                                 break;
 169                         default:
 170                                 break;
 171                         }
 172                 }
 173         }
 174
 175         *pstate = state;
 176         return 0;
 177 }
 178
 179 static bool
 180 netlink_policy_dump_finished(struct netlink_policy_dump_state *state)
 181 {
 182         return state->policy_idx >= state->n_alloc ||
 183                !state->policies[state->policy_idx].policy;
 184 }
 185
 186 /**
 187  * netlink_policy_dump_loop - dumping loop indicator
 188  * @state: the policy dump state
 189  *
 190  * Returns: %true if the dump continues, %false otherwise
 191  *
 192  * Note: this frees the dump state when finishing
 193  */
 194 bool netlink_policy_dump_loop(struct netlink_policy_dump_state *state)
 195 {
 196         return !netlink_policy_dump_finished(state);
 197 }
 198
 199 int netlink_policy_dump_attr_size_estimate(const struct nla_policy *pt)
 200 {
 201         /* nested + type */
 202         int common = 2 * nla_attr_size(sizeof(u32));
 203
 204         switch (pt->type) {
 205         case NLA_UNSPEC:
 206         case NLA_REJECT:
 207                 /* these actually don't need any space */
 208                 return 0;
 209         case NLA_NESTED:
 210         case NLA_NESTED_ARRAY:
 211                 /* common, policy idx, policy maxattr */
 212                 return common + 2 * nla_attr_size(sizeof(u32));
 213         case NLA_U8:
 214         case NLA_U16:
 215         case NLA_U32:
 216         case NLA_U64:
 217         case NLA_MSECS:
 218         case NLA_S8:
 219         case NLA_S16:
 220         case NLA_S32:
 221         case NLA_S64:
 222                 /* maximum is common, u64 min/max with padding */
 223                 return common +
 224                        2 * (nla_attr_size(0) + nla_attr_size(sizeof(u64)));
 225         case NLA_BITFIELD32:
 226                 return common + nla_attr_size(sizeof(u32));
 227         case NLA_STRING:
 228         case NLA_NUL_STRING:
 229         case NLA_BINARY:
 230                 /* maximum is common, u32 min-length/max-length */
 231                 return common + 2 * nla_attr_size(sizeof(u32));
 232         case NLA_FLAG:
 233                 return common;
 234         }
 235
 236         /* this should then cause a warning later */
 237         return 0;
 238 }
 239
 240 static int
 241 __netlink_policy_dump_write_attr(struct netlink_policy_dump_state *state,
 242                                  struct sk_buff *skb,
 243                                  const struct nla_policy *pt,
 244                                  int nestattr)
 245 {
 246         int estimate = netlink_policy_dump_attr_size_estimate(pt);
 247         enum netlink_attribute_type type;
 248         struct nlattr *attr;
 249
 250         attr = nla_nest_start(skb, nestattr);
 251         if (!attr)
 252                 return -ENOBUFS;
 253
 254         switch (pt->type) {
 255         default:
 256         case NLA_UNSPEC:
 257         case NLA_REJECT:
 258                 /* skip - use NLA_MIN_LEN to advertise such */
 259                 nla_nest_cancel(skb, attr);
 260                 return -ENODATA;
 261         case NLA_NESTED:
 262                 type = NL_ATTR_TYPE_NESTED;
 263                 fallthrough;
 264         case NLA_NESTED_ARRAY:
 265                 if (pt->type == NLA_NESTED_ARRAY)
 266                         type = NL_ATTR_TYPE_NESTED_ARRAY;
 267                 if (state && pt->nested_policy && pt->len &&
 268                     (nla_put_u32(skb, NL_POLICY_TYPE_ATTR_POLICY_IDX,
 269                                  netlink_policy_dump_get_policy_idx(state,
 270                                                                     pt->nested_policy,
 271                                                                     pt->len)) ||
 272                      nla_put_u32(skb, NL_POLICY_TYPE_ATTR_POLICY_MAXTYPE,
 273                                  pt->len)))
 274                         goto nla_put_failure;
 275                 break;
 276         case NLA_U8:
 277         case NLA_U16:
 278         case NLA_U32:
 279         case NLA_U64:
 280         case NLA_MSECS: {
 281                 struct netlink_range_validation range;
 282
 283                 if (pt->type == NLA_U8)
 284                         type = NL_ATTR_TYPE_U8;
 285                 else if (pt->type == NLA_U16)
 286                         type = NL_ATTR_TYPE_U16;
 287                 else if (pt->type == NLA_U32)
 288                         type = NL_ATTR_TYPE_U32;
 289                 else
 290                         type = NL_ATTR_TYPE_U64;
 291
 292                 if (pt->validation_type == NLA_VALIDATE_MASK) {
 293                         if (nla_put_u64_64bit(skb, NL_POLICY_TYPE_ATTR_MASK,
 294                                               pt->mask,
 295                                               NL_POLICY_TYPE_ATTR_PAD))
 296                                 goto nla_put_failure;
 297                         break;
 298                 }
 299
 300                 nla_get_range_unsigned(pt, &range);
 301
 302                 if (nla_put_u64_64bit(skb, NL_POLICY_TYPE_ATTR_MIN_VALUE_U,
 303                                       range.min, NL_POLICY_TYPE_ATTR_PAD) ||
 304                     nla_put_u64_64bit(skb, NL_POLICY_TYPE_ATTR_MAX_VALUE_U,
 305                                       range.max, NL_POLICY_TYPE_ATTR_PAD))
 306                         goto nla_put_failure;
 307                 break;
 308         }
 309         case NLA_S8:
 310         case NLA_S16:
 311         case NLA_S32:
 312         case NLA_S64: {
 313                 struct netlink_range_validation_signed range;
 314
 315                 if (pt->type == NLA_S8)
 316                         type = NL_ATTR_TYPE_S8;
 317                 else if (pt->type == NLA_S16)
 318                         type = NL_ATTR_TYPE_S16;
 319                 else if (pt->type == NLA_S32)
 320                         type = NL_ATTR_TYPE_S32;
 321                 else
 322                         type = NL_ATTR_TYPE_S64;
 323
 324                 nla_get_range_signed(pt, &range);
 325
 326                 if (nla_put_s64(skb, NL_POLICY_TYPE_ATTR_MIN_VALUE_S,
 327                                 range.min, NL_POLICY_TYPE_ATTR_PAD) ||
 328                     nla_put_s64(skb, NL_POLICY_TYPE_ATTR_MAX_VALUE_S,
 329                                 range.max, NL_POLICY_TYPE_ATTR_PAD))
 330                         goto nla_put_failure;
 331                 break;
 332         }
 333         case NLA_BITFIELD32:
 334                 type = NL_ATTR_TYPE_BITFIELD32;
 335                 if (nla_put_u32(skb, NL_POLICY_TYPE_ATTR_BITFIELD32_MASK,
 336                                 pt->bitfield32_valid))
 337                         goto nla_put_failure;
 338                 break;
 339         case NLA_STRING:
 340         case NLA_NUL_STRING:
 341         case NLA_BINARY:
 342                 if (pt->type == NLA_STRING)
 343                         type = NL_ATTR_TYPE_STRING;
 344                 else if (pt->type == NLA_NUL_STRING)
 345                         type = NL_ATTR_TYPE_NUL_STRING;
 346                 else
 347                         type = NL_ATTR_TYPE_BINARY;
 348
 349                 if (pt->validation_type == NLA_VALIDATE_RANGE ||
 350                     pt->validation_type == NLA_VALIDATE_RANGE_WARN_TOO_LONG) {
 351                         struct netlink_range_validation range;
 352
 353                         nla_get_range_unsigned(pt, &range);
 354
 355                         if (range.min &&
 356                             nla_put_u32(skb, NL_POLICY_TYPE_ATTR_MIN_LENGTH,
 357                                         range.min))
 358                                 goto nla_put_failure;
 359
 360                         if (range.max < U16_MAX &&
 361                             nla_put_u32(skb, NL_POLICY_TYPE_ATTR_MAX_LENGTH,
 362                                         range.max))
 363                                 goto nla_put_failure;
 364                 } else if (pt->len &&
 365                            nla_put_u32(skb, NL_POLICY_TYPE_ATTR_MAX_LENGTH,
 366                                        pt->len)) {
 367                         goto nla_put_failure;
 368                 }
 369                 break;
 370         case NLA_FLAG:
 371                 type = NL_ATTR_TYPE_FLAG;
 372                 break;
 373         }
 374
 375         if (nla_put_u32(skb, NL_POLICY_TYPE_ATTR_TYPE, type))
 376                 goto nla_put_failure;
 377
 378         nla_nest_end(skb, attr);
 379         WARN_ON(attr->nla_len > estimate);
 380
 381         return 0;
 382 nla_put_failure:
 383         nla_nest_cancel(skb, attr);
 384         return -ENOBUFS;
 385 }
 386
 387 /**
 388  * netlink_policy_dump_write_attr - write a given attribute policy
 389  * @skb: the message skb to write to
 390  * @pt: the attribute's policy
 391  * @nestattr: the nested attribute ID to use
 392  *
 393  * Returns: 0 on success, an error code otherwise; -%ENODATA is
 394  *          special, indicating that there's no policy data and
 395  *          the attribute is generally rejected.
 396  */
 397 int netlink_policy_dump_write_attr(struct sk_buff *skb,
 398                                    const struct nla_policy *pt,
 399                                    int nestattr)
 400 {
 401         return __netlink_policy_dump_write_attr(NULL, skb, pt, nestattr);
 402 }
 403
 404 /**
 405  * netlink_policy_dump_write - write current policy dump attributes
 406  * @skb: the message skb to write to
 407  * @state: the policy dump state
 408  *
 409  * Returns: 0 on success, an error code otherwise
 410  */
 411 int netlink_policy_dump_write(struct sk_buff *skb,
 412                               struct netlink_policy_dump_state *state)
 413 {
 414         const struct nla_policy *pt;
 415         struct nlattr *policy;
 416         bool again;
 417         int err;
 418
 419 send_attribute:
 420         again = false;
 421
 422         pt = &state->policies[state->policy_idx].policy[state->attr_idx];
 423
 424         policy = nla_nest_start(skb, state->policy_idx);
 425         if (!policy)
 426                 return -ENOBUFS;
 427
 428         err = __netlink_policy_dump_write_attr(state, skb, pt, state->attr_idx);
 429         if (err == -ENODATA) {
 430                 nla_nest_cancel(skb, policy);
 431                 again = true;
 432                 goto next;
 433         } else if (err) {
 434                 goto nla_put_failure;
 435         }
 436
 437         /* finish and move state to next attribute */
 438         nla_nest_end(skb, policy);
 439
 440 next:
 441         state->attr_idx += 1;
 442         if (state->attr_idx > state->policies[state->policy_idx].maxtype) {
 443                 state->attr_idx = 0;
 444                 state->policy_idx++;
 445         }
 446
 447         if (again) {
 448                 if (netlink_policy_dump_finished(state))
 449                         return -ENODATA;
 450                 goto send_attribute;
 451         }
 452
 453         return 0;
 454
 455 nla_put_failure:
 456         nla_nest_cancel(skb, policy);
 457         return -ENOBUFS;
 458 }
 459
 460 /**
 461  * netlink_policy_dump_free - free policy dump state
 462  * @state: the policy dump state to free
 463  *
 464  * Call this from the done() method to ensure dump state is freed.
 465  */
 466 void netlink_policy_dump_free(struct netlink_policy_dump_state *state)
 467 {
 468         kfree(state);
 469 }