1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 22e6032be1Smarks * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #include <sys/types.h> 27fa9e4066Sahrens #include <sys/param.h> 28fa9e4066Sahrens #include <sys/time.h> 29fa9e4066Sahrens #include <sys/systm.h> 30fa9e4066Sahrens #include <sys/sysmacros.h> 31fa9e4066Sahrens #include <sys/resource.h> 32fa9e4066Sahrens #include <sys/vfs.h> 33fa9e4066Sahrens #include <sys/vnode.h> 34da6c28aaSamw #include <sys/sid.h> 35fa9e4066Sahrens #include <sys/file.h> 36fa9e4066Sahrens #include <sys/stat.h> 37fa9e4066Sahrens #include <sys/kmem.h> 38fa9e4066Sahrens #include <sys/cmn_err.h> 39fa9e4066Sahrens #include <sys/errno.h> 40fa9e4066Sahrens #include <sys/unistd.h> 41169cdae2Smarks #include <sys/sdt.h> 42fa9e4066Sahrens #include <sys/fs/zfs.h> 43fa9e4066Sahrens #include <sys/mode.h> 44fa9e4066Sahrens #include <sys/policy.h> 45fa9e4066Sahrens #include <sys/zfs_znode.h> 46da6c28aaSamw #include <sys/zfs_fuid.h> 47fa9e4066Sahrens #include <sys/zfs_acl.h> 48fa9e4066Sahrens #include <sys/zfs_dir.h> 49fa9e4066Sahrens #include <sys/zfs_vfsops.h> 50fa9e4066Sahrens #include <sys/dmu.h> 51da6c28aaSamw #include <sys/dnode.h> 52fa9e4066Sahrens #include <sys/zap.h> 53fa9e4066Sahrens #include "fs/fs_subr.h" 54fa9e4066Sahrens #include <acl/acl_common.h> 55fa9e4066Sahrens 56fa9e4066Sahrens #define ALLOW ACE_ACCESS_ALLOWED_ACE_TYPE 57fa9e4066Sahrens #define DENY ACE_ACCESS_DENIED_ACE_TYPE 58da6c28aaSamw #define MAX_ACE_TYPE ACE_SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE 59*003c2582SMark Shellenbaum #define MIN_ACE_TYPE ALLOW 60fa9e4066Sahrens 61fa9e4066Sahrens #define OWNING_GROUP (ACE_GROUP|ACE_IDENTIFIER_GROUP) 62fa9e4066Sahrens #define EVERYONE_ALLOW_MASK (ACE_READ_ACL|ACE_READ_ATTRIBUTES | \ 63fa9e4066Sahrens ACE_READ_NAMED_ATTRS|ACE_SYNCHRONIZE) 64fa9e4066Sahrens #define EVERYONE_DENY_MASK (ACE_WRITE_ACL|ACE_WRITE_OWNER | \ 65fa9e4066Sahrens ACE_WRITE_ATTRIBUTES|ACE_WRITE_NAMED_ATTRS) 66fa9e4066Sahrens #define OWNER_ALLOW_MASK (ACE_WRITE_ACL | ACE_WRITE_OWNER | \ 67fa9e4066Sahrens ACE_WRITE_ATTRIBUTES|ACE_WRITE_NAMED_ATTRS) 68da6c28aaSamw #define WRITE_MASK_DATA (ACE_WRITE_DATA|ACE_APPEND_DATA|ACE_WRITE_NAMED_ATTRS) 69da6c28aaSamw 70da6c28aaSamw #define ZFS_CHECKED_MASKS (ACE_READ_ACL|ACE_READ_ATTRIBUTES|ACE_READ_DATA| \ 71da6c28aaSamw ACE_READ_NAMED_ATTRS|ACE_WRITE_DATA|ACE_WRITE_ATTRIBUTES| \ 72da6c28aaSamw ACE_WRITE_NAMED_ATTRS|ACE_APPEND_DATA|ACE_EXECUTE|ACE_WRITE_OWNER| \ 73da6c28aaSamw ACE_WRITE_ACL|ACE_DELETE|ACE_DELETE_CHILD|ACE_SYNCHRONIZE) 74da6c28aaSamw 75da6c28aaSamw #define WRITE_MASK (WRITE_MASK_DATA|ACE_WRITE_ATTRIBUTES|ACE_WRITE_ACL|\ 76b249c65cSmarks ACE_WRITE_OWNER|ACE_DELETE|ACE_DELETE_CHILD) 77fa9e4066Sahrens 78fa9e4066Sahrens #define OGE_CLEAR (ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \ 79fa9e4066Sahrens ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_EXECUTE) 80fa9e4066Sahrens 81fa9e4066Sahrens #define OKAY_MASK_BITS (ACE_READ_DATA|ACE_LIST_DIRECTORY|ACE_WRITE_DATA| \ 82fa9e4066Sahrens ACE_ADD_FILE|ACE_APPEND_DATA|ACE_ADD_SUBDIRECTORY|ACE_EXECUTE) 83fa9e4066Sahrens 84fa9e4066Sahrens #define ALL_INHERIT (ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE | \ 85da6c28aaSamw ACE_NO_PROPAGATE_INHERIT_ACE|ACE_INHERIT_ONLY_ACE|ACE_INHERITED_ACE) 86fa9e4066Sahrens 87b3d141f8Smarks #define RESTRICTED_CLEAR (ACE_WRITE_ACL|ACE_WRITE_OWNER) 88fa9e4066Sahrens 89da6c28aaSamw #define V4_ACL_WIDE_FLAGS (ZFS_ACL_AUTO_INHERIT|ZFS_ACL_DEFAULTED|\ 90da6c28aaSamw ZFS_ACL_PROTECTED) 91da6c28aaSamw 92da6c28aaSamw #define ZFS_ACL_WIDE_FLAGS (V4_ACL_WIDE_FLAGS|ZFS_ACL_TRIVIAL|ZFS_INHERIT_ACE|\ 93da6c28aaSamw ZFS_ACL_OBJ_ACE) 94da6c28aaSamw 95da6c28aaSamw static uint16_t 96da6c28aaSamw zfs_ace_v0_get_type(void *acep) 97da6c28aaSamw { 98da6c28aaSamw return (((zfs_oldace_t *)acep)->z_type); 99da6c28aaSamw } 100da6c28aaSamw 101da6c28aaSamw static uint16_t 102da6c28aaSamw zfs_ace_v0_get_flags(void *acep) 103da6c28aaSamw { 104da6c28aaSamw return (((zfs_oldace_t *)acep)->z_flags); 105da6c28aaSamw } 106fa9e4066Sahrens 107da6c28aaSamw static uint32_t 108da6c28aaSamw zfs_ace_v0_get_mask(void *acep) 109da6c28aaSamw { 110da6c28aaSamw return (((zfs_oldace_t *)acep)->z_access_mask); 111da6c28aaSamw } 112da6c28aaSamw 113da6c28aaSamw static uint64_t 114da6c28aaSamw zfs_ace_v0_get_who(void *acep) 115da6c28aaSamw { 116da6c28aaSamw return (((zfs_oldace_t *)acep)->z_fuid); 117da6c28aaSamw } 118da6c28aaSamw 119da6c28aaSamw static void 120da6c28aaSamw zfs_ace_v0_set_type(void *acep, uint16_t type) 121da6c28aaSamw { 122da6c28aaSamw ((zfs_oldace_t *)acep)->z_type = type; 123da6c28aaSamw } 124da6c28aaSamw 125da6c28aaSamw static void 126da6c28aaSamw zfs_ace_v0_set_flags(void *acep, uint16_t flags) 127da6c28aaSamw { 128da6c28aaSamw ((zfs_oldace_t *)acep)->z_flags = flags; 129da6c28aaSamw } 130da6c28aaSamw 131da6c28aaSamw static void 132da6c28aaSamw zfs_ace_v0_set_mask(void *acep, uint32_t mask) 133da6c28aaSamw { 134da6c28aaSamw ((zfs_oldace_t *)acep)->z_access_mask = mask; 135da6c28aaSamw } 136da6c28aaSamw 137da6c28aaSamw static void 138da6c28aaSamw zfs_ace_v0_set_who(void *acep, uint64_t who) 139da6c28aaSamw { 140da6c28aaSamw ((zfs_oldace_t *)acep)->z_fuid = who; 141da6c28aaSamw } 142da6c28aaSamw 143da6c28aaSamw /*ARGSUSED*/ 144da6c28aaSamw static size_t 145da6c28aaSamw zfs_ace_v0_size(void *acep) 146da6c28aaSamw { 147da6c28aaSamw return (sizeof (zfs_oldace_t)); 148da6c28aaSamw } 149da6c28aaSamw 150da6c28aaSamw static size_t 151da6c28aaSamw zfs_ace_v0_abstract_size(void) 152da6c28aaSamw { 153da6c28aaSamw return (sizeof (zfs_oldace_t)); 154da6c28aaSamw } 155da6c28aaSamw 156da6c28aaSamw static int 157da6c28aaSamw zfs_ace_v0_mask_off(void) 158da6c28aaSamw { 159da6c28aaSamw return (offsetof(zfs_oldace_t, z_access_mask)); 160da6c28aaSamw } 161da6c28aaSamw 162da6c28aaSamw /*ARGSUSED*/ 163da6c28aaSamw static int 164da6c28aaSamw zfs_ace_v0_data(void *acep, void **datap) 165da6c28aaSamw { 166da6c28aaSamw *datap = NULL; 167da6c28aaSamw return (0); 168da6c28aaSamw } 169da6c28aaSamw 170da6c28aaSamw static acl_ops_t zfs_acl_v0_ops = { 171da6c28aaSamw zfs_ace_v0_get_mask, 172da6c28aaSamw zfs_ace_v0_set_mask, 173da6c28aaSamw zfs_ace_v0_get_flags, 174da6c28aaSamw zfs_ace_v0_set_flags, 175da6c28aaSamw zfs_ace_v0_get_type, 176da6c28aaSamw zfs_ace_v0_set_type, 177da6c28aaSamw zfs_ace_v0_get_who, 178da6c28aaSamw zfs_ace_v0_set_who, 179da6c28aaSamw zfs_ace_v0_size, 180da6c28aaSamw zfs_ace_v0_abstract_size, 181da6c28aaSamw zfs_ace_v0_mask_off, 182da6c28aaSamw zfs_ace_v0_data 183da6c28aaSamw }; 184da6c28aaSamw 185da6c28aaSamw static uint16_t 186da6c28aaSamw zfs_ace_fuid_get_type(void *acep) 187da6c28aaSamw { 188da6c28aaSamw return (((zfs_ace_hdr_t *)acep)->z_type); 189da6c28aaSamw } 190da6c28aaSamw 191da6c28aaSamw static uint16_t 192da6c28aaSamw zfs_ace_fuid_get_flags(void *acep) 193da6c28aaSamw { 194da6c28aaSamw return (((zfs_ace_hdr_t *)acep)->z_flags); 195da6c28aaSamw } 196da6c28aaSamw 197da6c28aaSamw static uint32_t 198da6c28aaSamw zfs_ace_fuid_get_mask(void *acep) 199da6c28aaSamw { 200da6c28aaSamw return (((zfs_ace_hdr_t *)acep)->z_access_mask); 201da6c28aaSamw } 202da6c28aaSamw 203da6c28aaSamw static uint64_t 204da6c28aaSamw zfs_ace_fuid_get_who(void *args) 205da6c28aaSamw { 206da6c28aaSamw uint16_t entry_type; 207da6c28aaSamw zfs_ace_t *acep = args; 208da6c28aaSamw 209da6c28aaSamw entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS; 210da6c28aaSamw 211da6c28aaSamw if (entry_type == ACE_OWNER || entry_type == OWNING_GROUP || 212da6c28aaSamw entry_type == ACE_EVERYONE) 213da6c28aaSamw return (-1); 214da6c28aaSamw return (((zfs_ace_t *)acep)->z_fuid); 215da6c28aaSamw } 216da6c28aaSamw 217da6c28aaSamw static void 218da6c28aaSamw zfs_ace_fuid_set_type(void *acep, uint16_t type) 219da6c28aaSamw { 220da6c28aaSamw ((zfs_ace_hdr_t *)acep)->z_type = type; 221da6c28aaSamw } 222da6c28aaSamw 223da6c28aaSamw static void 224da6c28aaSamw zfs_ace_fuid_set_flags(void *acep, uint16_t flags) 225da6c28aaSamw { 226da6c28aaSamw ((zfs_ace_hdr_t *)acep)->z_flags = flags; 227da6c28aaSamw } 228da6c28aaSamw 229da6c28aaSamw static void 230da6c28aaSamw zfs_ace_fuid_set_mask(void *acep, uint32_t mask) 231da6c28aaSamw { 232da6c28aaSamw ((zfs_ace_hdr_t *)acep)->z_access_mask = mask; 233da6c28aaSamw } 234da6c28aaSamw 235da6c28aaSamw static void 236da6c28aaSamw zfs_ace_fuid_set_who(void *arg, uint64_t who) 237da6c28aaSamw { 238da6c28aaSamw zfs_ace_t *acep = arg; 239da6c28aaSamw 240da6c28aaSamw uint16_t entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS; 241da6c28aaSamw 242da6c28aaSamw if (entry_type == ACE_OWNER || entry_type == OWNING_GROUP || 243da6c28aaSamw entry_type == ACE_EVERYONE) 244da6c28aaSamw return; 245da6c28aaSamw acep->z_fuid = who; 246da6c28aaSamw } 247da6c28aaSamw 248da6c28aaSamw static size_t 249da6c28aaSamw zfs_ace_fuid_size(void *acep) 250da6c28aaSamw { 251da6c28aaSamw zfs_ace_hdr_t *zacep = acep; 252da6c28aaSamw uint16_t entry_type; 253da6c28aaSamw 254da6c28aaSamw switch (zacep->z_type) { 255da6c28aaSamw case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 256da6c28aaSamw case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 257da6c28aaSamw case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 258da6c28aaSamw case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 259da6c28aaSamw return (sizeof (zfs_object_ace_t)); 260da6c28aaSamw case ALLOW: 261da6c28aaSamw case DENY: 262da6c28aaSamw entry_type = 263da6c28aaSamw (((zfs_ace_hdr_t *)acep)->z_flags & ACE_TYPE_FLAGS); 264da6c28aaSamw if (entry_type == ACE_OWNER || 2651ab99678SMark Shellenbaum entry_type == OWNING_GROUP || 266da6c28aaSamw entry_type == ACE_EVERYONE) 267da6c28aaSamw return (sizeof (zfs_ace_hdr_t)); 268da6c28aaSamw /*FALLTHROUGH*/ 269da6c28aaSamw default: 270da6c28aaSamw return (sizeof (zfs_ace_t)); 271da6c28aaSamw } 272da6c28aaSamw } 273da6c28aaSamw 274da6c28aaSamw static size_t 275da6c28aaSamw zfs_ace_fuid_abstract_size(void) 276da6c28aaSamw { 277da6c28aaSamw return (sizeof (zfs_ace_hdr_t)); 278da6c28aaSamw } 279da6c28aaSamw 280da6c28aaSamw static int 281da6c28aaSamw zfs_ace_fuid_mask_off(void) 282da6c28aaSamw { 283da6c28aaSamw return (offsetof(zfs_ace_hdr_t, z_access_mask)); 284da6c28aaSamw } 285da6c28aaSamw 286da6c28aaSamw static int 287da6c28aaSamw zfs_ace_fuid_data(void *acep, void **datap) 288da6c28aaSamw { 289da6c28aaSamw zfs_ace_t *zacep = acep; 290da6c28aaSamw zfs_object_ace_t *zobjp; 291da6c28aaSamw 292da6c28aaSamw switch (zacep->z_hdr.z_type) { 293da6c28aaSamw case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 294da6c28aaSamw case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 295da6c28aaSamw case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 296da6c28aaSamw case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 297da6c28aaSamw zobjp = acep; 298da6c28aaSamw *datap = (caddr_t)zobjp + sizeof (zfs_ace_t); 299da6c28aaSamw return (sizeof (zfs_object_ace_t) - sizeof (zfs_ace_t)); 300da6c28aaSamw default: 301da6c28aaSamw *datap = NULL; 302da6c28aaSamw return (0); 303da6c28aaSamw } 304da6c28aaSamw } 305da6c28aaSamw 306da6c28aaSamw static acl_ops_t zfs_acl_fuid_ops = { 307da6c28aaSamw zfs_ace_fuid_get_mask, 308da6c28aaSamw zfs_ace_fuid_set_mask, 309da6c28aaSamw zfs_ace_fuid_get_flags, 310da6c28aaSamw zfs_ace_fuid_set_flags, 311da6c28aaSamw zfs_ace_fuid_get_type, 312da6c28aaSamw zfs_ace_fuid_set_type, 313da6c28aaSamw zfs_ace_fuid_get_who, 314da6c28aaSamw zfs_ace_fuid_set_who, 315da6c28aaSamw zfs_ace_fuid_size, 316da6c28aaSamw zfs_ace_fuid_abstract_size, 317da6c28aaSamw zfs_ace_fuid_mask_off, 318da6c28aaSamw zfs_ace_fuid_data 319da6c28aaSamw }; 320da6c28aaSamw 321da6c28aaSamw static int 322da6c28aaSamw zfs_acl_version(int version) 323da6c28aaSamw { 324da6c28aaSamw if (version < ZPL_VERSION_FUID) 325da6c28aaSamw return (ZFS_ACL_VERSION_INITIAL); 326da6c28aaSamw else 327da6c28aaSamw return (ZFS_ACL_VERSION_FUID); 328da6c28aaSamw } 329da6c28aaSamw 330da6c28aaSamw static int 331da6c28aaSamw zfs_acl_version_zp(znode_t *zp) 332da6c28aaSamw { 333da6c28aaSamw return (zfs_acl_version(zp->z_zfsvfs->z_version)); 334da6c28aaSamw } 335fa9e4066Sahrens 336fa9e4066Sahrens static zfs_acl_t * 337da6c28aaSamw zfs_acl_alloc(int vers) 338fa9e4066Sahrens { 339fa9e4066Sahrens zfs_acl_t *aclp; 340fa9e4066Sahrens 341fa9e4066Sahrens aclp = kmem_zalloc(sizeof (zfs_acl_t), KM_SLEEP); 342da6c28aaSamw list_create(&aclp->z_acl, sizeof (zfs_acl_node_t), 343da6c28aaSamw offsetof(zfs_acl_node_t, z_next)); 344da6c28aaSamw aclp->z_version = vers; 345da6c28aaSamw if (vers == ZFS_ACL_VERSION_FUID) 346da6c28aaSamw aclp->z_ops = zfs_acl_fuid_ops; 347da6c28aaSamw else 348da6c28aaSamw aclp->z_ops = zfs_acl_v0_ops; 349fa9e4066Sahrens return (aclp); 350fa9e4066Sahrens } 351fa9e4066Sahrens 352da6c28aaSamw static zfs_acl_node_t * 353da6c28aaSamw zfs_acl_node_alloc(size_t bytes) 354da6c28aaSamw { 355da6c28aaSamw zfs_acl_node_t *aclnode; 356da6c28aaSamw 357da6c28aaSamw aclnode = kmem_zalloc(sizeof (zfs_acl_node_t), KM_SLEEP); 358da6c28aaSamw if (bytes) { 359da6c28aaSamw aclnode->z_acldata = kmem_alloc(bytes, KM_SLEEP); 360da6c28aaSamw aclnode->z_allocdata = aclnode->z_acldata; 361da6c28aaSamw aclnode->z_allocsize = bytes; 362da6c28aaSamw aclnode->z_size = bytes; 363da6c28aaSamw } 364da6c28aaSamw 365da6c28aaSamw return (aclnode); 366da6c28aaSamw } 367da6c28aaSamw 368da6c28aaSamw static void 369da6c28aaSamw zfs_acl_node_free(zfs_acl_node_t *aclnode) 370da6c28aaSamw { 371da6c28aaSamw if (aclnode->z_allocsize) 372da6c28aaSamw kmem_free(aclnode->z_allocdata, aclnode->z_allocsize); 373da6c28aaSamw kmem_free(aclnode, sizeof (zfs_acl_node_t)); 374da6c28aaSamw } 375da6c28aaSamw 3762459a9eaSmarks static void 3772459a9eaSmarks zfs_acl_release_nodes(zfs_acl_t *aclp) 378fa9e4066Sahrens { 379da6c28aaSamw zfs_acl_node_t *aclnode; 380da6c28aaSamw 381da6c28aaSamw while (aclnode = list_head(&aclp->z_acl)) { 382da6c28aaSamw list_remove(&aclp->z_acl, aclnode); 383da6c28aaSamw zfs_acl_node_free(aclnode); 384fa9e4066Sahrens } 3852459a9eaSmarks aclp->z_acl_count = 0; 3862459a9eaSmarks aclp->z_acl_bytes = 0; 3872459a9eaSmarks } 388da6c28aaSamw 3892459a9eaSmarks void 3902459a9eaSmarks zfs_acl_free(zfs_acl_t *aclp) 3912459a9eaSmarks { 3922459a9eaSmarks zfs_acl_release_nodes(aclp); 393da6c28aaSamw list_destroy(&aclp->z_acl); 394fa9e4066Sahrens kmem_free(aclp, sizeof (zfs_acl_t)); 395fa9e4066Sahrens } 396fa9e4066Sahrens 397da6c28aaSamw static boolean_t 398*003c2582SMark Shellenbaum zfs_acl_valid_ace_type(uint_t type, uint_t flags) 399fa9e4066Sahrens { 400*003c2582SMark Shellenbaum uint16_t entry_type; 401da6c28aaSamw 402*003c2582SMark Shellenbaum switch (type) { 403*003c2582SMark Shellenbaum case ALLOW: 404*003c2582SMark Shellenbaum case DENY: 405*003c2582SMark Shellenbaum case ACE_SYSTEM_AUDIT_ACE_TYPE: 406*003c2582SMark Shellenbaum case ACE_SYSTEM_ALARM_ACE_TYPE: 407*003c2582SMark Shellenbaum entry_type = flags & ACE_TYPE_FLAGS; 408*003c2582SMark Shellenbaum return (entry_type == ACE_OWNER || 409*003c2582SMark Shellenbaum entry_type == OWNING_GROUP || 410*003c2582SMark Shellenbaum entry_type == ACE_EVERYONE || entry_type == 0 || 411*003c2582SMark Shellenbaum entry_type == ACE_IDENTIFIER_GROUP); 412da6c28aaSamw default: 413*003c2582SMark Shellenbaum if (type >= MIN_ACE_TYPE && type <= MAX_ACE_TYPE) 414*003c2582SMark Shellenbaum return (B_TRUE); 415da6c28aaSamw } 416*003c2582SMark Shellenbaum return (B_FALSE); 417*003c2582SMark Shellenbaum } 418fa9e4066Sahrens 419*003c2582SMark Shellenbaum static boolean_t 420*003c2582SMark Shellenbaum zfs_ace_valid(vtype_t obj_type, zfs_acl_t *aclp, uint16_t type, uint16_t iflags) 421*003c2582SMark Shellenbaum { 422169cdae2Smarks /* 423*003c2582SMark Shellenbaum * first check type of entry 424169cdae2Smarks */ 425fa9e4066Sahrens 426*003c2582SMark Shellenbaum if (!zfs_acl_valid_ace_type(type, iflags)) 427da6c28aaSamw return (B_FALSE); 428da6c28aaSamw 429da6c28aaSamw switch (type) { 430da6c28aaSamw case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 431da6c28aaSamw case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 432da6c28aaSamw case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 433da6c28aaSamw case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 434da6c28aaSamw if (aclp->z_version < ZFS_ACL_VERSION_FUID) 435da6c28aaSamw return (B_FALSE); 436da6c28aaSamw aclp->z_hints |= ZFS_ACL_OBJ_ACE; 437da6c28aaSamw } 438da6c28aaSamw 439*003c2582SMark Shellenbaum /* 440*003c2582SMark Shellenbaum * next check inheritance level flags 441*003c2582SMark Shellenbaum */ 442*003c2582SMark Shellenbaum 443b249c65cSmarks if (obj_type == VDIR && 444b249c65cSmarks (iflags & (ACE_FILE_INHERIT_ACE|ACE_DIRECTORY_INHERIT_ACE))) 445da6c28aaSamw aclp->z_hints |= ZFS_INHERIT_ACE; 446da6c28aaSamw 447da6c28aaSamw if (iflags & (ACE_INHERIT_ONLY_ACE|ACE_NO_PROPAGATE_INHERIT_ACE)) { 448da6c28aaSamw if ((iflags & (ACE_FILE_INHERIT_ACE| 449da6c28aaSamw ACE_DIRECTORY_INHERIT_ACE)) == 0) { 450da6c28aaSamw return (B_FALSE); 451da6c28aaSamw } 452da6c28aaSamw } 453da6c28aaSamw 454da6c28aaSamw return (B_TRUE); 455da6c28aaSamw } 456da6c28aaSamw 457da6c28aaSamw static void * 458da6c28aaSamw zfs_acl_next_ace(zfs_acl_t *aclp, void *start, uint64_t *who, 459da6c28aaSamw uint32_t *access_mask, uint16_t *iflags, uint16_t *type) 460da6c28aaSamw { 461da6c28aaSamw zfs_acl_node_t *aclnode; 462da6c28aaSamw 463da6c28aaSamw if (start == NULL) { 464da6c28aaSamw aclnode = list_head(&aclp->z_acl); 465da6c28aaSamw if (aclnode == NULL) 466da6c28aaSamw return (NULL); 467da6c28aaSamw 468da6c28aaSamw aclp->z_next_ace = aclnode->z_acldata; 469da6c28aaSamw aclp->z_curr_node = aclnode; 470da6c28aaSamw aclnode->z_ace_idx = 0; 471da6c28aaSamw } 472da6c28aaSamw 473da6c28aaSamw aclnode = aclp->z_curr_node; 474da6c28aaSamw 475da6c28aaSamw if (aclnode == NULL) 476da6c28aaSamw return (NULL); 477da6c28aaSamw 478da6c28aaSamw if (aclnode->z_ace_idx >= aclnode->z_ace_count) { 479da6c28aaSamw aclnode = list_next(&aclp->z_acl, aclnode); 480da6c28aaSamw if (aclnode == NULL) 481da6c28aaSamw return (NULL); 482da6c28aaSamw else { 483da6c28aaSamw aclp->z_curr_node = aclnode; 484da6c28aaSamw aclnode->z_ace_idx = 0; 485da6c28aaSamw aclp->z_next_ace = aclnode->z_acldata; 486da6c28aaSamw } 487da6c28aaSamw } 488da6c28aaSamw 489da6c28aaSamw if (aclnode->z_ace_idx < aclnode->z_ace_count) { 490da6c28aaSamw void *acep = aclp->z_next_ace; 491*003c2582SMark Shellenbaum size_t ace_size; 492*003c2582SMark Shellenbaum 493*003c2582SMark Shellenbaum /* 494*003c2582SMark Shellenbaum * Make sure we don't overstep our bounds 495*003c2582SMark Shellenbaum */ 496*003c2582SMark Shellenbaum ace_size = aclp->z_ops.ace_size(acep); 497*003c2582SMark Shellenbaum 498*003c2582SMark Shellenbaum if (((caddr_t)acep + ace_size) > 499*003c2582SMark Shellenbaum ((caddr_t)aclnode->z_acldata + aclnode->z_size)) { 500*003c2582SMark Shellenbaum return (NULL); 501*003c2582SMark Shellenbaum } 502*003c2582SMark Shellenbaum 503da6c28aaSamw *iflags = aclp->z_ops.ace_flags_get(acep); 504da6c28aaSamw *type = aclp->z_ops.ace_type_get(acep); 505da6c28aaSamw *access_mask = aclp->z_ops.ace_mask_get(acep); 506da6c28aaSamw *who = aclp->z_ops.ace_who_get(acep); 507*003c2582SMark Shellenbaum aclp->z_next_ace = (caddr_t)aclp->z_next_ace + ace_size; 508da6c28aaSamw aclnode->z_ace_idx++; 509da6c28aaSamw return ((void *)acep); 510da6c28aaSamw } 511da6c28aaSamw return (NULL); 512da6c28aaSamw } 513da6c28aaSamw 514da6c28aaSamw /*ARGSUSED*/ 515da6c28aaSamw static uint64_t 516da6c28aaSamw zfs_ace_walk(void *datap, uint64_t cookie, int aclcnt, 517da6c28aaSamw uint16_t *flags, uint16_t *type, uint32_t *mask) 518da6c28aaSamw { 519da6c28aaSamw zfs_acl_t *aclp = datap; 520da6c28aaSamw zfs_ace_hdr_t *acep = (zfs_ace_hdr_t *)(uintptr_t)cookie; 521da6c28aaSamw uint64_t who; 522da6c28aaSamw 523da6c28aaSamw acep = zfs_acl_next_ace(aclp, acep, &who, mask, 524da6c28aaSamw flags, type); 525da6c28aaSamw return ((uint64_t)(uintptr_t)acep); 526da6c28aaSamw } 527da6c28aaSamw 528da6c28aaSamw static zfs_acl_node_t * 529da6c28aaSamw zfs_acl_curr_node(zfs_acl_t *aclp) 530da6c28aaSamw { 531da6c28aaSamw ASSERT(aclp->z_curr_node); 532da6c28aaSamw return (aclp->z_curr_node); 533da6c28aaSamw } 534da6c28aaSamw 535da6c28aaSamw /* 536da6c28aaSamw * Copy ACE to internal ZFS format. 537da6c28aaSamw * While processing the ACL each ACE will be validated for correctness. 538da6c28aaSamw * ACE FUIDs will be created later. 539da6c28aaSamw */ 540da6c28aaSamw int 541da6c28aaSamw zfs_copy_ace_2_fuid(vtype_t obj_type, zfs_acl_t *aclp, void *datap, 542da6c28aaSamw zfs_ace_t *z_acl, int aclcnt, size_t *size) 543da6c28aaSamw { 544da6c28aaSamw int i; 545da6c28aaSamw uint16_t entry_type; 546da6c28aaSamw zfs_ace_t *aceptr = z_acl; 547da6c28aaSamw ace_t *acep = datap; 548da6c28aaSamw zfs_object_ace_t *zobjacep; 549da6c28aaSamw ace_object_t *aceobjp; 550da6c28aaSamw 551da6c28aaSamw for (i = 0; i != aclcnt; i++) { 552da6c28aaSamw aceptr->z_hdr.z_access_mask = acep->a_access_mask; 553da6c28aaSamw aceptr->z_hdr.z_flags = acep->a_flags; 554da6c28aaSamw aceptr->z_hdr.z_type = acep->a_type; 555da6c28aaSamw entry_type = aceptr->z_hdr.z_flags & ACE_TYPE_FLAGS; 556da6c28aaSamw if (entry_type != ACE_OWNER && entry_type != OWNING_GROUP && 5574c841f60Smarks entry_type != ACE_EVERYONE) { 5584c841f60Smarks if (!aclp->z_has_fuids) 559e0d35c44Smarks aclp->z_has_fuids = IS_EPHEMERAL(acep->a_who); 560da6c28aaSamw aceptr->z_fuid = (uint64_t)acep->a_who; 5614c841f60Smarks } 5624c841f60Smarks 563da6c28aaSamw /* 564da6c28aaSamw * Make sure ACE is valid 565da6c28aaSamw */ 566da6c28aaSamw if (zfs_ace_valid(obj_type, aclp, aceptr->z_hdr.z_type, 567da6c28aaSamw aceptr->z_hdr.z_flags) != B_TRUE) 568da6c28aaSamw return (EINVAL); 569da6c28aaSamw 570da6c28aaSamw switch (acep->a_type) { 571da6c28aaSamw case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 572da6c28aaSamw case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 573da6c28aaSamw case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 574da6c28aaSamw case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 575da6c28aaSamw zobjacep = (zfs_object_ace_t *)aceptr; 576da6c28aaSamw aceobjp = (ace_object_t *)acep; 577da6c28aaSamw 578da6c28aaSamw bcopy(aceobjp->a_obj_type, zobjacep->z_object_type, 579da6c28aaSamw sizeof (aceobjp->a_obj_type)); 580da6c28aaSamw bcopy(aceobjp->a_inherit_obj_type, 581da6c28aaSamw zobjacep->z_inherit_type, 582da6c28aaSamw sizeof (aceobjp->a_inherit_obj_type)); 583da6c28aaSamw acep = (ace_t *)((caddr_t)acep + sizeof (ace_object_t)); 584da6c28aaSamw break; 585da6c28aaSamw default: 586da6c28aaSamw acep = (ace_t *)((caddr_t)acep + sizeof (ace_t)); 587da6c28aaSamw } 588da6c28aaSamw 589da6c28aaSamw aceptr = (zfs_ace_t *)((caddr_t)aceptr + 590da6c28aaSamw aclp->z_ops.ace_size(aceptr)); 591da6c28aaSamw } 592da6c28aaSamw 593da6c28aaSamw *size = (caddr_t)aceptr - (caddr_t)z_acl; 594da6c28aaSamw 595da6c28aaSamw return (0); 596da6c28aaSamw } 597da6c28aaSamw 598da6c28aaSamw /* 599da6c28aaSamw * Copy ZFS ACEs to fixed size ace_t layout 600da6c28aaSamw */ 601da6c28aaSamw static void 602bda89588Sjp zfs_copy_fuid_2_ace(zfsvfs_t *zfsvfs, zfs_acl_t *aclp, cred_t *cr, 603bda89588Sjp void *datap, int filter) 604da6c28aaSamw { 605da6c28aaSamw uint64_t who; 606da6c28aaSamw uint32_t access_mask; 607da6c28aaSamw uint16_t iflags, type; 608da6c28aaSamw zfs_ace_hdr_t *zacep = NULL; 609da6c28aaSamw ace_t *acep = datap; 610da6c28aaSamw ace_object_t *objacep; 611da6c28aaSamw zfs_object_ace_t *zobjacep; 612da6c28aaSamw size_t ace_size; 613da6c28aaSamw uint16_t entry_type; 614da6c28aaSamw 615da6c28aaSamw while (zacep = zfs_acl_next_ace(aclp, zacep, 616da6c28aaSamw &who, &access_mask, &iflags, &type)) { 617da6c28aaSamw 618da6c28aaSamw switch (type) { 619da6c28aaSamw case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 620da6c28aaSamw case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 621da6c28aaSamw case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 622da6c28aaSamw case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 623da6c28aaSamw if (filter) { 624da6c28aaSamw continue; 625da6c28aaSamw } 626da6c28aaSamw zobjacep = (zfs_object_ace_t *)zacep; 627da6c28aaSamw objacep = (ace_object_t *)acep; 628da6c28aaSamw bcopy(zobjacep->z_object_type, 629da6c28aaSamw objacep->a_obj_type, 630da6c28aaSamw sizeof (zobjacep->z_object_type)); 631da6c28aaSamw bcopy(zobjacep->z_inherit_type, 632da6c28aaSamw objacep->a_inherit_obj_type, 633da6c28aaSamw sizeof (zobjacep->z_inherit_type)); 634da6c28aaSamw ace_size = sizeof (ace_object_t); 635da6c28aaSamw break; 636da6c28aaSamw default: 637da6c28aaSamw ace_size = sizeof (ace_t); 638da6c28aaSamw break; 639da6c28aaSamw } 640da6c28aaSamw 641da6c28aaSamw entry_type = (iflags & ACE_TYPE_FLAGS); 642da6c28aaSamw if ((entry_type != ACE_OWNER && 6431ab99678SMark Shellenbaum entry_type != OWNING_GROUP && 644e0d35c44Smarks entry_type != ACE_EVERYONE)) { 645e0d35c44Smarks acep->a_who = zfs_fuid_map_id(zfsvfs, who, 646e0d35c44Smarks cr, (entry_type & ACE_IDENTIFIER_GROUP) ? 647e0d35c44Smarks ZFS_ACE_GROUP : ZFS_ACE_USER); 648e0d35c44Smarks } else { 649da6c28aaSamw acep->a_who = (uid_t)(int64_t)who; 650e0d35c44Smarks } 651da6c28aaSamw acep->a_access_mask = access_mask; 652da6c28aaSamw acep->a_flags = iflags; 653da6c28aaSamw acep->a_type = type; 654da6c28aaSamw acep = (ace_t *)((caddr_t)acep + ace_size); 655da6c28aaSamw } 656da6c28aaSamw } 657da6c28aaSamw 658da6c28aaSamw static int 659da6c28aaSamw zfs_copy_ace_2_oldace(vtype_t obj_type, zfs_acl_t *aclp, ace_t *acep, 660da6c28aaSamw zfs_oldace_t *z_acl, int aclcnt, size_t *size) 661da6c28aaSamw { 662da6c28aaSamw int i; 663da6c28aaSamw zfs_oldace_t *aceptr = z_acl; 664da6c28aaSamw 665da6c28aaSamw for (i = 0; i != aclcnt; i++, aceptr++) { 666da6c28aaSamw aceptr->z_access_mask = acep[i].a_access_mask; 667da6c28aaSamw aceptr->z_type = acep[i].a_type; 668da6c28aaSamw aceptr->z_flags = acep[i].a_flags; 669da6c28aaSamw aceptr->z_fuid = acep[i].a_who; 670da6c28aaSamw /* 671da6c28aaSamw * Make sure ACE is valid 672da6c28aaSamw */ 673da6c28aaSamw if (zfs_ace_valid(obj_type, aclp, aceptr->z_type, 674da6c28aaSamw aceptr->z_flags) != B_TRUE) 675da6c28aaSamw return (EINVAL); 676da6c28aaSamw } 677da6c28aaSamw *size = (caddr_t)aceptr - (caddr_t)z_acl; 678da6c28aaSamw return (0); 679da6c28aaSamw } 680da6c28aaSamw 681da6c28aaSamw /* 682da6c28aaSamw * convert old ACL format to new 683da6c28aaSamw */ 684da6c28aaSamw void 685da6c28aaSamw zfs_acl_xform(znode_t *zp, zfs_acl_t *aclp) 686da6c28aaSamw { 687da6c28aaSamw zfs_oldace_t *oldaclp; 688da6c28aaSamw int i; 689da6c28aaSamw uint16_t type, iflags; 690da6c28aaSamw uint32_t access_mask; 691da6c28aaSamw uint64_t who; 692da6c28aaSamw void *cookie = NULL; 6932459a9eaSmarks zfs_acl_node_t *newaclnode; 694da6c28aaSamw 695da6c28aaSamw ASSERT(aclp->z_version == ZFS_ACL_VERSION_INITIAL); 696da6c28aaSamw /* 697da6c28aaSamw * First create the ACE in a contiguous piece of memory 698da6c28aaSamw * for zfs_copy_ace_2_fuid(). 699da6c28aaSamw * 700da6c28aaSamw * We only convert an ACL once, so this won't happen 701da6c28aaSamw * everytime. 702da6c28aaSamw */ 703da6c28aaSamw oldaclp = kmem_alloc(sizeof (zfs_oldace_t) * aclp->z_acl_count, 704da6c28aaSamw KM_SLEEP); 705da6c28aaSamw i = 0; 706da6c28aaSamw while (cookie = zfs_acl_next_ace(aclp, cookie, &who, 707da6c28aaSamw &access_mask, &iflags, &type)) { 708da6c28aaSamw oldaclp[i].z_flags = iflags; 709da6c28aaSamw oldaclp[i].z_type = type; 710da6c28aaSamw oldaclp[i].z_fuid = who; 711da6c28aaSamw oldaclp[i++].z_access_mask = access_mask; 712da6c28aaSamw } 713da6c28aaSamw 714da6c28aaSamw newaclnode = zfs_acl_node_alloc(aclp->z_acl_count * 715da6c28aaSamw sizeof (zfs_object_ace_t)); 716da6c28aaSamw aclp->z_ops = zfs_acl_fuid_ops; 717da6c28aaSamw VERIFY(zfs_copy_ace_2_fuid(ZTOV(zp)->v_type, aclp, oldaclp, 718da6c28aaSamw newaclnode->z_acldata, aclp->z_acl_count, 719da6c28aaSamw &newaclnode->z_size) == 0); 720da6c28aaSamw newaclnode->z_ace_count = aclp->z_acl_count; 721da6c28aaSamw aclp->z_version = ZFS_ACL_VERSION; 722da6c28aaSamw kmem_free(oldaclp, aclp->z_acl_count * sizeof (zfs_oldace_t)); 723da6c28aaSamw 724da6c28aaSamw /* 725da6c28aaSamw * Release all previous ACL nodes 726da6c28aaSamw */ 727da6c28aaSamw 7282459a9eaSmarks zfs_acl_release_nodes(aclp); 7292459a9eaSmarks 730da6c28aaSamw list_insert_head(&aclp->z_acl, newaclnode); 7312459a9eaSmarks 7322459a9eaSmarks aclp->z_acl_bytes = newaclnode->z_size; 7332459a9eaSmarks aclp->z_acl_count = newaclnode->z_ace_count; 7342459a9eaSmarks 735fa9e4066Sahrens } 736fa9e4066Sahrens 737fa9e4066Sahrens /* 738fa9e4066Sahrens * Convert unix access mask to v4 access mask 739fa9e4066Sahrens */ 740fa9e4066Sahrens static uint32_t 741fa9e4066Sahrens zfs_unix_to_v4(uint32_t access_mask) 742fa9e4066Sahrens { 743fa9e4066Sahrens uint32_t new_mask = 0; 744fa9e4066Sahrens 745da6c28aaSamw if (access_mask & S_IXOTH) 746da6c28aaSamw new_mask |= ACE_EXECUTE; 747da6c28aaSamw if (access_mask & S_IWOTH) 748da6c28aaSamw new_mask |= ACE_WRITE_DATA; 749da6c28aaSamw if (access_mask & S_IROTH) 750fa9e4066Sahrens new_mask |= ACE_READ_DATA; 751fa9e4066Sahrens return (new_mask); 752fa9e4066Sahrens } 753fa9e4066Sahrens 754fa9e4066Sahrens static void 755da6c28aaSamw zfs_set_ace(zfs_acl_t *aclp, void *acep, uint32_t access_mask, 756da6c28aaSamw uint16_t access_type, uint64_t fuid, uint16_t entry_type) 757fa9e4066Sahrens { 758da6c28aaSamw uint16_t type = entry_type & ACE_TYPE_FLAGS; 759da6c28aaSamw 760da6c28aaSamw aclp->z_ops.ace_mask_set(acep, access_mask); 761da6c28aaSamw aclp->z_ops.ace_type_set(acep, access_type); 762da6c28aaSamw aclp->z_ops.ace_flags_set(acep, entry_type); 7631ab99678SMark Shellenbaum if ((type != ACE_OWNER && type != OWNING_GROUP && 764da6c28aaSamw type != ACE_EVERYONE)) 765da6c28aaSamw aclp->z_ops.ace_who_set(acep, fuid); 766fa9e4066Sahrens } 767fa9e4066Sahrens 768da6c28aaSamw /* 769da6c28aaSamw * Determine mode of file based on ACL. 770da6c28aaSamw * Also, create FUIDs for any User/Group ACEs 771da6c28aaSamw */ 772fa9e4066Sahrens static uint64_t 773bda89588Sjp zfs_mode_fuid_compute(znode_t *zp, zfs_acl_t *aclp, cred_t *cr, 774bda89588Sjp zfs_fuid_info_t **fuidp, dmu_tx_t *tx) 775fa9e4066Sahrens { 776da6c28aaSamw int entry_type; 777da6c28aaSamw mode_t mode; 778da6c28aaSamw mode_t seen = 0; 779da6c28aaSamw zfs_ace_hdr_t *acep = NULL; 780da6c28aaSamw uint64_t who; 781da6c28aaSamw uint16_t iflags, type; 782da6c28aaSamw uint32_t access_mask; 783da6c28aaSamw 784da6c28aaSamw mode = (zp->z_phys->zp_mode & (S_IFMT | S_ISUID | S_ISGID | S_ISVTX)); 785fa9e4066Sahrens 786da6c28aaSamw while (acep = zfs_acl_next_ace(aclp, acep, &who, 787da6c28aaSamw &access_mask, &iflags, &type)) { 78829a0b737Smarks 789*003c2582SMark Shellenbaum if (!zfs_acl_valid_ace_type(type, iflags)) 790*003c2582SMark Shellenbaum continue; 791*003c2582SMark Shellenbaum 7921ab99678SMark Shellenbaum entry_type = (iflags & ACE_TYPE_FLAGS); 7931ab99678SMark Shellenbaum 79429a0b737Smarks /* 7951ab99678SMark Shellenbaum * Skip over owner@, group@ or everyone@ inherit only ACEs 79629a0b737Smarks */ 7971ab99678SMark Shellenbaum if ((iflags & ACE_INHERIT_ONLY_ACE) && 7981ab99678SMark Shellenbaum (entry_type == ACE_OWNER || entry_type == ACE_EVERYONE || 7991ab99678SMark Shellenbaum entry_type == OWNING_GROUP)) 80029a0b737Smarks continue; 80129a0b737Smarks 802fa9e4066Sahrens if (entry_type == ACE_OWNER) { 803da6c28aaSamw if ((access_mask & ACE_READ_DATA) && 804fa9e4066Sahrens (!(seen & S_IRUSR))) { 805fa9e4066Sahrens seen |= S_IRUSR; 806da6c28aaSamw if (type == ALLOW) { 807fa9e4066Sahrens mode |= S_IRUSR; 808fa9e4066Sahrens } 809fa9e4066Sahrens } 810da6c28aaSamw if ((access_mask & ACE_WRITE_DATA) && 811fa9e4066Sahrens (!(seen & S_IWUSR))) { 812fa9e4066Sahrens seen |= S_IWUSR; 813da6c28aaSamw if (type == ALLOW) { 814fa9e4066Sahrens mode |= S_IWUSR; 815fa9e4066Sahrens } 816fa9e4066Sahrens } 817da6c28aaSamw if ((access_mask & ACE_EXECUTE) && 818fa9e4066Sahrens (!(seen & S_IXUSR))) { 819fa9e4066Sahrens seen |= S_IXUSR; 820da6c28aaSamw if (type == ALLOW) { 821fa9e4066Sahrens mode |= S_IXUSR; 822fa9e4066Sahrens } 823fa9e4066Sahrens } 824fa9e4066Sahrens } else if (entry_type == OWNING_GROUP) { 825da6c28aaSamw if ((access_mask & ACE_READ_DATA) && 826fa9e4066Sahrens (!(seen & S_IRGRP))) { 827fa9e4066Sahrens seen |= S_IRGRP; 828da6c28aaSamw if (type == ALLOW) { 829fa9e4066Sahrens mode |= S_IRGRP; 830fa9e4066Sahrens } 831fa9e4066Sahrens } 832da6c28aaSamw if ((access_mask & ACE_WRITE_DATA) && 833fa9e4066Sahrens (!(seen & S_IWGRP))) { 834fa9e4066Sahrens seen |= S_IWGRP; 835da6c28aaSamw if (type == ALLOW) { 836fa9e4066Sahrens mode |= S_IWGRP; 837fa9e4066Sahrens } 838fa9e4066Sahrens } 839da6c28aaSamw if ((access_mask & ACE_EXECUTE) && 840fa9e4066Sahrens (!(seen & S_IXGRP))) { 841fa9e4066Sahrens seen |= S_IXGRP; 842da6c28aaSamw if (type == ALLOW) { 843fa9e4066Sahrens mode |= S_IXGRP; 844fa9e4066Sahrens } 845fa9e4066Sahrens } 846fa9e4066Sahrens } else if (entry_type == ACE_EVERYONE) { 847da6c28aaSamw if ((access_mask & ACE_READ_DATA)) { 848fa9e4066Sahrens if (!(seen & S_IRUSR)) { 849fa9e4066Sahrens seen |= S_IRUSR; 850da6c28aaSamw if (type == ALLOW) { 851fa9e4066Sahrens mode |= S_IRUSR; 852fa9e4066Sahrens } 853fa9e4066Sahrens } 854fa9e4066Sahrens if (!(seen & S_IRGRP)) { 855fa9e4066Sahrens seen |= S_IRGRP; 856da6c28aaSamw if (type == ALLOW) { 857fa9e4066Sahrens mode |= S_IRGRP; 858fa9e4066Sahrens } 859fa9e4066Sahrens } 860fa9e4066Sahrens if (!(seen & S_IROTH)) { 861fa9e4066Sahrens seen |= S_IROTH; 862da6c28aaSamw if (type == ALLOW) { 863fa9e4066Sahrens mode |= S_IROTH; 864fa9e4066Sahrens } 865fa9e4066Sahrens } 866fa9e4066Sahrens } 867da6c28aaSamw if ((access_mask & ACE_WRITE_DATA)) { 868fa9e4066Sahrens if (!(seen & S_IWUSR)) { 869fa9e4066Sahrens seen |= S_IWUSR; 870da6c28aaSamw if (type == ALLOW) { 871fa9e4066Sahrens mode |= S_IWUSR; 872fa9e4066Sahrens } 873fa9e4066Sahrens } 874fa9e4066Sahrens if (!(seen & S_IWGRP)) { 875fa9e4066Sahrens seen |= S_IWGRP; 876da6c28aaSamw if (type == ALLOW) { 877fa9e4066Sahrens mode |= S_IWGRP; 878fa9e4066Sahrens } 879fa9e4066Sahrens } 880fa9e4066Sahrens if (!(seen & S_IWOTH)) { 881fa9e4066Sahrens seen |= S_IWOTH; 882da6c28aaSamw if (type == ALLOW) { 883fa9e4066Sahrens mode |= S_IWOTH; 884fa9e4066Sahrens } 885fa9e4066Sahrens } 886fa9e4066Sahrens } 887da6c28aaSamw if ((access_mask & ACE_EXECUTE)) { 888fa9e4066Sahrens if (!(seen & S_IXUSR)) { 889fa9e4066Sahrens seen |= S_IXUSR; 890da6c28aaSamw if (type == ALLOW) { 891fa9e4066Sahrens mode |= S_IXUSR; 892fa9e4066Sahrens } 893fa9e4066Sahrens } 894fa9e4066Sahrens if (!(seen & S_IXGRP)) { 895fa9e4066Sahrens seen |= S_IXGRP; 896da6c28aaSamw if (type == ALLOW) { 897fa9e4066Sahrens mode |= S_IXGRP; 898fa9e4066Sahrens } 899fa9e4066Sahrens } 900fa9e4066Sahrens if (!(seen & S_IXOTH)) { 901fa9e4066Sahrens seen |= S_IXOTH; 902da6c28aaSamw if (type == ALLOW) { 903fa9e4066Sahrens mode |= S_IXOTH; 904fa9e4066Sahrens } 905fa9e4066Sahrens } 906fa9e4066Sahrens } 907fa9e4066Sahrens } 908da6c28aaSamw /* 909da6c28aaSamw * Now handle FUID create for user/group ACEs 910da6c28aaSamw */ 911da6c28aaSamw if (entry_type == 0 || entry_type == ACE_IDENTIFIER_GROUP) { 912da6c28aaSamw aclp->z_ops.ace_who_set(acep, 913bda89588Sjp zfs_fuid_create(zp->z_zfsvfs, who, cr, 914e0d35c44Smarks (entry_type == 0) ? ZFS_ACE_USER : ZFS_ACE_GROUP, 915e0d35c44Smarks tx, fuidp)); 916da6c28aaSamw } 917fa9e4066Sahrens } 918fa9e4066Sahrens return (mode); 919fa9e4066Sahrens } 920fa9e4066Sahrens 921fa9e4066Sahrens static zfs_acl_t * 922da6c28aaSamw zfs_acl_node_read_internal(znode_t *zp, boolean_t will_modify) 923fa9e4066Sahrens { 924fa9e4066Sahrens zfs_acl_t *aclp; 925da6c28aaSamw zfs_acl_node_t *aclnode; 926da6c28aaSamw 927da6c28aaSamw aclp = zfs_acl_alloc(zp->z_phys->zp_acl.z_acl_version); 928da6c28aaSamw 929da6c28aaSamw /* 930da6c28aaSamw * Version 0 to 1 znode_acl_phys has the size/count fields swapped. 931da6c28aaSamw * Version 0 didn't have a size field, only a count. 932da6c28aaSamw */ 933da6c28aaSamw if (zp->z_phys->zp_acl.z_acl_version == ZFS_ACL_VERSION_INITIAL) { 934da6c28aaSamw aclp->z_acl_count = zp->z_phys->zp_acl.z_acl_size; 935da6c28aaSamw aclp->z_acl_bytes = ZFS_ACL_SIZE(aclp->z_acl_count); 936da6c28aaSamw } else { 937da6c28aaSamw aclp->z_acl_count = zp->z_phys->zp_acl.z_acl_count; 938da6c28aaSamw aclp->z_acl_bytes = zp->z_phys->zp_acl.z_acl_size; 939da6c28aaSamw } 940da6c28aaSamw 941da6c28aaSamw aclnode = zfs_acl_node_alloc(will_modify ? aclp->z_acl_bytes : 0); 942da6c28aaSamw aclnode->z_ace_count = aclp->z_acl_count; 943da6c28aaSamw if (will_modify) { 944da6c28aaSamw bcopy(zp->z_phys->zp_acl.z_ace_data, aclnode->z_acldata, 945da6c28aaSamw aclp->z_acl_bytes); 946da6c28aaSamw } else { 947da6c28aaSamw aclnode->z_size = aclp->z_acl_bytes; 948da6c28aaSamw aclnode->z_acldata = &zp->z_phys->zp_acl.z_ace_data[0]; 949da6c28aaSamw } 950fa9e4066Sahrens 951da6c28aaSamw list_insert_head(&aclp->z_acl, aclnode); 952fa9e4066Sahrens 953fa9e4066Sahrens return (aclp); 954fa9e4066Sahrens } 955fa9e4066Sahrens 956fa9e4066Sahrens /* 957fa9e4066Sahrens * Read an external acl object. 958fa9e4066Sahrens */ 959ea8dc4b6Seschrock static int 960da6c28aaSamw zfs_acl_node_read(znode_t *zp, zfs_acl_t **aclpp, boolean_t will_modify) 961fa9e4066Sahrens { 962fa9e4066Sahrens uint64_t extacl = zp->z_phys->zp_acl.z_acl_extern_obj; 963fa9e4066Sahrens zfs_acl_t *aclp; 964da6c28aaSamw size_t aclsize; 965da6c28aaSamw size_t acl_count; 966da6c28aaSamw zfs_acl_node_t *aclnode; 967ea8dc4b6Seschrock int error; 968fa9e4066Sahrens 969fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_acl_lock)); 970fa9e4066Sahrens 971ea8dc4b6Seschrock if (zp->z_phys->zp_acl.z_acl_extern_obj == 0) { 972da6c28aaSamw *aclpp = zfs_acl_node_read_internal(zp, will_modify); 973ea8dc4b6Seschrock return (0); 974ea8dc4b6Seschrock } 975fa9e4066Sahrens 976da6c28aaSamw aclp = zfs_acl_alloc(zp->z_phys->zp_acl.z_acl_version); 977da6c28aaSamw if (zp->z_phys->zp_acl.z_acl_version == ZFS_ACL_VERSION_INITIAL) { 978da6c28aaSamw zfs_acl_phys_v0_t *zacl0 = 979da6c28aaSamw (zfs_acl_phys_v0_t *)&zp->z_phys->zp_acl; 980fa9e4066Sahrens 981da6c28aaSamw aclsize = ZFS_ACL_SIZE(zacl0->z_acl_count); 982da6c28aaSamw acl_count = zacl0->z_acl_count; 983da6c28aaSamw } else { 984da6c28aaSamw aclsize = zp->z_phys->zp_acl.z_acl_size; 985da6c28aaSamw acl_count = zp->z_phys->zp_acl.z_acl_count; 986da6c28aaSamw if (aclsize == 0) 987da6c28aaSamw aclsize = acl_count * sizeof (zfs_ace_t); 988da6c28aaSamw } 989da6c28aaSamw aclnode = zfs_acl_node_alloc(aclsize); 990da6c28aaSamw list_insert_head(&aclp->z_acl, aclnode); 991ea8dc4b6Seschrock error = dmu_read(zp->z_zfsvfs->z_os, extacl, 0, 992da6c28aaSamw aclsize, aclnode->z_acldata); 993da6c28aaSamw aclnode->z_ace_count = acl_count; 994da6c28aaSamw aclp->z_acl_count = acl_count; 995da6c28aaSamw aclp->z_acl_bytes = aclsize; 996da6c28aaSamw 997ea8dc4b6Seschrock if (error != 0) { 998ea8dc4b6Seschrock zfs_acl_free(aclp); 999b87f3af3Sperrin /* convert checksum errors into IO errors */ 1000b87f3af3Sperrin if (error == ECKSUM) 1001b87f3af3Sperrin error = EIO; 1002ea8dc4b6Seschrock return (error); 1003ea8dc4b6Seschrock } 1004fa9e4066Sahrens 1005ea8dc4b6Seschrock *aclpp = aclp; 1006ea8dc4b6Seschrock return (0); 1007fa9e4066Sahrens } 1008fa9e4066Sahrens 1009fa9e4066Sahrens /* 1010da6c28aaSamw * common code for setting ACLs. 1011fa9e4066Sahrens * 1012fa9e4066Sahrens * This function is called from zfs_mode_update, zfs_perm_init, and zfs_setacl. 1013fa9e4066Sahrens * zfs_setacl passes a non-NULL inherit pointer (ihp) to indicate that it's 1014fa9e4066Sahrens * already checked the acl and knows whether to inherit. 1015fa9e4066Sahrens */ 1016fa9e4066Sahrens int 1017bda89588Sjp zfs_aclset_common(znode_t *zp, zfs_acl_t *aclp, cred_t *cr, 1018bda89588Sjp zfs_fuid_info_t **fuidp, dmu_tx_t *tx) 1019fa9e4066Sahrens { 1020fa9e4066Sahrens int error; 1021fa9e4066Sahrens znode_phys_t *zphys = zp->z_phys; 1022da6c28aaSamw zfs_acl_phys_t *zacl = &zphys->zp_acl; 1023fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1024fa9e4066Sahrens uint64_t aoid = zphys->zp_acl.z_acl_extern_obj; 1025da6c28aaSamw uint64_t off = 0; 1026da6c28aaSamw dmu_object_type_t otype; 1027da6c28aaSamw zfs_acl_node_t *aclnode; 1028fa9e4066Sahrens 1029fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_lock)); 1030fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_acl_lock)); 1031fa9e4066Sahrens 1032fa9e4066Sahrens dmu_buf_will_dirty(zp->z_dbuf, tx); 1033fa9e4066Sahrens 1034bda89588Sjp zphys->zp_mode = zfs_mode_fuid_compute(zp, aclp, cr, fuidp, tx); 1035da6c28aaSamw 1036fa9e4066Sahrens /* 1037da6c28aaSamw * Decide which opbject type to use. If we are forced to 1038da6c28aaSamw * use old ACL format than transform ACL into zfs_oldace_t 1039da6c28aaSamw * layout. 1040fa9e4066Sahrens */ 1041da6c28aaSamw if (!zfsvfs->z_use_fuids) { 1042da6c28aaSamw otype = DMU_OT_OLDACL; 1043da6c28aaSamw } else { 1044da6c28aaSamw if ((aclp->z_version == ZFS_ACL_VERSION_INITIAL) && 1045da6c28aaSamw (zfsvfs->z_version >= ZPL_VERSION_FUID)) 1046da6c28aaSamw zfs_acl_xform(zp, aclp); 1047da6c28aaSamw ASSERT(aclp->z_version >= ZFS_ACL_VERSION_FUID); 1048da6c28aaSamw otype = DMU_OT_ACL; 1049da6c28aaSamw } 1050da6c28aaSamw 1051da6c28aaSamw if (aclp->z_acl_bytes > ZFS_ACE_SPACE) { 1052da6c28aaSamw /* 1053da6c28aaSamw * If ACL was previously external and we are now 1054da6c28aaSamw * converting to new ACL format then release old 1055da6c28aaSamw * ACL object and create a new one. 1056da6c28aaSamw */ 1057da6c28aaSamw if (aoid && aclp->z_version != zacl->z_acl_version) { 1058da6c28aaSamw error = dmu_object_free(zfsvfs->z_os, 1059da6c28aaSamw zp->z_phys->zp_acl.z_acl_extern_obj, tx); 1060da6c28aaSamw if (error) 1061da6c28aaSamw return (error); 1062da6c28aaSamw aoid = 0; 1063da6c28aaSamw } 1064fa9e4066Sahrens if (aoid == 0) { 1065fa9e4066Sahrens aoid = dmu_object_alloc(zfsvfs->z_os, 1066da6c28aaSamw otype, aclp->z_acl_bytes, 1067da6c28aaSamw otype == DMU_OT_ACL ? DMU_OT_SYSACL : DMU_OT_NONE, 1068da6c28aaSamw otype == DMU_OT_ACL ? DN_MAX_BONUSLEN : 0, tx); 1069fa9e4066Sahrens } else { 1070fa9e4066Sahrens (void) dmu_object_set_blocksize(zfsvfs->z_os, aoid, 1071da6c28aaSamw aclp->z_acl_bytes, 0, tx); 1072fa9e4066Sahrens } 1073fa9e4066Sahrens zphys->zp_acl.z_acl_extern_obj = aoid; 1074da6c28aaSamw for (aclnode = list_head(&aclp->z_acl); aclnode; 1075da6c28aaSamw aclnode = list_next(&aclp->z_acl, aclnode)) { 1076da6c28aaSamw if (aclnode->z_ace_count == 0) 1077da6c28aaSamw continue; 1078da6c28aaSamw dmu_write(zfsvfs->z_os, aoid, off, 1079da6c28aaSamw aclnode->z_size, aclnode->z_acldata, tx); 1080da6c28aaSamw off += aclnode->z_size; 1081da6c28aaSamw } 1082fa9e4066Sahrens } else { 1083da6c28aaSamw void *start = zacl->z_ace_data; 1084fa9e4066Sahrens /* 1085fa9e4066Sahrens * Migrating back embedded? 1086fa9e4066Sahrens */ 1087fa9e4066Sahrens if (zphys->zp_acl.z_acl_extern_obj) { 1088fa9e4066Sahrens error = dmu_object_free(zfsvfs->z_os, 10897106075aSmarks zp->z_phys->zp_acl.z_acl_extern_obj, tx); 1090fa9e4066Sahrens if (error) 1091fa9e4066Sahrens return (error); 1092fa9e4066Sahrens zphys->zp_acl.z_acl_extern_obj = 0; 1093fa9e4066Sahrens } 1094da6c28aaSamw 1095da6c28aaSamw for (aclnode = list_head(&aclp->z_acl); aclnode; 1096da6c28aaSamw aclnode = list_next(&aclp->z_acl, aclnode)) { 1097da6c28aaSamw if (aclnode->z_ace_count == 0) 1098da6c28aaSamw continue; 1099da6c28aaSamw bcopy(aclnode->z_acldata, start, aclnode->z_size); 1100da6c28aaSamw start = (caddr_t)start + aclnode->z_size; 1101da6c28aaSamw } 1102fa9e4066Sahrens } 1103de122929Smarks 1104da6c28aaSamw /* 1105da6c28aaSamw * If Old version then swap count/bytes to match old 1106da6c28aaSamw * layout of znode_acl_phys_t. 1107da6c28aaSamw */ 1108da6c28aaSamw if (aclp->z_version == ZFS_ACL_VERSION_INITIAL) { 1109da6c28aaSamw zphys->zp_acl.z_acl_size = aclp->z_acl_count; 1110da6c28aaSamw zphys->zp_acl.z_acl_count = aclp->z_acl_bytes; 1111da6c28aaSamw } else { 1112da6c28aaSamw zphys->zp_acl.z_acl_size = aclp->z_acl_bytes; 1113da6c28aaSamw zphys->zp_acl.z_acl_count = aclp->z_acl_count; 1114de122929Smarks } 1115fa9e4066Sahrens 1116da6c28aaSamw zphys->zp_acl.z_acl_version = aclp->z_version; 1117da6c28aaSamw 1118da6c28aaSamw /* 1119da6c28aaSamw * Replace ACL wide bits, but first clear them. 1120da6c28aaSamw */ 1121da6c28aaSamw zp->z_phys->zp_flags &= ~ZFS_ACL_WIDE_FLAGS; 1122da6c28aaSamw 1123da6c28aaSamw zp->z_phys->zp_flags |= aclp->z_hints; 1124fa9e4066Sahrens 1125da6c28aaSamw if (ace_trivial_common(aclp, 0, zfs_ace_walk) == 0) 1126da6c28aaSamw zp->z_phys->zp_flags |= ZFS_ACL_TRIVIAL; 1127da6c28aaSamw 1128da6c28aaSamw zfs_time_stamper_locked(zp, STATE_CHANGED, tx); 1129fa9e4066Sahrens return (0); 1130fa9e4066Sahrens } 1131fa9e4066Sahrens 1132fa9e4066Sahrens /* 1133fa9e4066Sahrens * Update access mask for prepended ACE 1134fa9e4066Sahrens * 1135fa9e4066Sahrens * This applies the "groupmask" value for aclmode property. 1136fa9e4066Sahrens */ 1137fa9e4066Sahrens static void 1138da6c28aaSamw zfs_acl_prepend_fixup(zfs_acl_t *aclp, void *acep, void *origacep, 1139da6c28aaSamw mode_t mode, uint64_t owner) 1140fa9e4066Sahrens { 1141fa9e4066Sahrens int rmask, wmask, xmask; 1142fa9e4066Sahrens int user_ace; 1143da6c28aaSamw uint16_t aceflags; 1144da6c28aaSamw uint32_t origmask, acepmask; 1145da6c28aaSamw uint64_t fuid; 1146da6c28aaSamw 1147da6c28aaSamw aceflags = aclp->z_ops.ace_flags_get(acep); 1148da6c28aaSamw fuid = aclp->z_ops.ace_who_get(acep); 1149da6c28aaSamw origmask = aclp->z_ops.ace_mask_get(origacep); 1150da6c28aaSamw acepmask = aclp->z_ops.ace_mask_get(acep); 1151fa9e4066Sahrens 1152da6c28aaSamw user_ace = (!(aceflags & 1153fa9e4066Sahrens (ACE_OWNER|ACE_GROUP|ACE_IDENTIFIER_GROUP))); 1154fa9e4066Sahrens 1155da6c28aaSamw if (user_ace && (fuid == owner)) { 1156fa9e4066Sahrens rmask = S_IRUSR; 1157fa9e4066Sahrens wmask = S_IWUSR; 1158fa9e4066Sahrens xmask = S_IXUSR; 1159fa9e4066Sahrens } else { 1160fa9e4066Sahrens rmask = S_IRGRP; 1161fa9e4066Sahrens wmask = S_IWGRP; 1162fa9e4066Sahrens xmask = S_IXGRP; 1163fa9e4066Sahrens } 1164fa9e4066Sahrens 1165da6c28aaSamw if (origmask & ACE_READ_DATA) { 1166da6c28aaSamw if (mode & rmask) { 1167da6c28aaSamw acepmask &= ~ACE_READ_DATA; 1168da6c28aaSamw } else { 1169da6c28aaSamw acepmask |= ACE_READ_DATA; 1170da6c28aaSamw } 1171fa9e4066Sahrens } 1172fa9e4066Sahrens 1173da6c28aaSamw if (origmask & ACE_WRITE_DATA) { 1174da6c28aaSamw if (mode & wmask) { 1175da6c28aaSamw acepmask &= ~ACE_WRITE_DATA; 1176da6c28aaSamw } else { 1177da6c28aaSamw acepmask |= ACE_WRITE_DATA; 1178da6c28aaSamw } 1179fa9e4066Sahrens } 1180fa9e4066Sahrens 1181da6c28aaSamw if (origmask & ACE_APPEND_DATA) { 1182da6c28aaSamw if (mode & wmask) { 1183da6c28aaSamw acepmask &= ~ACE_APPEND_DATA; 1184da6c28aaSamw } else { 1185da6c28aaSamw acepmask |= ACE_APPEND_DATA; 1186da6c28aaSamw } 1187fa9e4066Sahrens } 1188fa9e4066Sahrens 1189da6c28aaSamw if (origmask & ACE_EXECUTE) { 1190da6c28aaSamw if (mode & xmask) { 1191da6c28aaSamw acepmask &= ~ACE_EXECUTE; 1192da6c28aaSamw } else { 1193da6c28aaSamw acepmask |= ACE_EXECUTE; 1194da6c28aaSamw } 1195fa9e4066Sahrens } 1196da6c28aaSamw aclp->z_ops.ace_mask_set(acep, acepmask); 1197fa9e4066Sahrens } 1198fa9e4066Sahrens 1199fa9e4066Sahrens /* 1200fa9e4066Sahrens * Apply mode to canonical six ACEs. 1201fa9e4066Sahrens */ 1202fa9e4066Sahrens static void 1203fa9e4066Sahrens zfs_acl_fixup_canonical_six(zfs_acl_t *aclp, mode_t mode) 1204fa9e4066Sahrens { 1205da6c28aaSamw zfs_acl_node_t *aclnode = list_tail(&aclp->z_acl); 1206da6c28aaSamw void *acep; 1207da6c28aaSamw int maskoff = aclp->z_ops.ace_mask_off(); 1208da6c28aaSamw size_t abstract_size = aclp->z_ops.ace_abstract_size(); 1209fa9e4066Sahrens 1210da6c28aaSamw ASSERT(aclnode != NULL); 1211da6c28aaSamw 1212da6c28aaSamw acep = (void *)((caddr_t)aclnode->z_acldata + 1213da6c28aaSamw aclnode->z_size - (abstract_size * 6)); 1214fa9e4066Sahrens 1215fa9e4066Sahrens /* 1216fa9e4066Sahrens * Fixup final ACEs to match the mode 1217fa9e4066Sahrens */ 1218fa9e4066Sahrens 1219da6c28aaSamw adjust_ace_pair_common(acep, maskoff, abstract_size, 1220da6c28aaSamw (mode & 0700) >> 6); /* owner@ */ 1221da6c28aaSamw 1222da6c28aaSamw acep = (caddr_t)acep + (abstract_size * 2); 1223da6c28aaSamw 1224da6c28aaSamw adjust_ace_pair_common(acep, maskoff, abstract_size, 1225da6c28aaSamw (mode & 0070) >> 3); /* group@ */ 1226da6c28aaSamw 1227da6c28aaSamw acep = (caddr_t)acep + (abstract_size * 2); 1228da6c28aaSamw adjust_ace_pair_common(acep, maskoff, 1229da6c28aaSamw abstract_size, mode); /* everyone@ */ 1230fa9e4066Sahrens } 1231fa9e4066Sahrens 1232fa9e4066Sahrens 1233fa9e4066Sahrens static int 1234da6c28aaSamw zfs_acl_ace_match(zfs_acl_t *aclp, void *acep, int allow_deny, 1235da6c28aaSamw int entry_type, int accessmask) 1236fa9e4066Sahrens { 1237da6c28aaSamw uint32_t mask = aclp->z_ops.ace_mask_get(acep); 1238da6c28aaSamw uint16_t type = aclp->z_ops.ace_type_get(acep); 1239da6c28aaSamw uint16_t flags = aclp->z_ops.ace_flags_get(acep); 1240da6c28aaSamw 1241da6c28aaSamw return (mask == accessmask && type == allow_deny && 1242da6c28aaSamw ((flags & ACE_TYPE_FLAGS) == entry_type)); 1243fa9e4066Sahrens } 1244fa9e4066Sahrens 1245fa9e4066Sahrens /* 1246fa9e4066Sahrens * Can prepended ACE be reused? 1247fa9e4066Sahrens */ 1248fa9e4066Sahrens static int 1249da6c28aaSamw zfs_reuse_deny(zfs_acl_t *aclp, void *acep, void *prevacep) 1250fa9e4066Sahrens { 1251fa9e4066Sahrens int okay_masks; 1252da6c28aaSamw uint16_t prevtype; 1253da6c28aaSamw uint16_t prevflags; 1254da6c28aaSamw uint16_t flags; 1255da6c28aaSamw uint32_t mask, prevmask; 1256fa9e4066Sahrens 1257da6c28aaSamw if (prevacep == NULL) 1258fa9e4066Sahrens return (B_FALSE); 1259fa9e4066Sahrens 1260da6c28aaSamw prevtype = aclp->z_ops.ace_type_get(prevacep); 1261da6c28aaSamw prevflags = aclp->z_ops.ace_flags_get(prevacep); 1262da6c28aaSamw flags = aclp->z_ops.ace_flags_get(acep); 1263da6c28aaSamw mask = aclp->z_ops.ace_mask_get(acep); 1264da6c28aaSamw prevmask = aclp->z_ops.ace_mask_get(prevacep); 1265da6c28aaSamw 1266da6c28aaSamw if (prevtype != DENY) 1267fa9e4066Sahrens return (B_FALSE); 1268fa9e4066Sahrens 1269da6c28aaSamw if (prevflags != (flags & ACE_IDENTIFIER_GROUP)) 1270fa9e4066Sahrens return (B_FALSE); 1271fa9e4066Sahrens 1272da6c28aaSamw okay_masks = (mask & OKAY_MASK_BITS); 1273fa9e4066Sahrens 1274da6c28aaSamw if (prevmask & ~okay_masks) 1275fa9e4066Sahrens return (B_FALSE); 1276fa9e4066Sahrens 1277fa9e4066Sahrens return (B_TRUE); 1278fa9e4066Sahrens } 1279fa9e4066Sahrens 1280da6c28aaSamw 1281fa9e4066Sahrens /* 1282da6c28aaSamw * Insert new ACL node into chain of zfs_acl_node_t's 1283da6c28aaSamw * 1284da6c28aaSamw * This will result in two possible results. 1285da6c28aaSamw * 1. If the ACL is currently just a single zfs_acl_node and 1286da6c28aaSamw * we are prepending the entry then current acl node will have 1287da6c28aaSamw * a new node inserted above it. 1288da6c28aaSamw * 1289da6c28aaSamw * 2. If we are inserting in the middle of current acl node then 1290da6c28aaSamw * the current node will be split in two and new node will be inserted 1291da6c28aaSamw * in between the two split nodes. 1292fa9e4066Sahrens */ 1293da6c28aaSamw static zfs_acl_node_t * 1294da6c28aaSamw zfs_acl_ace_insert(zfs_acl_t *aclp, void *acep) 1295da6c28aaSamw { 1296da6c28aaSamw zfs_acl_node_t *newnode; 1297da6c28aaSamw zfs_acl_node_t *trailernode = NULL; 1298da6c28aaSamw zfs_acl_node_t *currnode = zfs_acl_curr_node(aclp); 1299da6c28aaSamw int curr_idx = aclp->z_curr_node->z_ace_idx; 1300da6c28aaSamw int trailer_count; 1301da6c28aaSamw size_t oldsize; 1302da6c28aaSamw 1303da6c28aaSamw newnode = zfs_acl_node_alloc(aclp->z_ops.ace_size(acep)); 1304da6c28aaSamw newnode->z_ace_count = 1; 1305da6c28aaSamw 1306da6c28aaSamw oldsize = currnode->z_size; 1307da6c28aaSamw 1308da6c28aaSamw if (curr_idx != 1) { 1309da6c28aaSamw trailernode = zfs_acl_node_alloc(0); 1310da6c28aaSamw trailernode->z_acldata = acep; 1311da6c28aaSamw 1312da6c28aaSamw trailer_count = currnode->z_ace_count - curr_idx + 1; 1313da6c28aaSamw currnode->z_ace_count = curr_idx - 1; 1314da6c28aaSamw currnode->z_size = (caddr_t)acep - (caddr_t)currnode->z_acldata; 1315da6c28aaSamw trailernode->z_size = oldsize - currnode->z_size; 1316da6c28aaSamw trailernode->z_ace_count = trailer_count; 1317fa9e4066Sahrens } 1318fa9e4066Sahrens 1319da6c28aaSamw aclp->z_acl_count += 1; 1320da6c28aaSamw aclp->z_acl_bytes += aclp->z_ops.ace_size(acep); 1321da6c28aaSamw 1322da6c28aaSamw if (curr_idx == 1) 1323da6c28aaSamw list_insert_before(&aclp->z_acl, currnode, newnode); 1324da6c28aaSamw else 1325da6c28aaSamw list_insert_after(&aclp->z_acl, currnode, newnode); 1326da6c28aaSamw if (trailernode) { 1327da6c28aaSamw list_insert_after(&aclp->z_acl, newnode, trailernode); 1328da6c28aaSamw aclp->z_curr_node = trailernode; 1329da6c28aaSamw trailernode->z_ace_idx = 1; 1330fa9e4066Sahrens } 1331fa9e4066Sahrens 1332da6c28aaSamw return (newnode); 1333fa9e4066Sahrens } 1334fa9e4066Sahrens 1335fa9e4066Sahrens /* 1336fa9e4066Sahrens * Prepend deny ACE 1337fa9e4066Sahrens */ 1338da6c28aaSamw static void * 1339da6c28aaSamw zfs_acl_prepend_deny(znode_t *zp, zfs_acl_t *aclp, void *acep, 1340fa9e4066Sahrens mode_t mode) 1341fa9e4066Sahrens { 1342da6c28aaSamw zfs_acl_node_t *aclnode; 1343da6c28aaSamw void *newacep; 1344da6c28aaSamw uint64_t fuid; 1345da6c28aaSamw uint16_t flags; 1346da6c28aaSamw 1347da6c28aaSamw aclnode = zfs_acl_ace_insert(aclp, acep); 1348da6c28aaSamw newacep = aclnode->z_acldata; 1349da6c28aaSamw fuid = aclp->z_ops.ace_who_get(acep); 1350da6c28aaSamw flags = aclp->z_ops.ace_flags_get(acep); 1351da6c28aaSamw zfs_set_ace(aclp, newacep, 0, DENY, fuid, (flags & ACE_TYPE_FLAGS)); 1352da6c28aaSamw zfs_acl_prepend_fixup(aclp, newacep, acep, mode, zp->z_phys->zp_uid); 1353da6c28aaSamw 1354da6c28aaSamw return (newacep); 1355fa9e4066Sahrens } 1356fa9e4066Sahrens 1357fa9e4066Sahrens /* 1358fa9e4066Sahrens * Split an inherited ACE into inherit_only ACE 1359fa9e4066Sahrens * and original ACE with inheritance flags stripped off. 1360fa9e4066Sahrens */ 1361fa9e4066Sahrens static void 1362da6c28aaSamw zfs_acl_split_ace(zfs_acl_t *aclp, zfs_ace_hdr_t *acep) 1363fa9e4066Sahrens { 1364da6c28aaSamw zfs_acl_node_t *aclnode; 1365569e6c63Smarks zfs_acl_node_t *currnode; 1366da6c28aaSamw void *newacep; 1367da6c28aaSamw uint16_t type, flags; 1368da6c28aaSamw uint32_t mask; 1369da6c28aaSamw uint64_t fuid; 1370da6c28aaSamw 1371da6c28aaSamw type = aclp->z_ops.ace_type_get(acep); 1372da6c28aaSamw flags = aclp->z_ops.ace_flags_get(acep); 1373da6c28aaSamw mask = aclp->z_ops.ace_mask_get(acep); 1374da6c28aaSamw fuid = aclp->z_ops.ace_who_get(acep); 1375da6c28aaSamw 1376da6c28aaSamw aclnode = zfs_acl_ace_insert(aclp, acep); 1377da6c28aaSamw newacep = aclnode->z_acldata; 1378da6c28aaSamw 1379da6c28aaSamw aclp->z_ops.ace_type_set(newacep, type); 1380da6c28aaSamw aclp->z_ops.ace_flags_set(newacep, flags | ACE_INHERIT_ONLY_ACE); 1381da6c28aaSamw aclp->z_ops.ace_mask_set(newacep, mask); 1382da6c28aaSamw aclp->z_ops.ace_type_set(newacep, type); 1383da6c28aaSamw aclp->z_ops.ace_who_set(newacep, fuid); 1384da6c28aaSamw aclp->z_next_ace = acep; 1385da6c28aaSamw flags &= ~ALL_INHERIT; 1386da6c28aaSamw aclp->z_ops.ace_flags_set(acep, flags); 1387569e6c63Smarks currnode = zfs_acl_curr_node(aclp); 1388569e6c63Smarks ASSERT(currnode->z_ace_idx >= 1); 1389da6c28aaSamw currnode->z_ace_idx -= 1; 1390fa9e4066Sahrens } 1391fa9e4066Sahrens 1392fa9e4066Sahrens /* 1393fa9e4066Sahrens * Are ACES started at index i, the canonical six ACES? 1394fa9e4066Sahrens */ 1395fa9e4066Sahrens static int 1396da6c28aaSamw zfs_have_canonical_six(zfs_acl_t *aclp) 1397fa9e4066Sahrens { 1398da6c28aaSamw void *acep; 1399da6c28aaSamw zfs_acl_node_t *aclnode = list_tail(&aclp->z_acl); 1400da6c28aaSamw int i = 0; 1401da6c28aaSamw size_t abstract_size = aclp->z_ops.ace_abstract_size(); 1402da6c28aaSamw 1403da6c28aaSamw ASSERT(aclnode != NULL); 1404da6c28aaSamw 1405da6c28aaSamw if (aclnode->z_ace_count < 6) 1406da6c28aaSamw return (0); 1407fa9e4066Sahrens 1408da6c28aaSamw acep = (void *)((caddr_t)aclnode->z_acldata + 1409da6c28aaSamw aclnode->z_size - (aclp->z_ops.ace_abstract_size() * 6)); 1410da6c28aaSamw 1411da6c28aaSamw if ((zfs_acl_ace_match(aclp, (caddr_t)acep + (abstract_size * i++), 1412fa9e4066Sahrens DENY, ACE_OWNER, 0) && 1413da6c28aaSamw zfs_acl_ace_match(aclp, (caddr_t)acep + (abstract_size * i++), 1414da6c28aaSamw ALLOW, ACE_OWNER, OWNER_ALLOW_MASK) && 1415da6c28aaSamw zfs_acl_ace_match(aclp, (caddr_t)acep + (abstract_size * i++), DENY, 1416da6c28aaSamw OWNING_GROUP, 0) && zfs_acl_ace_match(aclp, (caddr_t)acep + 1417da6c28aaSamw (abstract_size * i++), 1418da6c28aaSamw ALLOW, OWNING_GROUP, 0) && 1419da6c28aaSamw zfs_acl_ace_match(aclp, (caddr_t)acep + (abstract_size * i++), 1420fa9e4066Sahrens DENY, ACE_EVERYONE, EVERYONE_DENY_MASK) && 1421da6c28aaSamw zfs_acl_ace_match(aclp, (caddr_t)acep + (abstract_size * i++), 1422da6c28aaSamw ALLOW, ACE_EVERYONE, EVERYONE_ALLOW_MASK))) { 1423fa9e4066Sahrens return (1); 1424fa9e4066Sahrens } else { 1425fa9e4066Sahrens return (0); 1426fa9e4066Sahrens } 1427fa9e4066Sahrens } 1428fa9e4066Sahrens 1429da6c28aaSamw 1430fa9e4066Sahrens /* 1431fa9e4066Sahrens * Apply step 1g, to group entries 1432fa9e4066Sahrens * 1433fa9e4066Sahrens * Need to deal with corner case where group may have 1434fa9e4066Sahrens * greater permissions than owner. If so then limit 1435fa9e4066Sahrens * group permissions, based on what extra permissions 1436fa9e4066Sahrens * group has. 1437fa9e4066Sahrens */ 1438fa9e4066Sahrens static void 1439da6c28aaSamw zfs_fixup_group_entries(zfs_acl_t *aclp, void *acep, void *prevacep, 1440da6c28aaSamw mode_t mode) 1441fa9e4066Sahrens { 1442da6c28aaSamw uint32_t prevmask = aclp->z_ops.ace_mask_get(prevacep); 1443da6c28aaSamw uint32_t mask = aclp->z_ops.ace_mask_get(acep); 1444da6c28aaSamw uint16_t prevflags = aclp->z_ops.ace_flags_get(prevacep); 1445fa9e4066Sahrens mode_t extramode = (mode >> 3) & 07; 1446fa9e4066Sahrens mode_t ownermode = (mode >> 6); 1447fa9e4066Sahrens 1448da6c28aaSamw if (prevflags & ACE_IDENTIFIER_GROUP) { 1449fa9e4066Sahrens 1450fa9e4066Sahrens extramode &= ~ownermode; 1451fa9e4066Sahrens 1452fa9e4066Sahrens if (extramode) { 1453da6c28aaSamw if (extramode & S_IROTH) { 1454da6c28aaSamw prevmask &= ~ACE_READ_DATA; 1455da6c28aaSamw mask &= ~ACE_READ_DATA; 1456fa9e4066Sahrens } 1457da6c28aaSamw if (extramode & S_IWOTH) { 1458da6c28aaSamw prevmask &= ~(ACE_WRITE_DATA|ACE_APPEND_DATA); 1459da6c28aaSamw mask &= ~(ACE_WRITE_DATA|ACE_APPEND_DATA); 1460fa9e4066Sahrens } 1461da6c28aaSamw if (extramode & S_IXOTH) { 1462da6c28aaSamw prevmask &= ~ACE_EXECUTE; 1463da6c28aaSamw mask &= ~ACE_EXECUTE; 1464fa9e4066Sahrens } 1465fa9e4066Sahrens } 1466fa9e4066Sahrens } 1467da6c28aaSamw aclp->z_ops.ace_mask_set(acep, mask); 1468da6c28aaSamw aclp->z_ops.ace_mask_set(prevacep, prevmask); 1469fa9e4066Sahrens } 1470fa9e4066Sahrens 1471fa9e4066Sahrens /* 1472fa9e4066Sahrens * Apply the chmod algorithm as described 1473fa9e4066Sahrens * in PSARC/2002/240 1474fa9e4066Sahrens */ 14754c841f60Smarks static void 14764c841f60Smarks zfs_acl_chmod(znode_t *zp, uint64_t mode, zfs_acl_t *aclp) 1477fa9e4066Sahrens { 1478fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1479da6c28aaSamw void *acep = NULL, *prevacep = NULL; 1480da6c28aaSamw uint64_t who; 1481fa9e4066Sahrens int i; 1482fa9e4066Sahrens int entry_type; 1483fa9e4066Sahrens int reuse_deny; 1484fa9e4066Sahrens int need_canonical_six = 1; 1485da6c28aaSamw uint16_t iflags, type; 1486da6c28aaSamw uint32_t access_mask; 1487fa9e4066Sahrens 1488fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_acl_lock)); 1489fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_lock)); 1490fa9e4066Sahrens 1491da6c28aaSamw aclp->z_hints = (zp->z_phys->zp_flags & V4_ACL_WIDE_FLAGS); 14922459a9eaSmarks 14932459a9eaSmarks /* 14942459a9eaSmarks * If discard then just discard all ACL nodes which 14952459a9eaSmarks * represent the ACEs. 14962459a9eaSmarks * 14972459a9eaSmarks * New owner@/group@/everone@ ACEs will be added 14982459a9eaSmarks * later. 14992459a9eaSmarks */ 15002459a9eaSmarks if (zfsvfs->z_acl_mode == ZFS_ACL_DISCARD) 15012459a9eaSmarks zfs_acl_release_nodes(aclp); 15022459a9eaSmarks 1503da6c28aaSamw while (acep = zfs_acl_next_ace(aclp, acep, &who, &access_mask, 1504da6c28aaSamw &iflags, &type)) { 1505fa9e4066Sahrens 1506da6c28aaSamw entry_type = (iflags & ACE_TYPE_FLAGS); 1507da6c28aaSamw iflags = (iflags & ALL_INHERIT); 1508da6c28aaSamw 1509da6c28aaSamw if ((type != ALLOW && type != DENY) || 1510de122929Smarks (iflags & ACE_INHERIT_ONLY_ACE)) { 1511de122929Smarks if (iflags) 1512da6c28aaSamw aclp->z_hints |= ZFS_INHERIT_ACE; 1513da6c28aaSamw switch (type) { 1514da6c28aaSamw case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 1515da6c28aaSamw case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 1516da6c28aaSamw case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 1517da6c28aaSamw case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 1518da6c28aaSamw aclp->z_hints |= ZFS_ACL_OBJ_ACE; 1519da6c28aaSamw break; 1520da6c28aaSamw } 1521da6c28aaSamw goto nextace; 1522fa9e4066Sahrens } 1523fa9e4066Sahrens 1524fa9e4066Sahrens /* 1525fa9e4066Sahrens * Need to split ace into two? 1526fa9e4066Sahrens */ 1527de122929Smarks if ((iflags & (ACE_FILE_INHERIT_ACE| 1528fa9e4066Sahrens ACE_DIRECTORY_INHERIT_ACE)) && 1529de122929Smarks (!(iflags & ACE_INHERIT_ONLY_ACE))) { 1530da6c28aaSamw zfs_acl_split_ace(aclp, acep); 1531da6c28aaSamw aclp->z_hints |= ZFS_INHERIT_ACE; 1532da6c28aaSamw goto nextace; 1533fa9e4066Sahrens } 1534fa9e4066Sahrens 1535fa9e4066Sahrens if (entry_type == ACE_OWNER || entry_type == ACE_EVERYONE || 1536fa9e4066Sahrens (entry_type == OWNING_GROUP)) { 1537da6c28aaSamw access_mask &= ~OGE_CLEAR; 1538da6c28aaSamw aclp->z_ops.ace_mask_set(acep, access_mask); 1539da6c28aaSamw goto nextace; 1540fa9e4066Sahrens } else { 1541da6c28aaSamw reuse_deny = B_TRUE; 1542da6c28aaSamw if (type == ALLOW) { 1543fa9e4066Sahrens 1544fa9e4066Sahrens /* 1545fa9e4066Sahrens * Check preceding ACE if any, to see 1546fa9e4066Sahrens * if we need to prepend a DENY ACE. 1547fa9e4066Sahrens * This is only applicable when the acl_mode 1548fa9e4066Sahrens * property == groupmask. 1549fa9e4066Sahrens */ 1550e9dbad6fSeschrock if (zfsvfs->z_acl_mode == ZFS_ACL_GROUPMASK) { 1551fa9e4066Sahrens 1552da6c28aaSamw reuse_deny = zfs_reuse_deny(aclp, acep, 1553da6c28aaSamw prevacep); 1554fa9e4066Sahrens 1555e0d35c44Smarks if (!reuse_deny) { 1556da6c28aaSamw prevacep = 1557da6c28aaSamw zfs_acl_prepend_deny(zp, 1558da6c28aaSamw aclp, acep, mode); 1559fa9e4066Sahrens } else { 1560fa9e4066Sahrens zfs_acl_prepend_fixup( 1561da6c28aaSamw aclp, prevacep, 1562da6c28aaSamw acep, mode, 1563fa9e4066Sahrens zp->z_phys->zp_uid); 1564fa9e4066Sahrens } 1565da6c28aaSamw zfs_fixup_group_entries(aclp, acep, 1566da6c28aaSamw prevacep, mode); 1567da6c28aaSamw 1568fa9e4066Sahrens } 1569fa9e4066Sahrens } 1570fa9e4066Sahrens } 1571da6c28aaSamw nextace: 1572da6c28aaSamw prevacep = acep; 1573fa9e4066Sahrens } 1574fa9e4066Sahrens 1575fa9e4066Sahrens /* 1576fa9e4066Sahrens * Check out last six aces, if we have six. 1577fa9e4066Sahrens */ 1578fa9e4066Sahrens 1579fa9e4066Sahrens if (aclp->z_acl_count >= 6) { 1580da6c28aaSamw if (zfs_have_canonical_six(aclp)) { 1581fa9e4066Sahrens need_canonical_six = 0; 1582fa9e4066Sahrens } 1583fa9e4066Sahrens } 1584fa9e4066Sahrens 1585fa9e4066Sahrens if (need_canonical_six) { 1586da6c28aaSamw size_t abstract_size = aclp->z_ops.ace_abstract_size(); 1587da6c28aaSamw void *zacep; 1588da6c28aaSamw zfs_acl_node_t *aclnode = 1589da6c28aaSamw zfs_acl_node_alloc(abstract_size * 6); 1590da6c28aaSamw 1591da6c28aaSamw aclnode->z_size = abstract_size * 6; 1592da6c28aaSamw aclnode->z_ace_count = 6; 1593da6c28aaSamw aclp->z_acl_bytes += aclnode->z_size; 1594da6c28aaSamw list_insert_tail(&aclp->z_acl, aclnode); 1595da6c28aaSamw 1596da6c28aaSamw zacep = aclnode->z_acldata; 1597da6c28aaSamw 1598da6c28aaSamw i = 0; 1599da6c28aaSamw zfs_set_ace(aclp, (caddr_t)zacep + (abstract_size * i++), 1600da6c28aaSamw 0, DENY, -1, ACE_OWNER); 1601da6c28aaSamw zfs_set_ace(aclp, (caddr_t)zacep + (abstract_size * i++), 1602da6c28aaSamw OWNER_ALLOW_MASK, ALLOW, -1, ACE_OWNER); 1603da6c28aaSamw zfs_set_ace(aclp, (caddr_t)zacep + (abstract_size * i++), 0, 1604da6c28aaSamw DENY, -1, OWNING_GROUP); 1605da6c28aaSamw zfs_set_ace(aclp, (caddr_t)zacep + (abstract_size * i++), 0, 1606da6c28aaSamw ALLOW, -1, OWNING_GROUP); 1607da6c28aaSamw zfs_set_ace(aclp, (caddr_t)zacep + (abstract_size * i++), 1608da6c28aaSamw EVERYONE_DENY_MASK, DENY, -1, ACE_EVERYONE); 1609da6c28aaSamw zfs_set_ace(aclp, (caddr_t)zacep + (abstract_size * i++), 1610da6c28aaSamw EVERYONE_ALLOW_MASK, ALLOW, -1, ACE_EVERYONE); 1611fa9e4066Sahrens aclp->z_acl_count += 6; 1612fa9e4066Sahrens } 1613fa9e4066Sahrens 1614fa9e4066Sahrens zfs_acl_fixup_canonical_six(aclp, mode); 1615fa9e4066Sahrens } 1616fa9e4066Sahrens 1617fa9e4066Sahrens int 16184c841f60Smarks zfs_acl_chmod_setattr(znode_t *zp, zfs_acl_t **aclp, uint64_t mode) 1619fa9e4066Sahrens { 1620fa9e4066Sahrens int error; 1621fa9e4066Sahrens 16224c841f60Smarks mutex_enter(&zp->z_lock); 1623fa9e4066Sahrens mutex_enter(&zp->z_acl_lock); 16244c841f60Smarks *aclp = NULL; 16254c841f60Smarks error = zfs_acl_node_read(zp, aclp, B_TRUE); 1626ea8dc4b6Seschrock if (error == 0) 16274c841f60Smarks zfs_acl_chmod(zp, mode, *aclp); 1628fa9e4066Sahrens mutex_exit(&zp->z_acl_lock); 16294c841f60Smarks mutex_exit(&zp->z_lock); 1630fa9e4066Sahrens return (error); 1631fa9e4066Sahrens } 1632fa9e4066Sahrens 1633fa9e4066Sahrens /* 1634fa9e4066Sahrens * strip off write_owner and write_acl 1635fa9e4066Sahrens */ 1636fa9e4066Sahrens static void 1637b3d141f8Smarks zfs_restricted_update(zfsvfs_t *zfsvfs, zfs_acl_t *aclp, void *acep) 1638fa9e4066Sahrens { 1639da6c28aaSamw uint32_t mask = aclp->z_ops.ace_mask_get(acep); 1640da6c28aaSamw 1641b3d141f8Smarks if ((zfsvfs->z_acl_inherit == ZFS_ACL_RESTRICTED) && 1642da6c28aaSamw (aclp->z_ops.ace_type_get(acep) == ALLOW)) { 1643b3d141f8Smarks mask &= ~RESTRICTED_CLEAR; 1644da6c28aaSamw aclp->z_ops.ace_mask_set(acep, mask); 1645da6c28aaSamw } 1646da6c28aaSamw } 1647da6c28aaSamw 1648da6c28aaSamw /* 1649da6c28aaSamw * Should ACE be inherited? 1650da6c28aaSamw */ 1651da6c28aaSamw static int 1652da6c28aaSamw zfs_ace_can_use(znode_t *zp, uint16_t acep_flags) 1653da6c28aaSamw { 1654da6c28aaSamw int vtype = ZTOV(zp)->v_type; 1655da6c28aaSamw int iflags = (acep_flags & 0xf); 1656da6c28aaSamw 1657da6c28aaSamw if ((vtype == VDIR) && (iflags & ACE_DIRECTORY_INHERIT_ACE)) 1658da6c28aaSamw return (1); 1659da6c28aaSamw else if (iflags & ACE_FILE_INHERIT_ACE) 1660da6c28aaSamw return (!((vtype == VDIR) && 1661da6c28aaSamw (iflags & ACE_NO_PROPAGATE_INHERIT_ACE))); 1662da6c28aaSamw return (0); 1663fa9e4066Sahrens } 1664fa9e4066Sahrens 1665fa9e4066Sahrens /* 1666fa9e4066Sahrens * inherit inheritable ACEs from parent 1667fa9e4066Sahrens */ 1668fa9e4066Sahrens static zfs_acl_t * 1669b3d141f8Smarks zfs_acl_inherit(znode_t *zp, zfs_acl_t *paclp, boolean_t *need_chmod) 1670fa9e4066Sahrens { 1671fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1672da6c28aaSamw void *pacep; 1673da6c28aaSamw void *acep, *acep2; 1674da6c28aaSamw zfs_acl_node_t *aclnode, *aclnode2; 1675fa9e4066Sahrens zfs_acl_t *aclp = NULL; 1676da6c28aaSamw uint64_t who; 1677da6c28aaSamw uint32_t access_mask; 1678da6c28aaSamw uint16_t iflags, newflags, type; 1679da6c28aaSamw size_t ace_size; 1680da6c28aaSamw void *data1, *data2; 1681da6c28aaSamw size_t data1sz, data2sz; 1682b3d141f8Smarks enum vtype vntype = ZTOV(zp)->v_type; 1683da6c28aaSamw 1684b3d141f8Smarks *need_chmod = B_TRUE; 1685da6c28aaSamw pacep = NULL; 1686*003c2582SMark Shellenbaum aclp = zfs_acl_alloc(paclp->z_version); 1687e9dbad6fSeschrock if (zfsvfs->z_acl_inherit != ZFS_ACL_DISCARD) { 1688da6c28aaSamw while (pacep = zfs_acl_next_ace(paclp, pacep, &who, 1689da6c28aaSamw &access_mask, &iflags, &type)) { 1690fa9e4066Sahrens 1691*003c2582SMark Shellenbaum /* 1692*003c2582SMark Shellenbaum * don't inherit bogus ACEs 1693*003c2582SMark Shellenbaum */ 1694*003c2582SMark Shellenbaum if (!zfs_acl_valid_ace_type(type, iflags)) 1695*003c2582SMark Shellenbaum continue; 1696*003c2582SMark Shellenbaum 1697e9dbad6fSeschrock if (zfsvfs->z_acl_inherit == ZFS_ACL_NOALLOW && 1698da6c28aaSamw type == ALLOW) 1699fa9e4066Sahrens continue; 1700fa9e4066Sahrens 1701da6c28aaSamw ace_size = aclp->z_ops.ace_size(pacep); 1702169cdae2Smarks 1703b3d141f8Smarks if (!zfs_ace_can_use(zp, iflags)) 1704b3d141f8Smarks continue; 1705b3d141f8Smarks 1706b3d141f8Smarks /* 1707b3d141f8Smarks * If owner@, group@, or everyone@ inheritable 1708b3d141f8Smarks * then zfs_acl_chmod() isn't needed. 1709b3d141f8Smarks */ 1710b3d141f8Smarks if (zfsvfs->z_acl_inherit == 1711b3d141f8Smarks ZFS_ACL_PASSTHROUGH && 1712b3d141f8Smarks ((iflags & (ACE_OWNER|ACE_EVERYONE)) || 1713b3d141f8Smarks ((iflags & OWNING_GROUP) == 1714b3d141f8Smarks OWNING_GROUP)) && (vntype == VREG || 1715b3d141f8Smarks (vntype == VDIR && 1716b3d141f8Smarks (iflags & ACE_DIRECTORY_INHERIT_ACE)))) 1717b3d141f8Smarks *need_chmod = B_FALSE; 1718b3d141f8Smarks 1719b3d141f8Smarks aclnode = zfs_acl_node_alloc(ace_size); 1720b3d141f8Smarks list_insert_tail(&aclp->z_acl, aclnode); 1721b3d141f8Smarks acep = aclnode->z_acldata; 1722b3d141f8Smarks zfs_set_ace(aclp, acep, access_mask, type, 1723b3d141f8Smarks who, iflags|ACE_INHERITED_ACE); 1724b3d141f8Smarks 1725b3d141f8Smarks /* 1726b3d141f8Smarks * Copy special opaque data if any 1727b3d141f8Smarks */ 1728b3d141f8Smarks if ((data1sz = paclp->z_ops.ace_data(pacep, 1729b3d141f8Smarks &data1)) != 0) { 1730b3d141f8Smarks VERIFY((data2sz = aclp->z_ops.ace_data(acep, 1731b3d141f8Smarks &data2)) == data1sz); 1732b3d141f8Smarks bcopy(data1, data2, data2sz); 1733b3d141f8Smarks } 1734b3d141f8Smarks aclp->z_acl_count++; 1735b3d141f8Smarks aclnode->z_ace_count++; 1736b3d141f8Smarks aclp->z_acl_bytes += aclnode->z_size; 1737b3d141f8Smarks newflags = aclp->z_ops.ace_flags_get(acep); 1738b3d141f8Smarks 1739b3d141f8Smarks if (vntype == VDIR) 1740b3d141f8Smarks aclp->z_hints |= ZFS_INHERIT_ACE; 1741b3d141f8Smarks 1742b3d141f8Smarks if ((iflags & ACE_NO_PROPAGATE_INHERIT_ACE) || 1743b3d141f8Smarks (vntype != VDIR)) { 1744b3d141f8Smarks newflags &= ~ALL_INHERIT; 1745b3d141f8Smarks aclp->z_ops.ace_flags_set(acep, 1746b3d141f8Smarks newflags|ACE_INHERITED_ACE); 1747b3d141f8Smarks zfs_restricted_update(zfsvfs, aclp, acep); 1748b3d141f8Smarks continue; 1749b3d141f8Smarks } 1750fa9e4066Sahrens 1751b3d141f8Smarks ASSERT(vntype == VDIR); 1752b3d141f8Smarks 1753b3d141f8Smarks newflags = aclp->z_ops.ace_flags_get(acep); 1754b3d141f8Smarks if ((iflags & (ACE_FILE_INHERIT_ACE | 1755b3d141f8Smarks ACE_DIRECTORY_INHERIT_ACE)) != 1756b3d141f8Smarks ACE_FILE_INHERIT_ACE) { 1757b3d141f8Smarks aclnode2 = zfs_acl_node_alloc(ace_size); 1758b3d141f8Smarks list_insert_tail(&aclp->z_acl, aclnode2); 1759b3d141f8Smarks acep2 = aclnode2->z_acldata; 1760b3d141f8Smarks zfs_set_ace(aclp, acep2, 1761b3d141f8Smarks access_mask, type, who, 1762b3d141f8Smarks iflags|ACE_INHERITED_ACE); 1763b3d141f8Smarks newflags |= ACE_INHERIT_ONLY_ACE; 1764b3d141f8Smarks aclp->z_ops.ace_flags_set(acep, newflags); 1765b3d141f8Smarks newflags &= ~ALL_INHERIT; 1766b3d141f8Smarks aclp->z_ops.ace_flags_set(acep2, 1767b3d141f8Smarks newflags|ACE_INHERITED_ACE); 1768fa9e4066Sahrens 1769169cdae2Smarks /* 1770da6c28aaSamw * Copy special opaque data if any 1771169cdae2Smarks */ 1772b3d141f8Smarks if ((data1sz = aclp->z_ops.ace_data(acep, 1773da6c28aaSamw &data1)) != 0) { 1774da6c28aaSamw VERIFY((data2sz = 1775b3d141f8Smarks aclp->z_ops.ace_data(acep2, 1776da6c28aaSamw &data2)) == data1sz); 1777b3d141f8Smarks bcopy(data1, data2, data1sz); 1778da6c28aaSamw } 1779da6c28aaSamw aclp->z_acl_count++; 1780b3d141f8Smarks aclnode2->z_ace_count++; 1781da6c28aaSamw aclp->z_acl_bytes += aclnode->z_size; 1782b3d141f8Smarks zfs_restricted_update(zfsvfs, aclp, acep2); 1783b3d141f8Smarks } else { 1784b3d141f8Smarks newflags |= ACE_INHERIT_ONLY_ACE; 1785b3d141f8Smarks aclp->z_ops.ace_flags_set(acep, 1786b3d141f8Smarks newflags|ACE_INHERITED_ACE); 1787fa9e4066Sahrens } 1788fa9e4066Sahrens } 1789fa9e4066Sahrens } 1790fa9e4066Sahrens return (aclp); 1791fa9e4066Sahrens } 1792fa9e4066Sahrens 1793fa9e4066Sahrens /* 1794fa9e4066Sahrens * Create file system object initial permissions 1795fa9e4066Sahrens * including inheritable ACEs. 1796fa9e4066Sahrens */ 1797fa9e4066Sahrens void 1798fa9e4066Sahrens zfs_perm_init(znode_t *zp, znode_t *parent, int flag, 1799da6c28aaSamw vattr_t *vap, dmu_tx_t *tx, cred_t *cr, 1800da6c28aaSamw zfs_acl_t *setaclp, zfs_fuid_info_t **fuidp) 1801fa9e4066Sahrens { 1802e0d35c44Smarks uint64_t mode, fuid, fgid; 1803fa9e4066Sahrens int error; 1804da6c28aaSamw zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1805da6c28aaSamw zfs_acl_t *aclp = NULL; 1806da6c28aaSamw zfs_acl_t *paclp; 1807da6c28aaSamw xvattr_t *xvap = (xvattr_t *)vap; 1808e0d35c44Smarks gid_t gid; 1809b3d141f8Smarks boolean_t need_chmod = B_TRUE; 1810da6c28aaSamw 1811da6c28aaSamw if (setaclp) 1812da6c28aaSamw aclp = setaclp; 1813fa9e4066Sahrens 1814fa9e4066Sahrens mode = MAKEIMODE(vap->va_type, vap->va_mode); 1815fa9e4066Sahrens 1816fa9e4066Sahrens /* 1817fa9e4066Sahrens * Determine uid and gid. 1818fa9e4066Sahrens */ 1819fa9e4066Sahrens if ((flag & (IS_ROOT_NODE | IS_REPLAY)) || 1820fa9e4066Sahrens ((flag & IS_XATTR) && (vap->va_type == VDIR))) { 1821e0d35c44Smarks fuid = zfs_fuid_create(zfsvfs, vap->va_uid, cr, 1822da6c28aaSamw ZFS_OWNER, tx, fuidp); 1823e0d35c44Smarks fgid = zfs_fuid_create(zfsvfs, vap->va_gid, cr, 1824da6c28aaSamw ZFS_GROUP, tx, fuidp); 1825e0d35c44Smarks gid = vap->va_gid; 1826fa9e4066Sahrens } else { 1827e0d35c44Smarks fuid = zfs_fuid_create_cred(zfsvfs, ZFS_OWNER, tx, cr, fuidp); 1828e0d35c44Smarks fgid = 0; 1829e0d35c44Smarks if (vap->va_mask & AT_GID) { 1830e0d35c44Smarks fgid = zfs_fuid_create(zfsvfs, vap->va_gid, cr, 1831e0d35c44Smarks ZFS_GROUP, tx, fuidp); 1832e0d35c44Smarks gid = vap->va_gid; 1833e0d35c44Smarks if (fgid != parent->z_phys->zp_gid && 1834e0d35c44Smarks !groupmember(vap->va_gid, cr) && 1835e0d35c44Smarks secpolicy_vnode_create_gid(cr) != 0) 1836e0d35c44Smarks fgid = 0; 1837e0d35c44Smarks } 1838e0d35c44Smarks if (fgid == 0) { 1839e0d35c44Smarks if (parent->z_phys->zp_mode & S_ISGID) { 1840e0d35c44Smarks fgid = parent->z_phys->zp_gid; 1841e0d35c44Smarks gid = zfs_fuid_map_id(zfsvfs, fgid, 1842e0d35c44Smarks cr, ZFS_GROUP); 1843e0d35c44Smarks } else { 1844e0d35c44Smarks fgid = zfs_fuid_create_cred(zfsvfs, 1845e0d35c44Smarks ZFS_GROUP, tx, cr, fuidp); 1846e0d35c44Smarks gid = crgetgid(cr); 1847e0d35c44Smarks } 1848da6c28aaSamw } 1849fa9e4066Sahrens } 1850fa9e4066Sahrens 1851fa9e4066Sahrens /* 1852fa9e4066Sahrens * If we're creating a directory, and the parent directory has the 1853fa9e4066Sahrens * set-GID bit set, set in on the new directory. 1854fa9e4066Sahrens * Otherwise, if the user is neither privileged nor a member of the 1855fa9e4066Sahrens * file's new group, clear the file's set-GID bit. 1856fa9e4066Sahrens */ 1857fa9e4066Sahrens 1858e0d35c44Smarks if ((parent->z_phys->zp_mode & S_ISGID) && (vap->va_type == VDIR)) { 1859fa9e4066Sahrens mode |= S_ISGID; 1860e0d35c44Smarks } else { 1861fa9e4066Sahrens if ((mode & S_ISGID) && 1862fa9e4066Sahrens secpolicy_vnode_setids_setgids(cr, gid) != 0) 1863fa9e4066Sahrens mode &= ~S_ISGID; 1864fa9e4066Sahrens } 1865fa9e4066Sahrens 1866e0d35c44Smarks zp->z_phys->zp_uid = fuid; 1867e0d35c44Smarks zp->z_phys->zp_gid = fgid; 1868fa9e4066Sahrens zp->z_phys->zp_mode = mode; 1869fa9e4066Sahrens 1870da6c28aaSamw if (aclp == NULL) { 1871da6c28aaSamw mutex_enter(&parent->z_lock); 1872b249c65cSmarks if ((ZTOV(parent)->v_type == VDIR && 18731ab99678SMark Shellenbaum (parent->z_phys->zp_flags & ZFS_INHERIT_ACE)) && 18741ab99678SMark Shellenbaum !(zp->z_phys->zp_flags & ZFS_XATTR)) { 1875da6c28aaSamw mutex_enter(&parent->z_acl_lock); 1876da6c28aaSamw VERIFY(0 == zfs_acl_node_read(parent, &paclp, B_FALSE)); 1877da6c28aaSamw mutex_exit(&parent->z_acl_lock); 1878b3d141f8Smarks aclp = zfs_acl_inherit(zp, paclp, &need_chmod); 1879da6c28aaSamw zfs_acl_free(paclp); 1880da6c28aaSamw } else { 1881da6c28aaSamw aclp = zfs_acl_alloc(zfs_acl_version_zp(zp)); 1882da6c28aaSamw } 1883da6c28aaSamw mutex_exit(&parent->z_lock); 1884da6c28aaSamw mutex_enter(&zp->z_lock); 1885da6c28aaSamw mutex_enter(&zp->z_acl_lock); 1886b3d141f8Smarks if (need_chmod) 1887b3d141f8Smarks zfs_acl_chmod(zp, mode, aclp); 1888fa9e4066Sahrens } else { 1889da6c28aaSamw mutex_enter(&zp->z_lock); 1890da6c28aaSamw mutex_enter(&zp->z_acl_lock); 1891fa9e4066Sahrens } 1892da6c28aaSamw 1893da6c28aaSamw /* Force auto_inherit on all new directory objects */ 1894da6c28aaSamw if (vap->va_type == VDIR) 1895da6c28aaSamw aclp->z_hints |= ZFS_ACL_AUTO_INHERIT; 1896da6c28aaSamw 1897bda89588Sjp error = zfs_aclset_common(zp, aclp, cr, fuidp, tx); 1898da6c28aaSamw 1899da6c28aaSamw /* Set optional attributes if any */ 1900da6c28aaSamw if (vap->va_mask & AT_XVATTR) 1901da6c28aaSamw zfs_xvattr_set(zp, xvap); 1902da6c28aaSamw 1903fa9e4066Sahrens mutex_exit(&zp->z_lock); 1904fa9e4066Sahrens mutex_exit(&zp->z_acl_lock); 1905fa9e4066Sahrens ASSERT3U(error, ==, 0); 1906fa9e4066Sahrens 1907e0d35c44Smarks if (aclp != setaclp) 1908da6c28aaSamw zfs_acl_free(aclp); 1909fa9e4066Sahrens } 1910fa9e4066Sahrens 1911fa9e4066Sahrens /* 1912fa9e4066Sahrens * Retrieve a files ACL 1913fa9e4066Sahrens */ 1914fa9e4066Sahrens int 1915da6c28aaSamw zfs_getacl(znode_t *zp, vsecattr_t *vsecp, boolean_t skipaclchk, cred_t *cr) 1916fa9e4066Sahrens { 1917fa9e4066Sahrens zfs_acl_t *aclp; 1918da6c28aaSamw ulong_t mask; 1919fa9e4066Sahrens int error; 1920da6c28aaSamw int count = 0; 1921da6c28aaSamw int largeace = 0; 1922fa9e4066Sahrens 1923da6c28aaSamw mask = vsecp->vsa_mask & (VSA_ACE | VSA_ACECNT | 1924da6c28aaSamw VSA_ACE_ACLFLAGS | VSA_ACE_ALLTYPES); 1925da6c28aaSamw 1926da6c28aaSamw if (error = zfs_zaccess(zp, ACE_READ_ACL, 0, skipaclchk, cr)) 1927da6c28aaSamw return (error); 1928fa9e4066Sahrens 1929fa9e4066Sahrens if (mask == 0) 1930fa9e4066Sahrens return (ENOSYS); 1931fa9e4066Sahrens 1932fa9e4066Sahrens mutex_enter(&zp->z_acl_lock); 1933fa9e4066Sahrens 1934da6c28aaSamw error = zfs_acl_node_read(zp, &aclp, B_FALSE); 1935ea8dc4b6Seschrock if (error != 0) { 1936ea8dc4b6Seschrock mutex_exit(&zp->z_acl_lock); 1937ea8dc4b6Seschrock return (error); 1938ea8dc4b6Seschrock } 1939ea8dc4b6Seschrock 1940da6c28aaSamw /* 1941da6c28aaSamw * Scan ACL to determine number of ACEs 1942da6c28aaSamw */ 1943da6c28aaSamw if ((zp->z_phys->zp_flags & ZFS_ACL_OBJ_ACE) && 1944da6c28aaSamw !(mask & VSA_ACE_ALLTYPES)) { 1945da6c28aaSamw void *zacep = NULL; 1946da6c28aaSamw uint64_t who; 1947da6c28aaSamw uint32_t access_mask; 1948da6c28aaSamw uint16_t type, iflags; 1949da6c28aaSamw 1950da6c28aaSamw while (zacep = zfs_acl_next_ace(aclp, zacep, 1951da6c28aaSamw &who, &access_mask, &iflags, &type)) { 1952da6c28aaSamw switch (type) { 1953da6c28aaSamw case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 1954da6c28aaSamw case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 1955da6c28aaSamw case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 1956da6c28aaSamw case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 1957da6c28aaSamw largeace++; 1958da6c28aaSamw continue; 1959da6c28aaSamw default: 1960da6c28aaSamw count++; 1961da6c28aaSamw } 1962da6c28aaSamw } 1963da6c28aaSamw vsecp->vsa_aclcnt = count; 1964da6c28aaSamw } else 1965da6c28aaSamw count = aclp->z_acl_count; 1966fa9e4066Sahrens 1967fa9e4066Sahrens if (mask & VSA_ACECNT) { 1968da6c28aaSamw vsecp->vsa_aclcnt = count; 1969fa9e4066Sahrens } 1970fa9e4066Sahrens 1971fa9e4066Sahrens if (mask & VSA_ACE) { 1972da6c28aaSamw size_t aclsz; 1973da6c28aaSamw 1974da6c28aaSamw zfs_acl_node_t *aclnode = list_head(&aclp->z_acl); 1975da6c28aaSamw 1976da6c28aaSamw aclsz = count * sizeof (ace_t) + 1977da6c28aaSamw sizeof (ace_object_t) * largeace; 1978da6c28aaSamw 1979da6c28aaSamw vsecp->vsa_aclentp = kmem_alloc(aclsz, KM_SLEEP); 1980da6c28aaSamw vsecp->vsa_aclentsz = aclsz; 1981da6c28aaSamw 1982da6c28aaSamw if (aclp->z_version == ZFS_ACL_VERSION_FUID) 1983bda89588Sjp zfs_copy_fuid_2_ace(zp->z_zfsvfs, aclp, cr, 1984da6c28aaSamw vsecp->vsa_aclentp, !(mask & VSA_ACE_ALLTYPES)); 1985da6c28aaSamw else { 1986da6c28aaSamw bcopy(aclnode->z_acldata, vsecp->vsa_aclentp, 1987da6c28aaSamw count * sizeof (ace_t)); 1988da6c28aaSamw } 1989da6c28aaSamw } 1990da6c28aaSamw if (mask & VSA_ACE_ACLFLAGS) { 1991da6c28aaSamw vsecp->vsa_aclflags = 0; 1992da6c28aaSamw if (zp->z_phys->zp_flags & ZFS_ACL_DEFAULTED) 1993da6c28aaSamw vsecp->vsa_aclflags |= ACL_DEFAULTED; 1994da6c28aaSamw if (zp->z_phys->zp_flags & ZFS_ACL_PROTECTED) 1995da6c28aaSamw vsecp->vsa_aclflags |= ACL_PROTECTED; 1996da6c28aaSamw if (zp->z_phys->zp_flags & ZFS_ACL_AUTO_INHERIT) 1997da6c28aaSamw vsecp->vsa_aclflags |= ACL_AUTO_INHERIT; 1998fa9e4066Sahrens } 1999fa9e4066Sahrens 2000fa9e4066Sahrens mutex_exit(&zp->z_acl_lock); 2001fa9e4066Sahrens 2002fa9e4066Sahrens zfs_acl_free(aclp); 2003fa9e4066Sahrens 2004fa9e4066Sahrens return (0); 2005fa9e4066Sahrens } 2006fa9e4066Sahrens 2007da6c28aaSamw int 2008da6c28aaSamw zfs_vsec_2_aclp(zfsvfs_t *zfsvfs, vtype_t obj_type, 2009da6c28aaSamw vsecattr_t *vsecp, zfs_acl_t **zaclp) 2010da6c28aaSamw { 2011da6c28aaSamw zfs_acl_t *aclp; 2012da6c28aaSamw zfs_acl_node_t *aclnode; 2013da6c28aaSamw int aclcnt = vsecp->vsa_aclcnt; 2014da6c28aaSamw int error; 2015da6c28aaSamw 2016da6c28aaSamw if (vsecp->vsa_aclcnt > MAX_ACL_ENTRIES || vsecp->vsa_aclcnt <= 0) 2017da6c28aaSamw return (EINVAL); 2018da6c28aaSamw 2019da6c28aaSamw aclp = zfs_acl_alloc(zfs_acl_version(zfsvfs->z_version)); 2020da6c28aaSamw 2021da6c28aaSamw aclp->z_hints = 0; 2022da6c28aaSamw aclnode = zfs_acl_node_alloc(aclcnt * sizeof (zfs_object_ace_t)); 2023da6c28aaSamw if (aclp->z_version == ZFS_ACL_VERSION_INITIAL) { 2024da6c28aaSamw if ((error = zfs_copy_ace_2_oldace(obj_type, aclp, 2025da6c28aaSamw (ace_t *)vsecp->vsa_aclentp, aclnode->z_acldata, 2026da6c28aaSamw aclcnt, &aclnode->z_size)) != 0) { 2027da6c28aaSamw zfs_acl_free(aclp); 2028da6c28aaSamw zfs_acl_node_free(aclnode); 2029da6c28aaSamw return (error); 2030da6c28aaSamw } 2031da6c28aaSamw } else { 2032da6c28aaSamw if ((error = zfs_copy_ace_2_fuid(obj_type, aclp, 2033da6c28aaSamw vsecp->vsa_aclentp, aclnode->z_acldata, aclcnt, 2034da6c28aaSamw &aclnode->z_size)) != 0) { 2035da6c28aaSamw zfs_acl_free(aclp); 2036da6c28aaSamw zfs_acl_node_free(aclnode); 2037da6c28aaSamw return (error); 2038da6c28aaSamw } 2039da6c28aaSamw } 2040da6c28aaSamw aclp->z_acl_bytes = aclnode->z_size; 2041da6c28aaSamw aclnode->z_ace_count = aclcnt; 2042da6c28aaSamw aclp->z_acl_count = aclcnt; 2043da6c28aaSamw list_insert_head(&aclp->z_acl, aclnode); 2044da6c28aaSamw 2045da6c28aaSamw /* 2046da6c28aaSamw * If flags are being set then add them to z_hints 2047da6c28aaSamw */ 2048da6c28aaSamw if (vsecp->vsa_mask & VSA_ACE_ACLFLAGS) { 2049da6c28aaSamw if (vsecp->vsa_aclflags & ACL_PROTECTED) 2050da6c28aaSamw aclp->z_hints |= ZFS_ACL_PROTECTED; 2051da6c28aaSamw if (vsecp->vsa_aclflags & ACL_DEFAULTED) 2052da6c28aaSamw aclp->z_hints |= ZFS_ACL_DEFAULTED; 2053da6c28aaSamw if (vsecp->vsa_aclflags & ACL_AUTO_INHERIT) 2054da6c28aaSamw aclp->z_hints |= ZFS_ACL_AUTO_INHERIT; 2055da6c28aaSamw } 2056da6c28aaSamw 2057da6c28aaSamw *zaclp = aclp; 2058da6c28aaSamw 2059da6c28aaSamw return (0); 2060da6c28aaSamw } 2061da6c28aaSamw 2062fa9e4066Sahrens /* 2063fa9e4066Sahrens * Set a files ACL 2064fa9e4066Sahrens */ 2065fa9e4066Sahrens int 2066da6c28aaSamw zfs_setacl(znode_t *zp, vsecattr_t *vsecp, boolean_t skipaclchk, cred_t *cr) 2067fa9e4066Sahrens { 2068fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2069fa9e4066Sahrens zilog_t *zilog = zfsvfs->z_log; 2070fa9e4066Sahrens ulong_t mask = vsecp->vsa_mask & (VSA_ACE | VSA_ACECNT); 2071fa9e4066Sahrens dmu_tx_t *tx; 2072fa9e4066Sahrens int error; 2073fa9e4066Sahrens zfs_acl_t *aclp; 2074da6c28aaSamw zfs_fuid_info_t *fuidp = NULL; 2075fa9e4066Sahrens 2076fa9e4066Sahrens if (mask == 0) 20777106075aSmarks return (ENOSYS); 2078fa9e4066Sahrens 2079da6c28aaSamw if (zp->z_phys->zp_flags & ZFS_IMMUTABLE) 2080da6c28aaSamw return (EPERM); 2081da6c28aaSamw 2082da6c28aaSamw if (error = zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr)) 2083da6c28aaSamw return (error); 2084da6c28aaSamw 2085da6c28aaSamw error = zfs_vsec_2_aclp(zfsvfs, ZTOV(zp)->v_type, vsecp, &aclp); 2086da6c28aaSamw if (error) 2087da6c28aaSamw return (error); 2088da6c28aaSamw 2089da6c28aaSamw /* 2090da6c28aaSamw * If ACL wide flags aren't being set then preserve any 2091da6c28aaSamw * existing flags. 2092da6c28aaSamw */ 2093da6c28aaSamw if (!(vsecp->vsa_mask & VSA_ACE_ACLFLAGS)) { 2094da6c28aaSamw aclp->z_hints |= (zp->z_phys->zp_flags & V4_ACL_WIDE_FLAGS); 2095da6c28aaSamw } 2096fa9e4066Sahrens top: 2097da6c28aaSamw if (error = zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr)) { 2098da6c28aaSamw zfs_acl_free(aclp); 2099da6c28aaSamw return (error); 2100fa9e4066Sahrens } 2101fa9e4066Sahrens 2102fa9e4066Sahrens mutex_enter(&zp->z_lock); 2103fa9e4066Sahrens mutex_enter(&zp->z_acl_lock); 2104fa9e4066Sahrens 2105fa9e4066Sahrens tx = dmu_tx_create(zfsvfs->z_os); 2106fa9e4066Sahrens dmu_tx_hold_bonus(tx, zp->z_id); 2107fa9e4066Sahrens 2108fa9e4066Sahrens if (zp->z_phys->zp_acl.z_acl_extern_obj) { 2109da6c28aaSamw /* Are we upgrading ACL? */ 2110da6c28aaSamw if (zfsvfs->z_version <= ZPL_VERSION_FUID && 2111da6c28aaSamw zp->z_phys->zp_acl.z_acl_version == 2112da6c28aaSamw ZFS_ACL_VERSION_INITIAL) { 2113da6c28aaSamw dmu_tx_hold_free(tx, 2114da6c28aaSamw zp->z_phys->zp_acl.z_acl_extern_obj, 2115da6c28aaSamw 0, DMU_OBJECT_END); 2116da6c28aaSamw dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 21174c841f60Smarks 0, aclp->z_acl_bytes); 2118da6c28aaSamw } else { 2119da6c28aaSamw dmu_tx_hold_write(tx, 2120da6c28aaSamw zp->z_phys->zp_acl.z_acl_extern_obj, 2121da6c28aaSamw 0, aclp->z_acl_bytes); 2122da6c28aaSamw } 2123da6c28aaSamw } else if (aclp->z_acl_bytes > ZFS_ACE_SPACE) { 2124da6c28aaSamw dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, aclp->z_acl_bytes); 2125da6c28aaSamw } 21264c841f60Smarks if (aclp->z_has_fuids) { 21274c841f60Smarks if (zfsvfs->z_fuid_obj == 0) { 21284c841f60Smarks dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 2129da6c28aaSamw dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 21304c841f60Smarks FUID_SIZE_ESTIMATE(zfsvfs)); 21314c841f60Smarks dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, FALSE, NULL); 21324c841f60Smarks } else { 21334c841f60Smarks dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj); 21344c841f60Smarks dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0, 21354c841f60Smarks FUID_SIZE_ESTIMATE(zfsvfs)); 21364c841f60Smarks } 2137fa9e4066Sahrens } 2138fa9e4066Sahrens 2139fa9e4066Sahrens error = dmu_tx_assign(tx, zfsvfs->z_assign); 2140fa9e4066Sahrens if (error) { 2141fa9e4066Sahrens mutex_exit(&zp->z_acl_lock); 2142fa9e4066Sahrens mutex_exit(&zp->z_lock); 2143fa9e4066Sahrens 2144fa9e4066Sahrens if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) { 21458a2f1b91Sahrens dmu_tx_wait(tx); 21468a2f1b91Sahrens dmu_tx_abort(tx); 2147fa9e4066Sahrens goto top; 2148fa9e4066Sahrens } 21498a2f1b91Sahrens dmu_tx_abort(tx); 2150da6c28aaSamw zfs_acl_free(aclp); 2151fa9e4066Sahrens return (error); 2152fa9e4066Sahrens } 2153fa9e4066Sahrens 2154bda89588Sjp error = zfs_aclset_common(zp, aclp, cr, &fuidp, tx); 2155fa9e4066Sahrens ASSERT(error == 0); 2156fa9e4066Sahrens 2157da6c28aaSamw zfs_log_acl(zilog, tx, zp, vsecp, fuidp); 2158da6c28aaSamw 2159da6c28aaSamw if (fuidp) 2160da6c28aaSamw zfs_fuid_info_free(fuidp); 2161fa9e4066Sahrens zfs_acl_free(aclp); 2162fa9e4066Sahrens dmu_tx_commit(tx); 2163fa9e4066Sahrens done: 2164fa9e4066Sahrens mutex_exit(&zp->z_acl_lock); 2165fa9e4066Sahrens mutex_exit(&zp->z_lock); 2166fa9e4066Sahrens 2167fa9e4066Sahrens return (error); 2168fa9e4066Sahrens } 2169fa9e4066Sahrens 2170da6c28aaSamw /* 2171da6c28aaSamw * working_mode returns the permissions that were not granted 2172da6c28aaSamw */ 2173fa9e4066Sahrens static int 2174da6c28aaSamw zfs_zaccess_common(znode_t *zp, uint32_t v4_mode, uint32_t *working_mode, 2175da6c28aaSamw boolean_t *check_privs, boolean_t skipaclchk, cred_t *cr) 2176fa9e4066Sahrens { 2177fa9e4066Sahrens zfs_acl_t *aclp; 2178fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2179ea8dc4b6Seschrock int error; 2180fa9e4066Sahrens uid_t uid = crgetuid(cr); 2181da6c28aaSamw uint64_t who; 2182da6c28aaSamw uint16_t type, iflags; 2183da6c28aaSamw uint16_t entry_type; 2184da6c28aaSamw uint32_t access_mask; 218590fafcf0Smarks uint32_t deny_mask = 0; 2186da6c28aaSamw zfs_ace_hdr_t *acep = NULL; 2187da6c28aaSamw boolean_t checkit; 2188da6c28aaSamw uid_t fowner; 2189da6c28aaSamw uid_t gowner; 2190da6c28aaSamw 2191da6c28aaSamw /* 2192da6c28aaSamw * Short circuit empty requests 2193da6c28aaSamw */ 2194da6c28aaSamw if (v4_mode == 0) 2195da6c28aaSamw return (0); 2196da6c28aaSamw 2197da6c28aaSamw *check_privs = B_TRUE; 2198fa9e4066Sahrens 2199b19a79ecSperrin if (zfsvfs->z_assign >= TXG_INITIAL) { /* ZIL replay */ 2200b19a79ecSperrin *working_mode = 0; 2201fa9e4066Sahrens return (0); 2202b19a79ecSperrin } 2203b19a79ecSperrin 2204b19a79ecSperrin *working_mode = v4_mode; 2205fa9e4066Sahrens 2206fa9e4066Sahrens if ((v4_mode & WRITE_MASK) && 2207fa9e4066Sahrens (zp->z_zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) && 2208fa9e4066Sahrens (!IS_DEVVP(ZTOV(zp)))) { 2209da6c28aaSamw *check_privs = B_FALSE; 2210fa9e4066Sahrens return (EROFS); 2211fa9e4066Sahrens } 2212fa9e4066Sahrens 2213da6c28aaSamw /* 2214da6c28aaSamw * Only check for READONLY on non-directories. 2215da6c28aaSamw */ 2216da6c28aaSamw if ((v4_mode & WRITE_MASK_DATA) && 2217da6c28aaSamw (((ZTOV(zp)->v_type != VDIR) && 2218da6c28aaSamw (zp->z_phys->zp_flags & (ZFS_READONLY | ZFS_IMMUTABLE))) || 2219da6c28aaSamw (ZTOV(zp)->v_type == VDIR && 2220da6c28aaSamw (zp->z_phys->zp_flags & ZFS_IMMUTABLE)))) { 2221da6c28aaSamw *check_privs = B_FALSE; 2222da6c28aaSamw return (EPERM); 2223da6c28aaSamw } 2224da6c28aaSamw 2225da6c28aaSamw if ((v4_mode & (ACE_DELETE | ACE_DELETE_CHILD)) && 2226da6c28aaSamw (zp->z_phys->zp_flags & ZFS_NOUNLINK)) { 2227da6c28aaSamw *check_privs = B_FALSE; 2228da6c28aaSamw return (EPERM); 2229da6c28aaSamw } 2230da6c28aaSamw 2231da6c28aaSamw if (((v4_mode & (ACE_READ_DATA|ACE_EXECUTE)) && 2232da6c28aaSamw (zp->z_phys->zp_flags & ZFS_AV_QUARANTINED))) { 2233da6c28aaSamw *check_privs = B_FALSE; 2234da6c28aaSamw return (EACCES); 2235da6c28aaSamw } 2236da6c28aaSamw 2237da6c28aaSamw /* 2238da6c28aaSamw * The caller requested that the ACL check be skipped. This 2239da6c28aaSamw * would only happen if the caller checked VOP_ACCESS() with a 2240da6c28aaSamw * 32 bit ACE mask and already had the appropriate permissions. 2241da6c28aaSamw */ 2242da6c28aaSamw if (skipaclchk) { 2243da6c28aaSamw *working_mode = 0; 2244da6c28aaSamw return (0); 2245da6c28aaSamw } 2246da6c28aaSamw 2247bda89588Sjp zfs_fuid_map_ids(zp, cr, &fowner, &gowner); 2248da6c28aaSamw 2249fa9e4066Sahrens mutex_enter(&zp->z_acl_lock); 2250fa9e4066Sahrens 2251da6c28aaSamw error = zfs_acl_node_read(zp, &aclp, B_FALSE); 2252ea8dc4b6Seschrock if (error != 0) { 2253ea8dc4b6Seschrock mutex_exit(&zp->z_acl_lock); 2254ea8dc4b6Seschrock return (error); 2255ea8dc4b6Seschrock } 2256ea8dc4b6Seschrock 2257da6c28aaSamw while (acep = zfs_acl_next_ace(aclp, acep, &who, &access_mask, 2258da6c28aaSamw &iflags, &type)) { 2259fa9e4066Sahrens 2260*003c2582SMark Shellenbaum if (!zfs_acl_valid_ace_type(type, iflags)) 2261*003c2582SMark Shellenbaum continue; 2262*003c2582SMark Shellenbaum 2263b249c65cSmarks if (ZTOV(zp)->v_type == VDIR && (iflags & ACE_INHERIT_ONLY_ACE)) 2264da6c28aaSamw continue; 2265fa9e4066Sahrens 2266da6c28aaSamw entry_type = (iflags & ACE_TYPE_FLAGS); 2267169cdae2Smarks 2268da6c28aaSamw checkit = B_FALSE; 2269fa9e4066Sahrens 2270fa9e4066Sahrens switch (entry_type) { 2271fa9e4066Sahrens case ACE_OWNER: 2272da6c28aaSamw if (uid == fowner) 2273da6c28aaSamw checkit = B_TRUE; 2274fa9e4066Sahrens break; 2275da6c28aaSamw case OWNING_GROUP: 2276da6c28aaSamw who = gowner; 2277da6c28aaSamw /*FALLTHROUGH*/ 2278fa9e4066Sahrens case ACE_IDENTIFIER_GROUP: 2279da6c28aaSamw checkit = zfs_groupmember(zfsvfs, who, cr); 2280fa9e4066Sahrens break; 2281fa9e4066Sahrens case ACE_EVERYONE: 2282da6c28aaSamw checkit = B_TRUE; 2283fa9e4066Sahrens break; 2284fa9e4066Sahrens 2285fa9e4066Sahrens /* USER Entry */ 2286fa9e4066Sahrens default: 2287fa9e4066Sahrens if (entry_type == 0) { 2288da6c28aaSamw uid_t newid; 2289da6c28aaSamw 2290e0d35c44Smarks newid = zfs_fuid_map_id(zfsvfs, who, cr, 2291e0d35c44Smarks ZFS_ACE_USER); 2292da6c28aaSamw if (newid != IDMAP_WK_CREATOR_OWNER_UID && 2293da6c28aaSamw uid == newid) 2294da6c28aaSamw checkit = B_TRUE; 2295fa9e4066Sahrens break; 2296da6c28aaSamw } else { 2297da6c28aaSamw zfs_acl_free(aclp); 2298da6c28aaSamw mutex_exit(&zp->z_acl_lock); 2299da6c28aaSamw return (EIO); 2300da6c28aaSamw } 2301da6c28aaSamw } 2302da6c28aaSamw 2303da6c28aaSamw if (checkit) { 230490fafcf0Smarks uint32_t mask_matched = (access_mask & *working_mode); 230590fafcf0Smarks 230690fafcf0Smarks if (mask_matched) { 230790fafcf0Smarks if (type == DENY) 230890fafcf0Smarks deny_mask |= mask_matched; 230990fafcf0Smarks 231090fafcf0Smarks *working_mode &= ~mask_matched; 2311fa9e4066Sahrens } 2312fa9e4066Sahrens } 2313fa9e4066Sahrens 231490fafcf0Smarks /* Are we done? */ 231590fafcf0Smarks if (*working_mode == 0) 2316fa9e4066Sahrens break; 2317fa9e4066Sahrens } 2318fa9e4066Sahrens 2319fa9e4066Sahrens mutex_exit(&zp->z_acl_lock); 2320fa9e4066Sahrens zfs_acl_free(aclp); 232190fafcf0Smarks 232290fafcf0Smarks /* Put the found 'denies' back on the working mode */ 23237ed7e920Smarks if (deny_mask) { 23247ed7e920Smarks *working_mode |= deny_mask; 232590fafcf0Smarks return (EACCES); 23267ed7e920Smarks } else if (*working_mode) { 23277ed7e920Smarks return (-1); 23287ed7e920Smarks } 232990fafcf0Smarks 233090fafcf0Smarks return (0); 2331fa9e4066Sahrens } 2332fa9e4066Sahrens 2333da6c28aaSamw static int 2334da6c28aaSamw zfs_zaccess_append(znode_t *zp, uint32_t *working_mode, boolean_t *check_privs, 2335da6c28aaSamw cred_t *cr) 2336da6c28aaSamw { 2337da6c28aaSamw if (*working_mode != ACE_WRITE_DATA) 2338da6c28aaSamw return (EACCES); 2339da6c28aaSamw 2340da6c28aaSamw return (zfs_zaccess_common(zp, ACE_APPEND_DATA, working_mode, 2341da6c28aaSamw check_privs, B_FALSE, cr)); 2342da6c28aaSamw } 2343fa9e4066Sahrens 2344fa9e4066Sahrens /* 2345fa9e4066Sahrens * Determine whether Access should be granted/denied, invoking least 2346fa9e4066Sahrens * priv subsytem when a deny is determined. 2347fa9e4066Sahrens */ 2348fa9e4066Sahrens int 2349da6c28aaSamw zfs_zaccess(znode_t *zp, int mode, int flags, boolean_t skipaclchk, cred_t *cr) 2350fa9e4066Sahrens { 2351da6c28aaSamw uint32_t working_mode; 2352da6c28aaSamw int error; 2353da6c28aaSamw int is_attr; 2354da6c28aaSamw zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2355da6c28aaSamw boolean_t check_privs; 2356da6c28aaSamw znode_t *xzp; 2357da6c28aaSamw znode_t *check_zp = zp; 2358fa9e4066Sahrens 2359fa9e4066Sahrens is_attr = ((zp->z_phys->zp_flags & ZFS_XATTR) && 2360fa9e4066Sahrens (ZTOV(zp)->v_type == VDIR)); 2361fa9e4066Sahrens 2362fa9e4066Sahrens /* 2363fa9e4066Sahrens * If attribute then validate against base file 2364fa9e4066Sahrens */ 2365fa9e4066Sahrens if (is_attr) { 2366fa9e4066Sahrens if ((error = zfs_zget(zp->z_zfsvfs, 2367fa9e4066Sahrens zp->z_phys->zp_parent, &xzp)) != 0) { 2368fa9e4066Sahrens return (error); 2369fa9e4066Sahrens } 2370da6c28aaSamw 2371fa9e4066Sahrens check_zp = xzp; 2372da6c28aaSamw 2373fa9e4066Sahrens /* 2374fa9e4066Sahrens * fixup mode to map to xattr perms 2375fa9e4066Sahrens */ 2376fa9e4066Sahrens 2377fa9e4066Sahrens if (mode & (ACE_WRITE_DATA|ACE_APPEND_DATA)) { 2378fa9e4066Sahrens mode &= ~(ACE_WRITE_DATA|ACE_APPEND_DATA); 2379fa9e4066Sahrens mode |= ACE_WRITE_NAMED_ATTRS; 2380fa9e4066Sahrens } 2381fa9e4066Sahrens 2382fa9e4066Sahrens if (mode & (ACE_READ_DATA|ACE_EXECUTE)) { 2383fa9e4066Sahrens mode &= ~(ACE_READ_DATA|ACE_EXECUTE); 2384fa9e4066Sahrens mode |= ACE_READ_NAMED_ATTRS; 2385fa9e4066Sahrens } 2386fa9e4066Sahrens } 2387fa9e4066Sahrens 2388da6c28aaSamw if ((error = zfs_zaccess_common(check_zp, mode, &working_mode, 2389da6c28aaSamw &check_privs, skipaclchk, cr)) == 0) { 2390da6c28aaSamw if (is_attr) 2391da6c28aaSamw VN_RELE(ZTOV(xzp)); 2392da6c28aaSamw return (0); 2393da6c28aaSamw } 2394fa9e4066Sahrens 2395e0d35c44Smarks if (error && !check_privs) { 2396fa9e4066Sahrens if (is_attr) 2397fa9e4066Sahrens VN_RELE(ZTOV(xzp)); 2398fa9e4066Sahrens return (error); 2399fa9e4066Sahrens } 2400fa9e4066Sahrens 2401da6c28aaSamw if (error && (flags & V_APPEND)) { 2402da6c28aaSamw error = zfs_zaccess_append(zp, &working_mode, &check_privs, cr); 2403da6c28aaSamw } 2404da6c28aaSamw 2405da6c28aaSamw if (error && check_privs) { 2406da6c28aaSamw uid_t owner; 2407da6c28aaSamw mode_t checkmode = 0; 2408da6c28aaSamw 2409e0d35c44Smarks owner = zfs_fuid_map_id(zfsvfs, check_zp->z_phys->zp_uid, cr, 2410e0d35c44Smarks ZFS_OWNER); 2411da6c28aaSamw 2412da6c28aaSamw /* 2413da6c28aaSamw * First check for implicit owner permission on 2414da6c28aaSamw * read_acl/read_attributes 2415da6c28aaSamw */ 2416da6c28aaSamw 2417da6c28aaSamw error = 0; 2418da6c28aaSamw ASSERT(working_mode != 0); 2419da6c28aaSamw 2420da6c28aaSamw if ((working_mode & (ACE_READ_ACL|ACE_READ_ATTRIBUTES) && 2421da6c28aaSamw owner == crgetuid(cr))) 2422da6c28aaSamw working_mode &= ~(ACE_READ_ACL|ACE_READ_ATTRIBUTES); 2423da6c28aaSamw 2424da6c28aaSamw if (working_mode & (ACE_READ_DATA|ACE_READ_NAMED_ATTRS| 2425da6c28aaSamw ACE_READ_ACL|ACE_READ_ATTRIBUTES)) 2426da6c28aaSamw checkmode |= VREAD; 2427da6c28aaSamw if (working_mode & (ACE_WRITE_DATA|ACE_WRITE_NAMED_ATTRS| 2428da6c28aaSamw ACE_APPEND_DATA|ACE_WRITE_ATTRIBUTES)) 2429da6c28aaSamw checkmode |= VWRITE; 2430da6c28aaSamw if (working_mode & ACE_EXECUTE) 2431da6c28aaSamw checkmode |= VEXEC; 2432da6c28aaSamw 2433da6c28aaSamw if (checkmode) 2434da6c28aaSamw error = secpolicy_vnode_access(cr, ZTOV(check_zp), 2435da6c28aaSamw owner, checkmode); 2436da6c28aaSamw 2437da6c28aaSamw if (error == 0 && (working_mode & ACE_WRITE_OWNER)) 2438da6c28aaSamw error = secpolicy_vnode_create_gid(cr); 2439da6c28aaSamw if (error == 0 && (working_mode & ACE_WRITE_ACL)) 2440da6c28aaSamw error = secpolicy_vnode_setdac(cr, owner); 2441da6c28aaSamw 2442da6c28aaSamw if (error == 0 && (working_mode & 2443da6c28aaSamw (ACE_DELETE|ACE_DELETE_CHILD))) 2444da6c28aaSamw error = secpolicy_vnode_remove(cr); 2445da6c28aaSamw 2446da6c28aaSamw if (error == 0 && (working_mode & ACE_SYNCHRONIZE)) 2447da6c28aaSamw error = secpolicy_vnode_owner(cr, owner); 2448da6c28aaSamw 2449da6c28aaSamw if (error == 0) { 2450da6c28aaSamw /* 2451da6c28aaSamw * See if any bits other than those already checked 2452da6c28aaSamw * for are still present. If so then return EACCES 2453da6c28aaSamw */ 2454da6c28aaSamw if (working_mode & ~(ZFS_CHECKED_MASKS)) { 2455da6c28aaSamw error = EACCES; 2456da6c28aaSamw } 2457da6c28aaSamw } 2458fa9e4066Sahrens } 2459fa9e4066Sahrens 2460fa9e4066Sahrens if (is_attr) 2461fa9e4066Sahrens VN_RELE(ZTOV(xzp)); 2462fa9e4066Sahrens 2463fa9e4066Sahrens return (error); 2464fa9e4066Sahrens } 2465fa9e4066Sahrens 2466fa9e4066Sahrens /* 2467da6c28aaSamw * Translate traditional unix VREAD/VWRITE/VEXEC mode into 2468da6c28aaSamw * native ACL format and call zfs_zaccess() 2469fa9e4066Sahrens */ 2470fa9e4066Sahrens int 2471da6c28aaSamw zfs_zaccess_rwx(znode_t *zp, mode_t mode, int flags, cred_t *cr) 2472fa9e4066Sahrens { 2473da6c28aaSamw return (zfs_zaccess(zp, zfs_unix_to_v4(mode >> 6), flags, B_FALSE, cr)); 2474fa9e4066Sahrens } 2475fa9e4066Sahrens 2476fa9e4066Sahrens /* 2477da6c28aaSamw * Access function for secpolicy_vnode_setattr 2478fa9e4066Sahrens */ 2479fa9e4066Sahrens int 2480da6c28aaSamw zfs_zaccess_unix(znode_t *zp, mode_t mode, cred_t *cr) 2481fa9e4066Sahrens { 2482fa9e4066Sahrens int v4_mode = zfs_unix_to_v4(mode >> 6); 2483fa9e4066Sahrens 2484da6c28aaSamw return (zfs_zaccess(zp, v4_mode, 0, B_FALSE, cr)); 2485fa9e4066Sahrens } 2486fa9e4066Sahrens 248747db7e74Smarks static int 248823d5bb1fSmarks zfs_delete_final_check(znode_t *zp, znode_t *dzp, 248923d5bb1fSmarks mode_t missing_perms, cred_t *cr) 249047db7e74Smarks { 249147db7e74Smarks int error; 2492da6c28aaSamw uid_t downer; 2493da6c28aaSamw zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2494da6c28aaSamw 2495e0d35c44Smarks downer = zfs_fuid_map_id(zfsvfs, dzp->z_phys->zp_uid, cr, ZFS_OWNER); 249647db7e74Smarks 249723d5bb1fSmarks error = secpolicy_vnode_access(cr, ZTOV(dzp), downer, missing_perms); 249847db7e74Smarks 249947db7e74Smarks if (error == 0) 250047db7e74Smarks error = zfs_sticky_remove_access(dzp, zp, cr); 250147db7e74Smarks 250247db7e74Smarks return (error); 250347db7e74Smarks } 250447db7e74Smarks 2505fa9e4066Sahrens /* 2506fa9e4066Sahrens * Determine whether Access should be granted/deny, without 2507fa9e4066Sahrens * consulting least priv subsystem. 2508fa9e4066Sahrens * 2509fa9e4066Sahrens * 2510fa9e4066Sahrens * The following chart is the recommended NFSv4 enforcement for 2511fa9e4066Sahrens * ability to delete an object. 2512fa9e4066Sahrens * 2513fa9e4066Sahrens * ------------------------------------------------------- 2514fa9e4066Sahrens * | Parent Dir | Target Object Permissions | 2515fa9e4066Sahrens * | permissions | | 2516fa9e4066Sahrens * ------------------------------------------------------- 2517fa9e4066Sahrens * | | ACL Allows | ACL Denies| Delete | 2518fa9e4066Sahrens * | | Delete | Delete | unspecified| 2519fa9e4066Sahrens * ------------------------------------------------------- 2520fa9e4066Sahrens * | ACL Allows | Permit | Permit | Permit | 2521fa9e4066Sahrens * | DELETE_CHILD | | 2522fa9e4066Sahrens * ------------------------------------------------------- 2523fa9e4066Sahrens * | ACL Denies | Permit | Deny | Deny | 2524fa9e4066Sahrens * | DELETE_CHILD | | | | 2525fa9e4066Sahrens * ------------------------------------------------------- 2526fa9e4066Sahrens * | ACL specifies | | | | 2527fa9e4066Sahrens * | only allow | Permit | Permit | Permit | 2528fa9e4066Sahrens * | write and | | | | 2529fa9e4066Sahrens * | execute | | | | 2530fa9e4066Sahrens * ------------------------------------------------------- 2531fa9e4066Sahrens * | ACL denies | | | | 2532fa9e4066Sahrens * | write and | Permit | Deny | Deny | 2533fa9e4066Sahrens * | execute | | | | 2534fa9e4066Sahrens * ------------------------------------------------------- 2535fa9e4066Sahrens * ^ 2536fa9e4066Sahrens * | 2537fa9e4066Sahrens * No search privilege, can't even look up file? 2538fa9e4066Sahrens * 2539fa9e4066Sahrens */ 2540fa9e4066Sahrens int 2541fa9e4066Sahrens zfs_zaccess_delete(znode_t *dzp, znode_t *zp, cred_t *cr) 2542fa9e4066Sahrens { 2543da6c28aaSamw uint32_t dzp_working_mode = 0; 2544da6c28aaSamw uint32_t zp_working_mode = 0; 2545fa9e4066Sahrens int dzp_error, zp_error; 254623d5bb1fSmarks mode_t missing_perms; 2547da6c28aaSamw boolean_t dzpcheck_privs = B_TRUE; 2548da6c28aaSamw boolean_t zpcheck_privs = B_TRUE; 2549fa9e4066Sahrens 2550fa9e4066Sahrens /* 255123d5bb1fSmarks * We want specific DELETE permissions to 2552fa9e4066Sahrens * take precedence over WRITE/EXECUTE. We don't 2553fa9e4066Sahrens * want an ACL such as this to mess us up. 255447db7e74Smarks * user:joe:write_data:deny,user:joe:delete:allow 2555fa9e4066Sahrens * 2556fa9e4066Sahrens * However, deny permissions may ultimately be overridden 2557fa9e4066Sahrens * by secpolicy_vnode_access(). 255823d5bb1fSmarks * 255923d5bb1fSmarks * We will ask for all of the necessary permissions and then 256023d5bb1fSmarks * look at the working modes from the directory and target object 256123d5bb1fSmarks * to determine what was found. 2562fa9e4066Sahrens */ 2563fa9e4066Sahrens 2564da6c28aaSamw if (zp->z_phys->zp_flags & (ZFS_IMMUTABLE | ZFS_NOUNLINK)) 2565da6c28aaSamw return (EPERM); 2566da6c28aaSamw 256723d5bb1fSmarks /* 25687ed7e920Smarks * First row 256923d5bb1fSmarks * If the directory permissions allow the delete, we are done. 257023d5bb1fSmarks */ 25717ed7e920Smarks if ((dzp_error = zfs_zaccess_common(dzp, ACE_DELETE_CHILD, 257223d5bb1fSmarks &dzp_working_mode, &dzpcheck_privs, B_FALSE, cr)) == 0) 257323d5bb1fSmarks return (0); 2574fa9e4066Sahrens 257523d5bb1fSmarks /* 257623d5bb1fSmarks * If target object has delete permission then we are done 257723d5bb1fSmarks */ 257823d5bb1fSmarks if ((zp_error = zfs_zaccess_common(zp, ACE_DELETE, &zp_working_mode, 257923d5bb1fSmarks &zpcheck_privs, B_FALSE, cr)) == 0) 258023d5bb1fSmarks return (0); 258123d5bb1fSmarks 25827ed7e920Smarks ASSERT(dzp_error && zp_error); 25837ed7e920Smarks 258423d5bb1fSmarks if (!dzpcheck_privs) 2585fa9e4066Sahrens return (dzp_error); 25867ed7e920Smarks if (!zpcheck_privs) 258723d5bb1fSmarks return (zp_error); 2588fa9e4066Sahrens 2589fa9e4066Sahrens /* 2590fa9e4066Sahrens * Second row 25917ed7e920Smarks * 25927ed7e920Smarks * If directory returns EACCES then delete_child was denied 25937ed7e920Smarks * due to deny delete_child. In this case send the request through 25947ed7e920Smarks * secpolicy_vnode_remove(). We don't use zfs_delete_final_check() 25957ed7e920Smarks * since that *could* allow the delete based on write/execute permission 25967ed7e920Smarks * and we want delete permissions to override write/execute. 259747db7e74Smarks */ 259847db7e74Smarks 259947db7e74Smarks if (dzp_error == EACCES) 26007ed7e920Smarks return (secpolicy_vnode_remove(cr)); 260147db7e74Smarks 2602fa9e4066Sahrens /* 2603fa9e4066Sahrens * Third Row 260423d5bb1fSmarks * only need to see if we have write/execute on directory. 2605fa9e4066Sahrens */ 2606fa9e4066Sahrens 26077ed7e920Smarks if ((dzp_error = zfs_zaccess_common(dzp, ACE_EXECUTE|ACE_WRITE_DATA, 26087ed7e920Smarks &dzp_working_mode, &dzpcheck_privs, B_FALSE, cr)) == 0) 260947db7e74Smarks return (zfs_sticky_remove_access(dzp, zp, cr)); 2610fa9e4066Sahrens 26117ed7e920Smarks if (!dzpcheck_privs) 26127ed7e920Smarks return (dzp_error); 26137ed7e920Smarks 2614fa9e4066Sahrens /* 26157ed7e920Smarks * Fourth row 2616fa9e4066Sahrens */ 2617fa9e4066Sahrens 26187ed7e920Smarks missing_perms = (dzp_working_mode & ACE_WRITE_DATA) ? VWRITE : 0; 26197ed7e920Smarks missing_perms |= (dzp_working_mode & ACE_EXECUTE) ? VEXEC : 0; 26207ed7e920Smarks 26217ed7e920Smarks ASSERT(missing_perms); 2622fa9e4066Sahrens 262323d5bb1fSmarks return (zfs_delete_final_check(zp, dzp, missing_perms, cr)); 26247ed7e920Smarks 2625fa9e4066Sahrens } 2626fa9e4066Sahrens 2627fa9e4066Sahrens int 2628fa9e4066Sahrens zfs_zaccess_rename(znode_t *sdzp, znode_t *szp, znode_t *tdzp, 2629fa9e4066Sahrens znode_t *tzp, cred_t *cr) 2630fa9e4066Sahrens { 2631fa9e4066Sahrens int add_perm; 2632fa9e4066Sahrens int error; 2633fa9e4066Sahrens 2634da6c28aaSamw if (szp->z_phys->zp_flags & ZFS_AV_QUARANTINED) 2635da6c28aaSamw return (EACCES); 2636da6c28aaSamw 2637fa9e4066Sahrens add_perm = (ZTOV(szp)->v_type == VDIR) ? 2638fa9e4066Sahrens ACE_ADD_SUBDIRECTORY : ACE_ADD_FILE; 2639fa9e4066Sahrens 2640fa9e4066Sahrens /* 2641fa9e4066Sahrens * Rename permissions are combination of delete permission + 2642fa9e4066Sahrens * add file/subdir permission. 2643fa9e4066Sahrens */ 2644fa9e4066Sahrens 2645fa9e4066Sahrens /* 2646fa9e4066Sahrens * first make sure we do the delete portion. 2647fa9e4066Sahrens * 2648fa9e4066Sahrens * If that succeeds then check for add_file/add_subdir permissions 2649fa9e4066Sahrens */ 2650fa9e4066Sahrens 2651fa9e4066Sahrens if (error = zfs_zaccess_delete(sdzp, szp, cr)) 2652fa9e4066Sahrens return (error); 2653fa9e4066Sahrens 2654fa9e4066Sahrens /* 2655fa9e4066Sahrens * If we have a tzp, see if we can delete it? 2656fa9e4066Sahrens */ 2657fa9e4066Sahrens if (tzp) { 2658fa9e4066Sahrens if (error = zfs_zaccess_delete(tdzp, tzp, cr)) 2659fa9e4066Sahrens return (error); 2660fa9e4066Sahrens } 2661fa9e4066Sahrens 2662fa9e4066Sahrens /* 2663fa9e4066Sahrens * Now check for add permissions 2664fa9e4066Sahrens */ 2665da6c28aaSamw error = zfs_zaccess(tdzp, add_perm, 0, B_FALSE, cr); 2666fa9e4066Sahrens 2667fa9e4066Sahrens return (error); 2668fa9e4066Sahrens } 2669