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 nl_policy_dump { 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 nl_policy_dump **statep, 28 const struct nla_policy *policy, 29 unsigned int maxtype) 30 { 31 struct nl_policy_dump *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 return 0; 40 41 if (!state->policies[i].policy) { 42 state->policies[i].policy = policy; 43 state->policies[i].maxtype = maxtype; 44 return 0; 45 } 46 } 47 48 n_alloc = state->n_alloc + INITIAL_POLICIES_ALLOC; 49 state = krealloc(state, struct_size(state, policies, n_alloc), 50 GFP_KERNEL); 51 if (!state) 52 return -ENOMEM; 53 54 state->policies[state->n_alloc].policy = policy; 55 state->policies[state->n_alloc].maxtype = maxtype; 56 state->n_alloc = n_alloc; 57 *statep = state; 58 59 return 0; 60 } 61 62 static unsigned int get_policy_idx(struct nl_policy_dump *state, 63 const struct nla_policy *policy) 64 { 65 unsigned int i; 66 67 for (i = 0; i < state->n_alloc; i++) { 68 if (state->policies[i].policy == policy) 69 return i; 70 } 71 72 WARN_ON_ONCE(1); 73 return -1; 74 } 75 76 int netlink_policy_dump_start(const struct nla_policy *policy, 77 unsigned int maxtype, 78 unsigned long *_state) 79 { 80 struct nl_policy_dump *state; 81 unsigned int policy_idx; 82 int err; 83 84 /* also returns 0 if "*_state" is our ERR_PTR() end marker */ 85 if (*_state) 86 return 0; 87 88 /* 89 * walk the policies and nested ones first, and build 90 * a linear list of them. 91 */ 92 93 state = kzalloc(struct_size(state, policies, INITIAL_POLICIES_ALLOC), 94 GFP_KERNEL); 95 if (!state) 96 return -ENOMEM; 97 state->n_alloc = INITIAL_POLICIES_ALLOC; 98 99 err = add_policy(&state, policy, maxtype); 100 if (err) 101 return err; 102 103 for (policy_idx = 0; 104 policy_idx < state->n_alloc && state->policies[policy_idx].policy; 105 policy_idx++) { 106 const struct nla_policy *policy; 107 unsigned int type; 108 109 policy = state->policies[policy_idx].policy; 110 111 for (type = 0; 112 type <= state->policies[policy_idx].maxtype; 113 type++) { 114 switch (policy[type].type) { 115 case NLA_NESTED: 116 case NLA_NESTED_ARRAY: 117 err = add_policy(&state, 118 policy[type].nested_policy, 119 policy[type].len); 120 if (err) 121 return err; 122 break; 123 default: 124 break; 125 } 126 } 127 } 128 129 *_state = (unsigned long)state; 130 131 return 0; 132 } 133 134 static bool netlink_policy_dump_finished(struct nl_policy_dump *state) 135 { 136 return state->policy_idx >= state->n_alloc || 137 !state->policies[state->policy_idx].policy; 138 } 139 140 bool netlink_policy_dump_loop(unsigned long *_state) 141 { 142 struct nl_policy_dump *state = (void *)*_state; 143 144 if (IS_ERR(state)) 145 return false; 146 147 if (netlink_policy_dump_finished(state)) { 148 kfree(state); 149 /* store end marker instead of freed state */ 150 *_state = (unsigned long)ERR_PTR(-ENOENT); 151 return false; 152 } 153 154 return true; 155 } 156 157 int netlink_policy_dump_write(struct sk_buff *skb, unsigned long _state) 158 { 159 struct nl_policy_dump *state = (void *)_state; 160 const struct nla_policy *pt; 161 struct nlattr *policy, *attr; 162 enum netlink_attribute_type type; 163 bool again; 164 165 send_attribute: 166 again = false; 167 168 pt = &state->policies[state->policy_idx].policy[state->attr_idx]; 169 170 policy = nla_nest_start(skb, state->policy_idx); 171 if (!policy) 172 return -ENOBUFS; 173 174 attr = nla_nest_start(skb, state->attr_idx); 175 if (!attr) 176 goto nla_put_failure; 177 178 switch (pt->type) { 179 default: 180 case NLA_UNSPEC: 181 case NLA_REJECT: 182 /* skip - use NLA_MIN_LEN to advertise such */ 183 nla_nest_cancel(skb, policy); 184 again = true; 185 goto next; 186 case NLA_NESTED: 187 type = NL_ATTR_TYPE_NESTED; 188 /* fall through */ 189 case NLA_NESTED_ARRAY: 190 if (pt->type == NLA_NESTED_ARRAY) 191 type = NL_ATTR_TYPE_NESTED_ARRAY; 192 if (pt->nested_policy && pt->len && 193 (nla_put_u32(skb, NL_POLICY_TYPE_ATTR_POLICY_IDX, 194 get_policy_idx(state, pt->nested_policy)) || 195 nla_put_u32(skb, NL_POLICY_TYPE_ATTR_POLICY_MAXTYPE, 196 pt->len))) 197 goto nla_put_failure; 198 break; 199 case NLA_U8: 200 case NLA_U16: 201 case NLA_U32: 202 case NLA_U64: 203 case NLA_MSECS: { 204 struct netlink_range_validation range; 205 206 if (pt->type == NLA_U8) 207 type = NL_ATTR_TYPE_U8; 208 else if (pt->type == NLA_U16) 209 type = NL_ATTR_TYPE_U16; 210 else if (pt->type == NLA_U32) 211 type = NL_ATTR_TYPE_U32; 212 else 213 type = NL_ATTR_TYPE_U64; 214 215 nla_get_range_unsigned(pt, &range); 216 217 if (nla_put_u64_64bit(skb, NL_POLICY_TYPE_ATTR_MIN_VALUE_U, 218 range.min, NL_POLICY_TYPE_ATTR_PAD) || 219 nla_put_u64_64bit(skb, NL_POLICY_TYPE_ATTR_MAX_VALUE_U, 220 range.max, NL_POLICY_TYPE_ATTR_PAD)) 221 goto nla_put_failure; 222 break; 223 } 224 case NLA_S8: 225 case NLA_S16: 226 case NLA_S32: 227 case NLA_S64: { 228 struct netlink_range_validation_signed range; 229 230 if (pt->type == NLA_S8) 231 type = NL_ATTR_TYPE_S8; 232 else if (pt->type == NLA_S16) 233 type = NL_ATTR_TYPE_S16; 234 else if (pt->type == NLA_S32) 235 type = NL_ATTR_TYPE_S32; 236 else 237 type = NL_ATTR_TYPE_S64; 238 239 nla_get_range_signed(pt, &range); 240 241 if (nla_put_s64(skb, NL_POLICY_TYPE_ATTR_MIN_VALUE_S, 242 range.min, NL_POLICY_TYPE_ATTR_PAD) || 243 nla_put_s64(skb, NL_POLICY_TYPE_ATTR_MAX_VALUE_S, 244 range.max, NL_POLICY_TYPE_ATTR_PAD)) 245 goto nla_put_failure; 246 break; 247 } 248 case NLA_BITFIELD32: 249 type = NL_ATTR_TYPE_BITFIELD32; 250 if (nla_put_u32(skb, NL_POLICY_TYPE_ATTR_BITFIELD32_MASK, 251 pt->bitfield32_valid)) 252 goto nla_put_failure; 253 break; 254 case NLA_STRING: 255 case NLA_NUL_STRING: 256 case NLA_BINARY: 257 if (pt->type == NLA_STRING) 258 type = NL_ATTR_TYPE_STRING; 259 else if (pt->type == NLA_NUL_STRING) 260 type = NL_ATTR_TYPE_NUL_STRING; 261 else 262 type = NL_ATTR_TYPE_BINARY; 263 264 if (pt->validation_type != NLA_VALIDATE_NONE) { 265 struct netlink_range_validation range; 266 267 nla_get_range_unsigned(pt, &range); 268 269 if (range.min && 270 nla_put_u32(skb, NL_POLICY_TYPE_ATTR_MIN_LENGTH, 271 range.min)) 272 goto nla_put_failure; 273 274 if (range.max < U16_MAX && 275 nla_put_u32(skb, NL_POLICY_TYPE_ATTR_MAX_LENGTH, 276 range.max)) 277 goto nla_put_failure; 278 } else if (pt->len && 279 nla_put_u32(skb, NL_POLICY_TYPE_ATTR_MAX_LENGTH, 280 pt->len)) { 281 goto nla_put_failure; 282 } 283 break; 284 case NLA_FLAG: 285 type = NL_ATTR_TYPE_FLAG; 286 break; 287 } 288 289 if (nla_put_u32(skb, NL_POLICY_TYPE_ATTR_TYPE, type)) 290 goto nla_put_failure; 291 292 /* finish and move state to next attribute */ 293 nla_nest_end(skb, attr); 294 nla_nest_end(skb, policy); 295 296 next: 297 state->attr_idx += 1; 298 if (state->attr_idx > state->policies[state->policy_idx].maxtype) { 299 state->attr_idx = 0; 300 state->policy_idx++; 301 } 302 303 if (again) { 304 if (netlink_policy_dump_finished(state)) 305 return -ENODATA; 306 goto send_attribute; 307 } 308 309 return 0; 310 311 nla_put_failure: 312 nla_nest_cancel(skb, policy); 313 return -ENOBUFS; 314 } 315