fs/ubifs/ioctl.c

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