LCOV - code coverage report
Current view: top level - fs - fs_parser.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 37 125 29.6 %
Date: 2021-04-22 12:43:58 Functions: 6 16 37.5 %

          Line data    Source code
       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         664 : __lookup_constant(const struct constant_table *tbl, const char *name)
      28             : {
      29        3652 :         for ( ; tbl->name; tbl++)
      30        2988 :                 if (strcmp(name, tbl->name) == 0)
      31           0 :                         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         664 : int lookup_constant(const struct constant_table *tbl, const char *name, int not_found)
      42             : {
      43         664 :         const struct constant_table *p = __lookup_constant(tbl, name);
      44             : 
      45         664 :         return p ? p->value : not_found;
      46             : }
      47             : EXPORT_SYMBOL(lookup_constant);
      48             : 
      49         410 : static inline bool is_flag(const struct fs_parameter_spec *p)
      50             : {
      51         410 :         return p->type == NULL;
      52             : }
      53             : 
      54         313 : 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         313 :         const struct fs_parameter_spec *p, *other = NULL;
      59         313 :         const char *name = param->key;
      60         313 :         bool want_flag = param->type == fs_value_is_flag;
      61             : 
      62         313 :         *negated = false;
      63        2164 :         for (p = desc; p->name; p++) {
      64        2056 :                 if (strcmp(p->name, name) != 0)
      65        1851 :                         continue;
      66         205 :                 if (likely(is_flag(p) == want_flag))
      67         205 :                         return p;
      68             :                 other = p;
      69             :         }
      70         108 :         if (want_flag) {
      71           0 :                 if (name[0] == 'n' && name[1] == 'o' && name[2]) {
      72           0 :                         for (p = desc; p->name; p++) {
      73           0 :                                 if (strcmp(p->name, name + 2) != 0)
      74           0 :                                         continue;
      75           0 :                                 if (!(p->flags & fs_param_neg_with_no))
      76           0 :                                         continue;
      77           0 :                                 *negated = true;
      78           0 :                                 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         313 : 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         313 :         const struct fs_parameter_spec *p;
     109             : 
     110         313 :         result->uint_64 = 0;
     111             : 
     112         313 :         p = fs_lookup_key(desc, param, &result->negated);
     113         313 :         if (!p)
     114             :                 return -ENOPARAM;
     115             : 
     116         205 :         if (p->flags & fs_param_deprecated)
     117           0 :                 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         205 :         if (is_flag(p)) {
     123           3 :                 if (param->type != fs_value_is_flag)
     124           0 :                         return inval_plog(log, "Unexpected value for '%s'",
     125             :                                       param->key);
     126           3 :                 result->boolean = !result->negated;
     127             :         } else  {
     128         202 :                 int ret = p->type(log, p, param, result);
     129         202 :                 if (ret)
     130             :                         return ret;
     131             :         }
     132         205 :         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             :  * @_path: The result of the lookup
     142             :  */
     143           0 : int fs_lookup_param(struct fs_context *fc,
     144             :                     struct fs_parameter *param,
     145             :                     bool want_bdev,
     146             :                     struct path *_path)
     147             : {
     148           0 :         struct filename *f;
     149           0 :         unsigned int flags = 0;
     150           0 :         bool put_f;
     151           0 :         int ret;
     152             : 
     153           0 :         switch (param->type) {
     154           0 :         case fs_value_is_string:
     155           0 :                 f = getname_kernel(param->string);
     156           0 :                 if (IS_ERR(f))
     157           0 :                         return PTR_ERR(f);
     158             :                 put_f = true;
     159             :                 break;
     160           0 :         case fs_value_is_filename:
     161           0 :                 f = param->name;
     162           0 :                 put_f = false;
     163           0 :                 break;
     164           0 :         default:
     165           0 :                 return invalf(fc, "%s: not usable as path", param->key);
     166             :         }
     167             : 
     168           0 :         f->refcnt++; /* filename_lookup() drops our ref. */
     169           0 :         ret = filename_lookup(param->dirfd, f, flags, _path, NULL);
     170           0 :         if (ret < 0) {
     171           0 :                 errorf(fc, "%s: Lookup failure for '%s'", param->key, f->name);
     172           0 :                 goto out;
     173             :         }
     174             : 
     175           0 :         if (want_bdev &&
     176           0 :             !S_ISBLK(d_backing_inode(_path->dentry)->i_mode)) {
     177           0 :                 path_put(_path);
     178           0 :                 _path->dentry = NULL;
     179           0 :                 _path->mnt = NULL;
     180           0 :                 errorf(fc, "%s: Non-blockdev passed as '%s'",
     181             :                        param->key, f->name);
     182           0 :                 ret = -ENOTBLK;
     183             :         }
     184             : 
     185           0 : out:
     186           0 :         if (put_f)
     187           0 :                 putname(f);
     188             :         return ret;
     189             : }
     190             : EXPORT_SYMBOL(fs_lookup_param);
     191             : 
     192           0 : static int fs_param_bad_value(struct p_log *log, struct fs_parameter *param)
     193             : {
     194           0 :         return inval_plog(log, "Bad value for '%s'", param->key);
     195             : }
     196             : 
     197           0 : 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           0 :         int b;
     201           0 :         if (param->type != fs_value_is_string)
     202           0 :                 return fs_param_bad_value(log, param);
     203           0 :         b = lookup_constant(bool_names, param->string, -1);
     204           0 :         if (b == -1)
     205           0 :                 return fs_param_bad_value(log, param);
     206           0 :         result->boolean = b;
     207           0 :         return 0;
     208             : }
     209             : EXPORT_SYMBOL(fs_param_is_bool);
     210             : 
     211         105 : int fs_param_is_u32(struct p_log *log, const struct fs_parameter_spec *p,
     212             :                     struct fs_parameter *param, struct fs_parse_result *result)
     213             : {
     214         105 :         int base = (unsigned long)p->data;
     215         210 :         if (param->type != fs_value_is_string ||
     216         105 :             kstrtouint(param->string, base, &result->uint_32) < 0)
     217           0 :                 return fs_param_bad_value(log, param);
     218             :         return 0;
     219             : }
     220             : EXPORT_SYMBOL(fs_param_is_u32);
     221             : 
     222           0 : int fs_param_is_s32(struct p_log *log, const struct fs_parameter_spec *p,
     223             :                     struct fs_parameter *param, struct fs_parse_result *result)
     224             : {
     225           0 :         if (param->type != fs_value_is_string ||
     226           0 :             kstrtoint(param->string, 0, &result->int_32) < 0)
     227           0 :                 return fs_param_bad_value(log, param);
     228             :         return 0;
     229             : }
     230             : EXPORT_SYMBOL(fs_param_is_s32);
     231             : 
     232           0 : int fs_param_is_u64(struct p_log *log, const struct fs_parameter_spec *p,
     233             :                     struct fs_parameter *param, struct fs_parse_result *result)
     234             : {
     235           0 :         if (param->type != fs_value_is_string ||
     236           0 :             kstrtoull(param->string, 0, &result->uint_64) < 0)
     237           0 :                 return fs_param_bad_value(log, param);
     238             :         return 0;
     239             : }
     240             : EXPORT_SYMBOL(fs_param_is_u64);
     241             : 
     242           0 : int fs_param_is_enum(struct p_log *log, const struct fs_parameter_spec *p,
     243             :                      struct fs_parameter *param, struct fs_parse_result *result)
     244             : {
     245           0 :         const struct constant_table *c;
     246           0 :         if (param->type != fs_value_is_string)
     247           0 :                 return fs_param_bad_value(log, param);
     248           0 :         c = __lookup_constant(p->data, param->string);
     249           0 :         if (!c)
     250           0 :                 return fs_param_bad_value(log, param);
     251           0 :         result->uint_32 = c->value;
     252           0 :         return 0;
     253             : }
     254             : EXPORT_SYMBOL(fs_param_is_enum);
     255             : 
     256          97 : int fs_param_is_string(struct p_log *log, const struct fs_parameter_spec *p,
     257             :                        struct fs_parameter *param, struct fs_parse_result *result)
     258             : {
     259          97 :         if (param->type != fs_value_is_string || !*param->string)
     260           0 :                 return fs_param_bad_value(log, param);
     261             :         return 0;
     262             : }
     263             : EXPORT_SYMBOL(fs_param_is_string);
     264             : 
     265           0 : int fs_param_is_blob(struct p_log *log, const struct fs_parameter_spec *p,
     266             :                      struct fs_parameter *param, struct fs_parse_result *result)
     267             : {
     268           0 :         if (param->type != fs_value_is_blob)
     269           0 :                 return fs_param_bad_value(log, param);
     270             :         return 0;
     271             : }
     272             : EXPORT_SYMBOL(fs_param_is_blob);
     273             : 
     274           0 : int fs_param_is_fd(struct p_log *log, const struct fs_parameter_spec *p,
     275             :                   struct fs_parameter *param, struct fs_parse_result *result)
     276             : {
     277           0 :         switch (param->type) {
     278           0 :         case fs_value_is_string:
     279           0 :                 if (kstrtouint(param->string, 0, &result->uint_32) < 0)
     280             :                         break;
     281           0 :                 if (result->uint_32 <= INT_MAX)
     282             :                         return 0;
     283             :                 break;
     284           0 :         case fs_value_is_file:
     285           0 :                 result->uint_32 = param->dirfd;
     286           0 :                 if (result->uint_32 <= INT_MAX)
     287             :                         return 0;
     288             :                 break;
     289             :         default:
     290             :                 break;
     291             :         }
     292           0 :         return fs_param_bad_value(log, param);
     293             : }
     294             : EXPORT_SYMBOL(fs_param_is_fd);
     295             : 
     296           0 : int fs_param_is_blockdev(struct p_log *log, const struct fs_parameter_spec *p,
     297             :                   struct fs_parameter *param, struct fs_parse_result *result)
     298             : {
     299           0 :         return 0;
     300             : }
     301             : EXPORT_SYMBOL(fs_param_is_blockdev);
     302             : 
     303           0 : int fs_param_is_path(struct p_log *log, const struct fs_parameter_spec *p,
     304             :                      struct fs_parameter *param, struct fs_parse_result *result)
     305             : {
     306           0 :         return 0;
     307             : }
     308             : EXPORT_SYMBOL(fs_param_is_path);
     309             : 
     310             : #ifdef CONFIG_VALIDATE_FS_PARSER
     311             : /**
     312             :  * validate_constant_table - Validate a constant table
     313             :  * @name: Name to use in reporting
     314             :  * @tbl: The constant table to validate.
     315             :  * @tbl_size: The size of the table.
     316             :  * @low: The lowest permissible value.
     317             :  * @high: The highest permissible value.
     318             :  * @special: One special permissible value outside of the range.
     319             :  */
     320             : bool validate_constant_table(const struct constant_table *tbl, size_t tbl_size,
     321             :                              int low, int high, int special)
     322             : {
     323             :         size_t i;
     324             :         bool good = true;
     325             : 
     326             :         if (tbl_size == 0) {
     327             :                 pr_warn("VALIDATE C-TBL: Empty\n");
     328             :                 return true;
     329             :         }
     330             : 
     331             :         for (i = 0; i < tbl_size; i++) {
     332             :                 if (!tbl[i].name) {
     333             :                         pr_err("VALIDATE C-TBL[%zu]: Null\n", i);
     334             :                         good = false;
     335             :                 } else if (i > 0 && tbl[i - 1].name) {
     336             :                         int c = strcmp(tbl[i-1].name, tbl[i].name);
     337             : 
     338             :                         if (c == 0) {
     339             :                                 pr_err("VALIDATE C-TBL[%zu]: Duplicate %s\n",
     340             :                                        i, tbl[i].name);
     341             :                                 good = false;
     342             :                         }
     343             :                         if (c > 0) {
     344             :                                 pr_err("VALIDATE C-TBL[%zu]: Missorted %s>=%s\n",
     345             :                                        i, tbl[i-1].name, tbl[i].name);
     346             :                                 good = false;
     347             :                         }
     348             :                 }
     349             : 
     350             :                 if (tbl[i].value != special &&
     351             :                     (tbl[i].value < low || tbl[i].value > high)) {
     352             :                         pr_err("VALIDATE C-TBL[%zu]: %s->%d const out of range (%d-%d)\n",
     353             :                                i, tbl[i].name, tbl[i].value, low, high);
     354             :                         good = false;
     355             :                 }
     356             :         }
     357             : 
     358             :         return good;
     359             : }
     360             : 
     361             : /**
     362             :  * fs_validate_description - Validate a parameter description
     363             :  * @desc: The parameter description to validate.
     364             :  */
     365             : bool fs_validate_description(const char *name,
     366             :         const struct fs_parameter_spec *desc)
     367             : {
     368             :         const struct fs_parameter_spec *param, *p2;
     369             :         bool good = true;
     370             : 
     371             :         for (param = desc; param->name; param++) {
     372             :                 /* Check for duplicate parameter names */
     373             :                 for (p2 = desc; p2 < param; p2++) {
     374             :                         if (strcmp(param->name, p2->name) == 0) {
     375             :                                 if (is_flag(param) != is_flag(p2))
     376             :                                         continue;
     377             :                                 pr_err("VALIDATE %s: PARAM[%s]: Duplicate\n",
     378             :                                        name, param->name);
     379             :                                 good = false;
     380             :                         }
     381             :                 }
     382             :         }
     383             :         return good;
     384             : }
     385             : #endif /* CONFIG_VALIDATE_FS_PARSER */

Generated by: LCOV version 1.14