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
  27static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name)
  28{
  29        ssize_t size;
  30        void *value = NULL;
  31        struct posix_acl *acl = NULL;
  32
  33        size = v9fs_fid_xattr_get(fid, name, NULL, 0);
  34        if (size > 0) {
  35                value = kzalloc(size, GFP_NOFS);
  36                if (!value)
  37                        return ERR_PTR(-ENOMEM);
  38                size = v9fs_fid_xattr_get(fid, name, value, size);
  39                if (size > 0) {
  40                        acl = posix_acl_from_xattr(value, size);
  41                        if (IS_ERR(acl))
  42                                goto err_out;
  43                }
  44        } else if (size == -ENODATA || size == 0 ||
  45                   size == -ENOSYS || size == -EOPNOTSUPP) {
  46                acl = NULL;
  47        } else
  48                acl = ERR_PTR(-EIO);
  49
  50err_out:
  51        kfree(value);
  52        return acl;
  53}
  54
  55int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)
  56{
  57        int retval = 0;
  58        struct posix_acl *pacl, *dacl;
  59        struct v9fs_session_info *v9ses;
  60
  61        v9ses = v9fs_inode2v9ses(inode);
  62        if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) ||
  63                        ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) {
  64                set_cached_acl(inode, ACL_TYPE_DEFAULT, NULL);
  65                set_cached_acl(inode, ACL_TYPE_ACCESS, NULL);
  66                return 0;
  67        }
  68        /* get the default/access acl values and cache them */
  69        dacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_DEFAULT);
  70        pacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_ACCESS);
  71
  72        if (!IS_ERR(dacl) && !IS_ERR(pacl)) {
  73                set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl);
  74                set_cached_acl(inode, ACL_TYPE_ACCESS, pacl);
  75        } else
  76                retval = -EIO;
  77
  78        if (!IS_ERR(dacl))
  79                posix_acl_release(dacl);
  80
  81        if (!IS_ERR(pacl))
  82                posix_acl_release(pacl);
  83
  84        return retval;
  85}
  86
  87static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type)
  88{
  89        struct posix_acl *acl;
  90        /*
  91         * 9p Always cache the acl value when
  92         * instantiating the inode (v9fs_inode_from_fid)
  93         */
  94        acl = get_cached_acl(inode, type);
  95        BUG_ON(acl == ACL_NOT_CACHED);
  96        return acl;
  97}
  98
  99struct posix_acl *v9fs_iop_get_acl(struct inode *inode, int type)
 100{
 101        struct v9fs_session_info *v9ses;
 102
 103        v9ses = v9fs_inode2v9ses(inode);
 104        if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) ||
 105                        ((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) {
 106                /*
 107                 * On access = client  and acl = on mode get the acl
 108                 * values from the server
 109                 */
 110                return NULL;
 111        }
 112        return v9fs_get_cached_acl(inode, type);
 113
 114}
 115
 116static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl)
 117{
 118        int retval;
 119        char *name;
 120        size_t size;
 121        void *buffer;
 122        struct inode *inode = dentry->d_inode;
 123
 124        set_cached_acl(inode, type, acl);
 125
 126        if (!acl)
 127                return 0;
 128
 129        /* Set a setxattr request to server */
 130        size = posix_acl_xattr_size(acl->a_count);
 131        buffer = kmalloc(size, GFP_KERNEL);
 132        if (!buffer)
 133                return -ENOMEM;
 134        retval = posix_acl_to_xattr(acl, buffer, size);
 135        if (retval < 0)
 136                goto err_free_out;
 137        switch (type) {
 138        case ACL_TYPE_ACCESS:
 139                name = POSIX_ACL_XATTR_ACCESS;
 140                break;
 141        case ACL_TYPE_DEFAULT:
 142                name = POSIX_ACL_XATTR_DEFAULT;
 143                break;
 144        default:
 145                BUG();
 146        }
 147        retval = v9fs_xattr_set(dentry, name, buffer, size, 0);
 148err_free_out:
 149        kfree(buffer);
 150        return retval;
 151}
 152
 153int v9fs_acl_chmod(struct dentry *dentry)
 154{
 155        int retval = 0;
 156        struct posix_acl *acl;
 157        struct inode *inode = dentry->d_inode;
 158
 159        if (S_ISLNK(inode->i_mode))
 160                return -EOPNOTSUPP;
 161        acl = v9fs_get_cached_acl(inode, ACL_TYPE_ACCESS);
 162        if (acl) {
 163                retval = posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode);
 164                if (retval)
 165                        return retval;
 166                retval = v9fs_set_acl(dentry, ACL_TYPE_ACCESS, acl);
 167                posix_acl_release(acl);
 168        }
 169        return retval;
 170}
 171
 172int v9fs_set_create_acl(struct dentry *dentry,
 173                        struct posix_acl **dpacl, struct posix_acl **pacl)
 174{
 175        if (dentry) {
 176                v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, *dpacl);
 177                v9fs_set_acl(dentry, ACL_TYPE_ACCESS, *pacl);
 178        }
 179        posix_acl_release(*dpacl);
 180        posix_acl_release(*pacl);
 181        *dpacl = *pacl = NULL;
 182        return 0;
 183}
 184
 185int v9fs_acl_mode(struct inode *dir, umode_t *modep,
 186                  struct posix_acl **dpacl, struct posix_acl **pacl)
 187{
 188        int retval = 0;
 189        umode_t mode = *modep;
 190        struct posix_acl *acl = NULL;
 191
 192        if (!S_ISLNK(mode)) {
 193                acl = v9fs_get_cached_acl(dir, ACL_TYPE_DEFAULT);
 194                if (IS_ERR(acl))
 195                        return PTR_ERR(acl);
 196                if (!acl)
 197                        mode &= ~current_umask();
 198        }
 199        if (acl) {
 200                if (S_ISDIR(mode))
 201                        *dpacl = posix_acl_dup(acl);
 202                retval = posix_acl_create(&acl, GFP_NOFS, &mode);
 203                if (retval < 0)
 204                        return retval;
 205                if (retval > 0)
 206                        *pacl = acl;
 207                else
 208                        posix_acl_release(acl);
 209        }
 210        *modep  = mode;
 211        return 0;
 212}
 213
 214static int v9fs_remote_get_acl(struct dentry *dentry, const char *name,
 215                               void *buffer, size_t size, int type)
 216{
 217        char *full_name;
 218
 219        switch (type) {
 220        case ACL_TYPE_ACCESS:
 221                full_name =  POSIX_ACL_XATTR_ACCESS;
 222                break;
 223        case ACL_TYPE_DEFAULT:
 224                full_name = POSIX_ACL_XATTR_DEFAULT;
 225                break;
 226        default:
 227                BUG();
 228        }
 229        return v9fs_xattr_get(dentry, full_name, buffer, size);
 230}
 231
 232static int v9fs_xattr_get_acl(struct dentry *dentry, const char *name,
 233                              void *buffer, size_t size, int type)
 234{
 235        struct v9fs_session_info *v9ses;
 236        struct posix_acl *acl;
 237        int error;
 238
 239        if (strcmp(name, "") != 0)
 240                return -EINVAL;
 241
 242        v9ses = v9fs_dentry2v9ses(dentry);
 243        /*
 244         * We allow set/get/list of acl when access=client is not specified
 245         */
 246        if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
 247                return v9fs_remote_get_acl(dentry, name, buffer, size, type);
 248
 249        acl = v9fs_get_cached_acl(dentry->d_inode, type);
 250        if (IS_ERR(acl))
 251                return PTR_ERR(acl);
 252        if (acl == NULL)
 253                return -ENODATA;
 254        error = posix_acl_to_xattr(acl, buffer, size);
 255        posix_acl_release(acl);
 256
 257        return error;
 258}
 259
 260static int v9fs_remote_set_acl(struct dentry *dentry, const char *name,
 261                              const void *value, size_t size,
 262                              int flags, int type)
 263{
 264        char *full_name;
 265
 266        switch (type) {
 267        case ACL_TYPE_ACCESS:
 268                full_name =  POSIX_ACL_XATTR_ACCESS;
 269                break;
 270        case ACL_TYPE_DEFAULT:
 271                full_name = POSIX_ACL_XATTR_DEFAULT;
 272                break;
 273        default:
 274                BUG();
 275        }
 276        return v9fs_xattr_set(dentry, full_name, value, size, flags);
 277}
 278
 279
 280static int v9fs_xattr_set_acl(struct dentry *dentry, const char *name,
 281                              const void *value, size_t size,
 282                              int flags, int type)
 283{
 284        int retval;
 285        struct posix_acl *acl;
 286        struct v9fs_session_info *v9ses;
 287        struct inode *inode = dentry->d_inode;
 288
 289        if (strcmp(name, "") != 0)
 290                return -EINVAL;
 291
 292        v9ses = v9fs_dentry2v9ses(dentry);
 293        /*
 294         * set the attribute on the remote. Without even looking at the
 295         * xattr value. We leave it to the server to validate
 296         */
 297        if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
 298                return v9fs_remote_set_acl(dentry, name,
 299                                           value, size, flags, type);
 300
 301        if (S_ISLNK(inode->i_mode))
 302                return -EOPNOTSUPP;
 303        if (!inode_owner_or_capable(inode))
 304                return -EPERM;
 305        if (value) {
 306                /* update the cached acl value */
 307                acl = posix_acl_from_xattr(value, size);
 308                if (IS_ERR(acl))
 309                        return PTR_ERR(acl);
 310                else if (acl) {
 311                        retval = posix_acl_valid(acl);
 312                        if (retval)
 313                                goto err_out;
 314                }
 315        } else
 316                acl = NULL;
 317
 318        switch (type) {
 319        case ACL_TYPE_ACCESS:
 320                name = POSIX_ACL_XATTR_ACCESS;
 321                if (acl) {
 322                        umode_t mode = inode->i_mode;
 323                        retval = posix_acl_equiv_mode(acl, &mode);
 324                        if (retval < 0)
 325                                goto err_out;
 326                        else {
 327                                struct iattr iattr;
 328                                if (retval == 0) {
 329                                        /*
 330                                         * ACL can be represented
 331                                         * by the mode bits. So don't
 332                                         * update ACL.
 333                                         */
 334                                        acl = NULL;
 335                                        value = NULL;
 336                                        size = 0;
 337                                }
 338                                /* Updte the mode bits */
 339                                iattr.ia_mode = ((mode & S_IALLUGO) |
 340                                                 (inode->i_mode & ~S_IALLUGO));
 341                                iattr.ia_valid = ATTR_MODE;
 342                                /* FIXME should we update ctime ?
 343                                 * What is the following setxattr update the
 344                                 * mode ?
 345                                 */
 346                                v9fs_vfs_setattr_dotl(dentry, &iattr);
 347                        }
 348                }
 349                break;
 350        case ACL_TYPE_DEFAULT:
 351                name = POSIX_ACL_XATTR_DEFAULT;
 352                if (!S_ISDIR(inode->i_mode)) {
 353                        retval = acl ? -EINVAL : 0;
 354                        goto err_out;
 355                }
 356                break;
 357        default:
 358                BUG();
 359        }
 360        retval = v9fs_xattr_set(dentry, name, value, size, flags);
 361        if (!retval)
 362                set_cached_acl(inode, type, acl);
 363err_out:
 364        posix_acl_release(acl);
 365        return retval;
 366}
 367
 368const struct xattr_handler v9fs_xattr_acl_access_handler = {
 369        .prefix = POSIX_ACL_XATTR_ACCESS,
 370        .flags  = ACL_TYPE_ACCESS,
 371        .get    = v9fs_xattr_get_acl,
 372        .set    = v9fs_xattr_set_acl,
 373};
 374
 375const struct xattr_handler v9fs_xattr_acl_default_handler = {
 376        .prefix = POSIX_ACL_XATTR_DEFAULT,
 377        .flags  = ACL_TYPE_DEFAULT,
 378        .get    = v9fs_xattr_get_acl,
 379        .set    = v9fs_xattr_set_acl,
 380};
 381
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.