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