zfs_fuid.c (185029) | zfs_fuid.c (209962) |
---|---|
1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE --- 5 unchanged lines hidden (view full) --- 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* | 1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE --- 5 unchanged lines hidden (view full) --- 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* |
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. | 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. |
23 * Use is subject to license terms. 24 */ 25 26#include <sys/zfs_context.h> 27#include <sys/sunddi.h> 28#include <sys/dmu.h> 29#include <sys/avl.h> 30#include <sys/zap.h> --- 11 unchanged lines hidden (view full) --- 42 * FUID Domain table(s). 43 * 44 * The FUID table is stored as a packed nvlist of an array 45 * of nvlists which contain an index, domain string and offset 46 * 47 * During file system initialization the nvlist(s) are read and 48 * two AVL trees are created. One tree is keyed by the index number 49 * and the other by the domain string. Nodes are never removed from | 23 * Use is subject to license terms. 24 */ 25 26#include <sys/zfs_context.h> 27#include <sys/sunddi.h> 28#include <sys/dmu.h> 29#include <sys/avl.h> 30#include <sys/zap.h> --- 11 unchanged lines hidden (view full) --- 42 * FUID Domain table(s). 43 * 44 * The FUID table is stored as a packed nvlist of an array 45 * of nvlists which contain an index, domain string and offset 46 * 47 * During file system initialization the nvlist(s) are read and 48 * two AVL trees are created. One tree is keyed by the index number 49 * and the other by the domain string. Nodes are never removed from |
50 * trees, but new entries may be added. If a new entry is added then the 51 * on-disk packed nvlist will also be updated. | 50 * trees, but new entries may be added. If a new entry is added then 51 * the zfsvfs->z_fuid_dirty flag is set to true and the caller will then 52 * be responsible for calling zfs_fuid_sync() to sync the changes to disk. 53 * |
52 */ 53 54#define FUID_IDX "fuid_idx" 55#define FUID_DOMAIN "fuid_domain" 56#define FUID_OFFSET "fuid_offset" 57#define FUID_NVP_ARRAY "fuid_nvlist" 58 59typedef struct fuid_domain { --- 32 unchanged lines hidden (view full) --- 92 int val; 93 94 val = strcmp(node1->f_ksid->kd_name, node2->f_ksid->kd_name); 95 if (val == 0) 96 return (0); 97 return (val > 0 ? 1 : -1); 98} 99 | 54 */ 55 56#define FUID_IDX "fuid_idx" 57#define FUID_DOMAIN "fuid_domain" 58#define FUID_OFFSET "fuid_offset" 59#define FUID_NVP_ARRAY "fuid_nvlist" 60 61typedef struct fuid_domain { --- 32 unchanged lines hidden (view full) --- 94 int val; 95 96 val = strcmp(node1->f_ksid->kd_name, node2->f_ksid->kd_name); 97 if (val == 0) 98 return (0); 99 return (val > 0 ? 1 : -1); 100} 101 |
102void 103zfs_fuid_avl_tree_create(avl_tree_t *idx_tree, avl_tree_t *domain_tree) 104{ 105 avl_create(idx_tree, idx_compare, 106 sizeof (fuid_domain_t), offsetof(fuid_domain_t, f_idxnode)); 107 avl_create(domain_tree, domain_compare, 108 sizeof (fuid_domain_t), offsetof(fuid_domain_t, f_domnode)); 109} 110 |
|
100/* 101 * load initial fuid domain and idx trees. This function is used by 102 * both the kernel and zdb. 103 */ 104uint64_t 105zfs_fuid_table_load(objset_t *os, uint64_t fuid_obj, avl_tree_t *idx_tree, 106 avl_tree_t *domain_tree) 107{ 108 dmu_buf_t *db; 109 uint64_t fuid_size; 110 | 111/* 112 * load initial fuid domain and idx trees. This function is used by 113 * both the kernel and zdb. 114 */ 115uint64_t 116zfs_fuid_table_load(objset_t *os, uint64_t fuid_obj, avl_tree_t *idx_tree, 117 avl_tree_t *domain_tree) 118{ 119 dmu_buf_t *db; 120 uint64_t fuid_size; 121 |
111 avl_create(idx_tree, idx_compare, 112 sizeof (fuid_domain_t), offsetof(fuid_domain_t, f_idxnode)); 113 avl_create(domain_tree, domain_compare, 114 sizeof (fuid_domain_t), offsetof(fuid_domain_t, f_domnode)); 115 116 VERIFY(0 == dmu_bonus_hold(os, fuid_obj, FTAG, &db)); | 122 ASSERT(fuid_obj != 0); 123 VERIFY(0 == dmu_bonus_hold(os, fuid_obj, 124 FTAG, &db)); |
117 fuid_size = *(uint64_t *)db->db_data; 118 dmu_buf_rele(db, FTAG); 119 120 if (fuid_size) { 121 nvlist_t **fuidnvp; 122 nvlist_t *nvp = NULL; 123 uint_t count; 124 char *packed; 125 int i; 126 127 packed = kmem_alloc(fuid_size, KM_SLEEP); | 125 fuid_size = *(uint64_t *)db->db_data; 126 dmu_buf_rele(db, FTAG); 127 128 if (fuid_size) { 129 nvlist_t **fuidnvp; 130 nvlist_t *nvp = NULL; 131 uint_t count; 132 char *packed; 133 int i; 134 135 packed = kmem_alloc(fuid_size, KM_SLEEP); |
128 VERIFY(dmu_read(os, fuid_obj, 0, fuid_size, packed) == 0); | 136 VERIFY(dmu_read(os, fuid_obj, 0, 137 fuid_size, packed, DMU_READ_PREFETCH) == 0); |
129 VERIFY(nvlist_unpack(packed, fuid_size, 130 &nvp, 0) == 0); 131 VERIFY(nvlist_lookup_nvlist_array(nvp, FUID_NVP_ARRAY, 132 &fuidnvp, &count) == 0); 133 134 for (i = 0; i != count; i++) { 135 fuid_domain_t *domnode; 136 char *domain; --- 47 unchanged lines hidden (view full) --- 184 return (findnode ? findnode->f_ksid->kd_name : nulldomain); 185} 186 187#ifdef _KERNEL 188/* 189 * Load the fuid table(s) into memory. 190 */ 191static void | 138 VERIFY(nvlist_unpack(packed, fuid_size, 139 &nvp, 0) == 0); 140 VERIFY(nvlist_lookup_nvlist_array(nvp, FUID_NVP_ARRAY, 141 &fuidnvp, &count) == 0); 142 143 for (i = 0; i != count; i++) { 144 fuid_domain_t *domnode; 145 char *domain; --- 47 unchanged lines hidden (view full) --- 193 return (findnode ? findnode->f_ksid->kd_name : nulldomain); 194} 195 196#ifdef _KERNEL 197/* 198 * Load the fuid table(s) into memory. 199 */ 200static void |
192zfs_fuid_init(zfsvfs_t *zfsvfs, dmu_tx_t *tx) | 201zfs_fuid_init(zfsvfs_t *zfsvfs) |
193{ | 202{ |
194 int error = 0; 195 | |
196 rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER); 197 198 if (zfsvfs->z_fuid_loaded) { 199 rw_exit(&zfsvfs->z_fuid_lock); 200 return; 201 } 202 | 203 rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER); 204 205 if (zfsvfs->z_fuid_loaded) { 206 rw_exit(&zfsvfs->z_fuid_lock); 207 return; 208 } 209 |
203 if (zfsvfs->z_fuid_obj == 0) { | 210 zfs_fuid_avl_tree_create(&zfsvfs->z_fuid_idx, &zfsvfs->z_fuid_domain); |
204 | 211 |
205 /* first make sure we need to allocate object */ 206 207 error = zap_lookup(zfsvfs->z_os, MASTER_NODE_OBJ, 208 ZFS_FUID_TABLES, 8, 1, &zfsvfs->z_fuid_obj); 209 if (error == ENOENT && tx != NULL) { 210 zfsvfs->z_fuid_obj = dmu_object_alloc(zfsvfs->z_os, 211 DMU_OT_FUID, 1 << 14, DMU_OT_FUID_SIZE, 212 sizeof (uint64_t), tx); 213 VERIFY(zap_add(zfsvfs->z_os, MASTER_NODE_OBJ, 214 ZFS_FUID_TABLES, sizeof (uint64_t), 1, 215 &zfsvfs->z_fuid_obj, tx) == 0); 216 } 217 } 218 | 212 (void) zap_lookup(zfsvfs->z_os, MASTER_NODE_OBJ, 213 ZFS_FUID_TABLES, 8, 1, &zfsvfs->z_fuid_obj); |
219 if (zfsvfs->z_fuid_obj != 0) { 220 zfsvfs->z_fuid_size = zfs_fuid_table_load(zfsvfs->z_os, 221 zfsvfs->z_fuid_obj, &zfsvfs->z_fuid_idx, 222 &zfsvfs->z_fuid_domain); | 214 if (zfsvfs->z_fuid_obj != 0) { 215 zfsvfs->z_fuid_size = zfs_fuid_table_load(zfsvfs->z_os, 216 zfsvfs->z_fuid_obj, &zfsvfs->z_fuid_idx, 217 &zfsvfs->z_fuid_domain); |
223 zfsvfs->z_fuid_loaded = B_TRUE; | |
224 } 225 | 218 } 219 |
220 zfsvfs->z_fuid_loaded = B_TRUE; |
|
226 rw_exit(&zfsvfs->z_fuid_lock); 227} 228 229/* | 221 rw_exit(&zfsvfs->z_fuid_lock); 222} 223 224/* |
225 * sync out AVL trees to persistent storage. 226 */ 227void 228zfs_fuid_sync(zfsvfs_t *zfsvfs, dmu_tx_t *tx) 229{ 230 nvlist_t *nvp; 231 nvlist_t **fuids; 232 size_t nvsize = 0; 233 char *packed; 234 dmu_buf_t *db; 235 fuid_domain_t *domnode; 236 int numnodes; 237 int i; 238 239 if (!zfsvfs->z_fuid_dirty) { 240 return; 241 } 242 243 rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER); 244 245 /* 246 * First see if table needs to be created? 247 */ 248 if (zfsvfs->z_fuid_obj == 0) { 249 zfsvfs->z_fuid_obj = dmu_object_alloc(zfsvfs->z_os, 250 DMU_OT_FUID, 1 << 14, DMU_OT_FUID_SIZE, 251 sizeof (uint64_t), tx); 252 VERIFY(zap_add(zfsvfs->z_os, MASTER_NODE_OBJ, 253 ZFS_FUID_TABLES, sizeof (uint64_t), 1, 254 &zfsvfs->z_fuid_obj, tx) == 0); 255 } 256 257 VERIFY(nvlist_alloc(&nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0); 258 259 numnodes = avl_numnodes(&zfsvfs->z_fuid_idx); 260 fuids = kmem_alloc(numnodes * sizeof (void *), KM_SLEEP); 261 for (i = 0, domnode = avl_first(&zfsvfs->z_fuid_domain); domnode; i++, 262 domnode = AVL_NEXT(&zfsvfs->z_fuid_domain, domnode)) { 263 VERIFY(nvlist_alloc(&fuids[i], NV_UNIQUE_NAME, KM_SLEEP) == 0); 264 VERIFY(nvlist_add_uint64(fuids[i], FUID_IDX, 265 domnode->f_idx) == 0); 266 VERIFY(nvlist_add_uint64(fuids[i], FUID_OFFSET, 0) == 0); 267 VERIFY(nvlist_add_string(fuids[i], FUID_DOMAIN, 268 domnode->f_ksid->kd_name) == 0); 269 } 270 VERIFY(nvlist_add_nvlist_array(nvp, FUID_NVP_ARRAY, 271 fuids, numnodes) == 0); 272 for (i = 0; i != numnodes; i++) 273 nvlist_free(fuids[i]); 274 kmem_free(fuids, numnodes * sizeof (void *)); 275 VERIFY(nvlist_size(nvp, &nvsize, NV_ENCODE_XDR) == 0); 276 packed = kmem_alloc(nvsize, KM_SLEEP); 277 VERIFY(nvlist_pack(nvp, &packed, &nvsize, 278 NV_ENCODE_XDR, KM_SLEEP) == 0); 279 nvlist_free(nvp); 280 zfsvfs->z_fuid_size = nvsize; 281 dmu_write(zfsvfs->z_os, zfsvfs->z_fuid_obj, 0, 282 zfsvfs->z_fuid_size, packed, tx); 283 kmem_free(packed, zfsvfs->z_fuid_size); 284 VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, zfsvfs->z_fuid_obj, 285 FTAG, &db)); 286 dmu_buf_will_dirty(db, tx); 287 *(uint64_t *)db->db_data = zfsvfs->z_fuid_size; 288 dmu_buf_rele(db, FTAG); 289 290 zfsvfs->z_fuid_dirty = B_FALSE; 291 rw_exit(&zfsvfs->z_fuid_lock); 292} 293 294/* |
|
230 * Query domain table for a given domain. 231 * | 295 * Query domain table for a given domain. 296 * |
232 * If domain isn't found it is added to AVL trees and 233 * the results are pushed out to disk. | 297 * If domain isn't found and addok is set, it is added to AVL trees and 298 * the zfsvfs->z_fuid_dirty flag will be set to TRUE. It will then be 299 * necessary for the caller or another thread to detect the dirty table 300 * and sync out the changes. |
234 */ 235int | 301 */ 302int |
236zfs_fuid_find_by_domain(zfsvfs_t *zfsvfs, const char *domain, char **retdomain, 237 dmu_tx_t *tx) | 303zfs_fuid_find_by_domain(zfsvfs_t *zfsvfs, const char *domain, 304 char **retdomain, boolean_t addok) |
238{ 239 fuid_domain_t searchnode, *findnode; 240 avl_index_t loc; 241 krw_t rw = RW_READER; 242 243 /* 244 * If the dummy "nobody" domain then return an index of 0 245 * to cause the created FUID to be a standard POSIX id 246 * for the user nobody. 247 */ 248 if (domain[0] == '\0') { | 305{ 306 fuid_domain_t searchnode, *findnode; 307 avl_index_t loc; 308 krw_t rw = RW_READER; 309 310 /* 311 * If the dummy "nobody" domain then return an index of 0 312 * to cause the created FUID to be a standard POSIX id 313 * for the user nobody. 314 */ 315 if (domain[0] == '\0') { |
249 *retdomain = nulldomain; | 316 if (retdomain) 317 *retdomain = nulldomain; |
250 return (0); 251 } 252 253 searchnode.f_ksid = ksid_lookupdomain(domain); | 318 return (0); 319 } 320 321 searchnode.f_ksid = ksid_lookupdomain(domain); |
254 if (retdomain) { | 322 if (retdomain) |
255 *retdomain = searchnode.f_ksid->kd_name; | 323 *retdomain = searchnode.f_ksid->kd_name; |
256 } | |
257 if (!zfsvfs->z_fuid_loaded) | 324 if (!zfsvfs->z_fuid_loaded) |
258 zfs_fuid_init(zfsvfs, tx); | 325 zfs_fuid_init(zfsvfs); |
259 260retry: 261 rw_enter(&zfsvfs->z_fuid_lock, rw); 262 findnode = avl_find(&zfsvfs->z_fuid_domain, &searchnode, &loc); 263 264 if (findnode) { 265 rw_exit(&zfsvfs->z_fuid_lock); 266 ksiddomain_rele(searchnode.f_ksid); 267 return (findnode->f_idx); | 326 327retry: 328 rw_enter(&zfsvfs->z_fuid_lock, rw); 329 findnode = avl_find(&zfsvfs->z_fuid_domain, &searchnode, &loc); 330 331 if (findnode) { 332 rw_exit(&zfsvfs->z_fuid_lock); 333 ksiddomain_rele(searchnode.f_ksid); 334 return (findnode->f_idx); |
268 } else { | 335 } else if (addok) { |
269 fuid_domain_t *domnode; | 336 fuid_domain_t *domnode; |
270 nvlist_t *nvp; 271 nvlist_t **fuids; | |
272 uint64_t retidx; | 337 uint64_t retidx; |
273 size_t nvsize = 0; 274 char *packed; 275 dmu_buf_t *db; 276 int i = 0; | |
277 278 if (rw == RW_READER && !rw_tryupgrade(&zfsvfs->z_fuid_lock)) { 279 rw_exit(&zfsvfs->z_fuid_lock); 280 rw = RW_WRITER; 281 goto retry; 282 } 283 284 domnode = kmem_alloc(sizeof (fuid_domain_t), KM_SLEEP); 285 domnode->f_ksid = searchnode.f_ksid; 286 287 retidx = domnode->f_idx = avl_numnodes(&zfsvfs->z_fuid_idx) + 1; 288 289 avl_add(&zfsvfs->z_fuid_domain, domnode); 290 avl_add(&zfsvfs->z_fuid_idx, domnode); | 338 339 if (rw == RW_READER && !rw_tryupgrade(&zfsvfs->z_fuid_lock)) { 340 rw_exit(&zfsvfs->z_fuid_lock); 341 rw = RW_WRITER; 342 goto retry; 343 } 344 345 domnode = kmem_alloc(sizeof (fuid_domain_t), KM_SLEEP); 346 domnode->f_ksid = searchnode.f_ksid; 347 348 retidx = domnode->f_idx = avl_numnodes(&zfsvfs->z_fuid_idx) + 1; 349 350 avl_add(&zfsvfs->z_fuid_domain, domnode); 351 avl_add(&zfsvfs->z_fuid_idx, domnode); |
291 /* 292 * Now resync the on-disk nvlist. 293 */ 294 VERIFY(nvlist_alloc(&nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0); 295 296 domnode = avl_first(&zfsvfs->z_fuid_domain); 297 fuids = kmem_alloc(retidx * sizeof (void *), KM_SLEEP); 298 while (domnode) { 299 VERIFY(nvlist_alloc(&fuids[i], 300 NV_UNIQUE_NAME, KM_SLEEP) == 0); 301 VERIFY(nvlist_add_uint64(fuids[i], FUID_IDX, 302 domnode->f_idx) == 0); 303 VERIFY(nvlist_add_uint64(fuids[i], 304 FUID_OFFSET, 0) == 0); 305 VERIFY(nvlist_add_string(fuids[i++], FUID_DOMAIN, 306 domnode->f_ksid->kd_name) == 0); 307 domnode = AVL_NEXT(&zfsvfs->z_fuid_domain, domnode); 308 } 309 VERIFY(nvlist_add_nvlist_array(nvp, FUID_NVP_ARRAY, 310 fuids, retidx) == 0); 311 for (i = 0; i != retidx; i++) 312 nvlist_free(fuids[i]); 313 kmem_free(fuids, retidx * sizeof (void *)); 314 VERIFY(nvlist_size(nvp, &nvsize, NV_ENCODE_XDR) == 0); 315 packed = kmem_alloc(nvsize, KM_SLEEP); 316 VERIFY(nvlist_pack(nvp, &packed, &nvsize, 317 NV_ENCODE_XDR, KM_SLEEP) == 0); 318 nvlist_free(nvp); 319 zfsvfs->z_fuid_size = nvsize; 320 dmu_write(zfsvfs->z_os, zfsvfs->z_fuid_obj, 0, 321 zfsvfs->z_fuid_size, packed, tx); 322 kmem_free(packed, zfsvfs->z_fuid_size); 323 VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, zfsvfs->z_fuid_obj, 324 FTAG, &db)); 325 dmu_buf_will_dirty(db, tx); 326 *(uint64_t *)db->db_data = zfsvfs->z_fuid_size; 327 dmu_buf_rele(db, FTAG); 328 | 352 zfsvfs->z_fuid_dirty = B_TRUE; |
329 rw_exit(&zfsvfs->z_fuid_lock); 330 return (retidx); | 353 rw_exit(&zfsvfs->z_fuid_lock); 354 return (retidx); |
355 } else { 356 rw_exit(&zfsvfs->z_fuid_lock); 357 return (-1); |
|
331 } 332} 333 334/* 335 * Query domain table by index, returning domain string 336 * 337 * Returns a pointer from an avl node of the domain string. 338 * 339 */ | 358 } 359} 360 361/* 362 * Query domain table by index, returning domain string 363 * 364 * Returns a pointer from an avl node of the domain string. 365 * 366 */ |
340static char * | 367const char * |
341zfs_fuid_find_by_idx(zfsvfs_t *zfsvfs, uint32_t idx) 342{ 343 char *domain; 344 345 if (idx == 0 || !zfsvfs->z_use_fuids) 346 return (NULL); 347 348 if (!zfsvfs->z_fuid_loaded) | 368zfs_fuid_find_by_idx(zfsvfs_t *zfsvfs, uint32_t idx) 369{ 370 char *domain; 371 372 if (idx == 0 || !zfsvfs->z_use_fuids) 373 return (NULL); 374 375 if (!zfsvfs->z_fuid_loaded) |
349 zfs_fuid_init(zfsvfs, NULL); | 376 zfs_fuid_init(zfsvfs); |
350 351 rw_enter(&zfsvfs->z_fuid_lock, RW_READER); 352 353 if (zfsvfs->z_fuid_obj) 354 domain = zfs_fuid_idx_domain(&zfsvfs->z_fuid_idx, idx); 355 else 356 domain = nulldomain; 357 rw_exit(&zfsvfs->z_fuid_lock); --- 11 unchanged lines hidden (view full) --- 369 cr, ZFS_GROUP); 370} 371 372uid_t 373zfs_fuid_map_id(zfsvfs_t *zfsvfs, uint64_t fuid, 374 cred_t *cr, zfs_fuid_type_t type) 375{ 376 uint32_t index = FUID_INDEX(fuid); | 377 378 rw_enter(&zfsvfs->z_fuid_lock, RW_READER); 379 380 if (zfsvfs->z_fuid_obj) 381 domain = zfs_fuid_idx_domain(&zfsvfs->z_fuid_idx, idx); 382 else 383 domain = nulldomain; 384 rw_exit(&zfsvfs->z_fuid_lock); --- 11 unchanged lines hidden (view full) --- 396 cr, ZFS_GROUP); 397} 398 399uid_t 400zfs_fuid_map_id(zfsvfs_t *zfsvfs, uint64_t fuid, 401 cred_t *cr, zfs_fuid_type_t type) 402{ 403 uint32_t index = FUID_INDEX(fuid); |
377 char *domain; | 404 const char *domain; |
378 uid_t id; 379 380 if (index == 0) 381 return (fuid); 382 383 domain = zfs_fuid_find_by_idx(zfsvfs, index); 384 ASSERT(domain != NULL); 385 --- 52 unchanged lines hidden (view full) --- 438 fuid_domain->z_domain = domain; 439 fuid_domain->z_domidx = idx; 440 list_insert_tail(&fuidp->z_domains, fuid_domain); 441 fuidp->z_domain_str_sz += strlen(domain) + 1; 442 fuidp->z_domain_cnt++; 443 } 444 445 if (type == ZFS_ACE_USER || type == ZFS_ACE_GROUP) { | 405 uid_t id; 406 407 if (index == 0) 408 return (fuid); 409 410 domain = zfs_fuid_find_by_idx(zfsvfs, index); 411 ASSERT(domain != NULL); 412 --- 52 unchanged lines hidden (view full) --- 465 fuid_domain->z_domain = domain; 466 fuid_domain->z_domidx = idx; 467 list_insert_tail(&fuidp->z_domains, fuid_domain); 468 fuidp->z_domain_str_sz += strlen(domain) + 1; 469 fuidp->z_domain_cnt++; 470 } 471 472 if (type == ZFS_ACE_USER || type == ZFS_ACE_GROUP) { |
473 |
|
446 /* 447 * Now allocate fuid entry and add it on the end of the list 448 */ 449 450 fuid = kmem_alloc(sizeof (zfs_fuid_t), KM_SLEEP); 451 fuid->z_id = id; 452 fuid->z_domidx = idx; 453 fuid->z_logfuid = FUID_ENCODE(fuididx, rid); --- 8 unchanged lines hidden (view full) --- 462 } 463} 464 465/* 466 * Create a file system FUID, based on information in the users cred 467 */ 468uint64_t 469zfs_fuid_create_cred(zfsvfs_t *zfsvfs, zfs_fuid_type_t type, | 474 /* 475 * Now allocate fuid entry and add it on the end of the list 476 */ 477 478 fuid = kmem_alloc(sizeof (zfs_fuid_t), KM_SLEEP); 479 fuid->z_id = id; 480 fuid->z_domidx = idx; 481 fuid->z_logfuid = FUID_ENCODE(fuididx, rid); --- 8 unchanged lines hidden (view full) --- 490 } 491} 492 493/* 494 * Create a file system FUID, based on information in the users cred 495 */ 496uint64_t 497zfs_fuid_create_cred(zfsvfs_t *zfsvfs, zfs_fuid_type_t type, |
470 dmu_tx_t *tx, cred_t *cr, zfs_fuid_info_t **fuidp) | 498 cred_t *cr, zfs_fuid_info_t **fuidp) |
471{ 472 uint64_t idx; 473 ksid_t *ksid; 474 uint32_t rid; 475 char *kdomain; 476 const char *domain; 477 uid_t id; 478 --- 9 unchanged lines hidden (view full) --- 488 489#ifdef TODO 490 ksid = crgetsid(cr, (type == ZFS_OWNER) ? KSID_OWNER : KSID_GROUP); 491 492 VERIFY(ksid != NULL); 493 rid = ksid_getrid(ksid); 494 domain = ksid_getdomain(ksid); 495 | 499{ 500 uint64_t idx; 501 ksid_t *ksid; 502 uint32_t rid; 503 char *kdomain; 504 const char *domain; 505 uid_t id; 506 --- 9 unchanged lines hidden (view full) --- 516 517#ifdef TODO 518 ksid = crgetsid(cr, (type == ZFS_OWNER) ? KSID_OWNER : KSID_GROUP); 519 520 VERIFY(ksid != NULL); 521 rid = ksid_getrid(ksid); 522 domain = ksid_getdomain(ksid); 523 |
496 idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, tx); | 524 idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, B_TRUE); |
497 498 zfs_fuid_node_add(fuidp, kdomain, rid, idx, id, type); 499 500 return (FUID_ENCODE(idx, rid)); 501#else 502 panic(__func__); 503#endif 504} --- 7 unchanged lines hidden (view full) --- 512 * domain and rid. 513 * 514 * During replay operations the domain+rid information is 515 * found in the zfs_fuid_info_t that the replay code has 516 * attached to the zfsvfs of the file system. 517 */ 518uint64_t 519zfs_fuid_create(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr, | 525 526 zfs_fuid_node_add(fuidp, kdomain, rid, idx, id, type); 527 528 return (FUID_ENCODE(idx, rid)); 529#else 530 panic(__func__); 531#endif 532} --- 7 unchanged lines hidden (view full) --- 540 * domain and rid. 541 * 542 * During replay operations the domain+rid information is 543 * found in the zfs_fuid_info_t that the replay code has 544 * attached to the zfsvfs of the file system. 545 */ 546uint64_t 547zfs_fuid_create(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr, |
520 zfs_fuid_type_t type, dmu_tx_t *tx, zfs_fuid_info_t **fuidpp) | 548 zfs_fuid_type_t type, zfs_fuid_info_t **fuidpp) |
521{ 522 const char *domain; 523 char *kdomain; 524 uint32_t fuid_idx = FUID_INDEX(id); 525 uint32_t rid; 526 idmap_stat status; 527 uint64_t idx; | 549{ 550 const char *domain; 551 char *kdomain; 552 uint32_t fuid_idx = FUID_INDEX(id); 553 uint32_t rid; 554 idmap_stat status; 555 uint64_t idx; |
528 boolean_t is_replay = (zfsvfs->z_assign >= TXG_INITIAL); | |
529 zfs_fuid_t *zfuid = NULL; 530 zfs_fuid_info_t *fuidp; 531 532 /* 533 * If POSIX ID, or entry is already a FUID then 534 * just return the id 535 * 536 * We may also be handed an already FUID'ized id via 537 * chmod. 538 */ 539 540 if (!zfsvfs->z_use_fuids || !IS_EPHEMERAL(id) || fuid_idx != 0) 541 return (id); 542 | 556 zfs_fuid_t *zfuid = NULL; 557 zfs_fuid_info_t *fuidp; 558 559 /* 560 * If POSIX ID, or entry is already a FUID then 561 * just return the id 562 * 563 * We may also be handed an already FUID'ized id via 564 * chmod. 565 */ 566 567 if (!zfsvfs->z_use_fuids || !IS_EPHEMERAL(id) || fuid_idx != 0) 568 return (id); 569 |
543 if (is_replay) { | 570 if (zfsvfs->z_replay) { |
544 fuidp = zfsvfs->z_fuid_replay; 545 546 /* 547 * If we are passed an ephemeral id, but no 548 * fuid_info was logged then return NOBODY. 549 * This is most likely a result of idmap service 550 * not being available. 551 */ --- 35 unchanged lines hidden (view full) --- 587 rid = UID_NOBODY; 588 domain = nulldomain; 589 } 590#else 591 panic(__func__); 592#endif 593 } 594 | 571 fuidp = zfsvfs->z_fuid_replay; 572 573 /* 574 * If we are passed an ephemeral id, but no 575 * fuid_info was logged then return NOBODY. 576 * This is most likely a result of idmap service 577 * not being available. 578 */ --- 35 unchanged lines hidden (view full) --- 614 rid = UID_NOBODY; 615 domain = nulldomain; 616 } 617#else 618 panic(__func__); 619#endif 620 } 621 |
595 idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, tx); | 622 idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, B_TRUE); |
596 | 623 |
597 if (!is_replay) 598 zfs_fuid_node_add(fuidpp, kdomain, rid, idx, id, type); | 624 if (!zfsvfs->z_replay) 625 zfs_fuid_node_add(fuidpp, kdomain, 626 rid, idx, id, type); |
599 else if (zfuid != NULL) { 600 list_remove(&fuidp->z_fuids, zfuid); 601 kmem_free(zfuid, sizeof (zfs_fuid_t)); 602 } 603 return (FUID_ENCODE(idx, rid)); 604} 605 606void --- 56 unchanged lines hidden (view full) --- 663 * has ksid info then sidlist is checked first 664 * and if still not found then POSIX groups are checked 665 * 666 * Will use a straight FUID compare when possible. 667 */ 668boolean_t 669zfs_groupmember(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr) 670{ | 627 else if (zfuid != NULL) { 628 list_remove(&fuidp->z_fuids, zfuid); 629 kmem_free(zfuid, sizeof (zfs_fuid_t)); 630 } 631 return (FUID_ENCODE(idx, rid)); 632} 633 634void --- 56 unchanged lines hidden (view full) --- 691 * has ksid info then sidlist is checked first 692 * and if still not found then POSIX groups are checked 693 * 694 * Will use a straight FUID compare when possible. 695 */ 696boolean_t 697zfs_groupmember(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr) 698{ |
699#ifdef sun |
|
671 ksid_t *ksid = crgetsid(cr, KSID_GROUP); | 700 ksid_t *ksid = crgetsid(cr, KSID_GROUP); |
701 ksidlist_t *ksidlist = crgetsidlist(cr); 702#endif /* sun */ |
|
672 uid_t gid; 673 | 703 uid_t gid; 704 |
674#ifdef TODO 675 if (ksid) { | 705#ifdef sun 706 if (ksid && ksidlist) { |
676 int i; 677 ksid_t *ksid_groups; 678 ksidlist_t *ksidlist = crgetsidlist(cr); 679 uint32_t idx = FUID_INDEX(id); 680 uint32_t rid = FUID_RID(id); 681 682 ASSERT(ksidlist); 683 ksid_groups = ksidlist->ksl_sids; 684 685 for (i = 0; i != ksidlist->ksl_nsid; i++) { 686 if (idx == 0) { 687 if (id != IDMAP_WK_CREATOR_GROUP_GID && 688 id == ksid_groups[i].ks_id) { 689 return (B_TRUE); 690 } 691 } else { | 707 int i; 708 ksid_t *ksid_groups; 709 ksidlist_t *ksidlist = crgetsidlist(cr); 710 uint32_t idx = FUID_INDEX(id); 711 uint32_t rid = FUID_RID(id); 712 713 ASSERT(ksidlist); 714 ksid_groups = ksidlist->ksl_sids; 715 716 for (i = 0; i != ksidlist->ksl_nsid; i++) { 717 if (idx == 0) { 718 if (id != IDMAP_WK_CREATOR_GROUP_GID && 719 id == ksid_groups[i].ks_id) { 720 return (B_TRUE); 721 } 722 } else { |
692 char *domain; | 723 const char *domain; |
693 694 domain = zfs_fuid_find_by_idx(zfsvfs, idx); 695 ASSERT(domain != NULL); 696 697 if (strcmp(domain, 698 IDMAP_WK_CREATOR_SID_AUTHORITY) == 0) 699 return (B_FALSE); 700 701 if ((strcmp(domain, 702 ksid_groups[i].ks_domain->kd_name) == 0) && 703 rid == ksid_groups[i].ks_rid) 704 return (B_TRUE); 705 } 706 } 707 } | 724 725 domain = zfs_fuid_find_by_idx(zfsvfs, idx); 726 ASSERT(domain != NULL); 727 728 if (strcmp(domain, 729 IDMAP_WK_CREATOR_SID_AUTHORITY) == 0) 730 return (B_FALSE); 731 732 if ((strcmp(domain, 733 ksid_groups[i].ks_domain->kd_name) == 0) && 734 rid == ksid_groups[i].ks_rid) 735 return (B_TRUE); 736 } 737 } 738 } |
708#endif | 739#endif /* sun */ |
709 710 /* 711 * Not found in ksidlist, check posix groups 712 */ 713 gid = zfs_fuid_map_id(zfsvfs, id, cr, ZFS_GROUP); 714 return (groupmember(gid, cr)); 715} | 740 741 /* 742 * Not found in ksidlist, check posix groups 743 */ 744 gid = zfs_fuid_map_id(zfsvfs, id, cr, ZFS_GROUP); 745 return (groupmember(gid, cr)); 746} |
747 748void 749zfs_fuid_txhold(zfsvfs_t *zfsvfs, dmu_tx_t *tx) 750{ 751 if (zfsvfs->z_fuid_obj == 0) { 752 dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); 753 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 754 FUID_SIZE_ESTIMATE(zfsvfs)); 755 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, FALSE, NULL); 756 } else { 757 dmu_tx_hold_bonus(tx, zfsvfs->z_fuid_obj); 758 dmu_tx_hold_write(tx, zfsvfs->z_fuid_obj, 0, 759 FUID_SIZE_ESTIMATE(zfsvfs)); 760 } 761} |
|
716#endif | 762#endif |