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