a6d962323790c71795b2c1c1f0a8c5660ec286c1
[muen/linux.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 "rgrp.h"
28 #include "trans.h"
29 #include "util.h"
30
31 static const char *gfs2_acl_name(int type)
32 {
33         switch (type) {
34         case ACL_TYPE_ACCESS:
35                 return XATTR_POSIX_ACL_ACCESS;
36         case ACL_TYPE_DEFAULT:
37                 return XATTR_POSIX_ACL_DEFAULT;
38         }
39         return NULL;
40 }
41
42 static struct posix_acl *__gfs2_get_acl(struct inode *inode, int type)
43 {
44         struct gfs2_inode *ip = GFS2_I(inode);
45         struct posix_acl *acl;
46         const char *name;
47         char *data;
48         int len;
49
50         if (!ip->i_eattr)
51                 return NULL;
52
53         name = gfs2_acl_name(type);
54         len = gfs2_xattr_acl_get(ip, name, &data);
55         if (len <= 0)
56                 return ERR_PTR(len);
57         acl = posix_acl_from_xattr(&init_user_ns, data, len);
58         kfree(data);
59         return acl;
60 }
61
62 struct posix_acl *gfs2_get_acl(struct inode *inode, int type)
63 {
64         struct gfs2_inode *ip = GFS2_I(inode);
65         struct gfs2_holder gh;
66         bool need_unlock = false;
67         struct posix_acl *acl;
68
69         if (!gfs2_glock_is_locked_by_me(ip->i_gl)) {
70                 int ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
71                                              LM_FLAG_ANY, &gh);
72                 if (ret)
73                         return ERR_PTR(ret);
74                 need_unlock = true;
75         }
76         acl = __gfs2_get_acl(inode, type);
77         if (need_unlock)
78                 gfs2_glock_dq_uninit(&gh);
79         return acl;
80 }
81
82 int __gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
83 {
84         int error;
85         int len;
86         char *data;
87         const char *name = gfs2_acl_name(type);
88
89         if (acl) {
90                 len = posix_acl_to_xattr(&init_user_ns, acl, NULL, 0);
91                 if (len == 0)
92                         return 0;
93                 data = kmalloc(len, GFP_NOFS);
94                 if (data == NULL)
95                         return -ENOMEM;
96                 error = posix_acl_to_xattr(&init_user_ns, acl, data, len);
97                 if (error < 0)
98                         goto out;
99         } else {
100                 data = NULL;
101                 len = 0;
102         }
103
104         error = __gfs2_xattr_set(inode, name, data, len, 0, GFS2_EATYPE_SYS);
105         if (error)
106                 goto out;
107         set_cached_acl(inode, type, acl);
108 out:
109         kfree(data);
110         return error;
111 }
112
113 int gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
114 {
115         struct gfs2_inode *ip = GFS2_I(inode);
116         struct gfs2_holder gh;
117         bool need_unlock = false;
118         int ret;
119
120         if (acl && acl->a_count > GFS2_ACL_MAX_ENTRIES(GFS2_SB(inode)))
121                 return -E2BIG;
122
123         ret = gfs2_rsqa_alloc(ip);
124         if (ret)
125                 return ret;
126
127         if (!gfs2_glock_is_locked_by_me(ip->i_gl)) {
128                 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
129                 if (ret)
130                         return ret;
131                 need_unlock = true;
132         }
133         if (type == ACL_TYPE_ACCESS && acl) {
134                 umode_t mode = inode->i_mode;
135
136                 ret = posix_acl_update_mode(inode, &inode->i_mode, &acl);
137                 if (ret)
138                         goto unlock;
139                 if (mode != inode->i_mode)
140                         mark_inode_dirty(inode);
141         }
142
143         ret = __gfs2_set_acl(inode, acl, type);
144 unlock:
145         if (need_unlock)
146                 gfs2_glock_dq_uninit(&gh);
147         return ret;
148 }