Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland...
[linux-2.6.git] / fs / gfs2 / acl.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/xattr.h>
16 #include <linux/posix_acl.h>
17 #include <linux/posix_acl_xattr.h>
18 #include <linux/gfs2_ondisk.h>
19
20 #include "gfs2.h"
21 #include "incore.h"
22 #include "acl.h"
23 #include "xattr.h"
24 #include "glock.h"
25 #include "inode.h"
26 #include "meta_io.h"
27 #include "trans.h"
28 #include "util.h"
29
30 static const char *gfs2_acl_name(int type)
31 {
32         switch (type) {
33         case ACL_TYPE_ACCESS:
34                 return GFS2_POSIX_ACL_ACCESS;
35         case ACL_TYPE_DEFAULT:
36                 return GFS2_POSIX_ACL_DEFAULT;
37         }
38         return NULL;
39 }
40
41 struct posix_acl *gfs2_get_acl(struct inode *inode, int type)
42 {
43         struct gfs2_inode *ip = GFS2_I(inode);
44         struct posix_acl *acl;
45         const char *name;
46         char *data;
47         int len;
48
49         if (!ip->i_eattr)
50                 return NULL;
51
52         acl = get_cached_acl(&ip->i_inode, type);
53         if (acl != ACL_NOT_CACHED)
54                 return acl;
55
56         name = gfs2_acl_name(type);
57         if (name == NULL)
58                 return ERR_PTR(-EINVAL);
59
60         len = gfs2_xattr_acl_get(ip, name, &data);
61         if (len < 0)
62                 return ERR_PTR(len);
63         if (len == 0)
64                 return NULL;
65
66         acl = posix_acl_from_xattr(data, len);
67         kfree(data);
68         return acl;
69 }
70
71 static int gfs2_set_mode(struct inode *inode, umode_t mode)
72 {
73         int error = 0;
74
75         if (mode != inode->i_mode) {
76                 struct iattr iattr;
77
78                 iattr.ia_valid = ATTR_MODE;
79                 iattr.ia_mode = mode;
80
81                 error = gfs2_setattr_simple(inode, &iattr);
82         }
83
84         return error;
85 }
86
87 static int gfs2_acl_set(struct inode *inode, int type, struct posix_acl *acl)
88 {
89         int error;
90         int len;
91         char *data;
92         const char *name = gfs2_acl_name(type);
93
94         BUG_ON(name == NULL);
95         len = posix_acl_to_xattr(acl, NULL, 0);
96         if (len == 0)
97                 return 0;
98         data = kmalloc(len, GFP_NOFS);
99         if (data == NULL)
100                 return -ENOMEM;
101         error = posix_acl_to_xattr(acl, data, len);
102         if (error < 0)
103                 goto out;
104         error = __gfs2_xattr_set(inode, name, data, len, 0, GFS2_EATYPE_SYS);
105         if (!error)
106                 set_cached_acl(inode, type, acl);
107 out:
108         kfree(data);
109         return error;
110 }
111
112 int gfs2_acl_create(struct gfs2_inode *dip, struct inode *inode)
113 {
114         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
115         struct posix_acl *acl;
116         umode_t mode = inode->i_mode;
117         int error = 0;
118
119         if (!sdp->sd_args.ar_posix_acl)
120                 return 0;
121         if (S_ISLNK(inode->i_mode))
122                 return 0;
123
124         acl = gfs2_get_acl(&dip->i_inode, ACL_TYPE_DEFAULT);
125         if (IS_ERR(acl))
126                 return PTR_ERR(acl);
127         if (!acl) {
128                 mode &= ~current_umask();
129                 if (mode != inode->i_mode)
130                         error = gfs2_set_mode(inode, mode);
131                 return error;
132         }
133
134         if (S_ISDIR(inode->i_mode)) {
135                 error = gfs2_acl_set(inode, ACL_TYPE_DEFAULT, acl);
136                 if (error)
137                         goto out;
138         }
139
140         error = posix_acl_create(&acl, GFP_NOFS, &mode);
141         if (error < 0)
142                 return error;
143
144         if (error == 0)
145                 goto munge;
146
147         error = gfs2_acl_set(inode, ACL_TYPE_ACCESS, acl);
148         if (error)
149                 goto out;
150 munge:
151         error = gfs2_set_mode(inode, mode);
152 out:
153         posix_acl_release(acl);
154         return error;
155 }
156
157 int gfs2_acl_chmod(struct gfs2_inode *ip, struct iattr *attr)
158 {
159         struct inode *inode = &ip->i_inode;
160         struct posix_acl *acl;
161         char *data;
162         unsigned int len;
163         int error;
164
165         acl = gfs2_get_acl(&ip->i_inode, ACL_TYPE_ACCESS);
166         if (IS_ERR(acl))
167                 return PTR_ERR(acl);
168         if (!acl)
169                 return gfs2_setattr_simple(inode, attr);
170
171         error = posix_acl_chmod(&acl, GFP_NOFS, attr->ia_mode);
172         if (error)
173                 return error;
174
175         len = posix_acl_to_xattr(acl, NULL, 0);
176         data = kmalloc(len, GFP_NOFS);
177         error = -ENOMEM;
178         if (data == NULL)
179                 goto out;
180         posix_acl_to_xattr(acl, data, len);
181         error = gfs2_xattr_acl_chmod(ip, attr, data);
182         kfree(data);
183         set_cached_acl(&ip->i_inode, ACL_TYPE_ACCESS, acl);
184
185 out:
186         posix_acl_release(acl);
187         return error;
188 }
189
190 static int gfs2_acl_type(const char *name)
191 {
192         if (strcmp(name, GFS2_POSIX_ACL_ACCESS) == 0)
193                 return ACL_TYPE_ACCESS;
194         if (strcmp(name, GFS2_POSIX_ACL_DEFAULT) == 0)
195                 return ACL_TYPE_DEFAULT;
196         return -EINVAL;
197 }
198
199 static int gfs2_xattr_system_get(struct dentry *dentry, const char *name,
200                                  void *buffer, size_t size, int xtype)
201 {
202         struct inode *inode = dentry->d_inode;
203         struct gfs2_sbd *sdp = GFS2_SB(inode);
204         struct posix_acl *acl;
205         int type;
206         int error;
207
208         if (!sdp->sd_args.ar_posix_acl)
209                 return -EOPNOTSUPP;
210
211         type = gfs2_acl_type(name);
212         if (type < 0)
213                 return type;
214
215         acl = gfs2_get_acl(inode, type);
216         if (IS_ERR(acl))
217                 return PTR_ERR(acl);
218         if (acl == NULL)
219                 return -ENODATA;
220
221         error = posix_acl_to_xattr(acl, buffer, size);
222         posix_acl_release(acl);
223
224         return error;
225 }
226
227 static int gfs2_xattr_system_set(struct dentry *dentry, const char *name,
228                                  const void *value, size_t size, int flags,
229                                  int xtype)
230 {
231         struct inode *inode = dentry->d_inode;
232         struct gfs2_sbd *sdp = GFS2_SB(inode);
233         struct posix_acl *acl = NULL;
234         int error = 0, type;
235
236         if (!sdp->sd_args.ar_posix_acl)
237                 return -EOPNOTSUPP;
238
239         type = gfs2_acl_type(name);
240         if (type < 0)
241                 return type;
242         if (flags & XATTR_CREATE)
243                 return -EINVAL;
244         if (type == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode))
245                 return value ? -EACCES : 0;
246         if ((current_fsuid() != inode->i_uid) && !capable(CAP_FOWNER))
247                 return -EPERM;
248         if (S_ISLNK(inode->i_mode))
249                 return -EOPNOTSUPP;
250
251         if (!value)
252                 goto set_acl;
253
254         acl = posix_acl_from_xattr(value, size);
255         if (!acl) {
256                 /*
257                  * acl_set_file(3) may request that we set default ACLs with
258                  * zero length -- defend (gracefully) against that here.
259                  */
260                 goto out;
261         }
262         if (IS_ERR(acl)) {
263                 error = PTR_ERR(acl);
264                 goto out;
265         }
266
267         error = posix_acl_valid(acl);
268         if (error)
269                 goto out_release;
270
271         error = -EINVAL;
272         if (acl->a_count > GFS2_ACL_MAX_ENTRIES)
273                 goto out_release;
274
275         if (type == ACL_TYPE_ACCESS) {
276                 umode_t mode = inode->i_mode;
277                 error = posix_acl_equiv_mode(acl, &mode);
278
279                 if (error <= 0) {
280                         posix_acl_release(acl);
281                         acl = NULL;
282
283                         if (error < 0)
284                                 return error;
285                 }
286
287                 error = gfs2_set_mode(inode, mode);
288                 if (error)
289                         goto out_release;
290         }
291
292 set_acl:
293         error = __gfs2_xattr_set(inode, name, value, size, 0, GFS2_EATYPE_SYS);
294         if (!error) {
295                 if (acl)
296                         set_cached_acl(inode, type, acl);
297                 else
298                         forget_cached_acl(inode, type);
299         }
300 out_release:
301         posix_acl_release(acl);
302 out:
303         return error;
304 }
305
306 const struct xattr_handler gfs2_xattr_system_handler = {
307         .prefix = XATTR_SYSTEM_PREFIX,
308         .flags  = GFS2_EATYPE_SYS,
309         .get    = gfs2_xattr_system_get,
310         .set    = gfs2_xattr_system_set,
311 };
312