1
2
3
4
5
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
16static 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
27
28
29
30
31
32int __lookup_constant(const struct constant_table *tbl, size_t tbl_size,
33 const char *name, int not_found)
34{
35 unsigned int i;
36
37 for (i = 0; i < tbl_size; i++)
38 if (strcmp(name, tbl[i].name) == 0)
39 return tbl[i].value;
40
41 return not_found;
42}
43EXPORT_SYMBOL(__lookup_constant);
44
45static const struct fs_parameter_spec *fs_lookup_key(
46 const struct fs_parameter_description *desc,
47 const char *name)
48{
49 const struct fs_parameter_spec *p;
50
51 if (!desc->specs)
52 return NULL;
53
54 for (p = desc->specs; p->name; p++)
55 if (strcmp(p->name, name) == 0)
56 return p;
57
58 return NULL;
59}
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79int fs_parse(struct fs_context *fc,
80 const struct fs_parameter_description *desc,
81 struct fs_parameter *param,
82 struct fs_parse_result *result)
83{
84 const struct fs_parameter_spec *p;
85 const struct fs_parameter_enum *e;
86 int ret = -ENOPARAM, b;
87
88 result->has_value = !!param->string;
89 result->negated = false;
90 result->uint_64 = 0;
91
92 p = fs_lookup_key(desc, param->key);
93 if (!p) {
94
95
96
97
98 if (result->has_value)
99 goto unknown_parameter;
100 if (param->key[0] != 'n' || param->key[1] != 'o' || !param->key[2])
101 goto unknown_parameter;
102
103 p = fs_lookup_key(desc, param->key + 2);
104 if (!p)
105 goto unknown_parameter;
106 if (!(p->flags & fs_param_neg_with_no))
107 goto unknown_parameter;
108 result->boolean = false;
109 result->negated = true;
110 }
111
112 if (p->flags & fs_param_deprecated)
113 warnf(fc, "%s: Deprecated parameter '%s'",
114 desc->name, param->key);
115
116 if (result->negated)
117 goto okay;
118
119
120 switch (p->type) {
121 case __fs_param_wasnt_defined:
122 return -EINVAL;
123 case fs_param_is_u32:
124 case fs_param_is_u32_octal:
125 case fs_param_is_u32_hex:
126 case fs_param_is_s32:
127 case fs_param_is_u64:
128 case fs_param_is_enum:
129 case fs_param_is_string:
130 if (param->type != fs_value_is_string)
131 goto bad_value;
132 if (!result->has_value) {
133 if (p->flags & fs_param_v_optional)
134 goto okay;
135 goto bad_value;
136 }
137
138 default:
139 break;
140 }
141
142
143
144
145 switch (p->type) {
146 case fs_param_is_flag:
147 if (param->type != fs_value_is_flag &&
148 (param->type != fs_value_is_string || result->has_value))
149 return invalf(fc, "%s: Unexpected value for '%s'",
150 desc->name, param->key);
151 result->boolean = true;
152 goto okay;
153
154 case fs_param_is_bool:
155 switch (param->type) {
156 case fs_value_is_flag:
157 result->boolean = true;
158 goto okay;
159 case fs_value_is_string:
160 if (param->size == 0) {
161 result->boolean = true;
162 goto okay;
163 }
164 b = lookup_constant(bool_names, param->string, -1);
165 if (b == -1)
166 goto bad_value;
167 result->boolean = b;
168 goto okay;
169 default:
170 goto bad_value;
171 }
172
173 case fs_param_is_u32:
174 ret = kstrtouint(param->string, 0, &result->uint_32);
175 goto maybe_okay;
176 case fs_param_is_u32_octal:
177 ret = kstrtouint(param->string, 8, &result->uint_32);
178 goto maybe_okay;
179 case fs_param_is_u32_hex:
180 ret = kstrtouint(param->string, 16, &result->uint_32);
181 goto maybe_okay;
182 case fs_param_is_s32:
183 ret = kstrtoint(param->string, 0, &result->int_32);
184 goto maybe_okay;
185 case fs_param_is_u64:
186 ret = kstrtoull(param->string, 0, &result->uint_64);
187 goto maybe_okay;
188
189 case fs_param_is_enum:
190 for (e = desc->enums; e->name[0]; e++) {
191 if (e->opt == p->opt &&
192 strcmp(e->name, param->string) == 0) {
193 result->uint_32 = e->value;
194 goto okay;
195 }
196 }
197 goto bad_value;
198
199 case fs_param_is_string:
200 goto okay;
201 case fs_param_is_blob:
202 if (param->type != fs_value_is_blob)
203 goto bad_value;
204 goto okay;
205
206 case fs_param_is_fd: {
207 if (param->type != fs_value_is_file)
208 goto bad_value;
209 goto okay;
210 }
211
212 case fs_param_is_blockdev:
213 case fs_param_is_path:
214 goto okay;
215 default:
216 BUG();
217 }
218
219maybe_okay:
220 if (ret < 0)
221 goto bad_value;
222okay:
223 return p->opt;
224
225bad_value:
226 return invalf(fc, "%s: Bad value for '%s'", desc->name, param->key);
227unknown_parameter:
228 return -ENOPARAM;
229}
230EXPORT_SYMBOL(fs_parse);
231
232
233
234
235
236
237
238
239int fs_lookup_param(struct fs_context *fc,
240 struct fs_parameter *param,
241 bool want_bdev,
242 struct path *_path)
243{
244 struct filename *f;
245 unsigned int flags = 0;
246 bool put_f;
247 int ret;
248
249 switch (param->type) {
250 case fs_value_is_string:
251 f = getname_kernel(param->string);
252 if (IS_ERR(f))
253 return PTR_ERR(f);
254 put_f = true;
255 break;
256 case fs_value_is_filename_empty:
257 flags = LOOKUP_EMPTY;
258
259 case fs_value_is_filename:
260 f = param->name;
261 put_f = false;
262 break;
263 default:
264 return invalf(fc, "%s: not usable as path", param->key);
265 }
266
267 ret = filename_lookup(param->dirfd, f, flags, _path, NULL);
268 if (ret < 0) {
269 errorf(fc, "%s: Lookup failure for '%s'", param->key, f->name);
270 goto out;
271 }
272
273 if (want_bdev &&
274 !S_ISBLK(d_backing_inode(_path->dentry)->i_mode)) {
275 path_put(_path);
276 _path->dentry = NULL;
277 _path->mnt = NULL;
278 errorf(fc, "%s: Non-blockdev passed as '%s'",
279 param->key, f->name);
280 ret = -ENOTBLK;
281 }
282
283out:
284 if (put_f)
285 putname(f);
286 return ret;
287}
288EXPORT_SYMBOL(fs_lookup_param);
289
290#ifdef CONFIG_VALIDATE_FS_PARSER
291
292
293
294
295
296
297
298
299
300bool validate_constant_table(const struct constant_table *tbl, size_t tbl_size,
301 int low, int high, int special)
302{
303 size_t i;
304 bool good = true;
305
306 if (tbl_size == 0) {
307 pr_warn("VALIDATE C-TBL: Empty\n");
308 return true;
309 }
310
311 for (i = 0; i < tbl_size; i++) {
312 if (!tbl[i].name) {
313 pr_err("VALIDATE C-TBL[%zu]: Null\n", i);
314 good = false;
315 } else if (i > 0 && tbl[i - 1].name) {
316 int c = strcmp(tbl[i-1].name, tbl[i].name);
317
318 if (c == 0) {
319 pr_err("VALIDATE C-TBL[%zu]: Duplicate %s\n",
320 i, tbl[i].name);
321 good = false;
322 }
323 if (c > 0) {
324 pr_err("VALIDATE C-TBL[%zu]: Missorted %s>=%s\n",
325 i, tbl[i-1].name, tbl[i].name);
326 good = false;
327 }
328 }
329
330 if (tbl[i].value != special &&
331 (tbl[i].value < low || tbl[i].value > high)) {
332 pr_err("VALIDATE C-TBL[%zu]: %s->%d const out of range (%d-%d)\n",
333 i, tbl[i].name, tbl[i].value, low, high);
334 good = false;
335 }
336 }
337
338 return good;
339}
340
341
342
343
344
345bool fs_validate_description(const struct fs_parameter_description *desc)
346{
347 const struct fs_parameter_spec *param, *p2;
348 const struct fs_parameter_enum *e;
349 const char *name = desc->name;
350 unsigned int nr_params = 0;
351 bool good = true, enums = false;
352
353 pr_notice("*** VALIDATE %s ***\n", name);
354
355 if (!name[0]) {
356 pr_err("VALIDATE Parser: No name\n");
357 name = "Unknown";
358 good = false;
359 }
360
361 if (desc->specs) {
362 for (param = desc->specs; param->name; param++) {
363 enum fs_parameter_type t = param->type;
364
365
366 if (t == __fs_param_wasnt_defined ||
367 t >= nr__fs_parameter_type) {
368 pr_err("VALIDATE %s: PARAM[%s] Bad type %u\n",
369 name, param->name, t);
370 good = false;
371 } else if (t == fs_param_is_enum) {
372 enums = true;
373 }
374
375
376 for (p2 = desc->specs; p2 < param; p2++) {
377 if (strcmp(param->name, p2->name) == 0) {
378 pr_err("VALIDATE %s: PARAM[%s]: Duplicate\n",
379 name, param->name);
380 good = false;
381 }
382 }
383 }
384
385 nr_params = param - desc->specs;
386 }
387
388 if (desc->enums) {
389 if (!nr_params) {
390 pr_err("VALIDATE %s: Enum table but no parameters\n",
391 name);
392 good = false;
393 goto no_enums;
394 }
395 if (!enums) {
396 pr_err("VALIDATE %s: Enum table but no enum-type values\n",
397 name);
398 good = false;
399 goto no_enums;
400 }
401
402 for (e = desc->enums; e->name[0]; e++) {
403
404
405
406 for (param = desc->specs; param->name; param++) {
407 if (param->opt == e->opt &&
408 param->type != fs_param_is_enum) {
409 pr_err("VALIDATE %s: e[%tu] enum val for %s\n",
410 name, e - desc->enums, param->name);
411 good = false;
412 }
413 }
414 }
415
416
417
418
419 for (param = desc->specs; param->name; param++) {
420 if (param->type != fs_param_is_enum)
421 continue;
422 for (e = desc->enums; e->name[0]; e++)
423 if (e->opt == param->opt)
424 break;
425 if (!e->name[0]) {
426 pr_err("VALIDATE %s: PARAM[%s] enum with no values\n",
427 name, param->name);
428 good = false;
429 }
430 }
431 } else {
432 if (enums) {
433 pr_err("VALIDATE %s: enum-type values, but no enum table\n",
434 name);
435 good = false;
436 goto no_enums;
437 }
438 }
439
440no_enums:
441 return good;
442}
443#endif
444