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