1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* Filesystem parameter parser. |
3 | * |
4 | * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. |
5 | * Written by David Howells (dhowells@redhat.com) |
6 | */ |
7 | |
8 | #include <linux/export.h> |
9 | #include <linux/fs_context.h> |
10 | #include <linux/fs_parser.h> |
11 | #include <linux/slab.h> |
12 | #include <linux/security.h> |
13 | #include <linux/namei.h> |
14 | #include "internal.h" |
15 | |
16 | static const struct constant_table bool_names[] = { |
17 | { "0" , false }, |
18 | { "1" , true }, |
19 | { "false" , false }, |
20 | { "no" , false }, |
21 | { "true" , true }, |
22 | { "yes" , true }, |
23 | { }, |
24 | }; |
25 | |
26 | static const struct constant_table * |
27 | __lookup_constant(const struct constant_table *tbl, const char *name) |
28 | { |
29 | for ( ; tbl->name; tbl++) |
30 | if (strcmp(name, tbl->name) == 0) |
31 | return tbl; |
32 | return NULL; |
33 | } |
34 | |
35 | /** |
36 | * lookup_constant - Look up a constant by name in an ordered table |
37 | * @tbl: The table of constants to search. |
38 | * @name: The name to look up. |
39 | * @not_found: The value to return if the name is not found. |
40 | */ |
41 | int lookup_constant(const struct constant_table *tbl, const char *name, int not_found) |
42 | { |
43 | const struct constant_table *p = __lookup_constant(tbl, name); |
44 | |
45 | return p ? p->value : not_found; |
46 | } |
47 | EXPORT_SYMBOL(lookup_constant); |
48 | |
49 | static inline bool is_flag(const struct fs_parameter_spec *p) |
50 | { |
51 | return p->type == NULL; |
52 | } |
53 | |
54 | static const struct fs_parameter_spec *fs_lookup_key( |
55 | const struct fs_parameter_spec *desc, |
56 | struct fs_parameter *param, bool *negated) |
57 | { |
58 | const struct fs_parameter_spec *p, *other = NULL; |
59 | const char *name = param->key; |
60 | bool want_flag = param->type == fs_value_is_flag; |
61 | |
62 | *negated = false; |
63 | for (p = desc; p->name; p++) { |
64 | if (strcmp(p->name, name) != 0) |
65 | continue; |
66 | if (likely(is_flag(p) == want_flag)) |
67 | return p; |
68 | other = p; |
69 | } |
70 | if (want_flag) { |
71 | if (name[0] == 'n' && name[1] == 'o' && name[2]) { |
72 | for (p = desc; p->name; p++) { |
73 | if (strcmp(p->name, name + 2) != 0) |
74 | continue; |
75 | if (!(p->flags & fs_param_neg_with_no)) |
76 | continue; |
77 | *negated = true; |
78 | return p; |
79 | } |
80 | } |
81 | } |
82 | return other; |
83 | } |
84 | |
85 | /* |
86 | * fs_parse - Parse a filesystem configuration parameter |
87 | * @fc: The filesystem context to log errors through. |
88 | * @desc: The parameter description to use. |
89 | * @param: The parameter. |
90 | * @result: Where to place the result of the parse |
91 | * |
92 | * Parse a filesystem configuration parameter and attempt a conversion for a |
93 | * simple parameter for which this is requested. If successful, the determined |
94 | * parameter ID is placed into @result->key, the desired type is indicated in |
95 | * @result->t and any converted value is placed into an appropriate member of |
96 | * the union in @result. |
97 | * |
98 | * The function returns the parameter number if the parameter was matched, |
99 | * -ENOPARAM if it wasn't matched and @desc->ignore_unknown indicated that |
100 | * unknown parameters are okay and -EINVAL if there was a conversion issue or |
101 | * the parameter wasn't recognised and unknowns aren't okay. |
102 | */ |
103 | int __fs_parse(struct p_log *log, |
104 | const struct fs_parameter_spec *desc, |
105 | struct fs_parameter *param, |
106 | struct fs_parse_result *result) |
107 | { |
108 | const struct fs_parameter_spec *p; |
109 | |
110 | result->uint_64 = 0; |
111 | |
112 | p = fs_lookup_key(desc, param, negated: &result->negated); |
113 | if (!p) |
114 | return -ENOPARAM; |
115 | |
116 | if (p->flags & fs_param_deprecated) |
117 | warn_plog(log, "Deprecated parameter '%s'" , param->key); |
118 | |
119 | /* Try to turn the type we were given into the type desired by the |
120 | * parameter and give an error if we can't. |
121 | */ |
122 | if (is_flag(p)) { |
123 | if (param->type != fs_value_is_flag) |
124 | return inval_plog(log, "Unexpected value for '%s'" , |
125 | param->key); |
126 | result->boolean = !result->negated; |
127 | } else { |
128 | int ret = p->type(log, p, param, result); |
129 | if (ret) |
130 | return ret; |
131 | } |
132 | return p->opt; |
133 | } |
134 | EXPORT_SYMBOL(__fs_parse); |
135 | |
136 | /** |
137 | * fs_lookup_param - Look up a path referred to by a parameter |
138 | * @fc: The filesystem context to log errors through. |
139 | * @param: The parameter. |
140 | * @want_bdev: T if want a blockdev |
141 | * @flags: Pathwalk flags passed to filename_lookup() |
142 | * @_path: The result of the lookup |
143 | */ |
144 | int fs_lookup_param(struct fs_context *fc, |
145 | struct fs_parameter *param, |
146 | bool want_bdev, |
147 | unsigned int flags, |
148 | struct path *_path) |
149 | { |
150 | struct filename *f; |
151 | bool put_f; |
152 | int ret; |
153 | |
154 | switch (param->type) { |
155 | case fs_value_is_string: |
156 | f = getname_kernel(param->string); |
157 | if (IS_ERR(ptr: f)) |
158 | return PTR_ERR(ptr: f); |
159 | put_f = true; |
160 | break; |
161 | case fs_value_is_filename: |
162 | f = param->name; |
163 | put_f = false; |
164 | break; |
165 | default: |
166 | return invalf(fc, "%s: not usable as path" , param->key); |
167 | } |
168 | |
169 | ret = filename_lookup(dfd: param->dirfd, name: f, flags, path: _path, NULL); |
170 | if (ret < 0) { |
171 | errorf(fc, "%s: Lookup failure for '%s'" , param->key, f->name); |
172 | goto out; |
173 | } |
174 | |
175 | if (want_bdev && |
176 | !S_ISBLK(d_backing_inode(_path->dentry)->i_mode)) { |
177 | path_put(_path); |
178 | _path->dentry = NULL; |
179 | _path->mnt = NULL; |
180 | errorf(fc, "%s: Non-blockdev passed as '%s'" , |
181 | param->key, f->name); |
182 | ret = -ENOTBLK; |
183 | } |
184 | |
185 | out: |
186 | if (put_f) |
187 | putname(name: f); |
188 | return ret; |
189 | } |
190 | EXPORT_SYMBOL(fs_lookup_param); |
191 | |
192 | static int fs_param_bad_value(struct p_log *log, struct fs_parameter *param) |
193 | { |
194 | return inval_plog(log, "Bad value for '%s'" , param->key); |
195 | } |
196 | |
197 | int fs_param_is_bool(struct p_log *log, const struct fs_parameter_spec *p, |
198 | struct fs_parameter *param, struct fs_parse_result *result) |
199 | { |
200 | int b; |
201 | if (param->type != fs_value_is_string) |
202 | return fs_param_bad_value(log, param); |
203 | if (!*param->string && (p->flags & fs_param_can_be_empty)) |
204 | return 0; |
205 | b = lookup_constant(bool_names, param->string, -1); |
206 | if (b == -1) |
207 | return fs_param_bad_value(log, param); |
208 | result->boolean = b; |
209 | return 0; |
210 | } |
211 | EXPORT_SYMBOL(fs_param_is_bool); |
212 | |
213 | int fs_param_is_u32(struct p_log *log, const struct fs_parameter_spec *p, |
214 | struct fs_parameter *param, struct fs_parse_result *result) |
215 | { |
216 | int base = (unsigned long)p->data; |
217 | if (param->type != fs_value_is_string) |
218 | return fs_param_bad_value(log, param); |
219 | if (!*param->string && (p->flags & fs_param_can_be_empty)) |
220 | return 0; |
221 | if (kstrtouint(s: param->string, base, res: &result->uint_32) < 0) |
222 | return fs_param_bad_value(log, param); |
223 | return 0; |
224 | } |
225 | EXPORT_SYMBOL(fs_param_is_u32); |
226 | |
227 | int fs_param_is_s32(struct p_log *log, const struct fs_parameter_spec *p, |
228 | struct fs_parameter *param, struct fs_parse_result *result) |
229 | { |
230 | if (param->type != fs_value_is_string) |
231 | return fs_param_bad_value(log, param); |
232 | if (!*param->string && (p->flags & fs_param_can_be_empty)) |
233 | return 0; |
234 | if (kstrtoint(s: param->string, base: 0, res: &result->int_32) < 0) |
235 | return fs_param_bad_value(log, param); |
236 | return 0; |
237 | } |
238 | EXPORT_SYMBOL(fs_param_is_s32); |
239 | |
240 | int fs_param_is_u64(struct p_log *log, const struct fs_parameter_spec *p, |
241 | struct fs_parameter *param, struct fs_parse_result *result) |
242 | { |
243 | if (param->type != fs_value_is_string) |
244 | return fs_param_bad_value(log, param); |
245 | if (!*param->string && (p->flags & fs_param_can_be_empty)) |
246 | return 0; |
247 | if (kstrtoull(s: param->string, base: 0, res: &result->uint_64) < 0) |
248 | return fs_param_bad_value(log, param); |
249 | return 0; |
250 | } |
251 | EXPORT_SYMBOL(fs_param_is_u64); |
252 | |
253 | int fs_param_is_enum(struct p_log *log, const struct fs_parameter_spec *p, |
254 | struct fs_parameter *param, struct fs_parse_result *result) |
255 | { |
256 | const struct constant_table *c; |
257 | if (param->type != fs_value_is_string) |
258 | return fs_param_bad_value(log, param); |
259 | if (!*param->string && (p->flags & fs_param_can_be_empty)) |
260 | return 0; |
261 | c = __lookup_constant(tbl: p->data, name: param->string); |
262 | if (!c) |
263 | return fs_param_bad_value(log, param); |
264 | result->uint_32 = c->value; |
265 | return 0; |
266 | } |
267 | EXPORT_SYMBOL(fs_param_is_enum); |
268 | |
269 | int fs_param_is_string(struct p_log *log, const struct fs_parameter_spec *p, |
270 | struct fs_parameter *param, struct fs_parse_result *result) |
271 | { |
272 | if (param->type != fs_value_is_string || |
273 | (!*param->string && !(p->flags & fs_param_can_be_empty))) |
274 | return fs_param_bad_value(log, param); |
275 | return 0; |
276 | } |
277 | EXPORT_SYMBOL(fs_param_is_string); |
278 | |
279 | int fs_param_is_blob(struct p_log *log, const struct fs_parameter_spec *p, |
280 | struct fs_parameter *param, struct fs_parse_result *result) |
281 | { |
282 | if (param->type != fs_value_is_blob) |
283 | return fs_param_bad_value(log, param); |
284 | return 0; |
285 | } |
286 | EXPORT_SYMBOL(fs_param_is_blob); |
287 | |
288 | int fs_param_is_fd(struct p_log *log, const struct fs_parameter_spec *p, |
289 | struct fs_parameter *param, struct fs_parse_result *result) |
290 | { |
291 | switch (param->type) { |
292 | case fs_value_is_string: |
293 | if ((!*param->string && !(p->flags & fs_param_can_be_empty)) || |
294 | kstrtouint(s: param->string, base: 0, res: &result->uint_32) < 0) |
295 | break; |
296 | if (result->uint_32 <= INT_MAX) |
297 | return 0; |
298 | break; |
299 | case fs_value_is_file: |
300 | result->uint_32 = param->dirfd; |
301 | if (result->uint_32 <= INT_MAX) |
302 | return 0; |
303 | break; |
304 | default: |
305 | break; |
306 | } |
307 | return fs_param_bad_value(log, param); |
308 | } |
309 | EXPORT_SYMBOL(fs_param_is_fd); |
310 | |
311 | int fs_param_is_blockdev(struct p_log *log, const struct fs_parameter_spec *p, |
312 | struct fs_parameter *param, struct fs_parse_result *result) |
313 | { |
314 | return 0; |
315 | } |
316 | EXPORT_SYMBOL(fs_param_is_blockdev); |
317 | |
318 | int fs_param_is_path(struct p_log *log, const struct fs_parameter_spec *p, |
319 | struct fs_parameter *param, struct fs_parse_result *result) |
320 | { |
321 | return 0; |
322 | } |
323 | EXPORT_SYMBOL(fs_param_is_path); |
324 | |
325 | #ifdef CONFIG_VALIDATE_FS_PARSER |
326 | /** |
327 | * validate_constant_table - Validate a constant table |
328 | * @tbl: The constant table to validate. |
329 | * @tbl_size: The size of the table. |
330 | * @low: The lowest permissible value. |
331 | * @high: The highest permissible value. |
332 | * @special: One special permissible value outside of the range. |
333 | */ |
334 | bool validate_constant_table(const struct constant_table *tbl, size_t tbl_size, |
335 | int low, int high, int special) |
336 | { |
337 | size_t i; |
338 | bool good = true; |
339 | |
340 | if (tbl_size == 0) { |
341 | pr_warn("VALIDATE C-TBL: Empty\n" ); |
342 | return true; |
343 | } |
344 | |
345 | for (i = 0; i < tbl_size; i++) { |
346 | if (!tbl[i].name) { |
347 | pr_err("VALIDATE C-TBL[%zu]: Null\n" , i); |
348 | good = false; |
349 | } else if (i > 0 && tbl[i - 1].name) { |
350 | int c = strcmp(tbl[i-1].name, tbl[i].name); |
351 | |
352 | if (c == 0) { |
353 | pr_err("VALIDATE C-TBL[%zu]: Duplicate %s\n" , |
354 | i, tbl[i].name); |
355 | good = false; |
356 | } |
357 | if (c > 0) { |
358 | pr_err("VALIDATE C-TBL[%zu]: Missorted %s>=%s\n" , |
359 | i, tbl[i-1].name, tbl[i].name); |
360 | good = false; |
361 | } |
362 | } |
363 | |
364 | if (tbl[i].value != special && |
365 | (tbl[i].value < low || tbl[i].value > high)) { |
366 | pr_err("VALIDATE C-TBL[%zu]: %s->%d const out of range (%d-%d)\n" , |
367 | i, tbl[i].name, tbl[i].value, low, high); |
368 | good = false; |
369 | } |
370 | } |
371 | |
372 | return good; |
373 | } |
374 | |
375 | /** |
376 | * fs_validate_description - Validate a parameter description |
377 | * @name: The parameter name to search for. |
378 | * @desc: The parameter description to validate. |
379 | */ |
380 | bool fs_validate_description(const char *name, |
381 | const struct fs_parameter_spec *desc) |
382 | { |
383 | const struct fs_parameter_spec *param, *p2; |
384 | bool good = true; |
385 | |
386 | for (param = desc; param->name; param++) { |
387 | /* Check for duplicate parameter names */ |
388 | for (p2 = desc; p2 < param; p2++) { |
389 | if (strcmp(param->name, p2->name) == 0) { |
390 | if (is_flag(p: param) != is_flag(p: p2)) |
391 | continue; |
392 | pr_err("VALIDATE %s: PARAM[%s]: Duplicate\n" , |
393 | name, param->name); |
394 | good = false; |
395 | } |
396 | } |
397 | } |
398 | return good; |
399 | } |
400 | #endif /* CONFIG_VALIDATE_FS_PARSER */ |
401 | |