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 b
= lookup_constant(bool_names
, param
->string
, -1);
204 return fs_param_bad_value(log
, param
);
208 EXPORT_SYMBOL(fs_param_is_bool
);
210 int fs_param_is_u32(struct p_log
*log
, const struct fs_parameter_spec
*p
,
211 struct fs_parameter
*param
, struct fs_parse_result
*result
)
213 int base
= (unsigned long)p
->data
;
214 if (param
->type
!= fs_value_is_string
||
215 kstrtouint(param
->string
, base
, &result
->uint_32
) < 0)
216 return fs_param_bad_value(log
, param
);
219 EXPORT_SYMBOL(fs_param_is_u32
);
221 int fs_param_is_s32(struct p_log
*log
, const struct fs_parameter_spec
*p
,
222 struct fs_parameter
*param
, struct fs_parse_result
*result
)
224 if (param
->type
!= fs_value_is_string
||
225 kstrtoint(param
->string
, 0, &result
->int_32
) < 0)
226 return fs_param_bad_value(log
, param
);
229 EXPORT_SYMBOL(fs_param_is_s32
);
231 int fs_param_is_u64(struct p_log
*log
, const struct fs_parameter_spec
*p
,
232 struct fs_parameter
*param
, struct fs_parse_result
*result
)
234 if (param
->type
!= fs_value_is_string
||
235 kstrtoull(param
->string
, 0, &result
->uint_64
) < 0)
236 return fs_param_bad_value(log
, param
);
239 EXPORT_SYMBOL(fs_param_is_u64
);
241 int fs_param_is_enum(struct p_log
*log
, const struct fs_parameter_spec
*p
,
242 struct fs_parameter
*param
, struct fs_parse_result
*result
)
244 const struct constant_table
*c
;
245 if (param
->type
!= fs_value_is_string
)
246 return fs_param_bad_value(log
, param
);
247 c
= __lookup_constant(p
->data
, param
->string
);
249 return fs_param_bad_value(log
, param
);
250 result
->uint_32
= c
->value
;
253 EXPORT_SYMBOL(fs_param_is_enum
);
255 int fs_param_is_string(struct p_log
*log
, const struct fs_parameter_spec
*p
,
256 struct fs_parameter
*param
, struct fs_parse_result
*result
)
258 if (param
->type
!= fs_value_is_string
|| !*param
->string
)
259 return fs_param_bad_value(log
, param
);
262 EXPORT_SYMBOL(fs_param_is_string
);
264 int fs_param_is_blob(struct p_log
*log
, const struct fs_parameter_spec
*p
,
265 struct fs_parameter
*param
, struct fs_parse_result
*result
)
267 if (param
->type
!= fs_value_is_blob
)
268 return fs_param_bad_value(log
, param
);
271 EXPORT_SYMBOL(fs_param_is_blob
);
273 int fs_param_is_fd(struct p_log
*log
, const struct fs_parameter_spec
*p
,
274 struct fs_parameter
*param
, struct fs_parse_result
*result
)
276 switch (param
->type
) {
277 case fs_value_is_string
:
278 if (kstrtouint(param
->string
, 0, &result
->uint_32
) < 0)
280 if (result
->uint_32
<= INT_MAX
)
283 case fs_value_is_file
:
284 result
->uint_32
= param
->dirfd
;
285 if (result
->uint_32
<= INT_MAX
)
291 return fs_param_bad_value(log
, param
);
293 EXPORT_SYMBOL(fs_param_is_fd
);
295 int fs_param_is_blockdev(struct p_log
*log
, const struct fs_parameter_spec
*p
,
296 struct fs_parameter
*param
, struct fs_parse_result
*result
)
300 EXPORT_SYMBOL(fs_param_is_blockdev
);
302 int fs_param_is_path(struct p_log
*log
, const struct fs_parameter_spec
*p
,
303 struct fs_parameter
*param
, struct fs_parse_result
*result
)
307 EXPORT_SYMBOL(fs_param_is_path
);
309 #ifdef CONFIG_VALIDATE_FS_PARSER
311 * validate_constant_table - Validate a constant table
312 * @tbl: The constant table to validate.
313 * @tbl_size: The size of the table.
314 * @low: The lowest permissible value.
315 * @high: The highest permissible value.
316 * @special: One special permissible value outside of the range.
318 bool validate_constant_table(const struct constant_table
*tbl
, size_t tbl_size
,
319 int low
, int high
, int special
)
325 pr_warn("VALIDATE C-TBL: Empty\n");
329 for (i
= 0; i
< tbl_size
; i
++) {
331 pr_err("VALIDATE C-TBL[%zu]: Null\n", i
);
333 } else if (i
> 0 && tbl
[i
- 1].name
) {
334 int c
= strcmp(tbl
[i
-1].name
, tbl
[i
].name
);
337 pr_err("VALIDATE C-TBL[%zu]: Duplicate %s\n",
342 pr_err("VALIDATE C-TBL[%zu]: Missorted %s>=%s\n",
343 i
, tbl
[i
-1].name
, tbl
[i
].name
);
348 if (tbl
[i
].value
!= special
&&
349 (tbl
[i
].value
< low
|| tbl
[i
].value
> high
)) {
350 pr_err("VALIDATE C-TBL[%zu]: %s->%d const out of range (%d-%d)\n",
351 i
, tbl
[i
].name
, tbl
[i
].value
, low
, high
);
360 * fs_validate_description - Validate a parameter description
361 * @name: The parameter name to search for.
362 * @desc: The parameter description to validate.
364 bool fs_validate_description(const char *name
,
365 const struct fs_parameter_spec
*desc
)
367 const struct fs_parameter_spec
*param
, *p2
;
370 for (param
= desc
; param
->name
; param
++) {
371 /* Check for duplicate parameter names */
372 for (p2
= desc
; p2
< param
; p2
++) {
373 if (strcmp(param
->name
, p2
->name
) == 0) {
374 if (is_flag(param
) != is_flag(p2
))
376 pr_err("VALIDATE %s: PARAM[%s]: Duplicate\n",
384 #endif /* CONFIG_VALIDATE_FS_PARSER */