ocfs2/trivial: Remove trailing whitespaces
[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
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