Root/target/linux/generic/patches-2.6.39/040-backport_tmpfs_xattr.patch

1--- a/fs/Kconfig
2+++ b/fs/Kconfig
3@@ -121,9 +121,25 @@ config TMPFS
4 
5       See <file:Documentation/filesystems/tmpfs.txt> for details.
6 
7+config TMPFS_XATTR
8+ bool "Tmpfs extended attributes"
9+ depends on TMPFS
10+ default n
11+ help
12+ Extended attributes are name:value pairs associated with inodes by
13+ the kernel or by users (see the attr(5) manual page, or visit
14+ <http://acl.bestbits.at/> for details).
15+
16+ Currently this enables support for the trusted.* and
17+ security.* namespaces.
18+
19+ If unsure, say N.
20+
21+ You need this for POSIX ACL support on tmpfs.
22+
23 config TMPFS_POSIX_ACL
24     bool "Tmpfs POSIX Access Control Lists"
25- depends on TMPFS
26+ depends on TMPFS_XATTR
27     select GENERIC_ACL
28     help
29       POSIX Access Control Lists (ACLs) support permissions for users and
30--- a/include/linux/shmem_fs.h
31+++ b/include/linux/shmem_fs.h
32@@ -9,6 +9,8 @@
33 
34 #define SHMEM_NR_DIRECT 16
35 
36+#define SHMEM_SYMLINK_INLINE_LEN (SHMEM_NR_DIRECT * sizeof(swp_entry_t))
37+
38 struct shmem_inode_info {
39     spinlock_t lock;
40     unsigned long flags;
41@@ -17,8 +19,12 @@ struct shmem_inode_info {
42     unsigned long next_index; /* highest alloced index + 1 */
43     struct shared_policy policy; /* NUMA memory alloc policy */
44     struct page *i_indirect; /* top indirect blocks page */
45- swp_entry_t i_direct[SHMEM_NR_DIRECT]; /* first blocks */
46+ union {
47+ swp_entry_t i_direct[SHMEM_NR_DIRECT]; /* first blocks */
48+ char inline_symlink[SHMEM_SYMLINK_INLINE_LEN];
49+ };
50     struct list_head swaplist; /* chain of maybes on swap */
51+ struct list_head xattr_list; /* list of shmem_xattr */
52     struct inode vfs_inode;
53 };
54 
55--- a/mm/shmem.c
56+++ b/mm/shmem.c
57@@ -99,6 +99,13 @@ static struct vfsmount *shm_mnt;
58 /* Pretend that each entry is of this size in directory's i_size */
59 #define BOGO_DIRENT_SIZE 20
60 
61+struct shmem_xattr {
62+ struct list_head list; /* anchored by shmem_inode_info->xattr_list */
63+ char *name; /* xattr name */
64+ size_t size;
65+ char value[0];
66+};
67+
68 /* Flag allocation requirements to shmem_getpage and shmem_swp_alloc */
69 enum sgp_type {
70     SGP_READ, /* don't exceed i_size, don't allocate page */
71@@ -822,6 +829,7 @@ static int shmem_notify_change(struct de
72 static void shmem_evict_inode(struct inode *inode)
73 {
74     struct shmem_inode_info *info = SHMEM_I(inode);
75+ struct shmem_xattr *xattr, *nxattr;
76 
77     if (inode->i_mapping->a_ops == &shmem_aops) {
78         truncate_inode_pages(inode->i_mapping, 0);
79@@ -834,6 +842,11 @@ static void shmem_evict_inode(struct ino
80             mutex_unlock(&shmem_swaplist_mutex);
81         }
82     }
83+
84+ list_for_each_entry_safe(xattr, nxattr, &info->xattr_list, list) {
85+ kfree(xattr->name);
86+ kfree(xattr);
87+ }
88     BUG_ON(inode->i_blocks);
89     shmem_free_inode(inode->i_sb);
90     end_writeback(inode);
91@@ -1615,6 +1628,7 @@ static struct inode *shmem_get_inode(str
92         spin_lock_init(&info->lock);
93         info->flags = flags & VM_NORESERVE;
94         INIT_LIST_HEAD(&info->swaplist);
95+ INIT_LIST_HEAD(&info->xattr_list);
96         cache_no_acl(inode);
97 
98         switch (mode & S_IFMT) {
99@@ -2014,9 +2028,9 @@ static int shmem_symlink(struct inode *d
100 
101     info = SHMEM_I(inode);
102     inode->i_size = len-1;
103- if (len <= (char *)inode - (char *)info) {
104+ if (len <= SHMEM_SYMLINK_INLINE_LEN) {
105         /* do it inline */
106- memcpy(info, symname, len);
107+ memcpy(info->inline_symlink, symname, len);
108         inode->i_op = &shmem_symlink_inline_operations;
109     } else {
110         error = shmem_getpage(inode, 0, &page, SGP_WRITE, NULL);
111@@ -2042,7 +2056,7 @@ static int shmem_symlink(struct inode *d
112 
113 static void *shmem_follow_link_inline(struct dentry *dentry, struct nameidata *nd)
114 {
115- nd_set_link(nd, (char *)SHMEM_I(dentry->d_inode));
116+ nd_set_link(nd, SHMEM_I(dentry->d_inode)->inline_symlink);
117     return NULL;
118 }
119 
120@@ -2066,63 +2080,253 @@ static void shmem_put_link(struct dentry
121     }
122 }
123 
124-static const struct inode_operations shmem_symlink_inline_operations = {
125- .readlink = generic_readlink,
126- .follow_link = shmem_follow_link_inline,
127-};
128-
129-static const struct inode_operations shmem_symlink_inode_operations = {
130- .readlink = generic_readlink,
131- .follow_link = shmem_follow_link,
132- .put_link = shmem_put_link,
133-};
134-
135-#ifdef CONFIG_TMPFS_POSIX_ACL
136+#ifdef CONFIG_TMPFS_XATTR
137 /*
138- * Superblocks without xattr inode operations will get security.* xattr
139- * support from the VFS "for free". As soon as we have any other xattrs
140+ * Superblocks without xattr inode operations may get some security.* xattr
141+ * support from the LSM "for free". As soon as we have any other xattrs
142  * like ACLs, we also need to implement the security.* handlers at
143  * filesystem level, though.
144  */
145 
146-static size_t shmem_xattr_security_list(struct dentry *dentry, char *list,
147- size_t list_len, const char *name,
148- size_t name_len, int handler_flags)
149+static int shmem_xattr_get(struct dentry *dentry, const char *name,
150+ void *buffer, size_t size)
151 {
152- return security_inode_listsecurity(dentry->d_inode, list, list_len);
153-}
154+ struct shmem_inode_info *info;
155+ struct shmem_xattr *xattr;
156+ int ret = -ENODATA;
157 
158-static int shmem_xattr_security_get(struct dentry *dentry, const char *name,
159- void *buffer, size_t size, int handler_flags)
160-{
161- if (strcmp(name, "") == 0)
162- return -EINVAL;
163- return xattr_getsecurity(dentry->d_inode, name, buffer, size);
164+ info = SHMEM_I(dentry->d_inode);
165+
166+ spin_lock(&info->lock);
167+ list_for_each_entry(xattr, &info->xattr_list, list) {
168+ if (strcmp(name, xattr->name))
169+ continue;
170+
171+ ret = xattr->size;
172+ if (buffer) {
173+ if (size < xattr->size)
174+ ret = -ERANGE;
175+ else
176+ memcpy(buffer, xattr->value, xattr->size);
177+ }
178+ break;
179+ }
180+ spin_unlock(&info->lock);
181+ return ret;
182 }
183 
184-static int shmem_xattr_security_set(struct dentry *dentry, const char *name,
185- const void *value, size_t size, int flags, int handler_flags)
186+static int shmem_xattr_set(struct dentry *dentry, const char *name,
187+ const void *value, size_t size, int flags)
188 {
189- if (strcmp(name, "") == 0)
190- return -EINVAL;
191- return security_inode_setsecurity(dentry->d_inode, name, value,
192- size, flags);
193+ struct inode *inode = dentry->d_inode;
194+ struct shmem_inode_info *info = SHMEM_I(inode);
195+ struct shmem_xattr *xattr;
196+ struct shmem_xattr *new_xattr = NULL;
197+ size_t len;
198+ int err = 0;
199+
200+ /* value == NULL means remove */
201+ if (value) {
202+ /* wrap around? */
203+ len = sizeof(*new_xattr) + size;
204+ if (len <= sizeof(*new_xattr))
205+ return -ENOMEM;
206+
207+ new_xattr = kmalloc(len, GFP_KERNEL);
208+ if (!new_xattr)
209+ return -ENOMEM;
210+
211+ new_xattr->name = kstrdup(name, GFP_KERNEL);
212+ if (!new_xattr->name) {
213+ kfree(new_xattr);
214+ return -ENOMEM;
215+ }
216+
217+ new_xattr->size = size;
218+ memcpy(new_xattr->value, value, size);
219+ }
220+
221+ spin_lock(&info->lock);
222+ list_for_each_entry(xattr, &info->xattr_list, list) {
223+ if (!strcmp(name, xattr->name)) {
224+ if (flags & XATTR_CREATE) {
225+ xattr = new_xattr;
226+ err = -EEXIST;
227+ } else if (new_xattr) {
228+ list_replace(&xattr->list, &new_xattr->list);
229+ } else {
230+ list_del(&xattr->list);
231+ }
232+ goto out;
233+ }
234+ }
235+ if (flags & XATTR_REPLACE) {
236+ xattr = new_xattr;
237+ err = -ENODATA;
238+ } else {
239+ list_add(&new_xattr->list, &info->xattr_list);
240+ xattr = NULL;
241+ }
242+out:
243+ spin_unlock(&info->lock);
244+ if (xattr)
245+ kfree(xattr->name);
246+ kfree(xattr);
247+ return err;
248 }
249 
250-static const struct xattr_handler shmem_xattr_security_handler = {
251- .prefix = XATTR_SECURITY_PREFIX,
252- .list = shmem_xattr_security_list,
253- .get = shmem_xattr_security_get,
254- .set = shmem_xattr_security_set,
255-};
256 
257 static const struct xattr_handler *shmem_xattr_handlers[] = {
258+#ifdef CONFIG_TMPFS_POSIX_ACL
259     &generic_acl_access_handler,
260     &generic_acl_default_handler,
261- &shmem_xattr_security_handler,
262+#endif
263     NULL
264 };
265+
266+static int shmem_xattr_validate(const char *name)
267+{
268+ struct { const char *prefix; size_t len; } arr[] = {
269+ { XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN },
270+ { XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN }
271+ };
272+ int i;
273+
274+ for (i = 0; i < ARRAY_SIZE(arr); i++) {
275+ size_t preflen = arr[i].len;
276+ if (strncmp(name, arr[i].prefix, preflen) == 0) {
277+ if (!name[preflen])
278+ return -EINVAL;
279+ return 0;
280+ }
281+ }
282+ return -EOPNOTSUPP;
283+}
284+
285+static ssize_t shmem_getxattr(struct dentry *dentry, const char *name,
286+ void *buffer, size_t size)
287+{
288+ int err;
289+
290+ /*
291+ * If this is a request for a synthetic attribute in the system.*
292+ * namespace use the generic infrastructure to resolve a handler
293+ * for it via sb->s_xattr.
294+ */
295+ if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
296+ return generic_getxattr(dentry, name, buffer, size);
297+
298+ err = shmem_xattr_validate(name);
299+ if (err)
300+ return err;
301+
302+ return shmem_xattr_get(dentry, name, buffer, size);
303+}
304+
305+static int shmem_setxattr(struct dentry *dentry, const char *name,
306+ const void *value, size_t size, int flags)
307+{
308+ int err;
309+
310+ /*
311+ * If this is a request for a synthetic attribute in the system.*
312+ * namespace use the generic infrastructure to resolve a handler
313+ * for it via sb->s_xattr.
314+ */
315+ if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
316+ return generic_setxattr(dentry, name, value, size, flags);
317+
318+ err = shmem_xattr_validate(name);
319+ if (err)
320+ return err;
321+
322+ if (size == 0)
323+ value = ""; /* empty EA, do not remove */
324+
325+ return shmem_xattr_set(dentry, name, value, size, flags);
326+
327+}
328+
329+static int shmem_removexattr(struct dentry *dentry, const char *name)
330+{
331+ int err;
332+
333+ /*
334+ * If this is a request for a synthetic attribute in the system.*
335+ * namespace use the generic infrastructure to resolve a handler
336+ * for it via sb->s_xattr.
337+ */
338+ if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
339+ return generic_removexattr(dentry, name);
340+
341+ err = shmem_xattr_validate(name);
342+ if (err)
343+ return err;
344+
345+ return shmem_xattr_set(dentry, name, NULL, 0, XATTR_REPLACE);
346+}
347+
348+static bool xattr_is_trusted(const char *name)
349+{
350+ return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
351+}
352+
353+static ssize_t shmem_listxattr(struct dentry *dentry, char *buffer, size_t size)
354+{
355+ bool trusted = capable(CAP_SYS_ADMIN);
356+ struct shmem_xattr *xattr;
357+ struct shmem_inode_info *info;
358+ size_t used = 0;
359+
360+ info = SHMEM_I(dentry->d_inode);
361+
362+ spin_lock(&info->lock);
363+ list_for_each_entry(xattr, &info->xattr_list, list) {
364+ size_t len;
365+
366+ /* skip "trusted." attributes for unprivileged callers */
367+ if (!trusted && xattr_is_trusted(xattr->name))
368+ continue;
369+
370+ len = strlen(xattr->name) + 1;
371+ used += len;
372+ if (buffer) {
373+ if (size < used) {
374+ used = -ERANGE;
375+ break;
376+ }
377+ memcpy(buffer, xattr->name, len);
378+ buffer += len;
379+ }
380+ }
381+ spin_unlock(&info->lock);
382+
383+ return used;
384+}
385+#endif /* CONFIG_TMPFS_XATTR */
386+
387+static const struct inode_operations shmem_symlink_inline_operations = {
388+ .readlink = generic_readlink,
389+ .follow_link = shmem_follow_link_inline,
390+#ifdef CONFIG_TMPFS_XATTR
391+ .setxattr = shmem_setxattr,
392+ .getxattr = shmem_getxattr,
393+ .listxattr = shmem_listxattr,
394+ .removexattr = shmem_removexattr,
395+#endif
396+};
397+
398+static const struct inode_operations shmem_symlink_inode_operations = {
399+ .readlink = generic_readlink,
400+ .follow_link = shmem_follow_link,
401+ .put_link = shmem_put_link,
402+#ifdef CONFIG_TMPFS_XATTR
403+ .setxattr = shmem_setxattr,
404+ .getxattr = shmem_getxattr,
405+ .listxattr = shmem_listxattr,
406+ .removexattr = shmem_removexattr,
407 #endif
408+};
409 
410 static struct dentry *shmem_get_parent(struct dentry *child)
411 {
412@@ -2402,8 +2606,10 @@ int shmem_fill_super(struct super_block
413     sb->s_magic = TMPFS_MAGIC;
414     sb->s_op = &shmem_ops;
415     sb->s_time_gran = 1;
416-#ifdef CONFIG_TMPFS_POSIX_ACL
417+#ifdef CONFIG_TMPFS_XATTR
418     sb->s_xattr = shmem_xattr_handlers;
419+#endif
420+#ifdef CONFIG_TMPFS_POSIX_ACL
421     sb->s_flags |= MS_POSIXACL;
422 #endif
423 
424@@ -2501,11 +2707,13 @@ static const struct file_operations shme
425 static const struct inode_operations shmem_inode_operations = {
426     .setattr = shmem_notify_change,
427     .truncate_range = shmem_truncate_range,
428+#ifdef CONFIG_TMPFS_XATTR
429+ .setxattr = shmem_setxattr,
430+ .getxattr = shmem_getxattr,
431+ .listxattr = shmem_listxattr,
432+ .removexattr = shmem_removexattr,
433+#endif
434 #ifdef CONFIG_TMPFS_POSIX_ACL
435- .setxattr = generic_setxattr,
436- .getxattr = generic_getxattr,
437- .listxattr = generic_listxattr,
438- .removexattr = generic_removexattr,
439     .check_acl = generic_check_acl,
440 #endif
441 
442@@ -2523,23 +2731,27 @@ static const struct inode_operations shm
443     .mknod = shmem_mknod,
444     .rename = shmem_rename,
445 #endif
446+#ifdef CONFIG_TMPFS_XATTR
447+ .setxattr = shmem_setxattr,
448+ .getxattr = shmem_getxattr,
449+ .listxattr = shmem_listxattr,
450+ .removexattr = shmem_removexattr,
451+#endif
452 #ifdef CONFIG_TMPFS_POSIX_ACL
453     .setattr = shmem_notify_change,
454- .setxattr = generic_setxattr,
455- .getxattr = generic_getxattr,
456- .listxattr = generic_listxattr,
457- .removexattr = generic_removexattr,
458     .check_acl = generic_check_acl,
459 #endif
460 };
461 
462 static const struct inode_operations shmem_special_inode_operations = {
463+#ifdef CONFIG_TMPFS_XATTR
464+ .setxattr = shmem_setxattr,
465+ .getxattr = shmem_getxattr,
466+ .listxattr = shmem_listxattr,
467+ .removexattr = shmem_removexattr,
468+#endif
469 #ifdef CONFIG_TMPFS_POSIX_ACL
470     .setattr = shmem_notify_change,
471- .setxattr = generic_setxattr,
472- .getxattr = generic_getxattr,
473- .listxattr = generic_listxattr,
474- .removexattr = generic_removexattr,
475     .check_acl = generic_check_acl,
476 #endif
477 };
478

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive