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