fs/orangefs/acl.c

   1 /*
   2  * (C) 2001 Clemson University and The University of Chicago
   3  *
   4  * See COPYING in top-level directory.
   5  */
   6
   7 #include "protocol.h"
   8 #include "orangefs-kernel.h"
   9 #include "orangefs-bufmap.h"
  10 #include <linux/posix_acl_xattr.h>
  11 #include <linux/fs_struct.h>
  12
  13 struct posix_acl *orangefs_get_acl(struct inode *inode, int type)
  14 {
  15         struct posix_acl *acl;
  16         int ret;
  17         char *key = NULL, *value = NULL;
  18
  19         switch (type) {
  20         case ACL_TYPE_ACCESS:
  21                 key = XATTR_NAME_POSIX_ACL_ACCESS;
  22                 break;
  23         case ACL_TYPE_DEFAULT:
  24                 key = XATTR_NAME_POSIX_ACL_DEFAULT;
  25                 break;
  26         default:
  27                 gossip_err("orangefs_get_acl: bogus value of type %d\n", type);
  28                 return ERR_PTR(-EINVAL);
  29         }
  30         /*
  31          * Rather than incurring a network call just to determine the exact
  32          * length of the attribute, I just allocate a max length to save on
  33          * the network call. Conceivably, we could pass NULL to
  34          * orangefs_inode_getxattr() to probe the length of the value, but
  35          * I don't do that for now.
  36          */
  37         value = kmalloc(ORANGEFS_MAX_XATTR_VALUELEN, GFP_KERNEL);
  38         if (value == NULL)
  39                 return ERR_PTR(-ENOMEM);
  40
  41         gossip_debug(GOSSIP_ACL_DEBUG,
  42                      "inode %pU, key %s, type %d\n",
  43                      get_khandle_from_ino(inode),
  44                      key,
  45                      type);
  46         ret = orangefs_inode_getxattr(inode, key, value,
  47                                       ORANGEFS_MAX_XATTR_VALUELEN);
  48         /* if the key exists, convert it to an in-memory rep */
  49         if (ret > 0) {
  50                 acl = posix_acl_from_xattr(&init_user_ns, value, ret);
  51         } else if (ret == -ENODATA || ret == -ENOSYS) {
  52                 acl = NULL;
  53         } else {
  54                 gossip_err("inode %pU retrieving acl's failed with error %d\n",
  55                            get_khandle_from_ino(inode),
  56                            ret);
  57                 acl = ERR_PTR(ret);
  58         }
  59         /* kfree(NULL) is safe, so don't worry if value ever got used */
  60         kfree(value);
  61         return acl;
  62 }
  63
  64 int orangefs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
  65 {
  66         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
  67         int error = 0;
  68         void *value = NULL;
  69         size_t size = 0;
  70         const char *name = NULL;
  71
  72         switch (type) {
  73         case ACL_TYPE_ACCESS:
  74                 name = XATTR_NAME_POSIX_ACL_ACCESS;
  75                 if (acl) {
  76                         umode_t mode;
  77
  78                         error = posix_acl_update_mode(inode, &mode, &acl);
  79                         if (error) {
  80                                 gossip_err("%s: posix_acl_update_mode err: %d\n",
  81                                            __func__,
  82                                            error);
  83                                 return error;
  84                         }
  85
  86                         if (inode->i_mode != mode)
  87                                 SetModeFlag(orangefs_inode);
  88                         inode->i_mode = mode;
  89                         mark_inode_dirty_sync(inode);
  90                 }
  91                 break;
  92         case ACL_TYPE_DEFAULT:
  93                 name = XATTR_NAME_POSIX_ACL_DEFAULT;
  94                 break;
  95         default:
  96                 gossip_err("%s: invalid type %d!\n", __func__, type);
  97                 return -EINVAL;
  98         }
  99
 100         gossip_debug(GOSSIP_ACL_DEBUG,
 101                      "%s: inode %pU, key %s type %d\n",
 102                      __func__, get_khandle_from_ino(inode),
 103                      name,
 104                      type);
 105
 106         if (acl) {
 107                 size = posix_acl_xattr_size(acl->a_count);
 108                 value = kmalloc(size, GFP_KERNEL);
 109                 if (!value)
 110                         return -ENOMEM;
 111
 112                 error = posix_acl_to_xattr(&init_user_ns, acl, value, size);
 113                 if (error < 0)
 114                         goto out;
 115         }
 116
 117         gossip_debug(GOSSIP_ACL_DEBUG,
 118                      "%s: name %s, value %p, size %zd, acl %p\n",
 119                      __func__, name, value, size, acl);
 120         /*
 121          * Go ahead and set the extended attribute now. NOTE: Suppose acl
 122          * was NULL, then value will be NULL and size will be 0 and that
 123          * will xlate to a removexattr. However, we don't want removexattr
 124          * complain if attributes does not exist.
 125          */
 126         error = orangefs_inode_setxattr(inode, name, value, size, 0);
 127
 128 out:
 129         kfree(value);
 130         if (!error)
 131                 set_cached_acl(inode, type, acl);
 132         return error;
 133 }
 134
 135 int orangefs_init_acl(struct inode *inode, struct inode *dir)
 136 {
 137         struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
 138         struct posix_acl *default_acl, *acl;
 139         umode_t mode = inode->i_mode;
 140         int error = 0;
 141
 142         ClearModeFlag(orangefs_inode);
 143
 144         error = posix_acl_create(dir, &mode, &default_acl, &acl);
 145         if (error)
 146                 return error;
 147
 148         if (default_acl) {
 149                 error = orangefs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
 150                 posix_acl_release(default_acl);
 151         }
 152
 153         if (acl) {
 154                 if (!error)
 155                         error = orangefs_set_acl(inode, acl, ACL_TYPE_ACCESS);
 156                 posix_acl_release(acl);
 157         }
 158
 159         /* If mode of the inode was changed, then do a forcible ->setattr */
 160         if (mode != inode->i_mode) {
 161                 SetModeFlag(orangefs_inode);
 162                 inode->i_mode = mode;
 163                 orangefs_flush_inode(inode);
 164         }
 165
 166         return error;
 167 }