Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /* Filesystem access-by-fd.
       3                 :            :  *
       4                 :            :  * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
       5                 :            :  * Written by David Howells (dhowells@redhat.com)
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <linux/fs_context.h>
       9                 :            : #include <linux/fs_parser.h>
      10                 :            : #include <linux/slab.h>
      11                 :            : #include <linux/uaccess.h>
      12                 :            : #include <linux/syscalls.h>
      13                 :            : #include <linux/security.h>
      14                 :            : #include <linux/anon_inodes.h>
      15                 :            : #include <linux/namei.h>
      16                 :            : #include <linux/file.h>
      17                 :            : #include <uapi/linux/mount.h>
      18                 :            : #include "internal.h"
      19                 :            : #include "mount.h"
      20                 :            : 
      21                 :            : /*
      22                 :            :  * Allow the user to read back any error, warning or informational messages.
      23                 :            :  */
      24                 :          0 : static ssize_t fscontext_read(struct file *file,
      25                 :            :                               char __user *_buf, size_t len, loff_t *pos)
      26                 :            : {
      27                 :          0 :         struct fs_context *fc = file->private_data;
      28                 :          0 :         struct fc_log *log = fc->log;
      29                 :            :         unsigned int logsize = ARRAY_SIZE(log->buffer);
      30                 :            :         ssize_t ret;
      31                 :            :         char *p;
      32                 :            :         bool need_free;
      33                 :            :         int index, n;
      34                 :            : 
      35                 :          0 :         ret = mutex_lock_interruptible(&fc->uapi_mutex);
      36                 :          0 :         if (ret < 0)
      37                 :            :                 return ret;
      38                 :            : 
      39                 :          0 :         if (log->head == log->tail) {
      40                 :          0 :                 mutex_unlock(&fc->uapi_mutex);
      41                 :          0 :                 return -ENODATA;
      42                 :            :         }
      43                 :            : 
      44                 :          0 :         index = log->tail & (logsize - 1);
      45                 :          0 :         p = log->buffer[index];
      46                 :          0 :         need_free = log->need_free & (1 << index);
      47                 :          0 :         log->buffer[index] = NULL;
      48                 :          0 :         log->need_free &= ~(1 << index);
      49                 :          0 :         log->tail++;
      50                 :          0 :         mutex_unlock(&fc->uapi_mutex);
      51                 :            : 
      52                 :            :         ret = -EMSGSIZE;
      53                 :          0 :         n = strlen(p);
      54                 :          0 :         if (n > len)
      55                 :            :                 goto err_free;
      56                 :            :         ret = -EFAULT;
      57                 :          0 :         if (copy_to_user(_buf, p, n) != 0)
      58                 :            :                 goto err_free;
      59                 :            :         ret = n;
      60                 :            : 
      61                 :            : err_free:
      62                 :          0 :         if (need_free)
      63                 :          0 :                 kfree(p);
      64                 :          0 :         return ret;
      65                 :            : }
      66                 :            : 
      67                 :          0 : static int fscontext_release(struct inode *inode, struct file *file)
      68                 :            : {
      69                 :          0 :         struct fs_context *fc = file->private_data;
      70                 :            : 
      71                 :          0 :         if (fc) {
      72                 :          0 :                 file->private_data = NULL;
      73                 :          0 :                 put_fs_context(fc);
      74                 :            :         }
      75                 :          0 :         return 0;
      76                 :            : }
      77                 :            : 
      78                 :            : const struct file_operations fscontext_fops = {
      79                 :            :         .read           = fscontext_read,
      80                 :            :         .release        = fscontext_release,
      81                 :            :         .llseek         = no_llseek,
      82                 :            : };
      83                 :            : 
      84                 :            : /*
      85                 :            :  * Attach a filesystem context to a file and an fd.
      86                 :            :  */
      87                 :          0 : static int fscontext_create_fd(struct fs_context *fc, unsigned int o_flags)
      88                 :            : {
      89                 :            :         int fd;
      90                 :            : 
      91                 :          0 :         fd = anon_inode_getfd("[fscontext]", &fscontext_fops, fc,
      92                 :          0 :                               O_RDWR | o_flags);
      93                 :          0 :         if (fd < 0)
      94                 :          0 :                 put_fs_context(fc);
      95                 :          0 :         return fd;
      96                 :            : }
      97                 :            : 
      98                 :          0 : static int fscontext_alloc_log(struct fs_context *fc)
      99                 :            : {
     100                 :          0 :         fc->log = kzalloc(sizeof(*fc->log), GFP_KERNEL);
     101                 :          0 :         if (!fc->log)
     102                 :            :                 return -ENOMEM;
     103                 :            :         refcount_set(&fc->log->usage, 1);
     104                 :          0 :         fc->log->owner = fc->fs_type->owner;
     105                 :          0 :         return 0;
     106                 :            : }
     107                 :            : 
     108                 :            : /*
     109                 :            :  * Open a filesystem by name so that it can be configured for mounting.
     110                 :            :  *
     111                 :            :  * We are allowed to specify a container in which the filesystem will be
     112                 :            :  * opened, thereby indicating which namespaces will be used (notably, which
     113                 :            :  * network namespace will be used for network filesystems).
     114                 :            :  */
     115                 :          0 : SYSCALL_DEFINE2(fsopen, const char __user *, _fs_name, unsigned int, flags)
     116                 :            : {
     117                 :            :         struct file_system_type *fs_type;
     118                 :            :         struct fs_context *fc;
     119                 :            :         const char *fs_name;
     120                 :            :         int ret;
     121                 :            : 
     122                 :          0 :         if (!ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN))
     123                 :            :                 return -EPERM;
     124                 :            : 
     125                 :          0 :         if (flags & ~FSOPEN_CLOEXEC)
     126                 :            :                 return -EINVAL;
     127                 :            : 
     128                 :          0 :         fs_name = strndup_user(_fs_name, PAGE_SIZE);
     129                 :          0 :         if (IS_ERR(fs_name))
     130                 :          0 :                 return PTR_ERR(fs_name);
     131                 :            : 
     132                 :          0 :         fs_type = get_fs_type(fs_name);
     133                 :          0 :         kfree(fs_name);
     134                 :          0 :         if (!fs_type)
     135                 :            :                 return -ENODEV;
     136                 :            : 
     137                 :          0 :         fc = fs_context_for_mount(fs_type, 0);
     138                 :          0 :         put_filesystem(fs_type);
     139                 :          0 :         if (IS_ERR(fc))
     140                 :          0 :                 return PTR_ERR(fc);
     141                 :            : 
     142                 :          0 :         fc->phase = FS_CONTEXT_CREATE_PARAMS;
     143                 :            : 
     144                 :          0 :         ret = fscontext_alloc_log(fc);
     145                 :          0 :         if (ret < 0)
     146                 :            :                 goto err_fc;
     147                 :            : 
     148                 :          0 :         return fscontext_create_fd(fc, flags & FSOPEN_CLOEXEC ? O_CLOEXEC : 0);
     149                 :            : 
     150                 :            : err_fc:
     151                 :          0 :         put_fs_context(fc);
     152                 :          0 :         return ret;
     153                 :            : }
     154                 :            : 
     155                 :            : /*
     156                 :            :  * Pick a superblock into a context for reconfiguration.
     157                 :            :  */
     158                 :          0 : SYSCALL_DEFINE3(fspick, int, dfd, const char __user *, path, unsigned int, flags)
     159                 :            : {
     160                 :            :         struct fs_context *fc;
     161                 :            :         struct path target;
     162                 :            :         unsigned int lookup_flags;
     163                 :            :         int ret;
     164                 :            : 
     165                 :          0 :         if (!ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN))
     166                 :            :                 return -EPERM;
     167                 :            : 
     168                 :          0 :         if ((flags & ~(FSPICK_CLOEXEC |
     169                 :            :                        FSPICK_SYMLINK_NOFOLLOW |
     170                 :            :                        FSPICK_NO_AUTOMOUNT |
     171                 :            :                        FSPICK_EMPTY_PATH)) != 0)
     172                 :            :                 return -EINVAL;
     173                 :            : 
     174                 :            :         lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT;
     175                 :          0 :         if (flags & FSPICK_SYMLINK_NOFOLLOW)
     176                 :            :                 lookup_flags &= ~LOOKUP_FOLLOW;
     177                 :          0 :         if (flags & FSPICK_NO_AUTOMOUNT)
     178                 :          0 :                 lookup_flags &= ~LOOKUP_AUTOMOUNT;
     179                 :          0 :         if (flags & FSPICK_EMPTY_PATH)
     180                 :          0 :                 lookup_flags |= LOOKUP_EMPTY;
     181                 :            :         ret = user_path_at(dfd, path, lookup_flags, &target);
     182                 :          0 :         if (ret < 0)
     183                 :            :                 goto err;
     184                 :            : 
     185                 :            :         ret = -EINVAL;
     186                 :          0 :         if (target.mnt->mnt_root != target.dentry)
     187                 :            :                 goto err_path;
     188                 :            : 
     189                 :          0 :         fc = fs_context_for_reconfigure(target.dentry, 0, 0);
     190                 :          0 :         if (IS_ERR(fc)) {
     191                 :            :                 ret = PTR_ERR(fc);
     192                 :          0 :                 goto err_path;
     193                 :            :         }
     194                 :            : 
     195                 :          0 :         fc->phase = FS_CONTEXT_RECONF_PARAMS;
     196                 :            : 
     197                 :          0 :         ret = fscontext_alloc_log(fc);
     198                 :          0 :         if (ret < 0)
     199                 :            :                 goto err_fc;
     200                 :            : 
     201                 :          0 :         path_put(&target);
     202                 :          0 :         return fscontext_create_fd(fc, flags & FSPICK_CLOEXEC ? O_CLOEXEC : 0);
     203                 :            : 
     204                 :            : err_fc:
     205                 :          0 :         put_fs_context(fc);
     206                 :            : err_path:
     207                 :          0 :         path_put(&target);
     208                 :            : err:
     209                 :          0 :         return ret;
     210                 :            : }
     211                 :            : 
     212                 :            : /*
     213                 :            :  * Check the state and apply the configuration.  Note that this function is
     214                 :            :  * allowed to 'steal' the value by setting param->xxx to NULL before returning.
     215                 :            :  */
     216                 :          0 : static int vfs_fsconfig_locked(struct fs_context *fc, int cmd,
     217                 :            :                                struct fs_parameter *param)
     218                 :            : {
     219                 :            :         struct super_block *sb;
     220                 :            :         int ret;
     221                 :            : 
     222                 :          0 :         ret = finish_clean_context(fc);
     223                 :          0 :         if (ret)
     224                 :            :                 return ret;
     225                 :          0 :         switch (cmd) {
     226                 :            :         case FSCONFIG_CMD_CREATE:
     227                 :          0 :                 if (fc->phase != FS_CONTEXT_CREATE_PARAMS)
     228                 :            :                         return -EBUSY;
     229                 :          0 :                 if (!mount_capable(fc))
     230                 :            :                         return -EPERM;
     231                 :          0 :                 fc->phase = FS_CONTEXT_CREATING;
     232                 :          0 :                 ret = vfs_get_tree(fc);
     233                 :          0 :                 if (ret)
     234                 :            :                         break;
     235                 :          0 :                 sb = fc->root->d_sb;
     236                 :          0 :                 ret = security_sb_kern_mount(sb);
     237                 :          0 :                 if (unlikely(ret)) {
     238                 :          0 :                         fc_drop_locked(fc);
     239                 :          0 :                         break;
     240                 :            :                 }
     241                 :          0 :                 up_write(&sb->s_umount);
     242                 :          0 :                 fc->phase = FS_CONTEXT_AWAITING_MOUNT;
     243                 :          0 :                 return 0;
     244                 :            :         case FSCONFIG_CMD_RECONFIGURE:
     245                 :          0 :                 if (fc->phase != FS_CONTEXT_RECONF_PARAMS)
     246                 :            :                         return -EBUSY;
     247                 :          0 :                 fc->phase = FS_CONTEXT_RECONFIGURING;
     248                 :          0 :                 sb = fc->root->d_sb;
     249                 :          0 :                 if (!ns_capable(sb->s_user_ns, CAP_SYS_ADMIN)) {
     250                 :            :                         ret = -EPERM;
     251                 :            :                         break;
     252                 :            :                 }
     253                 :          0 :                 down_write(&sb->s_umount);
     254                 :          0 :                 ret = reconfigure_super(fc);
     255                 :          0 :                 up_write(&sb->s_umount);
     256                 :          0 :                 if (ret)
     257                 :            :                         break;
     258                 :          0 :                 vfs_clean_context(fc);
     259                 :          0 :                 return 0;
     260                 :            :         default:
     261                 :          0 :                 if (fc->phase != FS_CONTEXT_CREATE_PARAMS &&
     262                 :            :                     fc->phase != FS_CONTEXT_RECONF_PARAMS)
     263                 :            :                         return -EBUSY;
     264                 :            : 
     265                 :          0 :                 return vfs_parse_fs_param(fc, param);
     266                 :            :         }
     267                 :          0 :         fc->phase = FS_CONTEXT_FAILED;
     268                 :          0 :         return ret;
     269                 :            : }
     270                 :            : 
     271                 :            : /**
     272                 :            :  * sys_fsconfig - Set parameters and trigger actions on a context
     273                 :            :  * @fd: The filesystem context to act upon
     274                 :            :  * @cmd: The action to take
     275                 :            :  * @_key: Where appropriate, the parameter key to set
     276                 :            :  * @_value: Where appropriate, the parameter value to set
     277                 :            :  * @aux: Additional information for the value
     278                 :            :  *
     279                 :            :  * This system call is used to set parameters on a context, including
     280                 :            :  * superblock settings, data source and security labelling.
     281                 :            :  *
     282                 :            :  * Actions include triggering the creation of a superblock and the
     283                 :            :  * reconfiguration of the superblock attached to the specified context.
     284                 :            :  *
     285                 :            :  * When setting a parameter, @cmd indicates the type of value being proposed
     286                 :            :  * and @_key indicates the parameter to be altered.
     287                 :            :  *
     288                 :            :  * @_value and @aux are used to specify the value, should a value be required:
     289                 :            :  *
     290                 :            :  * (*) fsconfig_set_flag: No value is specified.  The parameter must be boolean
     291                 :            :  *     in nature.  The key may be prefixed with "no" to invert the
     292                 :            :  *     setting. @_value must be NULL and @aux must be 0.
     293                 :            :  *
     294                 :            :  * (*) fsconfig_set_string: A string value is specified.  The parameter can be
     295                 :            :  *     expecting boolean, integer, string or take a path.  A conversion to an
     296                 :            :  *     appropriate type will be attempted (which may include looking up as a
     297                 :            :  *     path).  @_value points to a NUL-terminated string and @aux must be 0.
     298                 :            :  *
     299                 :            :  * (*) fsconfig_set_binary: A binary blob is specified.  @_value points to the
     300                 :            :  *     blob and @aux indicates its size.  The parameter must be expecting a
     301                 :            :  *     blob.
     302                 :            :  *
     303                 :            :  * (*) fsconfig_set_path: A non-empty path is specified.  The parameter must be
     304                 :            :  *     expecting a path object.  @_value points to a NUL-terminated string that
     305                 :            :  *     is the path and @aux is a file descriptor at which to start a relative
     306                 :            :  *     lookup or AT_FDCWD.
     307                 :            :  *
     308                 :            :  * (*) fsconfig_set_path_empty: As fsconfig_set_path, but with AT_EMPTY_PATH
     309                 :            :  *     implied.
     310                 :            :  *
     311                 :            :  * (*) fsconfig_set_fd: An open file descriptor is specified.  @_value must be
     312                 :            :  *     NULL and @aux indicates the file descriptor.
     313                 :            :  */
     314                 :          0 : SYSCALL_DEFINE5(fsconfig,
     315                 :            :                 int, fd,
     316                 :            :                 unsigned int, cmd,
     317                 :            :                 const char __user *, _key,
     318                 :            :                 const void __user *, _value,
     319                 :            :                 int, aux)
     320                 :            : {
     321                 :            :         struct fs_context *fc;
     322                 :            :         struct fd f;
     323                 :            :         int ret;
     324                 :            : 
     325                 :          0 :         struct fs_parameter param = {
     326                 :            :                 .type   = fs_value_is_undefined,
     327                 :            :         };
     328                 :            : 
     329                 :          0 :         if (fd < 0)
     330                 :            :                 return -EINVAL;
     331                 :            : 
     332                 :          0 :         switch (cmd) {
     333                 :            :         case FSCONFIG_SET_FLAG:
     334                 :          0 :                 if (!_key || _value || aux)
     335                 :            :                         return -EINVAL;
     336                 :            :                 break;
     337                 :            :         case FSCONFIG_SET_STRING:
     338                 :          0 :                 if (!_key || !_value || aux)
     339                 :            :                         return -EINVAL;
     340                 :            :                 break;
     341                 :            :         case FSCONFIG_SET_BINARY:
     342                 :          0 :                 if (!_key || !_value || aux <= 0 || aux > 1024 * 1024)
     343                 :            :                         return -EINVAL;
     344                 :            :                 break;
     345                 :            :         case FSCONFIG_SET_PATH:
     346                 :            :         case FSCONFIG_SET_PATH_EMPTY:
     347                 :          0 :                 if (!_key || !_value || (aux != AT_FDCWD && aux < 0))
     348                 :            :                         return -EINVAL;
     349                 :            :                 break;
     350                 :            :         case FSCONFIG_SET_FD:
     351                 :          0 :                 if (!_key || _value || aux < 0)
     352                 :            :                         return -EINVAL;
     353                 :            :                 break;
     354                 :            :         case FSCONFIG_CMD_CREATE:
     355                 :            :         case FSCONFIG_CMD_RECONFIGURE:
     356                 :          0 :                 if (_key || _value || aux)
     357                 :            :                         return -EINVAL;
     358                 :            :                 break;
     359                 :            :         default:
     360                 :            :                 return -EOPNOTSUPP;
     361                 :            :         }
     362                 :            : 
     363                 :          0 :         f = fdget(fd);
     364                 :          0 :         if (!f.file)
     365                 :            :                 return -EBADF;
     366                 :            :         ret = -EINVAL;
     367                 :          0 :         if (f.file->f_op != &fscontext_fops)
     368                 :            :                 goto out_f;
     369                 :            : 
     370                 :          0 :         fc = f.file->private_data;
     371                 :          0 :         if (fc->ops == &legacy_fs_context_ops) {
     372                 :          0 :                 switch (cmd) {
     373                 :            :                 case FSCONFIG_SET_BINARY:
     374                 :            :                 case FSCONFIG_SET_PATH:
     375                 :            :                 case FSCONFIG_SET_PATH_EMPTY:
     376                 :            :                 case FSCONFIG_SET_FD:
     377                 :            :                         ret = -EOPNOTSUPP;
     378                 :            :                         goto out_f;
     379                 :            :                 }
     380                 :            :         }
     381                 :            : 
     382                 :          0 :         if (_key) {
     383                 :          0 :                 param.key = strndup_user(_key, 256);
     384                 :          0 :                 if (IS_ERR(param.key)) {
     385                 :            :                         ret = PTR_ERR(param.key);
     386                 :          0 :                         goto out_f;
     387                 :            :                 }
     388                 :            :         }
     389                 :            : 
     390                 :          0 :         switch (cmd) {
     391                 :            :         case FSCONFIG_SET_FLAG:
     392                 :          0 :                 param.type = fs_value_is_flag;
     393                 :          0 :                 break;
     394                 :            :         case FSCONFIG_SET_STRING:
     395                 :          0 :                 param.type = fs_value_is_string;
     396                 :          0 :                 param.string = strndup_user(_value, 256);
     397                 :          0 :                 if (IS_ERR(param.string)) {
     398                 :            :                         ret = PTR_ERR(param.string);
     399                 :          0 :                         goto out_key;
     400                 :            :                 }
     401                 :          0 :                 param.size = strlen(param.string);
     402                 :          0 :                 break;
     403                 :            :         case FSCONFIG_SET_BINARY:
     404                 :          0 :                 param.type = fs_value_is_blob;
     405                 :          0 :                 param.size = aux;
     406                 :          0 :                 param.blob = memdup_user_nul(_value, aux);
     407                 :          0 :                 if (IS_ERR(param.blob)) {
     408                 :            :                         ret = PTR_ERR(param.blob);
     409                 :          0 :                         goto out_key;
     410                 :            :                 }
     411                 :            :                 break;
     412                 :            :         case FSCONFIG_SET_PATH:
     413                 :          0 :                 param.type = fs_value_is_filename;
     414                 :          0 :                 param.name = getname_flags(_value, 0, NULL);
     415                 :          0 :                 if (IS_ERR(param.name)) {
     416                 :            :                         ret = PTR_ERR(param.name);
     417                 :          0 :                         goto out_key;
     418                 :            :                 }
     419                 :          0 :                 param.dirfd = aux;
     420                 :          0 :                 param.size = strlen(param.name->name);
     421                 :          0 :                 break;
     422                 :            :         case FSCONFIG_SET_PATH_EMPTY:
     423                 :          0 :                 param.type = fs_value_is_filename_empty;
     424                 :          0 :                 param.name = getname_flags(_value, LOOKUP_EMPTY, NULL);
     425                 :          0 :                 if (IS_ERR(param.name)) {
     426                 :            :                         ret = PTR_ERR(param.name);
     427                 :          0 :                         goto out_key;
     428                 :            :                 }
     429                 :          0 :                 param.dirfd = aux;
     430                 :          0 :                 param.size = strlen(param.name->name);
     431                 :          0 :                 break;
     432                 :            :         case FSCONFIG_SET_FD:
     433                 :          0 :                 param.type = fs_value_is_file;
     434                 :            :                 ret = -EBADF;
     435                 :          0 :                 param.file = fget(aux);
     436                 :          0 :                 if (!param.file)
     437                 :            :                         goto out_key;
     438                 :            :                 break;
     439                 :            :         default:
     440                 :            :                 break;
     441                 :            :         }
     442                 :            : 
     443                 :          0 :         ret = mutex_lock_interruptible(&fc->uapi_mutex);
     444                 :          0 :         if (ret == 0) {
     445                 :          0 :                 ret = vfs_fsconfig_locked(fc, cmd, &param);
     446                 :          0 :                 mutex_unlock(&fc->uapi_mutex);
     447                 :            :         }
     448                 :            : 
     449                 :            :         /* Clean up the our record of any value that we obtained from
     450                 :            :          * userspace.  Note that the value may have been stolen by the LSM or
     451                 :            :          * filesystem, in which case the value pointer will have been cleared.
     452                 :            :          */
     453                 :          0 :         switch (cmd) {
     454                 :            :         case FSCONFIG_SET_STRING:
     455                 :            :         case FSCONFIG_SET_BINARY:
     456                 :          0 :                 kfree(param.string);
     457                 :          0 :                 break;
     458                 :            :         case FSCONFIG_SET_PATH:
     459                 :            :         case FSCONFIG_SET_PATH_EMPTY:
     460                 :          0 :                 if (param.name)
     461                 :          0 :                         putname(param.name);
     462                 :            :                 break;
     463                 :            :         case FSCONFIG_SET_FD:
     464                 :          0 :                 if (param.file)
     465                 :          0 :                         fput(param.file);
     466                 :            :                 break;
     467                 :            :         default:
     468                 :            :                 break;
     469                 :            :         }
     470                 :            : out_key:
     471                 :          0 :         kfree(param.key);
     472                 :            : out_f:
     473                 :            :         fdput(f);
     474                 :          0 :         return ret;
     475                 :            : }