1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * acl.c 5 * 6 * Copyright (C) 2004, 2008 Oracle. All rights reserved. 7 * 8 * CREDITS: 9 * Lots of code in this file is copy from linux/fs/ext3/acl.c. 10 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de> 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public 14 * License version 2 as published by the Free Software Foundation. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 */ 21 22 #include <linux/init.h> 23 #include <linux/module.h> 24 #include <linux/slab.h> 25 #include <linux/string.h> 26 27 #include <cluster/masklog.h> 28 29 #include "ocfs2.h" 30 #include "alloc.h" 31 #include "dlmglue.h" 32 #include "file.h" 33 #include "inode.h" 34 #include "journal.h" 35 #include "ocfs2_fs.h" 36 37 #include "xattr.h" 38 #include "acl.h" 39 40 /* 41 * Convert from xattr value to acl struct. 42 */ 43 static struct posix_acl *ocfs2_acl_from_xattr(const void *value, size_t size) 44 { 45 int n, count; 46 struct posix_acl *acl; 47 48 if (!value) 49 return NULL; 50 if (size < sizeof(struct posix_acl_entry)) 51 return ERR_PTR(-EINVAL); 52 53 count = size / sizeof(struct posix_acl_entry); 54 55 acl = posix_acl_alloc(count, GFP_NOFS); 56 if (!acl) 57 return ERR_PTR(-ENOMEM); 58 for (n = 0; n < count; n++) { 59 struct ocfs2_acl_entry *entry = 60 (struct ocfs2_acl_entry *)value; 61 62 acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag); 63 acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm); 64 switch(acl->a_entries[n].e_tag) { 65 case ACL_USER: 66 acl->a_entries[n].e_uid = 67 make_kuid(&init_user_ns, 68 le32_to_cpu(entry->e_id)); 69 break; 70 case ACL_GROUP: 71 acl->a_entries[n].e_gid = 72 make_kgid(&init_user_ns, 73 le32_to_cpu(entry->e_id)); 74 break; 75 default: 76 break; 77 } 78 value += sizeof(struct posix_acl_entry); 79 80 } 81 return acl; 82 } 83 84 /* 85 * Convert acl struct to xattr value. 86 */ 87 static void *ocfs2_acl_to_xattr(const struct posix_acl *acl, size_t *size) 88 { 89 struct ocfs2_acl_entry *entry = NULL; 90 char *ocfs2_acl; 91 size_t n; 92 93 *size = acl->a_count * sizeof(struct posix_acl_entry); 94 95 ocfs2_acl = kmalloc(*size, GFP_NOFS); 96 if (!ocfs2_acl) 97 return ERR_PTR(-ENOMEM); 98 99 entry = (struct ocfs2_acl_entry *)ocfs2_acl; 100 for (n = 0; n < acl->a_count; n++, entry++) { 101 entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag); 102 entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm); 103 switch(acl->a_entries[n].e_tag) { 104 case ACL_USER: 105 entry->e_id = cpu_to_le32( 106 from_kuid(&init_user_ns, 107 acl->a_entries[n].e_uid)); 108 break; 109 case ACL_GROUP: 110 entry->e_id = cpu_to_le32( 111 from_kgid(&init_user_ns, 112 acl->a_entries[n].e_gid)); 113 break; 114 default: 115 entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID); 116 break; 117 } 118 } 119 return ocfs2_acl; 120 } 121 122 static struct posix_acl *ocfs2_get_acl_nolock(struct inode *inode, 123 int type, 124 struct buffer_head *di_bh) 125 { 126 int name_index; 127 char *value = NULL; 128 struct posix_acl *acl; 129 int retval; 130 131 switch (type) { 132 case ACL_TYPE_ACCESS: 133 name_index = OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS; 134 break; 135 case ACL_TYPE_DEFAULT: 136 name_index = OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT; 137 break; 138 default: 139 return ERR_PTR(-EINVAL); 140 } 141 142 retval = ocfs2_xattr_get_nolock(inode, di_bh, name_index, "", NULL, 0); 143 if (retval > 0) { 144 value = kmalloc(retval, GFP_NOFS); 145 if (!value) 146 return ERR_PTR(-ENOMEM); 147 retval = ocfs2_xattr_get_nolock(inode, di_bh, name_index, 148 "", value, retval); 149 } 150 151 if (retval > 0) 152 acl = ocfs2_acl_from_xattr(value, retval); 153 else if (retval == -ENODATA || retval == 0) 154 acl = NULL; 155 else 156 acl = ERR_PTR(retval); 157 158 kfree(value); 159 160 return acl; 161 } 162 163 /* 164 * Helper function to set i_mode in memory and disk. Some call paths 165 * will not have di_bh or a journal handle to pass, in which case it 166 * will create it's own. 167 */ 168 static int ocfs2_acl_set_mode(struct inode *inode, struct buffer_head *di_bh, 169 handle_t *handle, umode_t new_mode) 170 { 171 int ret, commit_handle = 0; 172 struct ocfs2_dinode *di; 173 174 if (di_bh == NULL) { 175 ret = ocfs2_read_inode_block(inode, &di_bh); 176 if (ret) { 177 mlog_errno(ret); 178 goto out; 179 } 180 } else 181 get_bh(di_bh); 182 183 if (handle == NULL) { 184 handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), 185 OCFS2_INODE_UPDATE_CREDITS); 186 if (IS_ERR(handle)) { 187 ret = PTR_ERR(handle); 188 mlog_errno(ret); 189 goto out_brelse; 190 } 191 192 commit_handle = 1; 193 } 194 195 di = (struct ocfs2_dinode *)di_bh->b_data; 196 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 197 OCFS2_JOURNAL_ACCESS_WRITE); 198 if (ret) { 199 mlog_errno(ret); 200 goto out_commit; 201 } 202 203 inode->i_mode = new_mode; 204 inode->i_ctime = current_time(inode); 205 di->i_mode = cpu_to_le16(inode->i_mode); 206 di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 207 di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 208 ocfs2_update_inode_fsync_trans(handle, inode, 0); 209 210 ocfs2_journal_dirty(handle, di_bh); 211 212 out_commit: 213 if (commit_handle) 214 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); 215 out_brelse: 216 brelse(di_bh); 217 out: 218 return ret; 219 } 220 221 /* 222 * Set the access or default ACL of an inode. 223 */ 224 static int ocfs2_set_acl(handle_t *handle, 225 struct inode *inode, 226 struct buffer_head *di_bh, 227 int type, 228 struct posix_acl *acl, 229 struct ocfs2_alloc_context *meta_ac, 230 struct ocfs2_alloc_context *data_ac) 231 { 232 int name_index; 233 void *value = NULL; 234 size_t size = 0; 235 int ret; 236 237 if (S_ISLNK(inode->i_mode)) 238 return -EOPNOTSUPP; 239 240 switch (type) { 241 case ACL_TYPE_ACCESS: 242 name_index = OCFS2_XATTR_INDEX_POSIX_ACL_ACCESS; 243 break; 244 case ACL_TYPE_DEFAULT: 245 name_index = OCFS2_XATTR_INDEX_POSIX_ACL_DEFAULT; 246 if (!S_ISDIR(inode->i_mode)) 247 return acl ? -EACCES : 0; 248 break; 249 default: 250 return -EINVAL; 251 } 252 253 if (acl) { 254 value = ocfs2_acl_to_xattr(acl, &size); 255 if (IS_ERR(value)) 256 return (int)PTR_ERR(value); 257 } 258 259 if (handle) 260 ret = ocfs2_xattr_set_handle(handle, inode, di_bh, name_index, 261 "", value, size, 0, 262 meta_ac, data_ac); 263 else 264 ret = ocfs2_xattr_set(inode, name_index, "", value, size, 0); 265 266 kfree(value); 267 268 return ret; 269 } 270 271 int ocfs2_iop_set_acl(struct inode *inode, struct posix_acl *acl, int type) 272 { 273 struct buffer_head *bh = NULL; 274 int status, had_lock; 275 struct ocfs2_lock_holder oh; 276 277 had_lock = ocfs2_inode_lock_tracker(inode, &bh, 1, &oh); 278 if (had_lock < 0) 279 return had_lock; 280 if (type == ACL_TYPE_ACCESS && acl) { 281 umode_t mode; 282 283 status = posix_acl_update_mode(inode, &mode, &acl); 284 if (status) 285 goto unlock; 286 287 status = ocfs2_acl_set_mode(inode, bh, NULL, mode); 288 if (status) 289 goto unlock; 290 } 291 status = ocfs2_set_acl(NULL, inode, bh, type, acl, NULL, NULL); 292 unlock: 293 ocfs2_inode_unlock_tracker(inode, 1, &oh, had_lock); 294 brelse(bh); 295 return status; 296 } 297 298 struct posix_acl *ocfs2_iop_get_acl(struct inode *inode, int type) 299 { 300 struct ocfs2_super *osb; 301 struct buffer_head *di_bh = NULL; 302 struct posix_acl *acl; 303 int had_lock; 304 struct ocfs2_lock_holder oh; 305 306 osb = OCFS2_SB(inode->i_sb); 307 if (!(osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL)) 308 return NULL; 309 310 had_lock = ocfs2_inode_lock_tracker(inode, &di_bh, 0, &oh); 311 if (had_lock < 0) 312 return ERR_PTR(had_lock); 313 314 down_read(&OCFS2_I(inode)->ip_xattr_sem); 315 acl = ocfs2_get_acl_nolock(inode, type, di_bh); 316 up_read(&OCFS2_I(inode)->ip_xattr_sem); 317 318 ocfs2_inode_unlock_tracker(inode, 0, &oh, had_lock); 319 brelse(di_bh); 320 return acl; 321 } 322 323 int ocfs2_acl_chmod(struct inode *inode, struct buffer_head *bh) 324 { 325 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 326 struct posix_acl *acl; 327 int ret; 328 329 if (S_ISLNK(inode->i_mode)) 330 return -EOPNOTSUPP; 331 332 if (!(osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL)) 333 return 0; 334 335 down_read(&OCFS2_I(inode)->ip_xattr_sem); 336 acl = ocfs2_get_acl_nolock(inode, ACL_TYPE_ACCESS, bh); 337 up_read(&OCFS2_I(inode)->ip_xattr_sem); 338 if (IS_ERR(acl) || !acl) 339 return PTR_ERR(acl); 340 ret = __posix_acl_chmod(&acl, GFP_KERNEL, inode->i_mode); 341 if (ret) 342 return ret; 343 ret = ocfs2_set_acl(NULL, inode, NULL, ACL_TYPE_ACCESS, 344 acl, NULL, NULL); 345 posix_acl_release(acl); 346 return ret; 347 } 348 349 /* 350 * Initialize the ACLs of a new inode. If parent directory has default ACL, 351 * then clone to new inode. Called from ocfs2_mknod. 352 */ 353 int ocfs2_init_acl(handle_t *handle, 354 struct inode *inode, 355 struct inode *dir, 356 struct buffer_head *di_bh, 357 struct buffer_head *dir_bh, 358 struct ocfs2_alloc_context *meta_ac, 359 struct ocfs2_alloc_context *data_ac) 360 { 361 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 362 struct posix_acl *acl = NULL; 363 int ret = 0, ret2; 364 umode_t mode; 365 366 if (!S_ISLNK(inode->i_mode)) { 367 if (osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) { 368 down_read(&OCFS2_I(dir)->ip_xattr_sem); 369 acl = ocfs2_get_acl_nolock(dir, ACL_TYPE_DEFAULT, 370 dir_bh); 371 up_read(&OCFS2_I(dir)->ip_xattr_sem); 372 if (IS_ERR(acl)) 373 return PTR_ERR(acl); 374 } 375 if (!acl) { 376 mode = inode->i_mode & ~current_umask(); 377 ret = ocfs2_acl_set_mode(inode, di_bh, handle, mode); 378 if (ret) { 379 mlog_errno(ret); 380 goto cleanup; 381 } 382 } 383 } 384 if ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) && acl) { 385 if (S_ISDIR(inode->i_mode)) { 386 ret = ocfs2_set_acl(handle, inode, di_bh, 387 ACL_TYPE_DEFAULT, acl, 388 meta_ac, data_ac); 389 if (ret) 390 goto cleanup; 391 } 392 mode = inode->i_mode; 393 ret = __posix_acl_create(&acl, GFP_NOFS, &mode); 394 if (ret < 0) 395 return ret; 396 397 ret2 = ocfs2_acl_set_mode(inode, di_bh, handle, mode); 398 if (ret2) { 399 mlog_errno(ret2); 400 ret = ret2; 401 goto cleanup; 402 } 403 if (ret > 0) { 404 ret = ocfs2_set_acl(handle, inode, 405 di_bh, ACL_TYPE_ACCESS, 406 acl, meta_ac, data_ac); 407 } 408 } 409 cleanup: 410 posix_acl_release(acl); 411 return ret; 412 } 413