Commit | Line | Data |
---|---|---|
b4d0d230 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
31d921c7 DH |
2 | /* Filesystem parameter parser. |
3 | * | |
4 | * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. | |
5 | * Written by David Howells (dhowells@redhat.com) | |
31d921c7 DH |
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 }, | |
34264ae3 | 23 | { }, |
31d921c7 DH |
24 | }; |
25 | ||
34264ae3 AV |
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 | ||
31d921c7 DH |
35 | /** |
36 | * lookup_constant - Look up a constant by name in an ordered table | |
37 | * @tbl: The table of constants to search. | |
31d921c7 DH |
38 | * @name: The name to look up. |
39 | * @not_found: The value to return if the name is not found. | |
40 | */ | |
34264ae3 | 41 | int lookup_constant(const struct constant_table *tbl, const char *name, int not_found) |
31d921c7 | 42 | { |
34264ae3 | 43 | const struct constant_table *p = __lookup_constant(tbl, name); |
31d921c7 | 44 | |
34264ae3 | 45 | return p ? p->value : not_found; |
31d921c7 | 46 | } |
34264ae3 | 47 | EXPORT_SYMBOL(lookup_constant); |
31d921c7 | 48 | |
48ce73b1 AV |
49 | static inline bool is_flag(const struct fs_parameter_spec *p) |
50 | { | |
51 | return p->type == fs_param_is_flag; | |
52 | } | |
53 | ||
31d921c7 | 54 | static const struct fs_parameter_spec *fs_lookup_key( |
d7167b14 | 55 | const struct fs_parameter_spec *desc, |
48ce73b1 | 56 | struct fs_parameter *param, bool *negated) |
31d921c7 | 57 | { |
48ce73b1 AV |
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)) | |
31d921c7 | 67 | return p; |
48ce73b1 AV |
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; | |
31d921c7 DH |
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 | */ | |
7f5d3814 | 103 | int __fs_parse(struct p_log *log, |
d7167b14 | 104 | const struct fs_parameter_spec *desc, |
31d921c7 DH |
105 | struct fs_parameter *param, |
106 | struct fs_parse_result *result) | |
107 | { | |
108 | const struct fs_parameter_spec *p; | |
5eede625 | 109 | const struct constant_table *e; |
31d921c7 DH |
110 | int ret = -ENOPARAM, b; |
111 | ||
31d921c7 DH |
112 | result->uint_64 = 0; |
113 | ||
48ce73b1 AV |
114 | p = fs_lookup_key(desc, param, &result->negated); |
115 | if (!p) | |
116 | return -ENOPARAM; | |
31d921c7 DH |
117 | |
118 | if (p->flags & fs_param_deprecated) | |
7f5d3814 | 119 | warn_plog(log, "Deprecated parameter '%s'", param->key); |
31d921c7 | 120 | |
31d921c7 DH |
121 | /* Try to turn the type we were given into the type desired by the |
122 | * parameter and give an error if we can't. | |
123 | */ | |
124 | switch (p->type) { | |
48ce73b1 AV |
125 | case __fs_param_wasnt_defined: |
126 | return -EINVAL; | |
31d921c7 | 127 | case fs_param_is_flag: |
0f89589a | 128 | if (param->type != fs_value_is_flag) |
7f5d3814 AV |
129 | return inval_plog(log, "Unexpected value for '%s'", |
130 | param->key); | |
48ce73b1 | 131 | result->boolean = !result->negated; |
31d921c7 | 132 | goto okay; |
31d921c7 | 133 | case fs_param_is_bool: |
48ce73b1 | 134 | if (param->type != fs_value_is_string) |
31d921c7 | 135 | goto bad_value; |
48ce73b1 AV |
136 | b = lookup_constant(bool_names, param->string, -1); |
137 | if (b == -1) | |
138 | goto bad_value; | |
139 | result->boolean = b; | |
140 | goto okay; | |
31d921c7 | 141 | case fs_param_is_u32: |
48ce73b1 AV |
142 | if (param->type != fs_value_is_string) |
143 | goto bad_value; | |
31d921c7 DH |
144 | ret = kstrtouint(param->string, 0, &result->uint_32); |
145 | goto maybe_okay; | |
146 | case fs_param_is_u32_octal: | |
48ce73b1 AV |
147 | if (param->type != fs_value_is_string) |
148 | goto bad_value; | |
31d921c7 DH |
149 | ret = kstrtouint(param->string, 8, &result->uint_32); |
150 | goto maybe_okay; | |
151 | case fs_param_is_u32_hex: | |
48ce73b1 AV |
152 | if (param->type != fs_value_is_string) |
153 | goto bad_value; | |
31d921c7 DH |
154 | ret = kstrtouint(param->string, 16, &result->uint_32); |
155 | goto maybe_okay; | |
156 | case fs_param_is_s32: | |
48ce73b1 AV |
157 | if (param->type != fs_value_is_string) |
158 | goto bad_value; | |
31d921c7 DH |
159 | ret = kstrtoint(param->string, 0, &result->int_32); |
160 | goto maybe_okay; | |
161 | case fs_param_is_u64: | |
48ce73b1 AV |
162 | if (param->type != fs_value_is_string) |
163 | goto bad_value; | |
31d921c7 DH |
164 | ret = kstrtoull(param->string, 0, &result->uint_64); |
165 | goto maybe_okay; | |
31d921c7 | 166 | case fs_param_is_enum: |
48ce73b1 AV |
167 | if (param->type != fs_value_is_string) |
168 | goto bad_value; | |
34264ae3 AV |
169 | e = __lookup_constant(p->data, param->string); |
170 | if (e) { | |
171 | result->uint_32 = e->value; | |
172 | goto okay; | |
31d921c7 DH |
173 | } |
174 | goto bad_value; | |
31d921c7 | 175 | case fs_param_is_string: |
48ce73b1 AV |
176 | if (param->type != fs_value_is_string || !*param->string) |
177 | goto bad_value; | |
31d921c7 DH |
178 | goto okay; |
179 | case fs_param_is_blob: | |
180 | if (param->type != fs_value_is_blob) | |
181 | goto bad_value; | |
182 | goto okay; | |
31d921c7 | 183 | case fs_param_is_fd: { |
74983ac2 DH |
184 | switch (param->type) { |
185 | case fs_value_is_string: | |
74983ac2 DH |
186 | ret = kstrtouint(param->string, 0, &result->uint_32); |
187 | break; | |
188 | case fs_value_is_file: | |
189 | result->uint_32 = param->dirfd; | |
190 | ret = 0; | |
191 | default: | |
31d921c7 | 192 | goto bad_value; |
74983ac2 DH |
193 | } |
194 | ||
195 | if (result->uint_32 > INT_MAX) | |
196 | goto bad_value; | |
197 | goto maybe_okay; | |
31d921c7 | 198 | } |
31d921c7 DH |
199 | case fs_param_is_blockdev: |
200 | case fs_param_is_path: | |
201 | goto okay; | |
202 | default: | |
203 | BUG(); | |
204 | } | |
205 | ||
206 | maybe_okay: | |
207 | if (ret < 0) | |
208 | goto bad_value; | |
209 | okay: | |
210 | return p->opt; | |
211 | ||
212 | bad_value: | |
7f5d3814 | 213 | return inval_plog(log, "Bad value for '%s'", param->key); |
31d921c7 | 214 | } |
7f5d3814 AV |
215 | EXPORT_SYMBOL(__fs_parse); |
216 | ||
31d921c7 DH |
217 | /** |
218 | * fs_lookup_param - Look up a path referred to by a parameter | |
219 | * @fc: The filesystem context to log errors through. | |
220 | * @param: The parameter. | |
221 | * @want_bdev: T if want a blockdev | |
222 | * @_path: The result of the lookup | |
223 | */ | |
224 | int fs_lookup_param(struct fs_context *fc, | |
225 | struct fs_parameter *param, | |
226 | bool want_bdev, | |
227 | struct path *_path) | |
228 | { | |
229 | struct filename *f; | |
230 | unsigned int flags = 0; | |
231 | bool put_f; | |
232 | int ret; | |
233 | ||
234 | switch (param->type) { | |
235 | case fs_value_is_string: | |
236 | f = getname_kernel(param->string); | |
237 | if (IS_ERR(f)) | |
238 | return PTR_ERR(f); | |
239 | put_f = true; | |
240 | break; | |
31d921c7 DH |
241 | case fs_value_is_filename: |
242 | f = param->name; | |
243 | put_f = false; | |
244 | break; | |
245 | default: | |
246 | return invalf(fc, "%s: not usable as path", param->key); | |
247 | } | |
248 | ||
7cdfa442 | 249 | f->refcnt++; /* filename_lookup() drops our ref. */ |
31d921c7 DH |
250 | ret = filename_lookup(param->dirfd, f, flags, _path, NULL); |
251 | if (ret < 0) { | |
252 | errorf(fc, "%s: Lookup failure for '%s'", param->key, f->name); | |
253 | goto out; | |
254 | } | |
255 | ||
256 | if (want_bdev && | |
257 | !S_ISBLK(d_backing_inode(_path->dentry)->i_mode)) { | |
258 | path_put(_path); | |
259 | _path->dentry = NULL; | |
260 | _path->mnt = NULL; | |
261 | errorf(fc, "%s: Non-blockdev passed as '%s'", | |
262 | param->key, f->name); | |
263 | ret = -ENOTBLK; | |
264 | } | |
265 | ||
266 | out: | |
267 | if (put_f) | |
268 | putname(f); | |
269 | return ret; | |
270 | } | |
271 | EXPORT_SYMBOL(fs_lookup_param); | |
272 | ||
273 | #ifdef CONFIG_VALIDATE_FS_PARSER | |
274 | /** | |
275 | * validate_constant_table - Validate a constant table | |
276 | * @name: Name to use in reporting | |
277 | * @tbl: The constant table to validate. | |
278 | * @tbl_size: The size of the table. | |
279 | * @low: The lowest permissible value. | |
280 | * @high: The highest permissible value. | |
281 | * @special: One special permissible value outside of the range. | |
282 | */ | |
283 | bool validate_constant_table(const struct constant_table *tbl, size_t tbl_size, | |
284 | int low, int high, int special) | |
285 | { | |
286 | size_t i; | |
287 | bool good = true; | |
288 | ||
289 | if (tbl_size == 0) { | |
290 | pr_warn("VALIDATE C-TBL: Empty\n"); | |
291 | return true; | |
292 | } | |
293 | ||
294 | for (i = 0; i < tbl_size; i++) { | |
295 | if (!tbl[i].name) { | |
296 | pr_err("VALIDATE C-TBL[%zu]: Null\n", i); | |
297 | good = false; | |
298 | } else if (i > 0 && tbl[i - 1].name) { | |
299 | int c = strcmp(tbl[i-1].name, tbl[i].name); | |
300 | ||
301 | if (c == 0) { | |
302 | pr_err("VALIDATE C-TBL[%zu]: Duplicate %s\n", | |
303 | i, tbl[i].name); | |
304 | good = false; | |
305 | } | |
306 | if (c > 0) { | |
307 | pr_err("VALIDATE C-TBL[%zu]: Missorted %s>=%s\n", | |
308 | i, tbl[i-1].name, tbl[i].name); | |
309 | good = false; | |
310 | } | |
311 | } | |
312 | ||
313 | if (tbl[i].value != special && | |
314 | (tbl[i].value < low || tbl[i].value > high)) { | |
315 | pr_err("VALIDATE C-TBL[%zu]: %s->%d const out of range (%d-%d)\n", | |
316 | i, tbl[i].name, tbl[i].value, low, high); | |
317 | good = false; | |
318 | } | |
319 | } | |
320 | ||
321 | return good; | |
322 | } | |
323 | ||
324 | /** | |
325 | * fs_validate_description - Validate a parameter description | |
326 | * @desc: The parameter description to validate. | |
327 | */ | |
96cafb9c | 328 | bool fs_validate_description(const char *name, |
d7167b14 | 329 | const struct fs_parameter_spec *desc) |
31d921c7 DH |
330 | { |
331 | const struct fs_parameter_spec *param, *p2; | |
2710c957 | 332 | bool good = true; |
31d921c7 DH |
333 | |
334 | pr_notice("*** VALIDATE %s ***\n", name); | |
335 | ||
d7167b14 AV |
336 | for (param = desc; param->name; param++) { |
337 | enum fs_parameter_type t = param->type; | |
31d921c7 | 338 | |
d7167b14 AV |
339 | /* Check that the type is in range */ |
340 | if (t == __fs_param_wasnt_defined || | |
341 | t >= nr__fs_parameter_type) { | |
342 | pr_err("VALIDATE %s: PARAM[%s] Bad type %u\n", | |
343 | name, param->name, t); | |
344 | good = false; | |
345 | } else if (t == fs_param_is_enum) { | |
346 | const struct constant_table *e = param->data; | |
347 | if (!e || !e->name) { | |
348 | pr_err("VALIDATE %s: PARAM[%s] enum with no values\n", | |
349 | name, param->name); | |
31d921c7 | 350 | good = false; |
31d921c7 | 351 | } |
d7167b14 | 352 | } |
31d921c7 | 353 | |
d7167b14 AV |
354 | /* Check for duplicate parameter names */ |
355 | for (p2 = desc; p2 < param; p2++) { | |
356 | if (strcmp(param->name, p2->name) == 0) { | |
48ce73b1 AV |
357 | if (is_flag(param) != is_flag(p2)) |
358 | continue; | |
d7167b14 AV |
359 | pr_err("VALIDATE %s: PARAM[%s]: Duplicate\n", |
360 | name, param->name); | |
361 | good = false; | |
31d921c7 DH |
362 | } |
363 | } | |
31d921c7 | 364 | } |
31d921c7 DH |
365 | return good; |
366 | } | |
367 | #endif /* CONFIG_VALIDATE_FS_PARSER */ |