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/smp_lock.h>
  29 #include <linux/mount.h>
  30 #include "ubifs.h"
  31
  32 /**
  33  * ubifs_set_inode_flags - set VFS inode flags.
  34  * @inode: VFS inode to set flags for
  35  *
  36  * This function propagates flags from UBIFS inode object to VFS inode object.
  37  */
  38 void ubifs_set_inode_flags(struct inode *inode)
  39 {
  40         unsigned int flags = ubifs_inode(inode)->flags;
  41
  42         inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC);
  43         if (flags & UBIFS_SYNC_FL)
  44                 inode->i_flags |= S_SYNC;
  45         if (flags & UBIFS_APPEND_FL)
  46                 inode->i_flags |= S_APPEND;
  47         if (flags & UBIFS_IMMUTABLE_FL)
  48                 inode->i_flags |= S_IMMUTABLE;
  49         if (flags & UBIFS_DIRSYNC_FL)
  50                 inode->i_flags |= S_DIRSYNC;
  51 }
  52
  53 /*
  54  * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
  55  * @ioctl_flags: flags to convert
  56  *
  57  * This function convert ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
  58  * (@UBIFS_COMPR_FL, etc).
  59  */
  60 static int ioctl2ubifs(int ioctl_flags)
  61 {
  62         int ubifs_flags = 0;
  63
  64         if (ioctl_flags & FS_COMPR_FL)
  65                 ubifs_flags |= UBIFS_COMPR_FL;
  66         if (ioctl_flags & FS_SYNC_FL)
  67                 ubifs_flags |= UBIFS_SYNC_FL;
  68         if (ioctl_flags & FS_APPEND_FL)
  69                 ubifs_flags |= UBIFS_APPEND_FL;
  70         if (ioctl_flags & FS_IMMUTABLE_FL)
  71                 ubifs_flags |= UBIFS_IMMUTABLE_FL;
  72         if (ioctl_flags & FS_DIRSYNC_FL)
  73                 ubifs_flags |= UBIFS_DIRSYNC_FL;
  74
  75         return ubifs_flags;
  76 }
  77
  78 /*
  79  * ubifs2ioctl - convert UBIFS inode flags to ioctl inode flags.
  80  * @ubifs_flags: flags to convert
  81  *
  82  * This function convert UBIFS (@UBIFS_COMPR_FL, etc) to ioctl flags
  83  * (@FS_COMPR_FL, etc).
  84  */
  85 static int ubifs2ioctl(int ubifs_flags)
  86 {
  87         int ioctl_flags = 0;
  88
  89         if (ubifs_flags & UBIFS_COMPR_FL)
  90                 ioctl_flags |= FS_COMPR_FL;
  91         if (ubifs_flags & UBIFS_SYNC_FL)
  92                 ioctl_flags |= FS_SYNC_FL;
  93         if (ubifs_flags & UBIFS_APPEND_FL)
  94                 ioctl_flags |= FS_APPEND_FL;
  95         if (ubifs_flags & UBIFS_IMMUTABLE_FL)
  96                 ioctl_flags |= FS_IMMUTABLE_FL;
  97         if (ubifs_flags & UBIFS_DIRSYNC_FL)
  98                 ioctl_flags |= FS_DIRSYNC_FL;
  99
 100         return ioctl_flags;
 101 }
 102
 103 static int setflags(struct inode *inode, int flags)
 104 {
 105         int oldflags, err, release;
 106         struct ubifs_inode *ui = ubifs_inode(inode);
 107         struct ubifs_info *c = inode->i_sb->s_fs_info;
 108         struct ubifs_budget_req req = { .dirtied_ino = 1,
 109                                         .dirtied_ino_d = ui->data_len };
 110
 111         err = ubifs_budget_space(c, &req);
 112         if (err)
 113                 return err;
 114
 115         /*
 116          * The IMMUTABLE and APPEND_ONLY flags can only be changed by
 117          * the relevant capability.
 118          */
 119         mutex_lock(&ui->ui_mutex);
 120         oldflags = ubifs2ioctl(ui->flags);
 121         if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
 122                 if (!capable(CAP_LINUX_IMMUTABLE)) {
 123                         err = -EPERM;
 124                         goto out_unlock;
 125                 }
 126         }
 127
 128         ui->flags = ioctl2ubifs(flags);
 129         ubifs_set_inode_flags(inode);
 130         inode->i_ctime = ubifs_current_time(inode);
 131         release = ui->dirty;
 132         mark_inode_dirty_sync(inode);
 133         mutex_unlock(&ui->ui_mutex);
 134
 135         if (release)
 136                 ubifs_release_budget(c, &req);
 137         if (IS_SYNC(inode))
 138                 err = write_inode_now(inode, 1);
 139         return err;
 140
 141 out_unlock:
 142         ubifs_err("can't modify inode %lu attributes", inode->i_ino);
 143         mutex_unlock(&ui->ui_mutex);
 144         ubifs_release_budget(c, &req);
 145         return err;
 146 }
 147
 148 long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 149 {
 150         int flags, err;
 151         struct inode *inode = file->f_path.dentry->d_inode;
 152
 153         switch (cmd) {
 154         case FS_IOC_GETFLAGS:
 155                 flags = ubifs2ioctl(ubifs_inode(inode)->flags);
 156
 157                 dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
 158                 return put_user(flags, (int __user *) arg);
 159
 160         case FS_IOC_SETFLAGS: {
 161                 if (IS_RDONLY(inode))
 162                         return -EROFS;
 163
 164                 if (!is_owner_or_cap(inode))
 165                         return -EACCES;
 166
 167                 if (get_user(flags, (int __user *) arg))
 168                         return -EFAULT;
 169
 170                 if (!S_ISDIR(inode->i_mode))
 171                         flags &= ~FS_DIRSYNC_FL;
 172
 173                 /*
 174                  * Make sure the file-system is read-write and make sure it
 175                  * will not become read-only while we are changing the flags.
 176                  */
 177                 err = mnt_want_write(file->f_path.mnt);
 178                 if (err)
 179                         return err;
 180                 dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
 181                 err = setflags(inode, flags);
 182                 mnt_drop_write(file->f_path.mnt);
 183                 return err;
 184         }
 185
 186         default:
 187                 return -ENOTTY;
 188         }
 189 }
 190
 191 #ifdef CONFIG_COMPAT
 192 long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 193 {
 194         switch (cmd) {
 195         case FS_IOC32_GETFLAGS:
 196                 cmd = FS_IOC_GETFLAGS;
 197                 break;
 198         case FS_IOC32_SETFLAGS:
 199                 cmd = FS_IOC_SETFLAGS;
 200                 break;
 201         default:
 202                 return -ENOIOCTLCMD;
 203         }
 204         return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
 205 }
 206 #endif