linux/fs/9p/acl.c
<<
>>
Prefs
   1/*
   2 * Copyright IBM Corporation, 2010
   3 * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
   4 *
   5 * This program is free software; you can redistribute it and/or modify it
   6 * under the terms of version 2.1 of the GNU Lesser General Public License
   7 * as published by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it would be useful, but
  10 * WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12 *
  13 */
  14
  15#include <linux/module.h>
  16#include <linux/fs.h>
  17#include <net/9p/9p.h>
  18#include <net/9p/client.h>
  19#include <linux/slab.h>
  20#include <linux/sched.h>
  21#include <linux/posix_acl_xattr.h>
  22#include "xattr.h"
  23#include "acl.h"
  24#include "v9fs.h"
  25#include "v9fs_vfs.h"
  26#include "fid.h"
  27
  28static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name)
  29{
  30        ssize_t size;
  31        void *value = NULL;
  32        struct posix_acl *acl = NULL;
  33
  34        size = v9fs_fid_xattr_get(fid, name, NULL, 0);
  35        if (size > 0) {
  36                value = kzalloc(size, GFP_NOFS);
  37                if (!value)
  38                        return ERR_PTR(-ENOMEM);
  39                size = v9fs_fid_xattr_get(fid, name, value, size);
  40                if (size > 0) {
  41                        acl = posix_acl_from_xattr(&init_user_ns, value, size);
  42                        if (IS_ERR(acl))
  43                                goto err_out;
  44                }
  45        } else if (size == -ENODATA || size == 0 ||
  46                   size == -ENOSYS || size == -EOPNOTSUPP) {
  47                acl = NULL;
  48        } else
  49                acl = ERR_PTR(-EIO);
  50
  51err_out:
  52        kfree(value);
  53        return acl;
  54}
  55
  56int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)
  57{
  58        int retval = 0;
  59        struct posix_acl *pacl, *dacl;
  60        struct v9fs_session_info *v9ses;
  61
  62        v9ses = v9fs_inode2v9ses(inode);
  63        if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) ||
  64                        ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) {
  65                set_cached_acl(inode, ACL_TYPE_DEFAULT, NULL);
  66                set_cached_acl(inode, ACL_TYPE_ACCESS, NULL);
  67                return 0;
  68        }
  69        /* get the default/access acl values and cache them */
  70        dacl = __v9fs_get_acl(fid, XATTR_NAME_POSIX_ACL_DEFAULT);
  71        pacl = __v9fs_get_acl(fid, XATTR_NAME_POSIX_ACL_ACCESS);
  72
  73        if (!IS_ERR(dacl) && !IS_ERR(pacl)) {
  74                set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl);
  75                set_cached_acl(inode, ACL_TYPE_ACCESS, pacl);
  76        } else
  77                retval = -EIO;
  78
  79        if (!IS_ERR(dacl))
  80                posix_acl_release(dacl);
  81
  82        if (!IS_ERR(pacl))
  83                posix_acl_release(pacl);
  84
  85        return retval;
  86}
  87
  88static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type)
  89{
  90        struct posix_acl *acl;
  91        /*
  92         * 9p Always cache the acl value when
  93         * instantiating the inode (v9fs_inode_from_fid)
  94         */
  95        acl = get_cached_acl(inode, type);
  96        BUG_ON(is_uncached_acl(acl));
  97        return acl;
  98}
  99
 100struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type)
 101{
 102        struct v9fs_session_info *v9ses;
 103
 104        v9ses = v9fs_inode2v9ses(inode);
 105        if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) ||
 106                        ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) {
 107                /*
 108                 * On access = client  and acl = on mode get the acl
 109                 * values from the server
 110                 */
 111                return NULL;
 112        }
 113        return v9fs_get_cached_acl(inode, type);
 114
 115}
 116
 117static int v9fs_set_acl(struct p9_fid *fid, int type, struct posix_acl *acl)
 118{
 119        int retval;
 120        char *name;
 121        size_t size;
 122        void *buffer;
 123        if (!acl)
 124                return 0;
 125
 126        /* Set a setxattr request to server */
 127        size = posix_acl_xattr_size(acl->a_count);
 128        buffer = kmalloc(size, GFP_KERNEL);
 129        if (!buffer)
 130                return -ENOMEM;
 131        retval = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
 132        if (retval < 0)
 133                goto err_free_out;
 134        switch (type) {
 135        case ACL_TYPE_ACCESS:
 136                name = XATTR_NAME_POSIX_ACL_ACCESS;
 137                break;
 138        case ACL_TYPE_DEFAULT:
 139                name = XATTR_NAME_POSIX_ACL_DEFAULT;
 140                break;
 141        default:
 142                BUG();
 143        }
 144        retval = v9fs_fid_xattr_set(fid, name, buffer, size, 0);
 145err_free_out:
 146        kfree(buffer);
 147        return retval;
 148}
 149
 150int v9fs_acl_chmod(struct inode *inode, struct p9_fid *fid)
 151{
 152        int retval = 0;
 153        struct posix_acl *acl;
 154
 155        if (S_ISLNK(inode->i_mode))
 156                return -EOPNOTSUPP;
 157        acl = v9fs_get_cached_acl(inode, ACL_TYPE_ACCESS);
 158        if (acl) {
 159                retval = __posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode);
 160                if (retval)
 161                        return retval;
 162                set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
 163                retval = v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl);
 164                posix_acl_release(acl);
 165        }
 166        return retval;
 167}
 168
 169int v9fs_set_create_acl(struct inode *inode, struct p9_fid *fid,
 170                        struct posix_acl *dacl, struct posix_acl *acl)
 171{
 172        set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl);
 173        set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
 174        v9fs_set_acl(fid, ACL_TYPE_DEFAULT, dacl);
 175        v9fs_set_acl(fid, ACL_TYPE_ACCESS, acl);
 176        return 0;
 177}
 178
 179void v9fs_put_acl(struct posix_acl *dacl,
 180                  struct posix_acl *acl)
 181{
 182        posix_acl_release(dacl);
 183        posix_acl_release(acl);
 184}
 185
 186int v9fs_acl_mode(struct inode *dir, umode_t *modep,
 187                  struct posix_acl **dpacl, struct posix_acl **pacl)
 188{
 189        int retval = 0;
 190        umode_t mode = *modep;
 191        struct posix_acl *acl = NULL;
 192
 193        if (!S_ISLNK(mode)) {
 194                acl = v9fs_get_cached_acl(dir, ACL_TYPE_DEFAULT);
 195                if (IS_ERR(acl))
 196                        return PTR_ERR(acl);
 197                if (!acl)
 198                        mode &= ~current_umask();
 199        }
 200        if (acl) {
 201                if (S_ISDIR(mode))
 202                        *dpacl = posix_acl_dup(acl);
 203                retval = __posix_acl_create(&acl, GFP_NOFS, &mode);
 204                if (retval < 0)
 205                        return retval;
 206                if (retval > 0)
 207                        *pacl = acl;
 208                else
 209                        posix_acl_release(acl);
 210        }
 211        *modep  = mode;
 212        return 0;
 213}
 214
 215static int v9fs_xattr_get_acl(const struct xattr_handler *handler,
 216                              struct dentry *dentry, struct inode *inode,
 217                              const char *name, void *buffer, size_t size)
 218{
 219        struct v9fs_session_info *v9ses;
 220        struct posix_acl *acl;
 221        int error;
 222
 223        v9ses = v9fs_dentry2v9ses(dentry);
 224        /*
 225         * We allow set/get/list of acl when access=client is not specified
 226         */
 227        if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
 228                return v9fs_xattr_get(dentry, handler->name, buffer, size);
 229
 230        acl = v9fs_get_cached_acl(inode, handler->flags);
 231        if (IS_ERR(acl))
 232                return PTR_ERR(acl);
 233        if (acl == NULL)
 234                return -ENODATA;
 235        error = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
 236        posix_acl_release(acl);
 237
 238        return error;
 239}
 240
 241static int v9fs_xattr_set_acl(const struct xattr_handler *handler,
 242                              struct user_namespace *mnt_userns,
 243                              struct dentry *dentry, struct inode *inode,
 244                              const char *name, const void *value,
 245                              size_t size, int flags)
 246{
 247        int retval;
 248        struct posix_acl *acl;
 249        struct v9fs_session_info *v9ses;
 250
 251        v9ses = v9fs_dentry2v9ses(dentry);
 252        /*
 253         * set the attribute on the remote. Without even looking at the
 254         * xattr value. We leave it to the server to validate
 255         */
 256        if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
 257                return v9fs_xattr_set(dentry, handler->name, value, size,
 258                                      flags);
 259
 260        if (S_ISLNK(inode->i_mode))
 261                return -EOPNOTSUPP;
 262        if (!inode_owner_or_capable(&init_user_ns, inode))
 263                return -EPERM;
 264        if (value) {
 265                /* update the cached acl value */
 266                acl = posix_acl_from_xattr(&init_user_ns, value, size);
 267                if (IS_ERR(acl))
 268                        return PTR_ERR(acl);
 269                else if (acl) {
 270                        retval = posix_acl_valid(inode->i_sb->s_user_ns, acl);
 271                        if (retval)
 272                                goto err_out;
 273                }
 274        } else
 275                acl = NULL;
 276
 277        switch (handler->flags) {
 278        case ACL_TYPE_ACCESS:
 279                if (acl) {
 280                        struct iattr iattr = { 0 };
 281                        struct posix_acl *old_acl = acl;
 282
 283                        retval = posix_acl_update_mode(&init_user_ns, inode,
 284                                                       &iattr.ia_mode, &acl);
 285                        if (retval)
 286                                goto err_out;
 287                        if (!acl) {
 288                                /*
 289                                 * ACL can be represented
 290                                 * by the mode bits. So don't
 291                                 * update ACL.
 292                                 */
 293                                posix_acl_release(old_acl);
 294                                value = NULL;
 295                                size = 0;
 296                        }
 297                        iattr.ia_valid = ATTR_MODE;
 298                        /* FIXME should we update ctime ?
 299                         * What is the following setxattr update the
 300                         * mode ?
 301                         */
 302                        v9fs_vfs_setattr_dotl(&init_user_ns, dentry, &iattr);
 303                }
 304                break;
 305        case ACL_TYPE_DEFAULT:
 306                if (!S_ISDIR(inode->i_mode)) {
 307                        retval = acl ? -EINVAL : 0;
 308                        goto err_out;
 309                }
 310                break;
 311        default:
 312                BUG();
 313        }
 314        retval = v9fs_xattr_set(dentry, handler->name, value, size, flags);
 315        if (!retval)
 316                set_cached_acl(inode, handler->flags, acl);
 317err_out:
 318        posix_acl_release(acl);
 319        return retval;
 320}
 321
 322const struct xattr_handler v9fs_xattr_acl_access_handler = {
 323        .name   = XATTR_NAME_POSIX_ACL_ACCESS,
 324        .flags  = ACL_TYPE_ACCESS,
 325        .get    = v9fs_xattr_get_acl,
 326        .set    = v9fs_xattr_set_acl,
 327};
 328
 329const struct xattr_handler v9fs_xattr_acl_default_handler = {
 330        .name   = XATTR_NAME_POSIX_ACL_DEFAULT,
 331        .flags  = ACL_TYPE_DEFAULT,
 332        .get    = v9fs_xattr_get_acl,
 333        .set    = v9fs_xattr_set_acl,
 334};
 335