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