fs/ocfs2/ioctl.c

   1 /*
   2  * linux/fs/ocfs2/ioctl.c
   3  *
   4  * Copyright (C) 2006 Herbert Poetzl
   5  * adapted from Remy Card's ext2/ioctl.c
   6  */
   7
   8 #include <linux/fs.h>
   9 #include <linux/mount.h>
  10
  11 #define MLOG_MASK_PREFIX ML_INODE
  12 #include <cluster/masklog.h>
  13
  14 #include "ocfs2.h"
  15 #include "alloc.h"
  16 #include "dlmglue.h"
  17 #include "file.h"
  18 #include "inode.h"
  19 #include "journal.h"
  20
  21 #include "ocfs2_fs.h"
  22 #include "ioctl.h"
  23 #include "resize.h"
  24 #include "refcounttree.h"
  25
  26 #include <linux/ext2_fs.h>
  27
  28 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
  29 {
  30         int status;
  31
  32         status = ocfs2_inode_lock(inode, NULL, 0);
  33         if (status < 0) {
  34                 mlog_errno(status);
  35                 return status;
  36         }
  37         ocfs2_get_inode_flags(OCFS2_I(inode));
  38         *flags = OCFS2_I(inode)->ip_attr;
  39         ocfs2_inode_unlock(inode, 0);
  40
  41         mlog_exit(status);
  42         return status;
  43 }
  44
  45 static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
  46                                 unsigned mask)
  47 {
  48         struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode);
  49         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
  50         handle_t *handle = NULL;
  51         struct buffer_head *bh = NULL;
  52         unsigned oldflags;
  53         int status;
  54
  55         mutex_lock(&inode->i_mutex);
  56
  57         status = ocfs2_inode_lock(inode, &bh, 1);
  58         if (status < 0) {
  59                 mlog_errno(status);
  60                 goto bail;
  61         }
  62
  63         status = -EACCES;
  64         if (!is_owner_or_cap(inode))
  65                 goto bail_unlock;
  66
  67         if (!S_ISDIR(inode->i_mode))
  68                 flags &= ~OCFS2_DIRSYNC_FL;
  69
  70         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
  71         if (IS_ERR(handle)) {
  72                 status = PTR_ERR(handle);
  73                 mlog_errno(status);
  74                 goto bail_unlock;
  75         }
  76
  77         oldflags = ocfs2_inode->ip_attr;
  78         flags = flags & mask;
  79         flags |= oldflags & ~mask;
  80
  81         /*
  82          * The IMMUTABLE and APPEND_ONLY flags can only be changed by
  83          * the relevant capability.
  84          */
  85         status = -EPERM;
  86         if ((oldflags & OCFS2_IMMUTABLE_FL) || ((flags ^ oldflags) &
  87                 (OCFS2_APPEND_FL | OCFS2_IMMUTABLE_FL))) {
  88                 if (!capable(CAP_LINUX_IMMUTABLE))
  89                         goto bail_unlock;
  90         }
  91
  92         ocfs2_inode->ip_attr = flags;
  93         ocfs2_set_inode_flags(inode);
  94
  95         status = ocfs2_mark_inode_dirty(handle, inode, bh);
  96         if (status < 0)
  97                 mlog_errno(status);
  98
  99         ocfs2_commit_trans(osb, handle);
 100 bail_unlock:
 101         ocfs2_inode_unlock(inode, 1);
 102 bail:
 103         mutex_unlock(&inode->i_mutex);
 104
 105         brelse(bh);
 106
 107         mlog_exit(status);
 108         return status;
 109 }
 110
 111 long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 112 {
 113         struct inode *inode = filp->f_path.dentry->d_inode;
 114         unsigned int flags;
 115         int new_clusters;
 116         int status;
 117         struct ocfs2_space_resv sr;
 118         struct ocfs2_new_group_input input;
 119         struct reflink_arguments args;
 120         const char *old_path, *new_path;
 121         bool preserve;
 122
 123         switch (cmd) {
 124         case OCFS2_IOC_GETFLAGS:
 125                 status = ocfs2_get_inode_attr(inode, &flags);
 126                 if (status < 0)
 127                         return status;
 128
 129                 flags &= OCFS2_FL_VISIBLE;
 130                 return put_user(flags, (int __user *) arg);
 131         case OCFS2_IOC_SETFLAGS:
 132                 if (get_user(flags, (int __user *) arg))
 133                         return -EFAULT;
 134
 135                 status = mnt_want_write(filp->f_path.mnt);
 136                 if (status)
 137                         return status;
 138                 status = ocfs2_set_inode_attr(inode, flags,
 139                         OCFS2_FL_MODIFIABLE);
 140                 mnt_drop_write(filp->f_path.mnt);
 141                 return status;
 142         case OCFS2_IOC_RESVSP:
 143         case OCFS2_IOC_RESVSP64:
 144         case OCFS2_IOC_UNRESVSP:
 145         case OCFS2_IOC_UNRESVSP64:
 146                 if (copy_from_user(&sr, (int __user *) arg, sizeof(sr)))
 147                         return -EFAULT;
 148
 149                 return ocfs2_change_file_space(filp, cmd, &sr);
 150         case OCFS2_IOC_GROUP_EXTEND:
 151                 if (!capable(CAP_SYS_RESOURCE))
 152                         return -EPERM;
 153
 154                 if (get_user(new_clusters, (int __user *)arg))
 155                         return -EFAULT;
 156
 157                 return ocfs2_group_extend(inode, new_clusters);
 158         case OCFS2_IOC_GROUP_ADD:
 159         case OCFS2_IOC_GROUP_ADD64:
 160                 if (!capable(CAP_SYS_RESOURCE))
 161                         return -EPERM;
 162
 163                 if (copy_from_user(&input, (int __user *) arg, sizeof(input)))
 164                         return -EFAULT;
 165
 166                 return ocfs2_group_add(inode, &input);
 167         case OCFS2_IOC_REFLINK:
 168                 if (copy_from_user(&args, (struct reflink_arguments *)arg,
 169                                    sizeof(args)))
 170                         return -EFAULT;
 171                 old_path = (const char *)(unsigned long)args.old_path;
 172                 new_path = (const char *)(unsigned long)args.new_path;
 173                 preserve = (args.preserve != 0);
 174
 175                 return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve);
 176         default:
 177                 return -ENOTTY;
 178         }
 179 }
 180
 181 #ifdef CONFIG_COMPAT
 182 long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 183 {
 184         switch (cmd) {
 185         case OCFS2_IOC32_GETFLAGS:
 186                 cmd = OCFS2_IOC_GETFLAGS;
 187                 break;
 188         case OCFS2_IOC32_SETFLAGS:
 189                 cmd = OCFS2_IOC_SETFLAGS;
 190                 break;
 191         case OCFS2_IOC_RESVSP:
 192         case OCFS2_IOC_RESVSP64:
 193         case OCFS2_IOC_UNRESVSP:
 194         case OCFS2_IOC_UNRESVSP64:
 195         case OCFS2_IOC_GROUP_EXTEND:
 196         case OCFS2_IOC_GROUP_ADD:
 197         case OCFS2_IOC_GROUP_ADD64:
 198         case OCFS2_IOC_REFLINK:
 199                 break;
 200         default:
 201                 return -ENOIOCTLCMD;
 202         }
 203
 204         return ocfs2_ioctl(file, cmd, arg);
 205 }
 206 #endif