zfs_znode.c revision 173268
1168404Spjd/* 2168404Spjd * CDDL HEADER START 3168404Spjd * 4168404Spjd * The contents of this file are subject to the terms of the 5168404Spjd * Common Development and Distribution License (the "License"). 6168404Spjd * You may not use this file except in compliance with the License. 7168404Spjd * 8168404Spjd * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9168404Spjd * or http://www.opensolaris.org/os/licensing. 10168404Spjd * See the License for the specific language governing permissions 11168404Spjd * and limitations under the License. 12168404Spjd * 13168404Spjd * When distributing Covered Code, include this CDDL HEADER in each 14168404Spjd * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15168404Spjd * If applicable, add the following below this CDDL HEADER, with the 16168404Spjd * fields enclosed by brackets "[]" replaced with your own identifying 17168404Spjd * information: Portions Copyright [yyyy] [name of copyright owner] 18168404Spjd * 19168404Spjd * CDDL HEADER END 20168404Spjd */ 21168404Spjd/* 22168404Spjd * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23168404Spjd * Use is subject to license terms. 24168404Spjd */ 25168404Spjd 26169195Spjd/* Portions Copyright 2007 Jeremy Teo */ 27169195Spjd 28168404Spjd#pragma ident "%Z%%M% %I% %E% SMI" 29168404Spjd 30168404Spjd#ifdef _KERNEL 31168404Spjd#include <sys/types.h> 32168404Spjd#include <sys/param.h> 33168404Spjd#include <sys/time.h> 34168404Spjd#include <sys/systm.h> 35168404Spjd#include <sys/sysmacros.h> 36168404Spjd#include <sys/resource.h> 37168404Spjd#include <sys/mntent.h> 38168404Spjd#include <sys/vfs.h> 39168404Spjd#include <sys/vnode.h> 40168404Spjd#include <sys/file.h> 41168404Spjd#include <sys/kmem.h> 42168404Spjd#include <sys/cmn_err.h> 43168404Spjd#include <sys/errno.h> 44168404Spjd#include <sys/unistd.h> 45168404Spjd#include <sys/atomic.h> 46168404Spjd#include <sys/zfs_dir.h> 47168404Spjd#include <sys/zfs_acl.h> 48168404Spjd#include <sys/zfs_ioctl.h> 49168404Spjd#include <sys/zfs_rlock.h> 50168404Spjd#include <sys/fs/zfs.h> 51168404Spjd#endif /* _KERNEL */ 52168404Spjd 53168404Spjd#include <sys/dmu.h> 54168404Spjd#include <sys/refcount.h> 55168404Spjd#include <sys/stat.h> 56168404Spjd#include <sys/zap.h> 57168404Spjd#include <sys/zfs_znode.h> 58168404Spjd#include <sys/refcount.h> 59168404Spjd 60173268Slulf/* Used by fstat(1). */ 61173268SlulfSYSCTL_INT(_debug_sizeof, OID_AUTO, znode, CTLFLAG_RD, 0, sizeof(znode_t), 62173268Slulf "sizeof(znode_t)"); 63173268Slulf 64168404Spjd/* 65168404Spjd * Functions needed for userland (ie: libzpool) are not put under 66168404Spjd * #ifdef_KERNEL; the rest of the functions have dependencies 67168404Spjd * (such as VFS logic) that will not compile easily in userland. 68168404Spjd */ 69168404Spjd#ifdef _KERNEL 70168404Spjdstruct kmem_cache *znode_cache = NULL; 71168404Spjd 72168404Spjd/*ARGSUSED*/ 73168404Spjdstatic void 74168404Spjdznode_pageout_func(dmu_buf_t *dbuf, void *user_ptr) 75168404Spjd{ 76168404Spjd znode_t *zp = user_ptr; 77168488Spjd vnode_t *vp; 78168404Spjd 79168404Spjd mutex_enter(&zp->z_lock); 80168488Spjd vp = ZTOV(zp); 81168404Spjd if (vp == NULL) { 82168404Spjd mutex_exit(&zp->z_lock); 83168404Spjd zfs_znode_free(zp); 84168404Spjd } else if (vp->v_count == 0) { 85168404Spjd ZTOV(zp) = NULL; 86168488Spjd vhold(vp); 87168404Spjd mutex_exit(&zp->z_lock); 88168404Spjd vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curthread); 89168404Spjd vrecycle(vp, curthread); 90168404Spjd VOP_UNLOCK(vp, 0, curthread); 91168404Spjd vdrop(vp); 92168404Spjd zfs_znode_free(zp); 93168404Spjd } else { 94168404Spjd /* signal force unmount that this znode can be freed */ 95168404Spjd zp->z_dbuf = NULL; 96168404Spjd mutex_exit(&zp->z_lock); 97168404Spjd } 98168404Spjd} 99168404Spjd 100168404Spjdextern struct vop_vector zfs_vnodeops; 101168404Spjdextern struct vop_vector zfs_fifoops; 102168404Spjd 103168404Spjd/* 104168404Spjd * XXX: We cannot use this function as a cache constructor, because 105168404Spjd * there is one global cache for all file systems and we need 106168404Spjd * to pass vfsp here, which is not possible, because argument 107168404Spjd * 'cdrarg' is defined at kmem_cache_create() time. 108168404Spjd */ 109168404Spjdstatic int 110168404Spjdzfs_znode_cache_constructor(void *buf, void *cdrarg, int kmflags) 111168404Spjd{ 112168404Spjd znode_t *zp = buf; 113169196Spjd vnode_t *vp; 114168404Spjd vfs_t *vfsp = cdrarg; 115168404Spjd int error; 116168404Spjd 117168404Spjd if (cdrarg != NULL) { 118169196Spjd error = getnewvnode("zfs", vfsp, &zfs_vnodeops, &vp); 119168404Spjd ASSERT(error == 0); 120169196Spjd zp->z_vnode = vp; 121169196Spjd vp->v_data = (caddr_t)zp; 122169196Spjd vp->v_vnlock->lk_flags |= LK_CANRECURSE; 123169196Spjd vp->v_vnlock->lk_flags &= ~LK_NOSHARE; 124168404Spjd } else { 125168404Spjd zp->z_vnode = NULL; 126168404Spjd } 127168404Spjd mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL); 128168404Spjd rw_init(&zp->z_map_lock, NULL, RW_DEFAULT, NULL); 129168404Spjd rw_init(&zp->z_parent_lock, NULL, RW_DEFAULT, NULL); 130168404Spjd rw_init(&zp->z_name_lock, NULL, RW_DEFAULT, NULL); 131168404Spjd mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL); 132168404Spjd 133168404Spjd mutex_init(&zp->z_range_lock, NULL, MUTEX_DEFAULT, NULL); 134168404Spjd avl_create(&zp->z_range_avl, zfs_range_compare, 135168404Spjd sizeof (rl_t), offsetof(rl_t, r_node)); 136168404Spjd 137168404Spjd zp->z_dbuf_held = 0; 138168404Spjd zp->z_dirlocks = 0; 139168404Spjd zp->z_lockf = NULL; 140168404Spjd return (0); 141168404Spjd} 142168404Spjd 143168404Spjd/*ARGSUSED*/ 144168404Spjdstatic void 145168404Spjdzfs_znode_cache_destructor(void *buf, void *cdarg) 146168404Spjd{ 147168404Spjd znode_t *zp = buf; 148168404Spjd 149168404Spjd ASSERT(zp->z_dirlocks == 0); 150168404Spjd mutex_destroy(&zp->z_lock); 151168404Spjd rw_destroy(&zp->z_map_lock); 152168404Spjd rw_destroy(&zp->z_parent_lock); 153168404Spjd rw_destroy(&zp->z_name_lock); 154168404Spjd mutex_destroy(&zp->z_acl_lock); 155168404Spjd mutex_destroy(&zp->z_range_lock); 156168404Spjd avl_destroy(&zp->z_range_avl); 157168404Spjd 158168404Spjd ASSERT(zp->z_dbuf_held == 0); 159168404Spjd} 160168404Spjd 161168404Spjdvoid 162168404Spjdzfs_znode_init(void) 163168404Spjd{ 164168404Spjd /* 165168404Spjd * Initialize zcache 166168404Spjd */ 167168404Spjd ASSERT(znode_cache == NULL); 168168404Spjd znode_cache = kmem_cache_create("zfs_znode_cache", 169168404Spjd sizeof (znode_t), 0, /* zfs_znode_cache_constructor */ NULL, 170168404Spjd zfs_znode_cache_destructor, NULL, NULL, NULL, 0); 171168404Spjd} 172168404Spjd 173168404Spjdvoid 174168404Spjdzfs_znode_fini(void) 175168404Spjd{ 176168404Spjd /* 177168404Spjd * Cleanup zcache 178168404Spjd */ 179168404Spjd if (znode_cache) 180168404Spjd kmem_cache_destroy(znode_cache); 181168404Spjd znode_cache = NULL; 182168404Spjd} 183168404Spjd 184168404Spjd/* 185168404Spjd * zfs_init_fs - Initialize the zfsvfs struct and the file system 186168404Spjd * incore "master" object. Verify version compatibility. 187168404Spjd */ 188168404Spjdint 189168404Spjdzfs_init_fs(zfsvfs_t *zfsvfs, znode_t **zpp, cred_t *cr) 190168404Spjd{ 191168404Spjd objset_t *os = zfsvfs->z_os; 192168404Spjd uint64_t version = ZPL_VERSION; 193168404Spjd int i, error; 194168404Spjd dmu_object_info_t doi; 195168404Spjd uint64_t fsid_guid; 196168404Spjd 197168404Spjd *zpp = NULL; 198168404Spjd 199168404Spjd /* 200168404Spjd * XXX - hack to auto-create the pool root filesystem at 201168404Spjd * the first attempted mount. 202168404Spjd */ 203168404Spjd if (dmu_object_info(os, MASTER_NODE_OBJ, &doi) == ENOENT) { 204168404Spjd dmu_tx_t *tx = dmu_tx_create(os); 205168404Spjd 206168404Spjd dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* master */ 207168404Spjd dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* del queue */ 208168404Spjd dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); /* root node */ 209168404Spjd error = dmu_tx_assign(tx, TXG_WAIT); 210168404Spjd ASSERT3U(error, ==, 0); 211168404Spjd zfs_create_fs(os, cr, tx); 212168404Spjd dmu_tx_commit(tx); 213168404Spjd } 214168404Spjd 215168404Spjd error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_OBJ, 8, 1, 216168404Spjd &version); 217168404Spjd if (error) { 218168404Spjd return (error); 219168404Spjd } else if (version != ZPL_VERSION) { 220168404Spjd (void) printf("Mismatched versions: File system " 221168404Spjd "is version %lld on-disk format, which is " 222168404Spjd "incompatible with this software version %lld!", 223168404Spjd (u_longlong_t)version, ZPL_VERSION); 224168404Spjd return (ENOTSUP); 225168404Spjd } 226168404Spjd 227168404Spjd /* 228168404Spjd * The fsid is 64 bits, composed of an 8-bit fs type, which 229168404Spjd * separates our fsid from any other filesystem types, and a 230168404Spjd * 56-bit objset unique ID. The objset unique ID is unique to 231168404Spjd * all objsets open on this system, provided by unique_create(). 232168404Spjd * The 8-bit fs type must be put in the low bits of fsid[1] 233168404Spjd * because that's where other Solaris filesystems put it. 234168404Spjd */ 235168404Spjd fsid_guid = dmu_objset_fsid_guid(os); 236168404Spjd ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0); 237168404Spjd zfsvfs->z_vfs->vfs_fsid.val[0] = fsid_guid; 238168404Spjd zfsvfs->z_vfs->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) | 239168404Spjd zfsvfs->z_vfs->mnt_vfc->vfc_typenum & 0xFF; 240168404Spjd 241168404Spjd error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, 242168404Spjd &zfsvfs->z_root); 243168404Spjd if (error) 244168404Spjd return (error); 245168404Spjd ASSERT(zfsvfs->z_root != 0); 246168404Spjd 247168404Spjd /* 248168404Spjd * Create the per mount vop tables. 249168404Spjd */ 250168404Spjd 251168404Spjd /* 252168404Spjd * Initialize zget mutex's 253168404Spjd */ 254168404Spjd for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 255168404Spjd mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL); 256168404Spjd 257168404Spjd error = zfs_zget(zfsvfs, zfsvfs->z_root, zpp); 258168404Spjd if (error) 259168404Spjd return (error); 260168404Spjd ASSERT3U((*zpp)->z_id, ==, zfsvfs->z_root); 261168404Spjd 262168404Spjd error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1, 263168404Spjd &zfsvfs->z_unlinkedobj); 264168404Spjd if (error) 265168404Spjd return (error); 266168404Spjd 267168404Spjd return (0); 268168404Spjd} 269168404Spjd 270168404Spjd/* 271168404Spjd * define a couple of values we need available 272168404Spjd * for both 64 and 32 bit environments. 273168404Spjd */ 274168404Spjd#ifndef NBITSMINOR64 275168404Spjd#define NBITSMINOR64 32 276168404Spjd#endif 277168404Spjd#ifndef MAXMAJ64 278168404Spjd#define MAXMAJ64 0xffffffffUL 279168404Spjd#endif 280168404Spjd#ifndef MAXMIN64 281168404Spjd#define MAXMIN64 0xffffffffUL 282168404Spjd#endif 283168958Spjd#ifndef major 284168958Spjd#define major(x) ((int)(((u_int)(x) >> 8)&0xff)) /* major number */ 285168958Spjd#endif 286168958Spjd#ifndef minor 287168958Spjd#define minor(x) ((int)((x)&0xffff00ff)) /* minor number */ 288168958Spjd#endif 289168404Spjd 290168404Spjd/* 291168404Spjd * Create special expldev for ZFS private use. 292168404Spjd * Can't use standard expldev since it doesn't do 293168404Spjd * what we want. The standard expldev() takes a 294168404Spjd * dev32_t in LP64 and expands it to a long dev_t. 295168404Spjd * We need an interface that takes a dev32_t in ILP32 296168404Spjd * and expands it to a long dev_t. 297168404Spjd */ 298168404Spjdstatic uint64_t 299168404Spjdzfs_expldev(dev_t dev) 300168404Spjd{ 301168958Spjd return (((uint64_t)major(dev) << NBITSMINOR64) | minor(dev)); 302168404Spjd} 303168404Spjd/* 304168404Spjd * Special cmpldev for ZFS private use. 305168404Spjd * Can't use standard cmpldev since it takes 306168404Spjd * a long dev_t and compresses it to dev32_t in 307168404Spjd * LP64. We need to do a compaction of a long dev_t 308168404Spjd * to a dev32_t in ILP32. 309168404Spjd */ 310168404Spjddev_t 311168404Spjdzfs_cmpldev(uint64_t dev) 312168404Spjd{ 313168958Spjd return (makedev((dev >> NBITSMINOR64), (dev & MAXMIN64))); 314168404Spjd} 315168404Spjd 316168404Spjd/* 317168404Spjd * Construct a new znode/vnode and intialize. 318168404Spjd * 319168404Spjd * This does not do a call to dmu_set_user() that is 320168404Spjd * up to the caller to do, in case you don't want to 321168404Spjd * return the znode 322168404Spjd */ 323168404Spjdstatic znode_t * 324168404Spjdzfs_znode_alloc(zfsvfs_t *zfsvfs, dmu_buf_t *db, uint64_t obj_num, int blksz) 325168404Spjd{ 326168404Spjd znode_t *zp; 327168404Spjd vnode_t *vp; 328168404Spjd int error; 329168404Spjd 330168404Spjd zp = kmem_cache_alloc(znode_cache, KM_SLEEP); 331168404Spjd zfs_znode_cache_constructor(zp, zfsvfs->z_vfs, 0); 332168404Spjd 333168404Spjd ASSERT(zp->z_dirlocks == NULL); 334168404Spjd 335168404Spjd zp->z_phys = db->db_data; 336168404Spjd zp->z_zfsvfs = zfsvfs; 337168404Spjd zp->z_unlinked = 0; 338168404Spjd zp->z_atime_dirty = 0; 339168404Spjd zp->z_dbuf_held = 0; 340168404Spjd zp->z_mapcnt = 0; 341168404Spjd zp->z_last_itx = 0; 342168404Spjd zp->z_dbuf = db; 343168404Spjd zp->z_id = obj_num; 344168404Spjd zp->z_blksz = blksz; 345168404Spjd zp->z_seq = 0x7A4653; 346168404Spjd zp->z_sync_cnt = 0; 347168404Spjd 348168404Spjd mutex_enter(&zfsvfs->z_znodes_lock); 349168404Spjd list_insert_tail(&zfsvfs->z_all_znodes, zp); 350168404Spjd mutex_exit(&zfsvfs->z_znodes_lock); 351168404Spjd 352168404Spjd vp = ZTOV(zp); 353168404Spjd if (vp == NULL) 354168404Spjd return (zp); 355168404Spjd 356168404Spjd error = insmntque(vp, zfsvfs->z_vfs); 357168404Spjd KASSERT(error == 0, ("insmntque() failed: error %d", error)); 358168404Spjd 359168404Spjd vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode); 360168404Spjd switch (vp->v_type) { 361168404Spjd case VDIR: 362168404Spjd zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */ 363168404Spjd break; 364168404Spjd case VFIFO: 365168404Spjd vp->v_op = &zfs_fifoops; 366168404Spjd break; 367168404Spjd } 368168404Spjd 369168404Spjd return (zp); 370168404Spjd} 371168404Spjd 372168404Spjdstatic void 373168404Spjdzfs_znode_dmu_init(znode_t *zp) 374168404Spjd{ 375168404Spjd znode_t *nzp; 376168404Spjd zfsvfs_t *zfsvfs = zp->z_zfsvfs; 377168404Spjd dmu_buf_t *db = zp->z_dbuf; 378168404Spjd 379168404Spjd mutex_enter(&zp->z_lock); 380168404Spjd 381169056Spjd nzp = dmu_buf_set_user_ie(db, zp, &zp->z_phys, znode_pageout_func); 382168404Spjd 383168404Spjd /* 384168404Spjd * there should be no 385168404Spjd * concurrent zgets on this object. 386168404Spjd */ 387168404Spjd ASSERT3P(nzp, ==, NULL); 388168404Spjd 389168404Spjd /* 390168404Spjd * Slap on VROOT if we are the root znode 391168404Spjd */ 392168404Spjd if (zp->z_id == zfsvfs->z_root) { 393168404Spjd ZTOV(zp)->v_flag |= VROOT; 394168404Spjd } 395168404Spjd 396168404Spjd ASSERT(zp->z_dbuf_held == 0); 397168404Spjd zp->z_dbuf_held = 1; 398168404Spjd VFS_HOLD(zfsvfs->z_vfs); 399168404Spjd mutex_exit(&zp->z_lock); 400168404Spjd} 401168404Spjd 402168404Spjd/* 403168404Spjd * Create a new DMU object to hold a zfs znode. 404168404Spjd * 405168404Spjd * IN: dzp - parent directory for new znode 406168404Spjd * vap - file attributes for new znode 407168404Spjd * tx - dmu transaction id for zap operations 408168404Spjd * cr - credentials of caller 409168404Spjd * flag - flags: 410168404Spjd * IS_ROOT_NODE - new object will be root 411168404Spjd * IS_XATTR - new object is an attribute 412168404Spjd * IS_REPLAY - intent log replay 413168404Spjd * 414168404Spjd * OUT: oid - ID of created object 415168404Spjd * 416168404Spjd */ 417168404Spjdvoid 418168404Spjdzfs_mknode(znode_t *dzp, vattr_t *vap, uint64_t *oid, dmu_tx_t *tx, cred_t *cr, 419168404Spjd uint_t flag, znode_t **zpp, int bonuslen) 420168404Spjd{ 421168404Spjd dmu_buf_t *dbp; 422168404Spjd znode_phys_t *pzp; 423168404Spjd znode_t *zp; 424168404Spjd zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 425168404Spjd timestruc_t now; 426168404Spjd uint64_t gen; 427168404Spjd int err; 428168404Spjd 429168404Spjd ASSERT(vap && (vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE)); 430168404Spjd 431168404Spjd if (zfsvfs->z_assign >= TXG_INITIAL) { /* ZIL replay */ 432168404Spjd *oid = vap->va_nodeid; 433168404Spjd flag |= IS_REPLAY; 434168404Spjd now = vap->va_ctime; /* see zfs_replay_create() */ 435168404Spjd gen = vap->va_nblocks; /* ditto */ 436168404Spjd } else { 437168404Spjd *oid = 0; 438168404Spjd gethrestime(&now); 439168404Spjd gen = dmu_tx_get_txg(tx); 440168404Spjd } 441168404Spjd 442168404Spjd /* 443168404Spjd * Create a new DMU object. 444168404Spjd */ 445168404Spjd /* 446168404Spjd * There's currently no mechanism for pre-reading the blocks that will 447168404Spjd * be to needed allocate a new object, so we accept the small chance 448168404Spjd * that there will be an i/o error and we will fail one of the 449168404Spjd * assertions below. 450168404Spjd */ 451168404Spjd if (vap->va_type == VDIR) { 452168404Spjd if (flag & IS_REPLAY) { 453168404Spjd err = zap_create_claim(zfsvfs->z_os, *oid, 454168404Spjd DMU_OT_DIRECTORY_CONTENTS, 455168404Spjd DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 456168404Spjd ASSERT3U(err, ==, 0); 457168404Spjd } else { 458168404Spjd *oid = zap_create(zfsvfs->z_os, 459168404Spjd DMU_OT_DIRECTORY_CONTENTS, 460168404Spjd DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 461168404Spjd } 462168404Spjd } else { 463168404Spjd if (flag & IS_REPLAY) { 464168404Spjd err = dmu_object_claim(zfsvfs->z_os, *oid, 465168404Spjd DMU_OT_PLAIN_FILE_CONTENTS, 0, 466168404Spjd DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 467168404Spjd ASSERT3U(err, ==, 0); 468168404Spjd } else { 469168404Spjd *oid = dmu_object_alloc(zfsvfs->z_os, 470168404Spjd DMU_OT_PLAIN_FILE_CONTENTS, 0, 471168404Spjd DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 472168404Spjd } 473168404Spjd } 474168404Spjd VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, *oid, NULL, &dbp)); 475168404Spjd dmu_buf_will_dirty(dbp, tx); 476168404Spjd 477168404Spjd /* 478168404Spjd * Initialize the znode physical data to zero. 479168404Spjd */ 480168404Spjd ASSERT(dbp->db_size >= sizeof (znode_phys_t)); 481168404Spjd bzero(dbp->db_data, dbp->db_size); 482168404Spjd pzp = dbp->db_data; 483168404Spjd 484168404Spjd /* 485168404Spjd * If this is the root, fix up the half-initialized parent pointer 486168404Spjd * to reference the just-allocated physical data area. 487168404Spjd */ 488168404Spjd if (flag & IS_ROOT_NODE) { 489168404Spjd dzp->z_phys = pzp; 490168404Spjd dzp->z_id = *oid; 491168404Spjd } 492168404Spjd 493168404Spjd /* 494168404Spjd * If parent is an xattr, so am I. 495168404Spjd */ 496168404Spjd if (dzp->z_phys->zp_flags & ZFS_XATTR) 497168404Spjd flag |= IS_XATTR; 498168404Spjd 499168404Spjd if (vap->va_type == VBLK || vap->va_type == VCHR) { 500168404Spjd pzp->zp_rdev = zfs_expldev(vap->va_rdev); 501168404Spjd } 502168404Spjd 503168404Spjd if (vap->va_type == VDIR) { 504168404Spjd pzp->zp_size = 2; /* contents ("." and "..") */ 505168404Spjd pzp->zp_links = (flag & (IS_ROOT_NODE | IS_XATTR)) ? 2 : 1; 506168404Spjd } 507168404Spjd 508168404Spjd pzp->zp_parent = dzp->z_id; 509168404Spjd if (flag & IS_XATTR) 510168404Spjd pzp->zp_flags |= ZFS_XATTR; 511168404Spjd 512168404Spjd pzp->zp_gen = gen; 513168404Spjd 514168404Spjd ZFS_TIME_ENCODE(&now, pzp->zp_crtime); 515168404Spjd ZFS_TIME_ENCODE(&now, pzp->zp_ctime); 516168404Spjd 517168404Spjd if (vap->va_mask & AT_ATIME) { 518168404Spjd ZFS_TIME_ENCODE(&vap->va_atime, pzp->zp_atime); 519168404Spjd } else { 520168404Spjd ZFS_TIME_ENCODE(&now, pzp->zp_atime); 521168404Spjd } 522168404Spjd 523168404Spjd if (vap->va_mask & AT_MTIME) { 524168404Spjd ZFS_TIME_ENCODE(&vap->va_mtime, pzp->zp_mtime); 525168404Spjd } else { 526168404Spjd ZFS_TIME_ENCODE(&now, pzp->zp_mtime); 527168404Spjd } 528168404Spjd 529168404Spjd pzp->zp_mode = MAKEIMODE(vap->va_type, vap->va_mode); 530168404Spjd zp = zfs_znode_alloc(zfsvfs, dbp, *oid, 0); 531168404Spjd 532168404Spjd zfs_perm_init(zp, dzp, flag, vap, tx, cr); 533168404Spjd 534168404Spjd if (zpp) { 535168404Spjd kmutex_t *hash_mtx = ZFS_OBJ_MUTEX(zp); 536168404Spjd 537168404Spjd mutex_enter(hash_mtx); 538168404Spjd zfs_znode_dmu_init(zp); 539168404Spjd mutex_exit(hash_mtx); 540168404Spjd 541168404Spjd *zpp = zp; 542168404Spjd } else { 543168404Spjd if (ZTOV(zp) != NULL) 544168404Spjd ZTOV(zp)->v_count = 0; 545168404Spjd dmu_buf_rele(dbp, NULL); 546168404Spjd zfs_znode_free(zp); 547168404Spjd } 548168404Spjd} 549168404Spjd 550168404Spjdint 551168404Spjdzfs_zget(zfsvfs_t *zfsvfs, uint64_t obj_num, znode_t **zpp) 552168404Spjd{ 553168404Spjd dmu_object_info_t doi; 554168404Spjd dmu_buf_t *db; 555168404Spjd znode_t *zp; 556168404Spjd vnode_t *vp; 557168404Spjd int err; 558168404Spjd 559168404Spjd *zpp = NULL; 560168404Spjd 561168404Spjd ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num); 562168404Spjd 563168404Spjd err = dmu_bonus_hold(zfsvfs->z_os, obj_num, NULL, &db); 564168404Spjd if (err) { 565168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 566168404Spjd return (err); 567168404Spjd } 568168404Spjd 569168404Spjd dmu_object_info_from_db(db, &doi); 570168404Spjd if (doi.doi_bonus_type != DMU_OT_ZNODE || 571168404Spjd doi.doi_bonus_size < sizeof (znode_phys_t)) { 572168404Spjd dmu_buf_rele(db, NULL); 573168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 574168404Spjd return (EINVAL); 575168404Spjd } 576168404Spjd 577168404Spjd ASSERT(db->db_object == obj_num); 578168404Spjd ASSERT(db->db_offset == -1); 579168404Spjd ASSERT(db->db_data != NULL); 580168404Spjd 581168404Spjd zp = dmu_buf_get_user(db); 582168404Spjd 583168404Spjd if (zp != NULL) { 584168404Spjd mutex_enter(&zp->z_lock); 585168404Spjd 586168404Spjd ASSERT3U(zp->z_id, ==, obj_num); 587168404Spjd if (zp->z_unlinked) { 588168404Spjd dmu_buf_rele(db, NULL); 589168404Spjd mutex_exit(&zp->z_lock); 590168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 591168404Spjd return (ENOENT); 592168404Spjd } else if (zp->z_dbuf_held) { 593168404Spjd dmu_buf_rele(db, NULL); 594168404Spjd } else { 595168404Spjd zp->z_dbuf_held = 1; 596168404Spjd VFS_HOLD(zfsvfs->z_vfs); 597168404Spjd } 598168404Spjd 599168404Spjd if (ZTOV(zp) != NULL) 600168404Spjd VN_HOLD(ZTOV(zp)); 601168404Spjd else { 602168404Spjd err = getnewvnode("zfs", zfsvfs->z_vfs, &zfs_vnodeops, 603168404Spjd &zp->z_vnode); 604168404Spjd ASSERT(err == 0); 605168404Spjd vp = ZTOV(zp); 606168404Spjd vp->v_data = (caddr_t)zp; 607169196Spjd vp->v_vnlock->lk_flags |= LK_CANRECURSE; 608169196Spjd vp->v_vnlock->lk_flags &= ~LK_NOSHARE; 609168404Spjd vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode); 610168404Spjd if (vp->v_type == VDIR) 611168404Spjd zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */ 612168404Spjd err = insmntque(vp, zfsvfs->z_vfs); 613168404Spjd KASSERT(err == 0, ("insmntque() failed: error %d", err)); 614168404Spjd } 615168404Spjd mutex_exit(&zp->z_lock); 616168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 617168404Spjd *zpp = zp; 618168404Spjd return (0); 619168404Spjd } 620168404Spjd 621168404Spjd /* 622168404Spjd * Not found create new znode/vnode 623168404Spjd */ 624168404Spjd zp = zfs_znode_alloc(zfsvfs, db, obj_num, doi.doi_data_block_size); 625168404Spjd ASSERT3U(zp->z_id, ==, obj_num); 626168404Spjd zfs_znode_dmu_init(zp); 627168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 628168404Spjd *zpp = zp; 629168404Spjd return (0); 630168404Spjd} 631168404Spjd 632168404Spjdvoid 633168404Spjdzfs_znode_delete(znode_t *zp, dmu_tx_t *tx) 634168404Spjd{ 635168404Spjd zfsvfs_t *zfsvfs = zp->z_zfsvfs; 636168404Spjd int error; 637168404Spjd 638168404Spjd ZFS_OBJ_HOLD_ENTER(zfsvfs, zp->z_id); 639168404Spjd if (zp->z_phys->zp_acl.z_acl_extern_obj) { 640168404Spjd error = dmu_object_free(zfsvfs->z_os, 641168404Spjd zp->z_phys->zp_acl.z_acl_extern_obj, tx); 642168404Spjd ASSERT3U(error, ==, 0); 643168404Spjd } 644168404Spjd error = dmu_object_free(zfsvfs->z_os, zp->z_id, tx); 645168404Spjd ASSERT3U(error, ==, 0); 646168404Spjd zp->z_dbuf_held = 0; 647168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, zp->z_id); 648168404Spjd dmu_buf_rele(zp->z_dbuf, NULL); 649168404Spjd} 650168404Spjd 651168404Spjdvoid 652168404Spjdzfs_zinactive(znode_t *zp) 653168404Spjd{ 654168404Spjd vnode_t *vp = ZTOV(zp); 655168404Spjd zfsvfs_t *zfsvfs = zp->z_zfsvfs; 656168404Spjd uint64_t z_id = zp->z_id; 657168404Spjd 658168404Spjd ASSERT(zp->z_dbuf_held && zp->z_phys); 659168404Spjd 660168404Spjd /* 661168404Spjd * Don't allow a zfs_zget() while were trying to release this znode 662168404Spjd */ 663168404Spjd ZFS_OBJ_HOLD_ENTER(zfsvfs, z_id); 664168404Spjd 665168404Spjd mutex_enter(&zp->z_lock); 666168404Spjd VI_LOCK(vp); 667168404Spjd if (vp->v_count > 0) { 668168404Spjd /* 669168404Spjd * If the hold count is greater than zero, somebody has 670168404Spjd * obtained a new reference on this znode while we were 671168404Spjd * processing it here, so we are done. 672168404Spjd */ 673168404Spjd VI_UNLOCK(vp); 674168404Spjd mutex_exit(&zp->z_lock); 675168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 676168404Spjd return; 677168404Spjd } 678168404Spjd VI_UNLOCK(vp); 679168404Spjd 680168404Spjd /* 681168404Spjd * If this was the last reference to a file with no links, 682168404Spjd * remove the file from the file system. 683168404Spjd */ 684168404Spjd if (zp->z_unlinked) { 685168404Spjd ZTOV(zp) = NULL; 686168404Spjd mutex_exit(&zp->z_lock); 687168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 688168404Spjd ASSERT(vp->v_count == 0); 689168404Spjd vrecycle(vp, curthread); 690168404Spjd zfs_rmnode(zp); 691168404Spjd VFS_RELE(zfsvfs->z_vfs); 692168404Spjd return; 693168404Spjd } 694168404Spjd ASSERT(zp->z_phys); 695168404Spjd ASSERT(zp->z_dbuf_held); 696168404Spjd mutex_exit(&zp->z_lock); 697168404Spjd ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 698168404Spjd} 699168404Spjd 700168404Spjdvoid 701168404Spjdzfs_znode_free(znode_t *zp) 702168404Spjd{ 703168404Spjd zfsvfs_t *zfsvfs = zp->z_zfsvfs; 704168404Spjd 705168404Spjd mutex_enter(&zfsvfs->z_znodes_lock); 706168404Spjd list_remove(&zfsvfs->z_all_znodes, zp); 707168404Spjd mutex_exit(&zfsvfs->z_znodes_lock); 708168404Spjd 709168404Spjd kmem_cache_free(znode_cache, zp); 710168404Spjd} 711168404Spjd 712168404Spjdvoid 713168404Spjdzfs_time_stamper_locked(znode_t *zp, uint_t flag, dmu_tx_t *tx) 714168404Spjd{ 715168404Spjd timestruc_t now; 716168404Spjd 717168404Spjd ASSERT(MUTEX_HELD(&zp->z_lock)); 718168404Spjd 719168404Spjd gethrestime(&now); 720168404Spjd 721168404Spjd if (tx) { 722168404Spjd dmu_buf_will_dirty(zp->z_dbuf, tx); 723168404Spjd zp->z_atime_dirty = 0; 724168404Spjd zp->z_seq++; 725168404Spjd } else { 726168404Spjd zp->z_atime_dirty = 1; 727168404Spjd } 728168404Spjd 729168404Spjd if (flag & AT_ATIME) 730168404Spjd ZFS_TIME_ENCODE(&now, zp->z_phys->zp_atime); 731168404Spjd 732168404Spjd if (flag & AT_MTIME) 733168404Spjd ZFS_TIME_ENCODE(&now, zp->z_phys->zp_mtime); 734168404Spjd 735168404Spjd if (flag & AT_CTIME) 736168404Spjd ZFS_TIME_ENCODE(&now, zp->z_phys->zp_ctime); 737168404Spjd} 738168404Spjd 739168404Spjd/* 740168404Spjd * Update the requested znode timestamps with the current time. 741168404Spjd * If we are in a transaction, then go ahead and mark the znode 742168404Spjd * dirty in the transaction so the timestamps will go to disk. 743168404Spjd * Otherwise, we will get pushed next time the znode is updated 744168404Spjd * in a transaction, or when this znode eventually goes inactive. 745168404Spjd * 746168404Spjd * Why is this OK? 747168404Spjd * 1 - Only the ACCESS time is ever updated outside of a transaction. 748168404Spjd * 2 - Multiple consecutive updates will be collapsed into a single 749168404Spjd * znode update by the transaction grouping semantics of the DMU. 750168404Spjd */ 751168404Spjdvoid 752168404Spjdzfs_time_stamper(znode_t *zp, uint_t flag, dmu_tx_t *tx) 753168404Spjd{ 754168404Spjd mutex_enter(&zp->z_lock); 755168404Spjd zfs_time_stamper_locked(zp, flag, tx); 756168404Spjd mutex_exit(&zp->z_lock); 757168404Spjd} 758168404Spjd 759168404Spjd/* 760168404Spjd * Grow the block size for a file. 761168404Spjd * 762168404Spjd * IN: zp - znode of file to free data in. 763168404Spjd * size - requested block size 764168404Spjd * tx - open transaction. 765168404Spjd * 766168404Spjd * NOTE: this function assumes that the znode is write locked. 767168404Spjd */ 768168404Spjdvoid 769168404Spjdzfs_grow_blocksize(znode_t *zp, uint64_t size, dmu_tx_t *tx) 770168404Spjd{ 771168404Spjd int error; 772168404Spjd u_longlong_t dummy; 773168404Spjd 774168404Spjd if (size <= zp->z_blksz) 775168404Spjd return; 776168404Spjd /* 777168404Spjd * If the file size is already greater than the current blocksize, 778168404Spjd * we will not grow. If there is more than one block in a file, 779168404Spjd * the blocksize cannot change. 780168404Spjd */ 781168404Spjd if (zp->z_blksz && zp->z_phys->zp_size > zp->z_blksz) 782168404Spjd return; 783168404Spjd 784168404Spjd error = dmu_object_set_blocksize(zp->z_zfsvfs->z_os, zp->z_id, 785168404Spjd size, 0, tx); 786168404Spjd if (error == ENOTSUP) 787168404Spjd return; 788168404Spjd ASSERT3U(error, ==, 0); 789168404Spjd 790168404Spjd /* What blocksize did we actually get? */ 791168404Spjd dmu_object_size_from_db(zp->z_dbuf, &zp->z_blksz, &dummy); 792168404Spjd} 793168404Spjd 794168404Spjd/* 795168404Spjd * Free space in a file. 796168404Spjd * 797168404Spjd * IN: zp - znode of file to free data in. 798168404Spjd * off - start of section to free. 799168404Spjd * len - length of section to free (0 => to EOF). 800168404Spjd * flag - current file open mode flags. 801168404Spjd * 802168404Spjd * RETURN: 0 if success 803168404Spjd * error code if failure 804168404Spjd */ 805168404Spjdint 806168404Spjdzfs_freesp(znode_t *zp, uint64_t off, uint64_t len, int flag, boolean_t log) 807168404Spjd{ 808168404Spjd vnode_t *vp = ZTOV(zp); 809168404Spjd dmu_tx_t *tx; 810168404Spjd zfsvfs_t *zfsvfs = zp->z_zfsvfs; 811168404Spjd zilog_t *zilog = zfsvfs->z_log; 812168404Spjd rl_t *rl; 813168404Spjd uint64_t end = off + len; 814168404Spjd uint64_t size, new_blksz; 815168404Spjd int error; 816168404Spjd 817168404Spjd if (ZTOV(zp)->v_type == VFIFO) 818168404Spjd return (0); 819168404Spjd 820168404Spjd /* 821168404Spjd * If we will change zp_size then lock the whole file, 822168404Spjd * otherwise just lock the range being freed. 823168404Spjd */ 824168404Spjd if (len == 0 || off + len > zp->z_phys->zp_size) { 825168404Spjd rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 826168404Spjd } else { 827168404Spjd rl = zfs_range_lock(zp, off, len, RL_WRITER); 828168404Spjd /* recheck, in case zp_size changed */ 829168404Spjd if (off + len > zp->z_phys->zp_size) { 830168404Spjd /* lost race: file size changed, lock whole file */ 831168404Spjd zfs_range_unlock(rl); 832168404Spjd rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 833168404Spjd } 834168404Spjd } 835168404Spjd 836168404Spjd /* 837168404Spjd * Nothing to do if file already at desired length. 838168404Spjd */ 839168404Spjd size = zp->z_phys->zp_size; 840169195Spjd if (len == 0 && size == off && off != 0) { 841168404Spjd zfs_range_unlock(rl); 842168404Spjd return (0); 843168404Spjd } 844168404Spjd 845168404Spjd tx = dmu_tx_create(zfsvfs->z_os); 846168404Spjd dmu_tx_hold_bonus(tx, zp->z_id); 847168404Spjd new_blksz = 0; 848168404Spjd if (end > size && 849168404Spjd (!ISP2(zp->z_blksz) || zp->z_blksz < zfsvfs->z_max_blksz)) { 850168404Spjd /* 851168404Spjd * We are growing the file past the current block size. 852168404Spjd */ 853168404Spjd if (zp->z_blksz > zp->z_zfsvfs->z_max_blksz) { 854168404Spjd ASSERT(!ISP2(zp->z_blksz)); 855168404Spjd new_blksz = MIN(end, SPA_MAXBLOCKSIZE); 856168404Spjd } else { 857168404Spjd new_blksz = MIN(end, zp->z_zfsvfs->z_max_blksz); 858168404Spjd } 859168404Spjd dmu_tx_hold_write(tx, zp->z_id, 0, MIN(end, new_blksz)); 860168404Spjd } else if (off < size) { 861168404Spjd /* 862168404Spjd * If len == 0, we are truncating the file. 863168404Spjd */ 864168404Spjd dmu_tx_hold_free(tx, zp->z_id, off, len ? len : DMU_OBJECT_END); 865168404Spjd } 866168404Spjd 867168404Spjd error = dmu_tx_assign(tx, zfsvfs->z_assign); 868168404Spjd if (error) { 869168404Spjd if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) 870168404Spjd dmu_tx_wait(tx); 871168404Spjd dmu_tx_abort(tx); 872168404Spjd zfs_range_unlock(rl); 873168404Spjd return (error); 874168404Spjd } 875168404Spjd 876168404Spjd if (new_blksz) 877168404Spjd zfs_grow_blocksize(zp, new_blksz, tx); 878168404Spjd 879168404Spjd if (end > size || len == 0) 880168404Spjd zp->z_phys->zp_size = end; 881168404Spjd 882168404Spjd if (off < size) { 883168404Spjd objset_t *os = zfsvfs->z_os; 884168404Spjd uint64_t rlen = len; 885168404Spjd 886168404Spjd if (len == 0) 887168404Spjd rlen = -1; 888168404Spjd else if (end > size) 889168404Spjd rlen = size - off; 890168404Spjd VERIFY(0 == dmu_free_range(os, zp->z_id, off, rlen, tx)); 891168404Spjd } 892168404Spjd 893168404Spjd if (log) { 894168404Spjd zfs_time_stamper(zp, CONTENT_MODIFIED, tx); 895168404Spjd zfs_log_truncate(zilog, tx, TX_TRUNCATE, zp, off, len); 896168404Spjd } 897168404Spjd 898168404Spjd zfs_range_unlock(rl); 899168404Spjd 900168404Spjd dmu_tx_commit(tx); 901168404Spjd 902168404Spjd /* 903168404Spjd * Clear any mapped pages in the truncated region. This has to 904168404Spjd * happen outside of the transaction to avoid the possibility of 905168404Spjd * a deadlock with someone trying to push a page that we are 906168404Spjd * about to invalidate. 907168404Spjd */ 908168404Spjd rw_enter(&zp->z_map_lock, RW_WRITER); 909168404Spjd if (end > size) 910168404Spjd vnode_pager_setsize(vp, end); 911168404Spjd else if (len == 0) { 912168404Spjd#if 0 913168404Spjd error = vtruncbuf(vp, curthread->td_ucred, curthread, end, PAGE_SIZE); 914168404Spjd#else 915168404Spjd error = vinvalbuf(vp, V_SAVE, curthread, 0, 0); 916168404Spjd vnode_pager_setsize(vp, end); 917168404Spjd#endif 918168404Spjd } 919168404Spjd rw_exit(&zp->z_map_lock); 920168404Spjd 921168404Spjd return (0); 922168404Spjd} 923168404Spjd 924168404Spjdvoid 925168404Spjdzfs_create_fs(objset_t *os, cred_t *cr, dmu_tx_t *tx) 926168404Spjd{ 927168404Spjd zfsvfs_t zfsvfs; 928168404Spjd uint64_t moid, doid, roid = 0; 929168404Spjd uint64_t version = ZPL_VERSION; 930168404Spjd int error; 931168404Spjd znode_t *rootzp = NULL; 932168404Spjd vattr_t vattr; 933168404Spjd 934168404Spjd /* 935168404Spjd * First attempt to create master node. 936168404Spjd */ 937168404Spjd /* 938168404Spjd * In an empty objset, there are no blocks to read and thus 939168404Spjd * there can be no i/o errors (which we assert below). 940168404Spjd */ 941168404Spjd moid = MASTER_NODE_OBJ; 942168404Spjd error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE, 943168404Spjd DMU_OT_NONE, 0, tx); 944168404Spjd ASSERT(error == 0); 945168404Spjd 946168404Spjd /* 947168404Spjd * Set starting attributes. 948168404Spjd */ 949168404Spjd 950168404Spjd error = zap_update(os, moid, ZPL_VERSION_OBJ, 8, 1, &version, tx); 951168404Spjd ASSERT(error == 0); 952168404Spjd 953168404Spjd /* 954168404Spjd * Create a delete queue. 955168404Spjd */ 956168404Spjd doid = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx); 957168404Spjd 958168404Spjd error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &doid, tx); 959168404Spjd ASSERT(error == 0); 960168404Spjd 961168404Spjd /* 962168404Spjd * Create root znode. Create minimal znode/vnode/zfsvfs 963168404Spjd * to allow zfs_mknode to work. 964168404Spjd */ 965168404Spjd vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE; 966168404Spjd vattr.va_type = VDIR; 967168404Spjd vattr.va_mode = S_IFDIR|0755; 968168404Spjd vattr.va_uid = UID_ROOT; 969168404Spjd vattr.va_gid = GID_WHEEL; 970168404Spjd 971168404Spjd rootzp = kmem_cache_alloc(znode_cache, KM_SLEEP); 972168404Spjd zfs_znode_cache_constructor(rootzp, NULL, 0); 973168404Spjd rootzp->z_zfsvfs = &zfsvfs; 974168404Spjd rootzp->z_unlinked = 0; 975168404Spjd rootzp->z_atime_dirty = 0; 976168404Spjd rootzp->z_dbuf_held = 0; 977168404Spjd 978168404Spjd bzero(&zfsvfs, sizeof (zfsvfs_t)); 979168404Spjd 980168404Spjd zfsvfs.z_os = os; 981168404Spjd zfsvfs.z_assign = TXG_NOWAIT; 982168404Spjd zfsvfs.z_parent = &zfsvfs; 983168404Spjd 984168404Spjd mutex_init(&zfsvfs.z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 985168404Spjd list_create(&zfsvfs.z_all_znodes, sizeof (znode_t), 986168404Spjd offsetof(znode_t, z_link_node)); 987168404Spjd 988168404Spjd zfs_mknode(rootzp, &vattr, &roid, tx, cr, IS_ROOT_NODE, NULL, 0); 989168404Spjd ASSERT3U(rootzp->z_id, ==, roid); 990168404Spjd error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &roid, tx); 991168404Spjd ASSERT(error == 0); 992168404Spjd 993169325Spjd mutex_destroy(&zfsvfs.z_znodes_lock); 994168404Spjd kmem_cache_free(znode_cache, rootzp); 995168404Spjd} 996168404Spjd#endif /* _KERNEL */ 997168404Spjd 998168404Spjd/* 999168404Spjd * Given an object number, return its parent object number and whether 1000168404Spjd * or not the object is an extended attribute directory. 1001168404Spjd */ 1002168404Spjdstatic int 1003168404Spjdzfs_obj_to_pobj(objset_t *osp, uint64_t obj, uint64_t *pobjp, int *is_xattrdir) 1004168404Spjd{ 1005168404Spjd dmu_buf_t *db; 1006168404Spjd dmu_object_info_t doi; 1007168404Spjd znode_phys_t *zp; 1008168404Spjd int error; 1009168404Spjd 1010168404Spjd if ((error = dmu_bonus_hold(osp, obj, FTAG, &db)) != 0) 1011168404Spjd return (error); 1012168404Spjd 1013168404Spjd dmu_object_info_from_db(db, &doi); 1014168404Spjd if (doi.doi_bonus_type != DMU_OT_ZNODE || 1015168404Spjd doi.doi_bonus_size < sizeof (znode_phys_t)) { 1016168404Spjd dmu_buf_rele(db, FTAG); 1017168404Spjd return (EINVAL); 1018168404Spjd } 1019168404Spjd 1020168404Spjd zp = db->db_data; 1021168404Spjd *pobjp = zp->zp_parent; 1022168404Spjd *is_xattrdir = ((zp->zp_flags & ZFS_XATTR) != 0) && 1023168404Spjd S_ISDIR(zp->zp_mode); 1024168404Spjd dmu_buf_rele(db, FTAG); 1025168404Spjd 1026168404Spjd return (0); 1027168404Spjd} 1028168404Spjd 1029168404Spjdint 1030168404Spjdzfs_obj_to_path(objset_t *osp, uint64_t obj, char *buf, int len) 1031168404Spjd{ 1032168404Spjd char *path = buf + len - 1; 1033168404Spjd int error; 1034168404Spjd 1035168404Spjd *path = '\0'; 1036168404Spjd 1037168404Spjd for (;;) { 1038168404Spjd uint64_t pobj; 1039168404Spjd char component[MAXNAMELEN + 2]; 1040168404Spjd size_t complen; 1041168404Spjd int is_xattrdir; 1042168404Spjd 1043168404Spjd if ((error = zfs_obj_to_pobj(osp, obj, &pobj, 1044168404Spjd &is_xattrdir)) != 0) 1045168404Spjd break; 1046168404Spjd 1047168404Spjd if (pobj == obj) { 1048168404Spjd if (path[0] != '/') 1049168404Spjd *--path = '/'; 1050168404Spjd break; 1051168404Spjd } 1052168404Spjd 1053168404Spjd component[0] = '/'; 1054168404Spjd if (is_xattrdir) { 1055168404Spjd (void) sprintf(component + 1, "<xattrdir>"); 1056168404Spjd } else { 1057168404Spjd error = zap_value_search(osp, pobj, obj, component + 1); 1058168404Spjd if (error != 0) 1059168404Spjd break; 1060168404Spjd } 1061168404Spjd 1062168404Spjd complen = strlen(component); 1063168404Spjd path -= complen; 1064168404Spjd ASSERT(path >= buf); 1065168404Spjd bcopy(component, path, complen); 1066168404Spjd obj = pobj; 1067168404Spjd } 1068168404Spjd 1069168404Spjd if (error == 0) 1070168404Spjd (void) memmove(buf, path, buf + len - path); 1071168404Spjd return (error); 1072168404Spjd} 1073