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 && acl->a_count > GFS2_ACL_MAX_ENTRIES(GFS2_SB(inode)))
  90                 return -E2BIG;
  91
  92         if (type == ACL_TYPE_ACCESS) {
  93                 umode_t mode = inode->i_mode;
  94
  95                 error = posix_acl_equiv_mode(acl, &mode);
  96                 if (error < 0)
  97                         return error;
  98
  99                 if (error == 0)
 100                         acl = NULL;
 101
 102                 if (mode != inode->i_mode) {
 103                         inode->i_mode = mode;
 104                         mark_inode_dirty(inode);
 105                 }
 106         }
 107
 108         if (acl) {
 109                 len = posix_acl_to_xattr(&init_user_ns, acl, NULL, 0);
 110                 if (len == 0)
 111                         return 0;
 112                 data = kmalloc(len, GFP_NOFS);
 113                 if (data == NULL)
 114                         return -ENOMEM;
 115                 error = posix_acl_to_xattr(&init_user_ns, acl, data, len);
 116                 if (error < 0)
 117                         goto out;
 118         } else {
 119                 data = NULL;
 120                 len = 0;
 121         }
 122
 123         error = __gfs2_xattr_set(inode, name, data, len, 0, GFS2_EATYPE_SYS);
 124         if (error)
 125                 goto out;
 126         set_cached_acl(inode, type, acl);
 127 out:
 128         kfree(data);
 129         return error;
 130 }
 131
 132 int gfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 133 {
 134         struct gfs2_inode *ip = GFS2_I(inode);
 135         struct gfs2_holder gh;
 136         bool need_unlock = false;
 137         int ret;
 138
 139         ret = gfs2_rsqa_alloc(ip);
 140         if (ret)
 141                 return ret;
 142
 143         if (!gfs2_glock_is_locked_by_me(ip->i_gl)) {
 144                 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 145                 if (ret)
 146                         return ret;
 147                 need_unlock = true;
 148         }
 149         ret = __gfs2_set_acl(inode, acl, type);
 150         if (need_unlock)
 151                 gfs2_glock_dq_uninit(&gh);
 152         return ret;
 153 }