1 5331 amw /* 2 5331 amw * CDDL HEADER START 3 5331 amw * 4 5331 amw * The contents of this file are subject to the terms of the 5 5331 amw * Common Development and Distribution License (the "License"). 6 5331 amw * You may not use this file except in compliance with the License. 7 5331 amw * 8 5331 amw * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 5331 amw * or http://www.opensolaris.org/os/licensing. 10 5331 amw * See the License for the specific language governing permissions 11 5331 amw * and limitations under the License. 12 5331 amw * 13 5331 amw * When distributing Covered Code, include this CDDL HEADER in each 14 5331 amw * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 5331 amw * If applicable, add the following below this CDDL HEADER, with the 16 5331 amw * fields enclosed by brackets "[]" replaced with your own identifying 17 5331 amw * information: Portions Copyright [yyyy] [name of copyright owner] 18 5331 amw * 19 5331 amw * CDDL HEADER END 20 5331 amw */ 21 5331 amw /* 22 9179 Mark * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 5331 amw * Use is subject to license terms. 24 5331 amw */ 25 5331 amw 26 5959 marks #include <sys/zfs_context.h> 27 5959 marks #include <sys/dmu.h> 28 5959 marks #include <sys/avl.h> 29 5959 marks #include <sys/zap.h> 30 5959 marks #include <sys/refcount.h> 31 5959 marks #include <sys/nvpair.h> 32 5959 marks #ifdef _KERNEL 33 5959 marks #include <sys/kidmap.h> 34 5959 marks #include <sys/sid.h> 35 5331 amw #include <sys/zfs_vfsops.h> 36 5331 amw #include <sys/zfs_znode.h> 37 5959 marks #endif 38 5331 amw #include <sys/zfs_fuid.h> 39 5331 amw 40 5331 amw /* 41 5331 amw * FUID Domain table(s). 42 5331 amw * 43 5331 amw * The FUID table is stored as a packed nvlist of an array 44 5331 amw * of nvlists which contain an index, domain string and offset 45 5331 amw * 46 5331 amw * During file system initialization the nvlist(s) are read and 47 5331 amw * two AVL trees are created. One tree is keyed by the index number 48 5331 amw * and the other by the domain string. Nodes are never removed from 49 9179 Mark * trees, but new entries may be added. If a new entry is added then 50 9179 Mark * the zfsvfs->z_fuid_dirty flag is set to true and the caller will then 51 9179 Mark * be responsible for calling zfs_fuid_sync() to sync the changes to disk. 52 9179 Mark * 53 5331 amw */ 54 5331 amw 55 5331 amw #define FUID_IDX "fuid_idx" 56 5331 amw #define FUID_DOMAIN "fuid_domain" 57 5331 amw #define FUID_OFFSET "fuid_offset" 58 5331 amw #define FUID_NVP_ARRAY "fuid_nvlist" 59 5331 amw 60 5331 amw typedef struct fuid_domain { 61 5959 marks avl_node_t f_domnode; 62 5959 marks avl_node_t f_idxnode; 63 5331 amw ksiddomain_t *f_ksid; 64 5959 marks uint64_t f_idx; 65 5331 amw } fuid_domain_t; 66 7559 Mark 67 7559 Mark static char *nulldomain = ""; 68 5331 amw 69 5331 amw /* 70 5331 amw * Compare two indexes. 71 5331 amw */ 72 5331 amw static int 73 5331 amw idx_compare(const void *arg1, const void *arg2) 74 5331 amw { 75 5959 marks const fuid_domain_t *node1 = arg1; 76 5959 marks const fuid_domain_t *node2 = arg2; 77 5331 amw 78 5331 amw if (node1->f_idx < node2->f_idx) 79 5331 amw return (-1); 80 5331 amw else if (node1->f_idx > node2->f_idx) 81 5331 amw return (1); 82 5331 amw return (0); 83 5331 amw } 84 5331 amw 85 5331 amw /* 86 5331 amw * Compare two domain strings. 87 5331 amw */ 88 5331 amw static int 89 5331 amw domain_compare(const void *arg1, const void *arg2) 90 5331 amw { 91 5331 amw const fuid_domain_t *node1 = arg1; 92 5331 amw const fuid_domain_t *node2 = arg2; 93 5331 amw int val; 94 5331 amw 95 5331 amw val = strcmp(node1->f_ksid->kd_name, node2->f_ksid->kd_name); 96 5331 amw if (val == 0) 97 5331 amw return (0); 98 5331 amw return (val > 0 ? 1 : -1); 99 5331 amw } 100 5331 amw 101 9179 Mark void 102 9179 Mark zfs_fuid_avl_tree_create(avl_tree_t *idx_tree, avl_tree_t *domain_tree) 103 9179 Mark { 104 9179 Mark avl_create(idx_tree, idx_compare, 105 9179 Mark sizeof (fuid_domain_t), offsetof(fuid_domain_t, f_idxnode)); 106 9179 Mark avl_create(domain_tree, domain_compare, 107 9179 Mark sizeof (fuid_domain_t), offsetof(fuid_domain_t, f_domnode)); 108 9179 Mark } 109 9179 Mark 110 5331 amw /* 111 5959 marks * load initial fuid domain and idx trees. This function is used by 112 5959 marks * both the kernel and zdb. 113 5959 marks */ 114 5959 marks uint64_t 115 5959 marks zfs_fuid_table_load(objset_t *os, uint64_t fuid_obj, avl_tree_t *idx_tree, 116 5959 marks avl_tree_t *domain_tree) 117 5959 marks { 118 5959 marks dmu_buf_t *db; 119 5959 marks uint64_t fuid_size; 120 5959 marks 121 9179 Mark ASSERT(fuid_obj != 0); 122 9179 Mark VERIFY(0 == dmu_bonus_hold(os, fuid_obj, 123 9179 Mark FTAG, &db)); 124 5959 marks fuid_size = *(uint64_t *)db->db_data; 125 5959 marks dmu_buf_rele(db, FTAG); 126 5959 marks 127 5959 marks if (fuid_size) { 128 5959 marks nvlist_t **fuidnvp; 129 5959 marks nvlist_t *nvp = NULL; 130 5959 marks uint_t count; 131 5959 marks char *packed; 132 5959 marks int i; 133 5959 marks 134 5959 marks packed = kmem_alloc(fuid_size, KM_SLEEP); 135 9179 Mark VERIFY(dmu_read(os, fuid_obj, 0, 136 9512 Neil fuid_size, packed, DMU_READ_PREFETCH) == 0); 137 5959 marks VERIFY(nvlist_unpack(packed, fuid_size, 138 5959 marks &nvp, 0) == 0); 139 5959 marks VERIFY(nvlist_lookup_nvlist_array(nvp, FUID_NVP_ARRAY, 140 5959 marks &fuidnvp, &count) == 0); 141 5959 marks 142 5959 marks for (i = 0; i != count; i++) { 143 5959 marks fuid_domain_t *domnode; 144 5959 marks char *domain; 145 5959 marks uint64_t idx; 146 5959 marks 147 5959 marks VERIFY(nvlist_lookup_string(fuidnvp[i], FUID_DOMAIN, 148 5959 marks &domain) == 0); 149 5959 marks VERIFY(nvlist_lookup_uint64(fuidnvp[i], FUID_IDX, 150 5959 marks &idx) == 0); 151 5959 marks 152 5959 marks domnode = kmem_alloc(sizeof (fuid_domain_t), KM_SLEEP); 153 5959 marks 154 5959 marks domnode->f_idx = idx; 155 5959 marks domnode->f_ksid = ksid_lookupdomain(domain); 156 5959 marks avl_add(idx_tree, domnode); 157 5959 marks avl_add(domain_tree, domnode); 158 5959 marks } 159 5959 marks nvlist_free(nvp); 160 5959 marks kmem_free(packed, fuid_size); 161 5959 marks } 162 5959 marks return (fuid_size); 163 5959 marks } 164 5959 marks 165 5959 marks void 166 5959 marks zfs_fuid_table_destroy(avl_tree_t *idx_tree, avl_tree_t *domain_tree) 167 5959 marks { 168 5959 marks fuid_domain_t *domnode; 169 5959 marks void *cookie; 170 5959 marks 171 5959 marks cookie = NULL; 172 5959 marks while (domnode = avl_destroy_nodes(domain_tree, &cookie)) 173 5959 marks ksiddomain_rele(domnode->f_ksid); 174 5959 marks 175 5959 marks avl_destroy(domain_tree); 176 5959 marks cookie = NULL; 177 5959 marks while (domnode = avl_destroy_nodes(idx_tree, &cookie)) 178 5959 marks kmem_free(domnode, sizeof (fuid_domain_t)); 179 5959 marks avl_destroy(idx_tree); 180 5959 marks } 181 5959 marks 182 5959 marks char * 183 5959 marks zfs_fuid_idx_domain(avl_tree_t *idx_tree, uint32_t idx) 184 5959 marks { 185 5959 marks fuid_domain_t searchnode, *findnode; 186 5959 marks avl_index_t loc; 187 5959 marks 188 5959 marks searchnode.f_idx = idx; 189 5959 marks 190 5959 marks findnode = avl_find(idx_tree, &searchnode, &loc); 191 5959 marks 192 7559 Mark return (findnode ? findnode->f_ksid->kd_name : nulldomain); 193 5959 marks } 194 5959 marks 195 5959 marks #ifdef _KERNEL 196 5959 marks /* 197 5331 amw * Load the fuid table(s) into memory. 198 5331 amw */ 199 5331 amw static void 200 9179 Mark zfs_fuid_init(zfsvfs_t *zfsvfs) 201 5331 amw { 202 5331 amw rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER); 203 5331 amw 204 5331 amw if (zfsvfs->z_fuid_loaded) { 205 5331 amw rw_exit(&zfsvfs->z_fuid_lock); 206 5331 amw return; 207 5331 amw } 208 5331 amw 209 9179 Mark zfs_fuid_avl_tree_create(&zfsvfs->z_fuid_idx, &zfsvfs->z_fuid_domain); 210 5331 amw 211 9179 Mark (void) zap_lookup(zfsvfs->z_os, MASTER_NODE_OBJ, 212 9179 Mark ZFS_FUID_TABLES, 8, 1, &zfsvfs->z_fuid_obj); 213 7559 Mark if (zfsvfs->z_fuid_obj != 0) { 214 7559 Mark zfsvfs->z_fuid_size = zfs_fuid_table_load(zfsvfs->z_os, 215 7559 Mark zfsvfs->z_fuid_obj, &zfsvfs->z_fuid_idx, 216 7559 Mark &zfsvfs->z_fuid_domain); 217 7559 Mark } 218 5331 amw 219 9179 Mark zfsvfs->z_fuid_loaded = B_TRUE; 220 9179 Mark rw_exit(&zfsvfs->z_fuid_lock); 221 9179 Mark } 222 9179 Mark 223 9179 Mark /* 224 9179 Mark * sync out AVL trees to persistent storage. 225 9179 Mark */ 226 9179 Mark void 227 9179 Mark zfs_fuid_sync(zfsvfs_t *zfsvfs, dmu_tx_t *tx) 228 9179 Mark { 229 9179 Mark nvlist_t *nvp; 230 9179 Mark nvlist_t **fuids; 231 9179 Mark size_t nvsize = 0; 232 9179 Mark char *packed; 233 9179 Mark dmu_buf_t *db; 234 9179 Mark fuid_domain_t *domnode; 235 9179 Mark int numnodes; 236 9179 Mark int i; 237 9179 Mark 238 9179 Mark if (!zfsvfs->z_fuid_dirty) { 239 9179 Mark return; 240 9179 Mark } 241 9179 Mark 242 9179 Mark rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER); 243 9179 Mark 244 9179 Mark /* 245 9179 Mark * First see if table needs to be created? 246 9179 Mark */ 247 9179 Mark if (zfsvfs->z_fuid_obj == 0) { 248 9179 Mark zfsvfs->z_fuid_obj = dmu_object_alloc(zfsvfs->z_os, 249 9179 Mark DMU_OT_FUID, 1 << 14, DMU_OT_FUID_SIZE, 250 9179 Mark sizeof (uint64_t), tx); 251 9179 Mark VERIFY(zap_add(zfsvfs->z_os, MASTER_NODE_OBJ, 252 9179 Mark ZFS_FUID_TABLES, sizeof (uint64_t), 1, 253 9179 Mark &zfsvfs->z_fuid_obj, tx) == 0); 254 9179 Mark } 255 9179 Mark 256 9179 Mark VERIFY(nvlist_alloc(&nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0); 257 9179 Mark 258 9179 Mark numnodes = avl_numnodes(&zfsvfs->z_fuid_idx); 259 9179 Mark fuids = kmem_alloc(numnodes * sizeof (void *), KM_SLEEP); 260 9179 Mark for (i = 0, domnode = avl_first(&zfsvfs->z_fuid_domain); domnode; i++, 261 9179 Mark domnode = AVL_NEXT(&zfsvfs->z_fuid_domain, domnode)) { 262 9179 Mark VERIFY(nvlist_alloc(&fuids[i], NV_UNIQUE_NAME, KM_SLEEP) == 0); 263 9179 Mark VERIFY(nvlist_add_uint64(fuids[i], FUID_IDX, 264 9179 Mark domnode->f_idx) == 0); 265 9179 Mark VERIFY(nvlist_add_uint64(fuids[i], FUID_OFFSET, 0) == 0); 266 9179 Mark VERIFY(nvlist_add_string(fuids[i], FUID_DOMAIN, 267 9179 Mark domnode->f_ksid->kd_name) == 0); 268 9179 Mark } 269 9179 Mark VERIFY(nvlist_add_nvlist_array(nvp, FUID_NVP_ARRAY, 270 9179 Mark fuids, numnodes) == 0); 271 9179 Mark for (i = 0; i != numnodes; i++) 272 9179 Mark nvlist_free(fuids[i]); 273 9179 Mark kmem_free(fuids, numnodes * sizeof (void *)); 274 9179 Mark VERIFY(nvlist_size(nvp, &nvsize, NV_ENCODE_XDR) == 0); 275 9179 Mark packed = kmem_alloc(nvsize, KM_SLEEP); 276 9179 Mark VERIFY(nvlist_pack(nvp, &packed, &nvsize, 277 9179 Mark NV_ENCODE_XDR, KM_SLEEP) == 0); 278 9179 Mark nvlist_free(nvp); 279 9179 Mark zfsvfs->z_fuid_size = nvsize; 280 9179 Mark dmu_write(zfsvfs->z_os, zfsvfs->z_fuid_obj, 0, 281 9179 Mark zfsvfs->z_fuid_size, packed, tx); 282 9179 Mark kmem_free(packed, zfsvfs->z_fuid_size); 283 9179 Mark VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, zfsvfs->z_fuid_obj, 284 9179 Mark FTAG, &db)); 285 9179 Mark dmu_buf_will_dirty(db, tx); 286 9179 Mark *(uint64_t *)db->db_data = zfsvfs->z_fuid_size; 287 9179 Mark dmu_buf_rele(db, FTAG); 288 9179 Mark 289 9179 Mark zfsvfs->z_fuid_dirty = B_FALSE; 290 5331 amw rw_exit(&zfsvfs->z_fuid_lock); 291 5331 amw } 292 5331 amw 293 5331 amw /* 294 5331 amw * Query domain table for a given domain. 295 5331 amw * 296 9396 Matthew * If domain isn't found and addok is set, it is added to AVL trees and 297 9396 Matthew * the zfsvfs->z_fuid_dirty flag will be set to TRUE. It will then be 298 9396 Matthew * necessary for the caller or another thread to detect the dirty table 299 9396 Matthew * and sync out the changes. 300 5331 amw */ 301 9396 Matthew int 302 9396 Matthew zfs_fuid_find_by_domain(zfsvfs_t *zfsvfs, const char *domain, 303 9396 Matthew char **retdomain, boolean_t addok) 304 5331 amw { 305 5331 amw fuid_domain_t searchnode, *findnode; 306 5331 amw avl_index_t loc; 307 7356 Mark krw_t rw = RW_READER; 308 5435 marks 309 5435 marks /* 310 5435 marks * If the dummy "nobody" domain then return an index of 0 311 5435 marks * to cause the created FUID to be a standard POSIX id 312 5435 marks * for the user nobody. 313 5435 marks */ 314 5435 marks if (domain[0] == '\0') { 315 9396 Matthew if (retdomain) 316 9396 Matthew *retdomain = nulldomain; 317 5435 marks return (0); 318 5435 marks } 319 5331 amw 320 5331 amw searchnode.f_ksid = ksid_lookupdomain(domain); 321 9396 Matthew if (retdomain) 322 5331 amw *retdomain = searchnode.f_ksid->kd_name; 323 5959 marks if (!zfsvfs->z_fuid_loaded) 324 9179 Mark zfs_fuid_init(zfsvfs); 325 5331 amw 326 7356 Mark retry: 327 7356 Mark rw_enter(&zfsvfs->z_fuid_lock, rw); 328 5331 amw findnode = avl_find(&zfsvfs->z_fuid_domain, &searchnode, &loc); 329 5331 amw 330 5331 amw if (findnode) { 331 7356 Mark rw_exit(&zfsvfs->z_fuid_lock); 332 5331 amw ksiddomain_rele(searchnode.f_ksid); 333 5331 amw return (findnode->f_idx); 334 9396 Matthew } else if (addok) { 335 5331 amw fuid_domain_t *domnode; 336 5331 amw uint64_t retidx; 337 5331 amw 338 7356 Mark if (rw == RW_READER && !rw_tryupgrade(&zfsvfs->z_fuid_lock)) { 339 7356 Mark rw_exit(&zfsvfs->z_fuid_lock); 340 7356 Mark rw = RW_WRITER; 341 7356 Mark goto retry; 342 7356 Mark } 343 7356 Mark 344 5331 amw domnode = kmem_alloc(sizeof (fuid_domain_t), KM_SLEEP); 345 5331 amw domnode->f_ksid = searchnode.f_ksid; 346 5331 amw 347 5959 marks retidx = domnode->f_idx = avl_numnodes(&zfsvfs->z_fuid_idx) + 1; 348 5331 amw 349 5331 amw avl_add(&zfsvfs->z_fuid_domain, domnode); 350 5959 marks avl_add(&zfsvfs->z_fuid_idx, domnode); 351 9179 Mark zfsvfs->z_fuid_dirty = B_TRUE; 352 5331 amw rw_exit(&zfsvfs->z_fuid_lock); 353 5331 amw return (retidx); 354 9396 Matthew } else { 355 10160 Matthew rw_exit(&zfsvfs->z_fuid_lock); 356 9396 Matthew return (-1); 357 5331 amw } 358 5331 amw } 359 5331 amw 360 5331 amw /* 361 5331 amw * Query domain table by index, returning domain string 362 5331 amw * 363 5331 amw * Returns a pointer from an avl node of the domain string. 364 5331 amw * 365 5331 amw */ 366 9396 Matthew const char * 367 5959 marks zfs_fuid_find_by_idx(zfsvfs_t *zfsvfs, uint32_t idx) 368 5331 amw { 369 5959 marks char *domain; 370 5331 amw 371 5959 marks if (idx == 0 || !zfsvfs->z_use_fuids) 372 5331 amw return (NULL); 373 5331 amw 374 5959 marks if (!zfsvfs->z_fuid_loaded) 375 9179 Mark zfs_fuid_init(zfsvfs); 376 5331 amw 377 5331 amw rw_enter(&zfsvfs->z_fuid_lock, RW_READER); 378 7559 Mark 379 7559 Mark if (zfsvfs->z_fuid_obj) 380 7559 Mark domain = zfs_fuid_idx_domain(&zfsvfs->z_fuid_idx, idx); 381 7559 Mark else 382 7559 Mark domain = nulldomain; 383 5331 amw rw_exit(&zfsvfs->z_fuid_lock); 384 5331 amw 385 5959 marks ASSERT(domain); 386 5959 marks return (domain); 387 5331 amw } 388 5331 amw 389 5331 amw void 390 5959 marks zfs_fuid_map_ids(znode_t *zp, cred_t *cr, uid_t *uidp, uid_t *gidp) 391 5331 amw { 392 5959 marks *uidp = zfs_fuid_map_id(zp->z_zfsvfs, zp->z_phys->zp_uid, 393 5959 marks cr, ZFS_OWNER); 394 5959 marks *gidp = zfs_fuid_map_id(zp->z_zfsvfs, zp->z_phys->zp_gid, 395 5959 marks cr, ZFS_GROUP); 396 5331 amw } 397 5331 amw 398 5959 marks uid_t 399 5959 marks zfs_fuid_map_id(zfsvfs_t *zfsvfs, uint64_t fuid, 400 5959 marks cred_t *cr, zfs_fuid_type_t type) 401 5331 amw { 402 5331 amw uint32_t index = FUID_INDEX(fuid); 403 9396 Matthew const char *domain; 404 5959 marks uid_t id; 405 5331 amw 406 5959 marks if (index == 0) 407 5959 marks return (fuid); 408 5331 amw 409 5331 amw domain = zfs_fuid_find_by_idx(zfsvfs, index); 410 5331 amw ASSERT(domain != NULL); 411 5331 amw 412 5959 marks if (type == ZFS_OWNER || type == ZFS_ACE_USER) { 413 5959 marks (void) kidmap_getuidbysid(crgetzone(cr), domain, 414 5959 marks FUID_RID(fuid), &id); 415 5331 amw } else { 416 5959 marks (void) kidmap_getgidbysid(crgetzone(cr), domain, 417 5959 marks FUID_RID(fuid), &id); 418 5331 amw } 419 5959 marks return (id); 420 5331 amw } 421 5331 amw 422 5331 amw /* 423 5331 amw * Add a FUID node to the list of fuid's being created for this 424 5331 amw * ACL 425 5331 amw * 426 5331 amw * If ACL has multiple domains, then keep only one copy of each unique 427 5331 amw * domain. 428 5331 amw */ 429 5331 amw static void 430 5331 amw zfs_fuid_node_add(zfs_fuid_info_t **fuidpp, const char *domain, uint32_t rid, 431 5331 amw uint64_t idx, uint64_t id, zfs_fuid_type_t type) 432 5331 amw { 433 5331 amw zfs_fuid_t *fuid; 434 5331 amw zfs_fuid_domain_t *fuid_domain; 435 5331 amw zfs_fuid_info_t *fuidp; 436 5331 amw uint64_t fuididx; 437 5331 amw boolean_t found = B_FALSE; 438 5331 amw 439 5331 amw if (*fuidpp == NULL) 440 5331 amw *fuidpp = zfs_fuid_info_alloc(); 441 5331 amw 442 5331 amw fuidp = *fuidpp; 443 5331 amw /* 444 5331 amw * First find fuid domain index in linked list 445 5331 amw * 446 5331 amw * If one isn't found then create an entry. 447 5331 amw */ 448 5331 amw 449 5331 amw for (fuididx = 1, fuid_domain = list_head(&fuidp->z_domains); 450 5331 amw fuid_domain; fuid_domain = list_next(&fuidp->z_domains, 451 5331 amw fuid_domain), fuididx++) { 452 5331 amw if (idx == fuid_domain->z_domidx) { 453 5331 amw found = B_TRUE; 454 5331 amw break; 455 5331 amw } 456 5331 amw } 457 5331 amw 458 5959 marks if (!found) { 459 5331 amw fuid_domain = kmem_alloc(sizeof (zfs_fuid_domain_t), KM_SLEEP); 460 5331 amw fuid_domain->z_domain = domain; 461 5331 amw fuid_domain->z_domidx = idx; 462 5331 amw list_insert_tail(&fuidp->z_domains, fuid_domain); 463 5331 amw fuidp->z_domain_str_sz += strlen(domain) + 1; 464 5331 amw fuidp->z_domain_cnt++; 465 5331 amw } 466 5331 amw 467 5331 amw if (type == ZFS_ACE_USER || type == ZFS_ACE_GROUP) { 468 9179 Mark 469 5331 amw /* 470 5331 amw * Now allocate fuid entry and add it on the end of the list 471 5331 amw */ 472 5331 amw 473 5331 amw fuid = kmem_alloc(sizeof (zfs_fuid_t), KM_SLEEP); 474 5331 amw fuid->z_id = id; 475 5331 amw fuid->z_domidx = idx; 476 5331 amw fuid->z_logfuid = FUID_ENCODE(fuididx, rid); 477 5331 amw 478 5331 amw list_insert_tail(&fuidp->z_fuids, fuid); 479 5331 amw fuidp->z_fuid_cnt++; 480 5331 amw } else { 481 5331 amw if (type == ZFS_OWNER) 482 5331 amw fuidp->z_fuid_owner = FUID_ENCODE(fuididx, rid); 483 5331 amw else 484 5331 amw fuidp->z_fuid_group = FUID_ENCODE(fuididx, rid); 485 5331 amw } 486 5331 amw } 487 5331 amw 488 5331 amw /* 489 5435 marks * Create a file system FUID, based on information in the users cred 490 5331 amw */ 491 5331 amw uint64_t 492 5959 marks zfs_fuid_create_cred(zfsvfs_t *zfsvfs, zfs_fuid_type_t type, 493 9179 Mark cred_t *cr, zfs_fuid_info_t **fuidp) 494 5331 amw { 495 5331 amw uint64_t idx; 496 5331 amw ksid_t *ksid; 497 5331 amw uint32_t rid; 498 5331 amw char *kdomain; 499 5331 amw const char *domain; 500 5959 marks uid_t id; 501 5331 amw 502 5331 amw VERIFY(type == ZFS_OWNER || type == ZFS_GROUP); 503 5331 amw 504 7847 Mark ksid = crgetsid(cr, (type == ZFS_OWNER) ? KSID_OWNER : KSID_GROUP); 505 7847 Mark if (ksid) { 506 7847 Mark id = ksid_getid(ksid); 507 7847 Mark } else { 508 7847 Mark if (type == ZFS_OWNER) 509 7847 Mark id = crgetuid(cr); 510 7847 Mark else 511 7847 Mark id = crgetgid(cr); 512 7847 Mark } 513 5959 marks 514 7847 Mark if (!zfsvfs->z_use_fuids || (!IS_EPHEMERAL(id))) 515 5331 amw return ((uint64_t)id); 516 5331 amw 517 5331 amw rid = ksid_getrid(ksid); 518 5331 amw domain = ksid_getdomain(ksid); 519 5331 amw 520 9396 Matthew idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, B_TRUE); 521 5331 amw 522 5331 amw zfs_fuid_node_add(fuidp, kdomain, rid, idx, id, type); 523 5331 amw 524 5331 amw return (FUID_ENCODE(idx, rid)); 525 5331 amw } 526 5331 amw 527 5331 amw /* 528 5331 amw * Create a file system FUID for an ACL ace 529 5331 amw * or a chown/chgrp of the file. 530 5331 amw * This is similar to zfs_fuid_create_cred, except that 531 5331 amw * we can't find the domain + rid information in the 532 5331 amw * cred. Instead we have to query Winchester for the 533 5331 amw * domain and rid. 534 5435 marks * 535 5435 marks * During replay operations the domain+rid information is 536 5435 marks * found in the zfs_fuid_info_t that the replay code has 537 5435 marks * attached to the zfsvfs of the file system. 538 5331 amw */ 539 5331 amw uint64_t 540 5771 jp151216 zfs_fuid_create(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr, 541 9179 Mark zfs_fuid_type_t type, zfs_fuid_info_t **fuidpp) 542 5331 amw { 543 5331 amw const char *domain; 544 5331 amw char *kdomain; 545 5331 amw uint32_t fuid_idx = FUID_INDEX(id); 546 5331 amw uint32_t rid; 547 5331 amw idmap_stat status; 548 5331 amw uint64_t idx; 549 5331 amw zfs_fuid_t *zfuid = NULL; 550 5331 amw zfs_fuid_info_t *fuidp; 551 5331 amw 552 5331 amw /* 553 5331 amw * If POSIX ID, or entry is already a FUID then 554 5331 amw * just return the id 555 5959 marks * 556 5959 marks * We may also be handed an already FUID'ized id via 557 5959 marks * chmod. 558 5331 amw */ 559 5959 marks 560 5959 marks if (!zfsvfs->z_use_fuids || !IS_EPHEMERAL(id) || fuid_idx != 0) 561 5331 amw return (id); 562 5331 amw 563 8227 Neil if (zfsvfs->z_replay) { 564 5331 amw fuidp = zfsvfs->z_fuid_replay; 565 5331 amw 566 5331 amw /* 567 5331 amw * If we are passed an ephemeral id, but no 568 5331 amw * fuid_info was logged then return NOBODY. 569 5331 amw * This is most likely a result of idmap service 570 5331 amw * not being available. 571 5331 amw */ 572 5331 amw if (fuidp == NULL) 573 5331 amw return (UID_NOBODY); 574 5331 amw 575 5331 amw switch (type) { 576 5331 amw case ZFS_ACE_USER: 577 5331 amw case ZFS_ACE_GROUP: 578 5331 amw zfuid = list_head(&fuidp->z_fuids); 579 5331 amw rid = FUID_RID(zfuid->z_logfuid); 580 5331 amw idx = FUID_INDEX(zfuid->z_logfuid); 581 5331 amw break; 582 5331 amw case ZFS_OWNER: 583 5331 amw rid = FUID_RID(fuidp->z_fuid_owner); 584 5331 amw idx = FUID_INDEX(fuidp->z_fuid_owner); 585 5331 amw break; 586 5331 amw case ZFS_GROUP: 587 5331 amw rid = FUID_RID(fuidp->z_fuid_group); 588 5331 amw idx = FUID_INDEX(fuidp->z_fuid_group); 589 5331 amw break; 590 5331 amw }; 591 5331 amw domain = fuidp->z_domain_table[idx -1]; 592 5331 amw } else { 593 5331 amw if (type == ZFS_OWNER || type == ZFS_ACE_USER) 594 5771 jp151216 status = kidmap_getsidbyuid(crgetzone(cr), id, 595 5771 jp151216 &domain, &rid); 596 5331 amw else 597 5771 jp151216 status = kidmap_getsidbygid(crgetzone(cr), id, 598 5771 jp151216 &domain, &rid); 599 5331 amw 600 5435 marks if (status != 0) { 601 5435 marks /* 602 5435 marks * When returning nobody we will need to 603 5435 marks * make a dummy fuid table entry for logging 604 5435 marks * purposes. 605 5435 marks */ 606 5435 marks rid = UID_NOBODY; 607 7559 Mark domain = nulldomain; 608 5435 marks } 609 5331 amw } 610 5331 amw 611 9396 Matthew idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, B_TRUE); 612 5331 amw 613 8227 Neil if (!zfsvfs->z_replay) 614 9179 Mark zfs_fuid_node_add(fuidpp, kdomain, 615 9179 Mark rid, idx, id, type); 616 5331 amw else if (zfuid != NULL) { 617 5331 amw list_remove(&fuidp->z_fuids, zfuid); 618 5331 amw kmem_free(zfuid, sizeof (zfs_fuid_t)); 619 5331 amw } 620 5331 amw return (FUID_ENCODE(idx, rid)); 621 5331 amw } 622 5331 amw 623 5331 amw void 624 5331 amw zfs_fuid_destroy(zfsvfs_t *zfsvfs) 625 5331 amw { 626 5331 amw rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER); 627 5959 marks if (!zfsvfs->z_fuid_loaded) { 628 5331 amw rw_exit(&zfsvfs->z_fuid_lock); 629 5331 amw return; 630 5331 amw } 631 5959 marks zfs_fuid_table_destroy(&zfsvfs->z_fuid_idx, &zfsvfs->z_fuid_domain); 632 5331 amw rw_exit(&zfsvfs->z_fuid_lock); 633 5331 amw } 634 5331 amw 635 5331 amw /* 636 5331 amw * Allocate zfs_fuid_info for tracking FUIDs created during 637 5331 amw * zfs_mknode, VOP_SETATTR() or VOP_SETSECATTR() 638 5331 amw */ 639 5331 amw zfs_fuid_info_t * 640 5331 amw zfs_fuid_info_alloc(void) 641 5331 amw { 642 5331 amw zfs_fuid_info_t *fuidp; 643 5331 amw 644 5331 amw fuidp = kmem_zalloc(sizeof (zfs_fuid_info_t), KM_SLEEP); 645 5331 amw list_create(&fuidp->z_domains, sizeof (zfs_fuid_domain_t), 646 5331 amw offsetof(zfs_fuid_domain_t, z_next)); 647 5331 amw list_create(&fuidp->z_fuids, sizeof (zfs_fuid_t), 648 5331 amw offsetof(zfs_fuid_t, z_next)); 649 5331 amw return (fuidp); 650 5331 amw } 651 5331 amw 652 5331 amw /* 653 5331 amw * Release all memory associated with zfs_fuid_info_t 654 5331 amw */ 655 5331 amw void 656 5331 amw zfs_fuid_info_free(zfs_fuid_info_t *fuidp) 657 5331 amw { 658 5331 amw zfs_fuid_t *zfuid; 659 5331 amw zfs_fuid_domain_t *zdomain; 660 5331 amw 661 5331 amw while ((zfuid = list_head(&fuidp->z_fuids)) != NULL) { 662 5331 amw list_remove(&fuidp->z_fuids, zfuid); 663 5331 amw kmem_free(zfuid, sizeof (zfs_fuid_t)); 664 5331 amw } 665 5331 amw 666 5331 amw if (fuidp->z_domain_table != NULL) 667 5331 amw kmem_free(fuidp->z_domain_table, 668 5331 amw (sizeof (char **)) * fuidp->z_domain_cnt); 669 5331 amw 670 5331 amw while ((zdomain = list_head(&fuidp->z_domains)) != NULL) { 671 5331 amw list_remove(&fuidp->z_domains, zdomain); 672 5331 amw kmem_free(zdomain, sizeof (zfs_fuid_domain_t)); 673 5331 amw } 674 5331 amw 675 5331 amw kmem_free(fuidp, sizeof (zfs_fuid_info_t)); 676 5331 amw } 677 5331 amw 678 5331 amw /* 679 5331 amw * Check to see if id is a groupmember. If cred 680 5331 amw * has ksid info then sidlist is checked first 681 5331 amw * and if still not found then POSIX groups are checked 682 5331 amw * 683 5331 amw * Will use a straight FUID compare when possible. 684 5331 amw */ 685 5331 amw boolean_t 686 5331 amw zfs_groupmember(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr) 687 5331 amw { 688 5331 amw ksid_t *ksid = crgetsid(cr, KSID_GROUP); 689 9465 Mark ksidlist_t *ksidlist = crgetsidlist(cr); 690 5331 amw uid_t gid; 691 5331 amw 692 9465 Mark if (ksid && ksidlist) { 693 5331 amw int i; 694 5331 amw ksid_t *ksid_groups; 695 5331 amw uint32_t idx = FUID_INDEX(id); 696 5331 amw uint32_t rid = FUID_RID(id); 697 5331 amw 698 5331 amw ksid_groups = ksidlist->ksl_sids; 699 5331 amw 700 5331 amw for (i = 0; i != ksidlist->ksl_nsid; i++) { 701 5331 amw if (idx == 0) { 702 5331 amw if (id != IDMAP_WK_CREATOR_GROUP_GID && 703 5331 amw id == ksid_groups[i].ks_id) { 704 5331 amw return (B_TRUE); 705 5331 amw } 706 5331 amw } else { 707 9396 Matthew const char *domain; 708 5331 amw 709 5331 amw domain = zfs_fuid_find_by_idx(zfsvfs, idx); 710 5331 amw ASSERT(domain != NULL); 711 5331 amw 712 5331 amw if (strcmp(domain, 713 5959 marks IDMAP_WK_CREATOR_SID_AUTHORITY) == 0) 714 5331 amw return (B_FALSE); 715 5331 amw 716 5331 amw if ((strcmp(domain, 717 5331 amw ksid_groups[i].ks_domain->kd_name) == 0) && 718 5959 marks rid == ksid_groups[i].ks_rid) 719 5331 amw return (B_TRUE); 720 5331 amw } 721 5331 amw } 722 5331 amw } 723 5331 amw 724 5331 amw /* 725 5331 amw * Not found in ksidlist, check posix groups 726 5331 amw */ 727 5959 marks gid = zfs_fuid_map_id(zfsvfs, id, cr, ZFS_GROUP); 728 5331 amw return (groupmember(gid, cr)); 729 5331 amw } 730 9396 Matthew 731 9396 Matthew void 732 9396 Matthew zfs_fuid_txhold(zfsvfs_t *zfsvfs, dmu_tx_t *tx) 733 9396 Matthew { 734 9396 Matthew if (zfsvfs->z_fuid_obj == 0) { 735 9396 Matthew dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 736 9396 Matthew dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 737 9396 Matthew FUID_SIZE_ESTIMATE(zfsvfs)); 738 9396 Matthew dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, FALSE, NULL); 739 9396 Matthew } else { 740 9396 Matthew dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj); 741 9396 Matthew dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0, 742 9396 Matthew FUID_SIZE_ESTIMATE(zfsvfs)); 743 9396 Matthew } 744 9396 Matthew } 745 5959 marks #endif 746
Indexes created Wed Nov 25 02:57:28 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.