mm/shmem_acl.c

   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  */
  17 static struct posix_acl *
  18 shmem_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(inode->i_acl);
  26                         break;
  27
  28                 case ACL_TYPE_DEFAULT:
  29                         acl = posix_acl_dup(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  */
  40 static void
  41 shmem_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 = inode->i_acl;
  49                         inode->i_acl = posix_acl_dup(acl);
  50                         break;
  51
  52                 case ACL_TYPE_DEFAULT:
  53                         free = inode->i_default_acl;
  54                         inode->i_default_acl = posix_acl_dup(acl);
  55                         break;
  56         }
  57         spin_unlock(&inode->i_lock);
  58         posix_acl_release(free);
  59 }
  60
  61 struct generic_acl_operations shmem_acl_ops = {
  62         .getacl = shmem_get_acl,
  63         .setacl = shmem_set_acl,
  64 };
  65
  66 static size_t
  67 shmem_xattr_list_acl(struct dentry *dentry, char *list, size_t list_size,
  68                 const char *name, size_t name_len, int type)
  69 {
  70         return generic_acl_list(dentry->d_inode, &shmem_acl_ops,
  71                                 type, list, list_size);
  72 }
  73
  74 static int
  75 shmem_xattr_get_acl(struct dentry *dentry, const char *name, void *buffer,
  76                      size_t size, int type)
  77 {
  78         if (strcmp(name, "") != 0)
  79                 return -EINVAL;
  80         return generic_acl_get(dentry->d_inode, &shmem_acl_ops, type,
  81                                buffer, size);
  82 }
  83
  84 static int
  85 shmem_xattr_set_acl(struct dentry *dentry, const char *name, const void *value,
  86                      size_t size, int flags, int type)
  87 {
  88         if (strcmp(name, "") != 0)
  89                 return -EINVAL;
  90         return generic_acl_set(dentry->d_inode, &shmem_acl_ops, type,
  91                                value, size);
  92 }
  93
  94 struct xattr_handler shmem_xattr_acl_access_handler = {
  95         .prefix = POSIX_ACL_XATTR_ACCESS,
  96         .flags  = ACL_TYPE_ACCESS,
  97         .list   = shmem_xattr_list_acl,
  98         .get    = shmem_xattr_get_acl,
  99         .set    = shmem_xattr_set_acl,
 100 };
 101
 102 struct xattr_handler shmem_xattr_acl_default_handler = {
 103         .prefix = POSIX_ACL_XATTR_DEFAULT,
 104         .flags  = ACL_TYPE_DEFAULT,
 105         .list   = shmem_xattr_list_acl,
 106         .get    = shmem_xattr_get_acl,
 107         .set    = shmem_xattr_set_acl,
 108 };
 109
 110 /**
 111  * shmem_acl_init  -  Inizialize the acl(s) of a new inode
 112  */
 113 int
 114 shmem_acl_init(struct inode *inode, struct inode *dir)
 115 {
 116         return generic_acl_init(inode, dir, &shmem_acl_ops);
 117 }
 118
 119 /**
 120  * shmem_check_acl  -  check_acl() callback for generic_permission()
 121  */
 122 int
 123 shmem_check_acl(struct inode *inode, int mask)
 124 {
 125         struct posix_acl *acl = shmem_get_acl(inode, ACL_TYPE_ACCESS);
 126
 127         if (acl) {
 128                 int error = posix_acl_permission(inode, acl, mask);
 129                 posix_acl_release(acl);
 130                 return error;
 131         }
 132         return -EAGAIN;
 133 }