1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Filesystem parameter parser.
4 * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
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>
16 static const struct constant_table bool_names
[] = {
26 static const struct constant_table
*
27 __lookup_constant(const struct constant_table
*tbl
, const char *name
)
29 for ( ; tbl
->name
; tbl
++)
30 if (strcmp(name
, tbl
->name
) == 0)
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.
41 int lookup_constant(const struct constant_table
*tbl
, const char *name
, int not_found
)
43 const struct constant_table
*p
= __lookup_constant(tbl
, name
);
45 return p
? p
->value
: not_found
;
47 EXPORT_SYMBOL(lookup_constant
);
49 static inline bool is_flag(const struct fs_parameter_spec
*p
)
51 return p
->type
== NULL
;
54 static const struct fs_parameter_spec
*fs_lookup_key(
55 const struct fs_parameter_spec
*desc
,
56 struct fs_parameter
*param
, bool *negated
)
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
;
63 for (p
= desc
; p
->name
; p
++) {
64 if (strcmp(p
->name
, name
) != 0)
66 if (likely(is_flag(p
) == 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)
75 if (!(p
->flags
& fs_param_neg_with_no
))
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
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.
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.
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
)
108 const struct fs_parameter_spec
*p
;
112 p
= fs_lookup_key(desc
, param
, &result
->negated
);
116 if (p
->flags
& fs_param_deprecated
)
117 warn_plog(log
, "Deprecated parameter '%s'", param
->key
);
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.
123 if (param
->type
!= fs_value_is_flag
)
124 return inval_plog(log
, "Unexpected value for '%s'",
126 result
->boolean
= !result
->negated
;
128 int ret
= p
->type(log
, p
, param
, result
);
134 EXPORT_SYMBOL(__fs_parse
);
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 * @_path: The result of the lookup
143 int fs_lookup_param(struct fs_context
*fc
,
144 struct fs_parameter
*param
,
149 unsigned int flags
= 0;
153 switch (param
->type
) {
154 case fs_value_is_string
:
155 f
= getname_kernel(param
->string
);
160 case fs_value_is_filename
:
165 return invalf(fc
, "%s: not usable as path", param
->key
);
168 ret
= filename_lookup(param
->dirfd
, f
, flags
, _path
, NULL
);
170 errorf(fc
, "%s: Lookup failure for '%s'", param
->key
, f
->name
);
175 !S_ISBLK(d_backing_inode(_path
->dentry
)->i_mode
)) {
177 _path
->dentry
= NULL
;
179 errorf(fc
, "%s: Non-blockdev passed as '%s'",
180 param
->key
, f
->name
);
189 EXPORT_SYMBOL(fs_lookup_param
);
191 static int fs_param_bad_value(struct p_log
*log
, struct fs_parameter
*param
)
193 return inval_plog(log
, "Bad value for '%s'", param
->key
);
196 int fs_param_is_bool(struct p_log
*log
, const struct fs_parameter_spec
*p
,
197 struct fs_parameter
*param
, struct fs_parse_result
*result
)
200 if (param
->type
!= fs_value_is_string
)
201 return fs_param_bad_value(log
, param
);
202 if (!*param
->string
&& (p
->flags
& fs_param_can_be_empty
))
204 b
= lookup_constant(bool_names
, param
->string
, -1);
206 return fs_param_bad_value(log
, param
);
210 EXPORT_SYMBOL(fs_param_is_bool
);
212 int fs_param_is_u32(struct p_log
*log
, const struct fs_parameter_spec
*p
,
213 struct fs_parameter
*param
, struct fs_parse_result
*result
)
215 int base
= (unsigned long)p
->data
;
216 if (param
->type
!= fs_value_is_string
)
217 return fs_param_bad_value(log
, param
);
218 if (!*param
->string
&& (p
->flags
& fs_param_can_be_empty
))
220 if (kstrtouint(param
->string
, base
, &result
->uint_32
) < 0)
221 return fs_param_bad_value(log
, param
);
224 EXPORT_SYMBOL(fs_param_is_u32
);
226 int fs_param_is_s32(struct p_log
*log
, const struct fs_parameter_spec
*p
,
227 struct fs_parameter
*param
, struct fs_parse_result
*result
)
229 if (param
->type
!= fs_value_is_string
)
230 return fs_param_bad_value(log
, param
);
231 if (!*param
->string
&& (p
->flags
& fs_param_can_be_empty
))
233 if (kstrtoint(param
->string
, 0, &result
->int_32
) < 0)
234 return fs_param_bad_value(log
, param
);
237 EXPORT_SYMBOL(fs_param_is_s32
);
239 int fs_param_is_u64(struct p_log
*log
, const struct fs_parameter_spec
*p
,
240 struct fs_parameter
*param
, struct fs_parse_result
*result
)
242 if (param
->type
!= fs_value_is_string
)
243 return fs_param_bad_value(log
, param
);
244 if (!*param
->string
&& (p
->flags
& fs_param_can_be_empty
))
246 if (kstrtoull(param
->string
, 0, &result
->uint_64
) < 0)
247 return fs_param_bad_value(log
, param
);
250 EXPORT_SYMBOL(fs_param_is_u64
);
252 int fs_param_is_enum(struct p_log
*log
, const struct fs_parameter_spec
*p
,
253 struct fs_parameter
*param
, struct fs_parse_result
*result
)
255 const struct constant_table
*c
;
256 if (param
->type
!= fs_value_is_string
)
257 return fs_param_bad_value(log
, param
);
258 if (!*param
->string
&& (p
->flags
& fs_param_can_be_empty
))
260 c
= __lookup_constant(p
->data
, param
->string
);
262 return fs_param_bad_value(log
, param
);
263 result
->uint_32
= c
->value
;
266 EXPORT_SYMBOL(fs_param_is_enum
);
268 int fs_param_is_string(struct p_log
*log
, const struct fs_parameter_spec
*p
,
269 struct fs_parameter
*param
, struct fs_parse_result
*result
)
271 if (param
->type
!= fs_value_is_string
||
272 (!*param
->string
&& !(p
->flags
& fs_param_can_be_empty
)))
273 return fs_param_bad_value(log
, param
);
276 EXPORT_SYMBOL(fs_param_is_string
);
278 int fs_param_is_blob(struct p_log
*log
, const struct fs_parameter_spec
*p
,
279 struct fs_parameter
*param
, struct fs_parse_result
*result
)
281 if (param
->type
!= fs_value_is_blob
)
282 return fs_param_bad_value(log
, param
);
285 EXPORT_SYMBOL(fs_param_is_blob
);
287 int fs_param_is_fd(struct p_log
*log
, const struct fs_parameter_spec
*p
,
288 struct fs_parameter
*param
, struct fs_parse_result
*result
)
290 switch (param
->type
) {
291 case fs_value_is_string
:
292 if ((!*param
->string
&& !(p
->flags
& fs_param_can_be_empty
)) ||
293 kstrtouint(param
->string
, 0, &result
->uint_32
) < 0)
295 if (result
->uint_32
<= INT_MAX
)
298 case fs_value_is_file
:
299 result
->uint_32
= param
->dirfd
;
300 if (result
->uint_32
<= INT_MAX
)
306 return fs_param_bad_value(log
, param
);
308 EXPORT_SYMBOL(fs_param_is_fd
);
310 int fs_param_is_blockdev(struct p_log
*log
, const struct fs_parameter_spec
*p
,
311 struct fs_parameter
*param
, struct fs_parse_result
*result
)
315 EXPORT_SYMBOL(fs_param_is_blockdev
);
317 int fs_param_is_path(struct p_log
*log
, const struct fs_parameter_spec
*p
,
318 struct fs_parameter
*param
, struct fs_parse_result
*result
)
322 EXPORT_SYMBOL(fs_param_is_path
);
324 #ifdef CONFIG_VALIDATE_FS_PARSER
326 * validate_constant_table - Validate a constant table
327 * @tbl: The constant table to validate.
328 * @tbl_size: The size of the table.
329 * @low: The lowest permissible value.
330 * @high: The highest permissible value.
331 * @special: One special permissible value outside of the range.
333 bool validate_constant_table(const struct constant_table
*tbl
, size_t tbl_size
,
334 int low
, int high
, int special
)
340 pr_warn("VALIDATE C-TBL: Empty\n");
344 for (i
= 0; i
< tbl_size
; i
++) {
346 pr_err("VALIDATE C-TBL[%zu]: Null\n", i
);
348 } else if (i
> 0 && tbl
[i
- 1].name
) {
349 int c
= strcmp(tbl
[i
-1].name
, tbl
[i
].name
);
352 pr_err("VALIDATE C-TBL[%zu]: Duplicate %s\n",
357 pr_err("VALIDATE C-TBL[%zu]: Missorted %s>=%s\n",
358 i
, tbl
[i
-1].name
, tbl
[i
].name
);
363 if (tbl
[i
].value
!= special
&&
364 (tbl
[i
].value
< low
|| tbl
[i
].value
> high
)) {
365 pr_err("VALIDATE C-TBL[%zu]: %s->%d const out of range (%d-%d)\n",
366 i
, tbl
[i
].name
, tbl
[i
].value
, low
, high
);
375 * fs_validate_description - Validate a parameter description
376 * @name: The parameter name to search for.
377 * @desc: The parameter description to validate.
379 bool fs_validate_description(const char *name
,
380 const struct fs_parameter_spec
*desc
)
382 const struct fs_parameter_spec
*param
, *p2
;
385 for (param
= desc
; param
->name
; param
++) {
386 /* Check for duplicate parameter names */
387 for (p2
= desc
; p2
< param
; p2
++) {
388 if (strcmp(param
->name
, p2
->name
) == 0) {
389 if (is_flag(param
) != is_flag(p2
))
391 pr_err("VALIDATE %s: PARAM[%s]: Duplicate\n",
399 #endif /* CONFIG_VALIDATE_FS_PARSER */