sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_fuid.c

   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
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  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 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>
  31 #include <sys/refcount.h>
  32 #include <sys/nvpair.h>
  33 #ifdef _KERNEL
  34 #include <sys/kidmap.h>
  35 #include <sys/sid.h>
  36 #include <sys/zfs_vfsops.h>
  37 #include <sys/zfs_znode.h>
  38 #endif
  39 #include <sys/zfs_fuid.h>
  40
  41 /*
  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
  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  *
  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
  61 typedef struct fuid_domain {
  62         avl_node_t      f_domnode;
  63         avl_node_t      f_idxnode;
  64         ksiddomain_t    *f_ksid;
  65         uint64_t        f_idx;
  66 } fuid_domain_t;
  67
  68 static char *nulldomain = "";
  69
  70 /*
  71  * Compare two indexes.
  72  */
  73 static int
  74 idx_compare(const void *arg1, const void *arg2)
  75 {
  76         const fuid_domain_t *node1 = arg1;
  77         const fuid_domain_t *node2 = arg2;
  78
  79         if (node1->f_idx < node2->f_idx)
  80                 return (-1);
  81         else if (node1->f_idx > node2->f_idx)
  82                 return (1);
  83         return (0);
  84 }
  85
  86 /*
  87  * Compare two domain strings.
  88  */
  89 static int
  90 domain_compare(const void *arg1, const void *arg2)
  91 {
  92         const fuid_domain_t *node1 = arg1;
  93         const fuid_domain_t *node2 = arg2;
  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
 102 void
 103 zfs_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
 111 /*
 112  * load initial fuid domain and idx trees.  This function is used by
 113  * both the kernel and zdb.
 114  */
 115 uint64_t
 116 zfs_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
 122         ASSERT(fuid_obj != 0);
 123         VERIFY(0 == dmu_bonus_hold(os, fuid_obj,
 124             FTAG, &db));
 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);
 136                 VERIFY(dmu_read(os, fuid_obj, 0,
 137                     fuid_size, packed, DMU_READ_PREFETCH) == 0);
 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;
 146                         uint64_t idx;
 147
 148                         VERIFY(nvlist_lookup_string(fuidnvp[i], FUID_DOMAIN,
 149                             &domain) == 0);
 150                         VERIFY(nvlist_lookup_uint64(fuidnvp[i], FUID_IDX,
 151                             &idx) == 0);
 152
 153                         domnode = kmem_alloc(sizeof (fuid_domain_t), KM_SLEEP);
 154
 155                         domnode->f_idx = idx;
 156                         domnode->f_ksid = ksid_lookupdomain(domain);
 157                         avl_add(idx_tree, domnode);
 158                         avl_add(domain_tree, domnode);
 159                 }
 160                 nvlist_free(nvp);
 161                 kmem_free(packed, fuid_size);
 162         }
 163         return (fuid_size);
 164 }
 165
 166 void
 167 zfs_fuid_table_destroy(avl_tree_t *idx_tree, avl_tree_t *domain_tree)
 168 {
 169         fuid_domain_t *domnode;
 170         void *cookie;
 171
 172         cookie = NULL;
 173         while (domnode = avl_destroy_nodes(domain_tree, &cookie))
 174                 ksiddomain_rele(domnode->f_ksid);
 175
 176         avl_destroy(domain_tree);
 177         cookie = NULL;
 178         while (domnode = avl_destroy_nodes(idx_tree, &cookie))
 179                 kmem_free(domnode, sizeof (fuid_domain_t));
 180         avl_destroy(idx_tree);
 181 }
 182
 183 char *
 184 zfs_fuid_idx_domain(avl_tree_t *idx_tree, uint32_t idx)
 185 {
 186         fuid_domain_t searchnode, *findnode;
 187         avl_index_t loc;
 188
 189         searchnode.f_idx = idx;
 190
 191         findnode = avl_find(idx_tree, &searchnode, &loc);
 192
 193         return (findnode ? findnode->f_ksid->kd_name : nulldomain);
 194 }
 195
 196 #ifdef _KERNEL
 197 /*
 198  * Load the fuid table(s) into memory.
 199  */
 200 static void
 201 zfs_fuid_init(zfsvfs_t *zfsvfs)
 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
 210         zfs_fuid_avl_tree_create(&zfsvfs->z_fuid_idx, &zfsvfs->z_fuid_domain);
 211
 212         (void) zap_lookup(zfsvfs->z_os, MASTER_NODE_OBJ,
 213             ZFS_FUID_TABLES, 8, 1, &zfsvfs->z_fuid_obj);
 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);
 218         }
 219
 220         zfsvfs->z_fuid_loaded = B_TRUE;
 221         rw_exit(&zfsvfs->z_fuid_lock);
 222 }
 223
 224 /*
 225  * sync out AVL trees to persistent storage.
 226  */
 227 void
 228 zfs_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 /*
 295  * Query domain table for a given domain.
 296  *
 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.
 301  */
 302 int
 303 zfs_fuid_find_by_domain(zfsvfs_t *zfsvfs, const char *domain,
 304     char **retdomain, boolean_t addok)
 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') {
 316                 if (retdomain)
 317                         *retdomain = nulldomain;
 318                 return (0);
 319         }
 320
 321         searchnode.f_ksid = ksid_lookupdomain(domain);
 322         if (retdomain)
 323                 *retdomain = searchnode.f_ksid->kd_name;
 324         if (!zfsvfs->z_fuid_loaded)
 325                 zfs_fuid_init(zfsvfs);
 326
 327 retry:
 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);
 335         } else if (addok) {
 336                 fuid_domain_t *domnode;
 337                 uint64_t retidx;
 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);
 352                 zfsvfs->z_fuid_dirty = B_TRUE;
 353                 rw_exit(&zfsvfs->z_fuid_lock);
 354                 return (retidx);
 355         } else {
 356                 rw_exit(&zfsvfs->z_fuid_lock);
 357                 return (-1);
 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  */
 367 const char *
 368 zfs_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)
 376                 zfs_fuid_init(zfsvfs);
 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);
 385
 386         ASSERT(domain);
 387         return (domain);
 388 }
 389
 390 void
 391 zfs_fuid_map_ids(znode_t *zp, cred_t *cr, uid_t *uidp, uid_t *gidp)
 392 {
 393         *uidp = zfs_fuid_map_id(zp->z_zfsvfs, zp->z_phys->zp_uid,
 394             cr, ZFS_OWNER);
 395         *gidp = zfs_fuid_map_id(zp->z_zfsvfs, zp->z_phys->zp_gid,
 396             cr, ZFS_GROUP);
 397 }
 398
 399 uid_t
 400 zfs_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);
 404         const char *domain;
 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
 413 #ifdef TODO
 414         if (type == ZFS_OWNER || type == ZFS_ACE_USER) {
 415                 (void) kidmap_getuidbysid(crgetzone(cr), domain,
 416                     FUID_RID(fuid), &id);
 417         } else {
 418                 (void) kidmap_getgidbysid(crgetzone(cr), domain,
 419                     FUID_RID(fuid), &id);
 420         }
 421 #else
 422         panic(__func__);
 423 #endif
 424         return (id);
 425 }
 426
 427 /*
 428  * Add a FUID node to the list of fuid's being created for this
 429  * ACL
 430  *
 431  * If ACL has multiple domains, then keep only one copy of each unique
 432  * domain.
 433  */
 434 static void
 435 zfs_fuid_node_add(zfs_fuid_info_t **fuidpp, const char *domain, uint32_t rid,
 436     uint64_t idx, uint64_t id, zfs_fuid_type_t type)
 437 {
 438         zfs_fuid_t *fuid;
 439         zfs_fuid_domain_t *fuid_domain;
 440         zfs_fuid_info_t *fuidp;
 441         uint64_t fuididx;
 442         boolean_t found = B_FALSE;
 443
 444         if (*fuidpp == NULL)
 445                 *fuidpp = zfs_fuid_info_alloc();
 446
 447         fuidp = *fuidpp;
 448         /*
 449          * First find fuid domain index in linked list
 450          *
 451          * If one isn't found then create an entry.
 452          */
 453
 454         for (fuididx = 1, fuid_domain = list_head(&fuidp->z_domains);
 455             fuid_domain; fuid_domain = list_next(&fuidp->z_domains,
 456             fuid_domain), fuididx++) {
 457                 if (idx == fuid_domain->z_domidx) {
 458                         found = B_TRUE;
 459                         break;
 460                 }
 461         }
 462
 463         if (!found) {
 464                 fuid_domain = kmem_alloc(sizeof (zfs_fuid_domain_t), KM_SLEEP);
 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
 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);
 482
 483                 list_insert_tail(&fuidp->z_fuids, fuid);
 484                 fuidp->z_fuid_cnt++;
 485         } else {
 486                 if (type == ZFS_OWNER)
 487                         fuidp->z_fuid_owner = FUID_ENCODE(fuididx, rid);
 488                 else
 489                         fuidp->z_fuid_group = FUID_ENCODE(fuididx, rid);
 490         }
 491 }
 492
 493 /*
 494  * Create a file system FUID, based on information in the users cred
 495  */
 496 uint64_t
 497 zfs_fuid_create_cred(zfsvfs_t *zfsvfs, zfs_fuid_type_t type,
 498     cred_t *cr, zfs_fuid_info_t **fuidp)
 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
 507         VERIFY(type == ZFS_OWNER || type == ZFS_GROUP);
 508
 509         if (type == ZFS_OWNER)
 510                 id = crgetuid(cr);
 511         else
 512                 id = crgetgid(cr);
 513
 514         if (!zfsvfs->z_use_fuids || !IS_EPHEMERAL(id))
 515                 return ((uint64_t)id);
 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
 524         idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, B_TRUE);
 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 }
 533
 534 /*
 535  * Create a file system FUID for an ACL ace
 536  * or a chown/chgrp of the file.
 537  * This is similar to zfs_fuid_create_cred, except that
 538  * we can't find the domain + rid information in the
 539  * cred.  Instead we have to query Winchester for the
 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  */
 546 uint64_t
 547 zfs_fuid_create(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr,
 548     zfs_fuid_type_t type, zfs_fuid_info_t **fuidpp)
 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;
 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
 570         if (zfsvfs->z_replay) {
 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                  */
 579                 if (fuidp == NULL)
 580                         return (UID_NOBODY);
 581
 582                 switch (type) {
 583                 case ZFS_ACE_USER:
 584                 case ZFS_ACE_GROUP:
 585                         zfuid = list_head(&fuidp->z_fuids);
 586                         rid = FUID_RID(zfuid->z_logfuid);
 587                         idx = FUID_INDEX(zfuid->z_logfuid);
 588                         break;
 589                 case ZFS_OWNER:
 590                         rid = FUID_RID(fuidp->z_fuid_owner);
 591                         idx = FUID_INDEX(fuidp->z_fuid_owner);
 592                         break;
 593                 case ZFS_GROUP:
 594                         rid = FUID_RID(fuidp->z_fuid_group);
 595                         idx = FUID_INDEX(fuidp->z_fuid_group);
 596                         break;
 597                 };
 598                 domain = fuidp->z_domain_table[idx -1];
 599         } else {
 600 #ifdef TODO
 601                 if (type == ZFS_OWNER || type == ZFS_ACE_USER)
 602                         status = kidmap_getsidbyuid(crgetzone(cr), id,
 603                             &domain, &rid);
 604                 else
 605                         status = kidmap_getsidbygid(crgetzone(cr), id,
 606                             &domain, &rid);
 607
 608                 if (status != 0) {
 609                         /*
 610                          * When returning nobody we will need to
 611                          * make a dummy fuid table entry for logging
 612                          * purposes.
 613                          */
 614                         rid = UID_NOBODY;
 615                         domain = nulldomain;
 616                 }
 617 #else
 618                 panic(__func__);
 619 #endif
 620         }
 621
 622         idx = zfs_fuid_find_by_domain(zfsvfs, domain, &kdomain, B_TRUE);
 623
 624         if (!zfsvfs->z_replay)
 625                 zfs_fuid_node_add(fuidpp, kdomain,
 626                     rid, idx, id, type);
 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
 634 void
 635 zfs_fuid_destroy(zfsvfs_t *zfsvfs)
 636 {
 637         rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER);
 638         if (!zfsvfs->z_fuid_loaded) {
 639                 rw_exit(&zfsvfs->z_fuid_lock);
 640                 return;
 641         }
 642         zfs_fuid_table_destroy(&zfsvfs->z_fuid_idx, &zfsvfs->z_fuid_domain);
 643         rw_exit(&zfsvfs->z_fuid_lock);
 644 }
 645
 646 /*
 647  * Allocate zfs_fuid_info for tracking FUIDs created during
 648  * zfs_mknode, VOP_SETATTR() or VOP_SETSECATTR()
 649  */
 650 zfs_fuid_info_t *
 651 zfs_fuid_info_alloc(void)
 652 {
 653         zfs_fuid_info_t *fuidp;
 654
 655         fuidp = kmem_zalloc(sizeof (zfs_fuid_info_t), KM_SLEEP);
 656         list_create(&fuidp->z_domains, sizeof (zfs_fuid_domain_t),
 657             offsetof(zfs_fuid_domain_t, z_next));
 658         list_create(&fuidp->z_fuids, sizeof (zfs_fuid_t),
 659             offsetof(zfs_fuid_t, z_next));
 660         return (fuidp);
 661 }
 662
 663 /*
 664  * Release all memory associated with zfs_fuid_info_t
 665  */
 666 void
 667 zfs_fuid_info_free(zfs_fuid_info_t *fuidp)
 668 {
 669         zfs_fuid_t *zfuid;
 670         zfs_fuid_domain_t *zdomain;
 671
 672         while ((zfuid = list_head(&fuidp->z_fuids)) != NULL) {
 673                 list_remove(&fuidp->z_fuids, zfuid);
 674                 kmem_free(zfuid, sizeof (zfs_fuid_t));
 675         }
 676
 677         if (fuidp->z_domain_table != NULL)
 678                 kmem_free(fuidp->z_domain_table,
 679                     (sizeof (char **)) * fuidp->z_domain_cnt);
 680
 681         while ((zdomain = list_head(&fuidp->z_domains)) != NULL) {
 682                 list_remove(&fuidp->z_domains, zdomain);
 683                 kmem_free(zdomain, sizeof (zfs_fuid_domain_t));
 684         }
 685
 686         kmem_free(fuidp, sizeof (zfs_fuid_info_t));
 687 }
 688
 689 /*
 690  * Check to see if id is a groupmember.  If cred
 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  */
 696 boolean_t
 697 zfs_groupmember(zfsvfs_t *zfsvfs, uint64_t id, cred_t *cr)
 698 {
 699 #ifdef sun
 700         ksid_t          *ksid = crgetsid(cr, KSID_GROUP);
 701         ksidlist_t      *ksidlist = crgetsidlist(cr);
 702 #endif  /* sun */
 703         uid_t           gid;
 704
 705 #ifdef sun
 706         if (ksid && ksidlist) {
 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 {
 723                                 const char *domain;
 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         }
 739 #endif  /* sun */
 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
 748 void
 749 zfs_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 }
 762 #endif