Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / 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
25 #include <linux/ext2_fs.h>
26
27 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
28 {
29         int status;
30
31         status = ocfs2_inode_lock(inode, NULL, 0);
32         if (status < 0) {
33                 mlog_errno(status);
34                 return status;
35         }
36         ocfs2_get_inode_flags(OCFS2_I(inode));
37         *flags = OCFS2_I(inode)->ip_attr;
38         ocfs2_inode_unlock(inode, 0);
39
40         mlog_exit(status);
41         return status;
42 }
43
44 static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
45                                 unsigned mask)
46 {
47         struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode);
48         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
49         handle_t *handle = NULL;
50         struct buffer_head *bh = NULL;
51         unsigned oldflags;
52         int status;
53
54         mutex_lock(&inode->i_mutex);
55
56         status = ocfs2_inode_lock(inode, &bh, 1);
57         if (status < 0) {
58                 mlog_errno(status);
59                 goto bail;
60         }
61
62         status = -EROFS;
63         if (IS_RDONLY(inode))
64                 goto bail_unlock;
65
66         status = -EACCES;
67         if (!is_owner_or_cap(inode))
68                 goto bail_unlock;
69
70         if (!S_ISDIR(inode->i_mode))
71                 flags &= ~OCFS2_DIRSYNC_FL;
72
73         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
74         if (IS_ERR(handle)) {
75                 status = PTR_ERR(handle);
76                 mlog_errno(status);
77                 goto bail_unlock;
78         }
79
80         oldflags = ocfs2_inode->ip_attr;
81         flags = flags & mask;
82         flags |= oldflags & ~mask;
83
84         /*
85          * The IMMUTABLE and APPEND_ONLY flags can only be changed by
86          * the relevant capability.
87          */
88         status = -EPERM;
89         if ((oldflags & OCFS2_IMMUTABLE_FL) || ((flags ^ oldflags) &
90                 (OCFS2_APPEND_FL | OCFS2_IMMUTABLE_FL))) {
91                 if (!capable(CAP_LINUX_IMMUTABLE))
92                         goto bail_unlock;
93         }
94
95         ocfs2_inode->ip_attr = flags;
96         ocfs2_set_inode_flags(inode);
97
98         status = ocfs2_mark_inode_dirty(handle, inode, bh);
99         if (status < 0)
100                 mlog_errno(status);
101
102         ocfs2_commit_trans(osb, handle);
103 bail_unlock:
104         ocfs2_inode_unlock(inode, 1);
105 bail:
106         mutex_unlock(&inode->i_mutex);
107
108         if (bh)
109                 brelse(bh);
110
111         mlog_exit(status);
112         return status;
113 }
114
115 int ocfs2_ioctl(struct inode * inode, struct file * filp,
116         unsigned int cmd, unsigned long arg)
117 {
118         unsigned int flags;
119         int new_clusters;
120         int status;
121         struct ocfs2_space_resv sr;
122         struct ocfs2_new_group_input input;
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                 return ocfs2_set_inode_attr(inode, flags,
137                         OCFS2_FL_MODIFIABLE);
138         case OCFS2_IOC_RESVSP:
139         case OCFS2_IOC_RESVSP64:
140         case OCFS2_IOC_UNRESVSP:
141         case OCFS2_IOC_UNRESVSP64:
142                 if (copy_from_user(&sr, (int __user *) arg, sizeof(sr)))
143                         return -EFAULT;
144
145                 return ocfs2_change_file_space(filp, cmd, &sr);
146         case OCFS2_IOC_GROUP_EXTEND:
147                 if (!capable(CAP_SYS_RESOURCE))
148                         return -EPERM;
149
150                 if (get_user(new_clusters, (int __user *)arg))
151                         return -EFAULT;
152
153                 return ocfs2_group_extend(inode, new_clusters);
154         case OCFS2_IOC_GROUP_ADD:
155         case OCFS2_IOC_GROUP_ADD64:
156                 if (!capable(CAP_SYS_RESOURCE))
157                         return -EPERM;
158
159                 if (copy_from_user(&input, (int __user *) arg, sizeof(input)))
160                         return -EFAULT;
161
162                 return ocfs2_group_add(inode, &input);
163         default:
164                 return -ENOTTY;
165         }
166 }
167
168 #ifdef CONFIG_COMPAT
169 long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
170 {
171         struct inode *inode = file->f_path.dentry->d_inode;
172         int ret;
173
174         switch (cmd) {
175         case OCFS2_IOC32_GETFLAGS:
176                 cmd = OCFS2_IOC_GETFLAGS;
177                 break;
178         case OCFS2_IOC32_SETFLAGS:
179                 cmd = OCFS2_IOC_SETFLAGS;
180                 break;
181         case OCFS2_IOC_RESVSP:
182         case OCFS2_IOC_RESVSP64:
183         case OCFS2_IOC_UNRESVSP:
184         case OCFS2_IOC_UNRESVSP64:
185         case OCFS2_IOC_GROUP_EXTEND:
186         case OCFS2_IOC_GROUP_ADD:
187         case OCFS2_IOC_GROUP_ADD64:
188                 break;
189         default:
190                 return -ENOIOCTLCMD;
191         }
192
193         lock_kernel();
194         ret = ocfs2_ioctl(inode, file, cmd, arg);
195         unlock_kernel();
196         return ret;
197 }
198 #endif