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