fs/ubifs/ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This file is part of UBIFS.
   4  *
   5  * Copyright (C) 2006-2008 Nokia Corporation.
   6  * Copyright (C) 2006, 2007 University of Szeged, Hungary
   7  *
   8  * Authors: Zoltan Sogor
   9  *          Artem Bityutskiy (Битюцкий Артём)
  10  *          Adrian Hunter
  11  */
  12
  13 /* This file implements EXT2-compatible extended attribute ioctl() calls */
  14
  15 #include <linux/compat.h>
  16 #include <linux/mount.h>
  17 #include "ubifs.h"
  18
  19 /* Need to be kept consistent with checked flags in ioctl2ubifs() */
  20 #define UBIFS_SETTABLE_IOCTL_FLAGS \
  21         (FS_COMPR_FL | FS_SYNC_FL | FS_APPEND_FL | \
  22          FS_IMMUTABLE_FL | FS_DIRSYNC_FL)
  23
  24 /* Need to be kept consistent with checked flags in ubifs2ioctl() */
  25 #define UBIFS_GETTABLE_IOCTL_FLAGS \
  26         (UBIFS_SETTABLE_IOCTL_FLAGS | FS_ENCRYPT_FL)
  27
  28 /**
  29  * ubifs_set_inode_flags - set VFS inode flags.
  30  * @inode: VFS inode to set flags for
  31  *
  32  * This function propagates flags from UBIFS inode object to VFS inode object.
  33  */
  34 void ubifs_set_inode_flags(struct inode *inode)
  35 {
  36         unsigned int flags = ubifs_inode(inode)->flags;
  37
  38         inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC |
  39                             S_ENCRYPTED);
  40         if (flags & UBIFS_SYNC_FL)
  41                 inode->i_flags |= S_SYNC;
  42         if (flags & UBIFS_APPEND_FL)
  43                 inode->i_flags |= S_APPEND;
  44         if (flags & UBIFS_IMMUTABLE_FL)
  45                 inode->i_flags |= S_IMMUTABLE;
  46         if (flags & UBIFS_DIRSYNC_FL)
  47                 inode->i_flags |= S_DIRSYNC;
  48         if (flags & UBIFS_CRYPT_FL)
  49                 inode->i_flags |= S_ENCRYPTED;
  50 }
  51
  52 /*
  53  * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
  54  * @ioctl_flags: flags to convert
  55  *
  56  * This function converts ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
  57  * (@UBIFS_COMPR_FL, etc).
  58  */
  59 static int ioctl2ubifs(int ioctl_flags)
  60 {
  61         int ubifs_flags = 0;
  62
  63         if (ioctl_flags & FS_COMPR_FL)
  64                 ubifs_flags |= UBIFS_COMPR_FL;
  65         if (ioctl_flags & FS_SYNC_FL)
  66                 ubifs_flags |= UBIFS_SYNC_FL;
  67         if (ioctl_flags & FS_APPEND_FL)
  68                 ubifs_flags |= UBIFS_APPEND_FL;
  69         if (ioctl_flags & FS_IMMUTABLE_FL)
  70                 ubifs_flags |= UBIFS_IMMUTABLE_FL;
  71         if (ioctl_flags & FS_DIRSYNC_FL)
  72                 ubifs_flags |= UBIFS_DIRSYNC_FL;
  73
  74         return ubifs_flags;
  75 }
  76
  77 /*
  78  * ubifs2ioctl - convert UBIFS inode flags to ioctl inode flags.
  79  * @ubifs_flags: flags to convert
  80  *
  81  * This function converts UBIFS inode flags (@UBIFS_COMPR_FL, etc) to ioctl
  82  * flags (@FS_COMPR_FL, etc).
  83  */
  84 static int ubifs2ioctl(int ubifs_flags)
  85 {
  86         int ioctl_flags = 0;
  87
  88         if (ubifs_flags & UBIFS_COMPR_FL)
  89                 ioctl_flags |= FS_COMPR_FL;
  90         if (ubifs_flags & UBIFS_SYNC_FL)
  91                 ioctl_flags |= FS_SYNC_FL;
  92         if (ubifs_flags & UBIFS_APPEND_FL)
  93                 ioctl_flags |= FS_APPEND_FL;
  94         if (ubifs_flags & UBIFS_IMMUTABLE_FL)
  95                 ioctl_flags |= FS_IMMUTABLE_FL;
  96         if (ubifs_flags & UBIFS_DIRSYNC_FL)
  97                 ioctl_flags |= FS_DIRSYNC_FL;
  98         if (ubifs_flags & UBIFS_CRYPT_FL)
  99                 ioctl_flags |= FS_ENCRYPT_FL;
 100
 101         return ioctl_flags;
 102 }
 103
 104 static int setflags(struct inode *inode, int flags)
 105 {
 106         int oldflags, err, release;
 107         struct ubifs_inode *ui = ubifs_inode(inode);
 108         struct ubifs_info *c = inode->i_sb->s_fs_info;
 109         struct ubifs_budget_req req = { .dirtied_ino = 1,
 110                                         .dirtied_ino_d = ui->data_len };
 111
 112         err = ubifs_budget_space(c, &req);
 113         if (err)
 114                 return err;
 115
 116         mutex_lock(&ui->ui_mutex);
 117         oldflags = ubifs2ioctl(ui->flags);
 118         err = vfs_ioc_setflags_prepare(inode, oldflags, flags);
 119         if (err)
 120                 goto out_unlock;
 121
 122         ui->flags &= ~ioctl2ubifs(UBIFS_SETTABLE_IOCTL_FLAGS);
 123         ui->flags |= ioctl2ubifs(flags);
 124         ubifs_set_inode_flags(inode);
 125         inode->i_ctime = current_time(inode);
 126         release = ui->dirty;
 127         mark_inode_dirty_sync(inode);
 128         mutex_unlock(&ui->ui_mutex);
 129
 130         if (release)
 131                 ubifs_release_budget(c, &req);
 132         if (IS_SYNC(inode))
 133                 err = write_inode_now(inode, 1);
 134         return err;
 135
 136 out_unlock:
 137         mutex_unlock(&ui->ui_mutex);
 138         ubifs_release_budget(c, &req);
 139         return err;
 140 }
 141
 142 long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 143 {
 144         int flags, err;
 145         struct inode *inode = file_inode(file);
 146
 147         switch (cmd) {
 148         case FS_IOC_GETFLAGS:
 149                 flags = ubifs2ioctl(ubifs_inode(inode)->flags);
 150
 151                 dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
 152                 return put_user(flags, (int __user *) arg);
 153
 154         case FS_IOC_SETFLAGS: {
 155                 if (IS_RDONLY(inode))
 156                         return -EROFS;
 157
 158                 if (!inode_owner_or_capable(inode))
 159                         return -EACCES;
 160
 161                 if (get_user(flags, (int __user *) arg))
 162                         return -EFAULT;
 163
 164                 if (flags & ~UBIFS_GETTABLE_IOCTL_FLAGS)
 165                         return -EOPNOTSUPP;
 166                 flags &= UBIFS_SETTABLE_IOCTL_FLAGS;
 167
 168                 if (!S_ISDIR(inode->i_mode))
 169                         flags &= ~FS_DIRSYNC_FL;
 170
 171                 /*
 172                  * Make sure the file-system is read-write and make sure it
 173                  * will not become read-only while we are changing the flags.
 174                  */
 175                 err = mnt_want_write_file(file);
 176                 if (err)
 177                         return err;
 178                 dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
 179                 err = setflags(inode, flags);
 180                 mnt_drop_write_file(file);
 181                 return err;
 182         }
 183         case FS_IOC_SET_ENCRYPTION_POLICY: {
 184                 struct ubifs_info *c = inode->i_sb->s_fs_info;
 185
 186                 err = ubifs_enable_encryption(c);
 187                 if (err)
 188                         return err;
 189
 190                 return fscrypt_ioctl_set_policy(file, (const void __user *)arg);
 191         }
 192         case FS_IOC_GET_ENCRYPTION_POLICY:
 193                 return fscrypt_ioctl_get_policy(file, (void __user *)arg);
 194
 195         case FS_IOC_GET_ENCRYPTION_POLICY_EX:
 196                 return fscrypt_ioctl_get_policy_ex(file, (void __user *)arg);
 197
 198         case FS_IOC_ADD_ENCRYPTION_KEY:
 199                 return fscrypt_ioctl_add_key(file, (void __user *)arg);
 200
 201         case FS_IOC_REMOVE_ENCRYPTION_KEY:
 202                 return fscrypt_ioctl_remove_key(file, (void __user *)arg);
 203
 204         case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
 205                 return fscrypt_ioctl_remove_key_all_users(file,
 206                                                           (void __user *)arg);
 207         case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
 208                 return fscrypt_ioctl_get_key_status(file, (void __user *)arg);
 209
 210         case FS_IOC_GET_ENCRYPTION_NONCE:
 211                 return fscrypt_ioctl_get_nonce(file, (void __user *)arg);
 212
 213         default:
 214                 return -ENOTTY;
 215         }
 216 }
 217
 218 #ifdef CONFIG_COMPAT
 219 long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 220 {
 221         switch (cmd) {
 222         case FS_IOC32_GETFLAGS:
 223                 cmd = FS_IOC_GETFLAGS;
 224                 break;
 225         case FS_IOC32_SETFLAGS:
 226                 cmd = FS_IOC_SETFLAGS;
 227                 break;
 228         case FS_IOC_SET_ENCRYPTION_POLICY:
 229         case FS_IOC_GET_ENCRYPTION_POLICY:
 230         case FS_IOC_GET_ENCRYPTION_POLICY_EX:
 231         case FS_IOC_ADD_ENCRYPTION_KEY:
 232         case FS_IOC_REMOVE_ENCRYPTION_KEY:
 233         case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS:
 234         case FS_IOC_GET_ENCRYPTION_KEY_STATUS:
 235         case FS_IOC_GET_ENCRYPTION_NONCE:
 236                 break;
 237         default:
 238                 return -ENOIOCTLCMD;
 239         }
 240         return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
 241 }
 242 #endif