fs/gfs2/acl.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/slab.h>
  12 #include <linux/spinlock.h>
  13 #include <linux/completion.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/xattr.h>
  16 #include <linux/posix_acl.h>
  17 #include <linux/posix_acl_xattr.h>
  18 #include <linux/gfs2_ondisk.h>
  19
  20 #include "gfs2.h"
  21 #include "incore.h"
  22 #include "acl.h"
  23 #include "xattr.h"
  24 #include "glock.h"
  25 #include "inode.h"
  26 #include "meta_io.h"
  27 #include "rgrp.h"
  28 #include "trans.h"
  29 #include "util.h"
  30
  31 static const char *gfs2_acl_name(int type)
  32 {
  33         switch (type) {
  34         case ACL_TYPE_ACCESS:
  35                 return XATTR_POSIX_ACL_ACCESS;
  36         case ACL_TYPE_DEFAULT:
  37                 return XATTR_POSIX_ACL_DEFAULT;
  38         }
  39         return NULL;
  40 }
  41
  42 static struct posix_acl *__gfs2_get_acl(struct inode *inode, int type)
  43 {
  44         struct gfs2_inode *ip = GFS2_I(inode);
  45         struct posix_acl *acl;
  46         const char *name;
  47         char *data;
  48         int len;
  49
  50         if (!ip->i_eattr)
  51                 return NULL;
  52
  53         name = gfs2_acl_name(type);
  54         len = gfs2_xattr_acl_get(ip, name, &data);
  55         if (len <= 0)
  56                 return ERR_PTR(len);
  57         acl = posix_acl_from_xattr(&init_user_ns, data, len);
  58         kfree(data);
  59         return acl;
  60 }
  61
  62 struct posix_acl *gfs2_get_acl(struct inode *inode, int type)
  63 {
  64         struct gfs2_inode *ip = GFS2_I(inode);
  65         struct gfs2_holder gh;
  66         bool need_unlock = false;
  67         struct posix_acl *acl;
  68
  69         if (!gfs2_glock_is_locked_by_me(ip->i_gl)) {
  70                 int ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
  71                                              LM_FLAG_ANY, &gh);
  72                 if (ret)
  73                         return ERR_PTR(ret);
  74                 need_unlock = true;
  75         }
  76         acl = __gfs2_get_acl(inode, type);
  77         if (need_unlock)
  78                 gfs2_glock_dq_uninit(&gh);
  79         return acl;
  80 }
  81
  82 int __gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
  83 {
  84         int error;
  85         int len;
  86         char *data;
  87         const char *name = gfs2_acl_name(type);
  88
  89         if (acl) {
  90                 len = posix_acl_to_xattr(&init_user_ns, acl, NULL, 0);
  91                 if (len == 0)
  92                         return 0;
  93                 data = kmalloc(len, GFP_NOFS);
  94                 if (data == NULL)
  95                         return -ENOMEM;
  96                 error = posix_acl_to_xattr(&init_user_ns, acl, data, len);
  97                 if (error < 0)
  98                         goto out;
  99         } else {
 100                 data = NULL;
 101                 len = 0;
 102         }
 103
 104         error = __gfs2_xattr_set(inode, name, data, len, 0, GFS2_EATYPE_SYS);
 105         if (error)
 106                 goto out;
 107         set_cached_acl(inode, type, acl);
 108 out:
 109         kfree(data);
 110         return error;
 111 }
 112
 113 int gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 114 {
 115         struct gfs2_inode *ip = GFS2_I(inode);
 116         struct gfs2_holder gh;
 117         bool need_unlock = false;
 118         int ret;
 119         umode_t mode;
 120
 121         if (acl && acl->a_count > GFS2_ACL_MAX_ENTRIES(GFS2_SB(inode)))
 122                 return -E2BIG;
 123
 124         ret = gfs2_rsqa_alloc(ip);
 125         if (ret)
 126                 return ret;
 127
 128         if (!gfs2_glock_is_locked_by_me(ip->i_gl)) {
 129                 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 130                 if (ret)
 131                         return ret;
 132                 need_unlock = true;
 133         }
 134
 135         mode = inode->i_mode;
 136         if (type == ACL_TYPE_ACCESS && acl) {
 137                 ret = posix_acl_update_mode(inode, &mode, &acl);
 138                 if (ret)
 139                         goto unlock;
 140         }
 141
 142         ret = __gfs2_set_acl(inode, acl, type);
 143         if (!ret && mode != inode->i_mode) {
 144                 inode->i_mode = mode;
 145                 mark_inode_dirty(inode);
 146         }
 147 unlock:
 148         if (need_unlock)
 149                 gfs2_glock_dq_uninit(&gh);
 150         return ret;
 151 }