1/*
2 * mm/shmem_acl.c
3 *
4 * (C) 2005 Andreas Gruenbacher <agruen@suse.de>
5 *
6 * This file is released under the GPL.
7 */
8
9#include <linux/fs.h>
10#include <linux/shmem_fs.h>
11#include <linux/xattr.h>
12#include <linux/generic_acl.h>
13
14/**
15 * shmem_get_acl  -   generic_acl_operations->getacl() operation
16 */
17static struct posix_acl *
18shmem_get_acl(struct inode *inode, int type)
19{
20	struct posix_acl *acl = NULL;
21
22	spin_lock(&inode->i_lock);
23	switch(type) {
24		case ACL_TYPE_ACCESS:
25			acl = posix_acl_dup(SHMEM_I(inode)->i_acl);
26			break;
27
28		case ACL_TYPE_DEFAULT:
29			acl = posix_acl_dup(SHMEM_I(inode)->i_default_acl);
30			break;
31	}
32	spin_unlock(&inode->i_lock);
33
34	return acl;
35}
36
37/**
38 * shmem_set_acl  -   generic_acl_operations->setacl() operation
39 */
40static void
41shmem_set_acl(struct inode *inode, int type, struct posix_acl *acl)
42{
43	struct posix_acl *free = NULL;
44
45	spin_lock(&inode->i_lock);
46	switch(type) {
47		case ACL_TYPE_ACCESS:
48			free = SHMEM_I(inode)->i_acl;
49			SHMEM_I(inode)->i_acl = posix_acl_dup(acl);
50			break;
51
52		case ACL_TYPE_DEFAULT:
53			free = SHMEM_I(inode)->i_default_acl;
54			SHMEM_I(inode)->i_default_acl = posix_acl_dup(acl);
55			break;
56	}
57	spin_unlock(&inode->i_lock);
58	posix_acl_release(free);
59}
60
61struct generic_acl_operations shmem_acl_ops = {
62	.getacl = shmem_get_acl,
63	.setacl = shmem_set_acl,
64};
65
66/**
67 * shmem_list_acl_access, shmem_get_acl_access, shmem_set_acl_access,
68 * shmem_xattr_acl_access_handler  -  plumbing code to implement the
69 * system.posix_acl_access xattr using the generic acl functions.
70 */
71
72static size_t
73shmem_list_acl_access(struct inode *inode, char *list, size_t list_size,
74		      const char *name, size_t name_len)
75{
76	return generic_acl_list(inode, &shmem_acl_ops, ACL_TYPE_ACCESS,
77				list, list_size);
78}
79
80static int
81shmem_get_acl_access(struct inode *inode, const char *name, void *buffer,
82		     size_t size)
83{
84	if (strcmp(name, "") != 0)
85		return -EINVAL;
86	return generic_acl_get(inode, &shmem_acl_ops, ACL_TYPE_ACCESS, buffer,
87			       size);
88}
89
90static int
91shmem_set_acl_access(struct inode *inode, const char *name, const void *value,
92		     size_t size, int flags)
93{
94	if (strcmp(name, "") != 0)
95		return -EINVAL;
96	return generic_acl_set(inode, &shmem_acl_ops, ACL_TYPE_ACCESS, value,
97			       size);
98}
99
100struct xattr_handler shmem_xattr_acl_access_handler = {
101	.prefix = POSIX_ACL_XATTR_ACCESS,
102	.list	= shmem_list_acl_access,
103	.get	= shmem_get_acl_access,
104	.set	= shmem_set_acl_access,
105};
106
107/**
108 * shmem_list_acl_default, shmem_get_acl_default, shmem_set_acl_default,
109 * shmem_xattr_acl_default_handler  -  plumbing code to implement the
110 * system.posix_acl_default xattr using the generic acl functions.
111 */
112
113static size_t
114shmem_list_acl_default(struct inode *inode, char *list, size_t list_size,
115		       const char *name, size_t name_len)
116{
117	return generic_acl_list(inode, &shmem_acl_ops, ACL_TYPE_DEFAULT,
118				list, list_size);
119}
120
121static int
122shmem_get_acl_default(struct inode *inode, const char *name, void *buffer,
123		      size_t size)
124{
125	if (strcmp(name, "") != 0)
126		return -EINVAL;
127	return generic_acl_get(inode, &shmem_acl_ops, ACL_TYPE_DEFAULT, buffer,
128			       size);
129}
130
131static int
132shmem_set_acl_default(struct inode *inode, const char *name, const void *value,
133		      size_t size, int flags)
134{
135	if (strcmp(name, "") != 0)
136		return -EINVAL;
137	return generic_acl_set(inode, &shmem_acl_ops, ACL_TYPE_DEFAULT, value,
138			       size);
139}
140
141struct xattr_handler shmem_xattr_acl_default_handler = {
142	.prefix = POSIX_ACL_XATTR_DEFAULT,
143	.list	= shmem_list_acl_default,
144	.get	= shmem_get_acl_default,
145	.set	= shmem_set_acl_default,
146};
147
148/**
149 * shmem_acl_init  -  Inizialize the acl(s) of a new inode
150 */
151int
152shmem_acl_init(struct inode *inode, struct inode *dir)
153{
154	return generic_acl_init(inode, dir, &shmem_acl_ops);
155}
156
157/**
158 * shmem_acl_destroy_inode  -  destroy acls hanging off the in-memory inode
159 *
160 * This is done before destroying the actual inode.
161 */
162
163void
164shmem_acl_destroy_inode(struct inode *inode)
165{
166	if (SHMEM_I(inode)->i_acl)
167		posix_acl_release(SHMEM_I(inode)->i_acl);
168	SHMEM_I(inode)->i_acl = NULL;
169	if (SHMEM_I(inode)->i_default_acl)
170		posix_acl_release(SHMEM_I(inode)->i_default_acl);
171	SHMEM_I(inode)->i_default_acl = NULL;
172}
173
174/**
175 * shmem_check_acl  -  check_acl() callback for generic_permission()
176 */
177static int
178shmem_check_acl(struct inode *inode, int mask)
179{
180	struct posix_acl *acl = shmem_get_acl(inode, ACL_TYPE_ACCESS);
181
182	if (acl) {
183		int error = posix_acl_permission(inode, acl, mask);
184		posix_acl_release(acl);
185		return error;
186	}
187	return -EAGAIN;
188}
189
190/**
191 * shmem_permission  -  permission() inode operation
192 */
193int
194shmem_permission(struct inode *inode, int mask, struct nameidata *nd)
195{
196	return generic_permission(inode, mask, shmem_check_acl);
197}
198