1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 21fa9e4066Sahrens /* 2255434c77Sek * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 2675c76197Speteh /* Portions Copyright 2007 Jeremy Teo */ 2775c76197Speteh 28fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 29fa9e4066Sahrens 3055434c77Sek #ifdef _KERNEL 31fa9e4066Sahrens #include <sys/types.h> 32fa9e4066Sahrens #include <sys/param.h> 33fa9e4066Sahrens #include <sys/time.h> 34fa9e4066Sahrens #include <sys/systm.h> 35fa9e4066Sahrens #include <sys/sysmacros.h> 36fa9e4066Sahrens #include <sys/resource.h> 37fa9e4066Sahrens #include <sys/mntent.h> 3872fc53bcSmarks #include <sys/mkdev.h> 39de8267e0Stimh #include <sys/u8_textprep.h> 40fa9e4066Sahrens #include <sys/vfs.h> 41aa59c4cbSrsb #include <sys/vfs_opreg.h> 42fa9e4066Sahrens #include <sys/vnode.h> 43fa9e4066Sahrens #include <sys/file.h> 44fa9e4066Sahrens #include <sys/kmem.h> 45fa9e4066Sahrens #include <sys/errno.h> 46fa9e4066Sahrens #include <sys/unistd.h> 47fa9e4066Sahrens #include <sys/mode.h> 48fa9e4066Sahrens #include <sys/atomic.h> 49fa9e4066Sahrens #include <vm/pvn.h> 50fa9e4066Sahrens #include "fs/fs_subr.h" 51fa9e4066Sahrens #include <sys/zfs_dir.h> 52fa9e4066Sahrens #include <sys/zfs_acl.h> 53fa9e4066Sahrens #include <sys/zfs_ioctl.h> 54104e2ed7Sperrin #include <sys/zfs_rlock.h> 55da6c28aaSamw #include <sys/zfs_fuid.h> 56fa9e4066Sahrens #include <sys/fs/zfs.h> 57da6c28aaSamw #include <sys/kidmap.h> 5855434c77Sek #endif /* _KERNEL */ 5955434c77Sek 6055434c77Sek #include <sys/dmu.h> 6155434c77Sek #include <sys/refcount.h> 6255434c77Sek #include <sys/stat.h> 6355434c77Sek #include <sys/zap.h> 6455434c77Sek #include <sys/zfs_znode.h> 65fa9e4066Sahrens 66de8267e0Stimh #include "zfs_prop.h" 67de8267e0Stimh 6855434c77Sek /* 6955434c77Sek * Functions needed for userland (ie: libzpool) are not put under 7055434c77Sek * #ifdef_KERNEL; the rest of the functions have dependencies 7155434c77Sek * (such as VFS logic) that will not compile easily in userland. 7255434c77Sek */ 7355434c77Sek #ifdef _KERNEL 74fa9e4066Sahrens struct kmem_cache *znode_cache = NULL; 75fa9e4066Sahrens 76fa9e4066Sahrens /*ARGSUSED*/ 77fa9e4066Sahrens static void 78*874395d5Smaybee znode_evict_error(dmu_buf_t *dbuf, void *user_ptr) 79fa9e4066Sahrens { 80*874395d5Smaybee /* 81*874395d5Smaybee * We should never drop all dbuf refs without first clearing 82*874395d5Smaybee * the eviction callback. 83*874395d5Smaybee */ 84*874395d5Smaybee panic("evicting znode %p\n", user_ptr); 85fa9e4066Sahrens } 86fa9e4066Sahrens 87fa9e4066Sahrens /*ARGSUSED*/ 88fa9e4066Sahrens static int 89fa9e4066Sahrens zfs_znode_cache_constructor(void *buf, void *cdrarg, int kmflags) 90fa9e4066Sahrens { 91fa9e4066Sahrens znode_t *zp = buf; 92fa9e4066Sahrens 93fa9e4066Sahrens zp->z_vnode = vn_alloc(KM_SLEEP); 94fa9e4066Sahrens zp->z_vnode->v_data = (caddr_t)zp; 95fa9e4066Sahrens mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL); 96fa9e4066Sahrens rw_init(&zp->z_map_lock, NULL, RW_DEFAULT, NULL); 97104e2ed7Sperrin rw_init(&zp->z_parent_lock, NULL, RW_DEFAULT, NULL); 98af2c4821Smaybee rw_init(&zp->z_name_lock, NULL, RW_DEFAULT, NULL); 99fa9e4066Sahrens mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL); 100104e2ed7Sperrin 101104e2ed7Sperrin mutex_init(&zp->z_range_lock, NULL, MUTEX_DEFAULT, NULL); 102104e2ed7Sperrin avl_create(&zp->z_range_avl, zfs_range_compare, 103104e2ed7Sperrin sizeof (rl_t), offsetof(rl_t, r_node)); 104104e2ed7Sperrin 1054ccbb6e7Sahrens zp->z_dbuf = NULL; 106fa9e4066Sahrens zp->z_dirlocks = 0; 107fa9e4066Sahrens return (0); 108fa9e4066Sahrens } 109fa9e4066Sahrens 110fa9e4066Sahrens /*ARGSUSED*/ 111fa9e4066Sahrens static void 112fa9e4066Sahrens zfs_znode_cache_destructor(void *buf, void *cdarg) 113fa9e4066Sahrens { 114fa9e4066Sahrens znode_t *zp = buf; 115fa9e4066Sahrens 116fa9e4066Sahrens ASSERT(zp->z_dirlocks == 0); 117fa9e4066Sahrens mutex_destroy(&zp->z_lock); 118fa9e4066Sahrens rw_destroy(&zp->z_map_lock); 119104e2ed7Sperrin rw_destroy(&zp->z_parent_lock); 120af2c4821Smaybee rw_destroy(&zp->z_name_lock); 121fa9e4066Sahrens mutex_destroy(&zp->z_acl_lock); 122104e2ed7Sperrin avl_destroy(&zp->z_range_avl); 123c25056deSgw mutex_destroy(&zp->z_range_lock); 124fa9e4066Sahrens 1254ccbb6e7Sahrens ASSERT(zp->z_dbuf == NULL); 126fa9e4066Sahrens ASSERT(ZTOV(zp)->v_count == 0); 127fa9e4066Sahrens vn_free(ZTOV(zp)); 128fa9e4066Sahrens } 129fa9e4066Sahrens 130fa9e4066Sahrens void 131fa9e4066Sahrens zfs_znode_init(void) 132fa9e4066Sahrens { 133fa9e4066Sahrens /* 134fa9e4066Sahrens * Initialize zcache 135fa9e4066Sahrens */ 136fa9e4066Sahrens ASSERT(znode_cache == NULL); 137fa9e4066Sahrens znode_cache = kmem_cache_create("zfs_znode_cache", 138fa9e4066Sahrens sizeof (znode_t), 0, zfs_znode_cache_constructor, 139fa9e4066Sahrens zfs_znode_cache_destructor, NULL, NULL, NULL, 0); 140fa9e4066Sahrens } 141fa9e4066Sahrens 142fa9e4066Sahrens void 143fa9e4066Sahrens zfs_znode_fini(void) 144fa9e4066Sahrens { 145fa9e4066Sahrens /* 146fa9e4066Sahrens * Cleanup vfs & vnode ops 147fa9e4066Sahrens */ 148fa9e4066Sahrens zfs_remove_op_tables(); 149fa9e4066Sahrens 150fa9e4066Sahrens /* 151fa9e4066Sahrens * Cleanup zcache 152fa9e4066Sahrens */ 153fa9e4066Sahrens if (znode_cache) 154fa9e4066Sahrens kmem_cache_destroy(znode_cache); 155fa9e4066Sahrens znode_cache = NULL; 156fa9e4066Sahrens } 157fa9e4066Sahrens 158fa9e4066Sahrens struct vnodeops *zfs_dvnodeops; 159fa9e4066Sahrens struct vnodeops *zfs_fvnodeops; 160fa9e4066Sahrens struct vnodeops *zfs_symvnodeops; 161fa9e4066Sahrens struct vnodeops *zfs_xdvnodeops; 162fa9e4066Sahrens struct vnodeops *zfs_evnodeops; 163fa9e4066Sahrens 164fa9e4066Sahrens void 165fa9e4066Sahrens zfs_remove_op_tables() 166fa9e4066Sahrens { 167fa9e4066Sahrens /* 168fa9e4066Sahrens * Remove vfs ops 169fa9e4066Sahrens */ 170fa9e4066Sahrens ASSERT(zfsfstype); 171fa9e4066Sahrens (void) vfs_freevfsops_by_type(zfsfstype); 172fa9e4066Sahrens zfsfstype = 0; 173fa9e4066Sahrens 174fa9e4066Sahrens /* 175fa9e4066Sahrens * Remove vnode ops 176fa9e4066Sahrens */ 177fa9e4066Sahrens if (zfs_dvnodeops) 178fa9e4066Sahrens vn_freevnodeops(zfs_dvnodeops); 179fa9e4066Sahrens if (zfs_fvnodeops) 180fa9e4066Sahrens vn_freevnodeops(zfs_fvnodeops); 181fa9e4066Sahrens if (zfs_symvnodeops) 182fa9e4066Sahrens vn_freevnodeops(zfs_symvnodeops); 183fa9e4066Sahrens if (zfs_xdvnodeops) 184fa9e4066Sahrens vn_freevnodeops(zfs_xdvnodeops); 185fa9e4066Sahrens if (zfs_evnodeops) 186fa9e4066Sahrens vn_freevnodeops(zfs_evnodeops); 187fa9e4066Sahrens 188fa9e4066Sahrens zfs_dvnodeops = NULL; 189fa9e4066Sahrens zfs_fvnodeops = NULL; 190fa9e4066Sahrens zfs_symvnodeops = NULL; 191fa9e4066Sahrens zfs_xdvnodeops = NULL; 192fa9e4066Sahrens zfs_evnodeops = NULL; 193fa9e4066Sahrens } 194fa9e4066Sahrens 195fa9e4066Sahrens extern const fs_operation_def_t zfs_dvnodeops_template[]; 196fa9e4066Sahrens extern const fs_operation_def_t zfs_fvnodeops_template[]; 197fa9e4066Sahrens extern const fs_operation_def_t zfs_xdvnodeops_template[]; 198fa9e4066Sahrens extern const fs_operation_def_t zfs_symvnodeops_template[]; 199fa9e4066Sahrens extern const fs_operation_def_t zfs_evnodeops_template[]; 200fa9e4066Sahrens 201fa9e4066Sahrens int 202fa9e4066Sahrens zfs_create_op_tables() 203fa9e4066Sahrens { 204fa9e4066Sahrens int error; 205fa9e4066Sahrens 206fa9e4066Sahrens /* 207fa9e4066Sahrens * zfs_dvnodeops can be set if mod_remove() calls mod_installfs() 208fa9e4066Sahrens * due to a failure to remove the the 2nd modlinkage (zfs_modldrv). 209fa9e4066Sahrens * In this case we just return as the ops vectors are already set up. 210fa9e4066Sahrens */ 211fa9e4066Sahrens if (zfs_dvnodeops) 212fa9e4066Sahrens return (0); 213fa9e4066Sahrens 214fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_dvnodeops_template, 215fa9e4066Sahrens &zfs_dvnodeops); 216fa9e4066Sahrens if (error) 217fa9e4066Sahrens return (error); 218fa9e4066Sahrens 219fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_fvnodeops_template, 220fa9e4066Sahrens &zfs_fvnodeops); 221fa9e4066Sahrens if (error) 222fa9e4066Sahrens return (error); 223fa9e4066Sahrens 224fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_symvnodeops_template, 225fa9e4066Sahrens &zfs_symvnodeops); 226fa9e4066Sahrens if (error) 227fa9e4066Sahrens return (error); 228fa9e4066Sahrens 229fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_xdvnodeops_template, 230fa9e4066Sahrens &zfs_xdvnodeops); 231fa9e4066Sahrens if (error) 232fa9e4066Sahrens return (error); 233fa9e4066Sahrens 234fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_evnodeops_template, 235fa9e4066Sahrens &zfs_evnodeops); 236fa9e4066Sahrens 237fa9e4066Sahrens return (error); 238fa9e4066Sahrens } 239fa9e4066Sahrens 240fa9e4066Sahrens /* 241fa9e4066Sahrens * zfs_init_fs - Initialize the zfsvfs struct and the file system 242fa9e4066Sahrens * incore "master" object. Verify version compatibility. 243fa9e4066Sahrens */ 244fa9e4066Sahrens int 245fa9e4066Sahrens zfs_init_fs(zfsvfs_t *zfsvfs, znode_t **zpp, cred_t *cr) 246fa9e4066Sahrens { 247fa9e4066Sahrens extern int zfsfstype; 248fa9e4066Sahrens 249fa9e4066Sahrens objset_t *os = zfsvfs->z_os; 250fa9e4066Sahrens int i, error; 251fa9e4066Sahrens dmu_object_info_t doi; 252a2eea2e1Sahrens uint64_t fsid_guid; 253de8267e0Stimh uint64_t zval; 254fa9e4066Sahrens 255fa9e4066Sahrens *zpp = NULL; 256fa9e4066Sahrens 257fa9e4066Sahrens /* 258fa9e4066Sahrens * XXX - hack to auto-create the pool root filesystem at 259fa9e4066Sahrens * the first attempted mount. 260fa9e4066Sahrens */ 261fa9e4066Sahrens if (dmu_object_info(os, MASTER_NODE_OBJ, &doi) == ENOENT) { 262fa9e4066Sahrens dmu_tx_t *tx = dmu_tx_create(os); 263da6c28aaSamw uint64_t zpl_version; 264de8267e0Stimh nvlist_t *zprops; 265fa9e4066Sahrens 266ea8dc4b6Seschrock dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* master */ 267ea8dc4b6Seschrock dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* del queue */ 268fa9e4066Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); /* root node */ 269fa9e4066Sahrens error = dmu_tx_assign(tx, TXG_WAIT); 270fa9e4066Sahrens ASSERT3U(error, ==, 0); 271da6c28aaSamw if (spa_version(dmu_objset_spa(os)) >= SPA_VERSION_FUID) 272da6c28aaSamw zpl_version = ZPL_VERSION; 273da6c28aaSamw else 274da6c28aaSamw zpl_version = ZPL_VERSION_FUID - 1; 275de8267e0Stimh 276de8267e0Stimh VERIFY(nvlist_alloc(&zprops, NV_UNIQUE_NAME, KM_SLEEP) == 0); 277de8267e0Stimh VERIFY(nvlist_add_uint64(zprops, 278de8267e0Stimh zfs_prop_to_name(ZFS_PROP_VERSION), zpl_version) == 0); 279de8267e0Stimh zfs_create_fs(os, cr, zprops, tx); 280de8267e0Stimh nvlist_free(zprops); 281fa9e4066Sahrens dmu_tx_commit(tx); 282fa9e4066Sahrens } 283fa9e4066Sahrens 284de8267e0Stimh error = zfs_get_zplprop(os, ZFS_PROP_VERSION, &zfsvfs->z_version); 285ea8dc4b6Seschrock if (error) { 286ea8dc4b6Seschrock return (error); 287e7437265Sahrens } else if (zfsvfs->z_version > ZPL_VERSION) { 288fa9e4066Sahrens (void) printf("Mismatched versions: File system " 289b3d911cbStimh "is version %llu on-disk format, which is " 290fa9e4066Sahrens "incompatible with this software version %lld!", 291e7437265Sahrens (u_longlong_t)zfsvfs->z_version, ZPL_VERSION); 292fa9e4066Sahrens return (ENOTSUP); 293fa9e4066Sahrens } 294fa9e4066Sahrens 295de8267e0Stimh if ((error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &zval)) != 0) 296de8267e0Stimh return (error); 297de8267e0Stimh zfsvfs->z_norm = (int)zval; 298de8267e0Stimh if ((error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &zval)) != 0) 299de8267e0Stimh return (error); 300de8267e0Stimh zfsvfs->z_utf8 = (zval != 0); 301de8267e0Stimh if ((error = zfs_get_zplprop(os, ZFS_PROP_CASE, &zval)) != 0) 302de8267e0Stimh return (error); 303de8267e0Stimh zfsvfs->z_case = (uint_t)zval; 304de8267e0Stimh /* 305de8267e0Stimh * Fold case on file systems that are always or sometimes case 306de8267e0Stimh * insensitive. 307de8267e0Stimh */ 308de8267e0Stimh if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE || 309de8267e0Stimh zfsvfs->z_case == ZFS_CASE_MIXED) 310de8267e0Stimh zfsvfs->z_norm |= U8_TEXTPREP_TOUPPER; 311de8267e0Stimh 312fa9e4066Sahrens /* 313fa9e4066Sahrens * The fsid is 64 bits, composed of an 8-bit fs type, which 314fa9e4066Sahrens * separates our fsid from any other filesystem types, and a 315fa9e4066Sahrens * 56-bit objset unique ID. The objset unique ID is unique to 316fa9e4066Sahrens * all objsets open on this system, provided by unique_create(). 317fa9e4066Sahrens * The 8-bit fs type must be put in the low bits of fsid[1] 318fa9e4066Sahrens * because that's where other Solaris filesystems put it. 319fa9e4066Sahrens */ 320a2eea2e1Sahrens fsid_guid = dmu_objset_fsid_guid(os); 321a2eea2e1Sahrens ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0); 322a2eea2e1Sahrens zfsvfs->z_vfs->vfs_fsid.val[0] = fsid_guid; 323a2eea2e1Sahrens zfsvfs->z_vfs->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) | 324fa9e4066Sahrens zfsfstype & 0xFF; 325fa9e4066Sahrens 326893a6d32Sahrens error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, 327893a6d32Sahrens &zfsvfs->z_root); 328ea8dc4b6Seschrock if (error) 329ea8dc4b6Seschrock return (error); 330893a6d32Sahrens ASSERT(zfsvfs->z_root != 0); 331fa9e4066Sahrens 332c25056deSgw error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1, 333c25056deSgw &zfsvfs->z_unlinkedobj); 334c25056deSgw if (error) 335c25056deSgw return (error); 336c25056deSgw 337fa9e4066Sahrens /* 338fa9e4066Sahrens * Initialize zget mutex's 339fa9e4066Sahrens */ 340fa9e4066Sahrens for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 341fa9e4066Sahrens mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL); 342fa9e4066Sahrens 343893a6d32Sahrens error = zfs_zget(zfsvfs, zfsvfs->z_root, zpp); 344c25056deSgw if (error) { 345c25056deSgw /* 346c25056deSgw * On error, we destroy the mutexes here since it's not 347c25056deSgw * possible for the caller to determine if the mutexes were 348c25056deSgw * initialized properly. 349c25056deSgw */ 350c25056deSgw for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 351c25056deSgw mutex_destroy(&zfsvfs->z_hold_mtx[i]); 352fa9e4066Sahrens return (error); 353c25056deSgw } 354893a6d32Sahrens ASSERT3U((*zpp)->z_id, ==, zfsvfs->z_root); 355da6c28aaSamw error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES, 8, 1, 356da6c28aaSamw &zfsvfs->z_fuid_obj); 357da6c28aaSamw if (error == ENOENT) 358da6c28aaSamw error = 0; 359da6c28aaSamw 360fa9e4066Sahrens return (0); 361fa9e4066Sahrens } 362fa9e4066Sahrens 36372fc53bcSmarks /* 36472fc53bcSmarks * define a couple of values we need available 36572fc53bcSmarks * for both 64 and 32 bit environments. 36672fc53bcSmarks */ 36772fc53bcSmarks #ifndef NBITSMINOR64 36872fc53bcSmarks #define NBITSMINOR64 32 36972fc53bcSmarks #endif 37072fc53bcSmarks #ifndef MAXMAJ64 37172fc53bcSmarks #define MAXMAJ64 0xffffffffUL 37272fc53bcSmarks #endif 37372fc53bcSmarks #ifndef MAXMIN64 37472fc53bcSmarks #define MAXMIN64 0xffffffffUL 37572fc53bcSmarks #endif 37672fc53bcSmarks 37772fc53bcSmarks /* 37872fc53bcSmarks * Create special expldev for ZFS private use. 37972fc53bcSmarks * Can't use standard expldev since it doesn't do 38072fc53bcSmarks * what we want. The standard expldev() takes a 38172fc53bcSmarks * dev32_t in LP64 and expands it to a long dev_t. 38272fc53bcSmarks * We need an interface that takes a dev32_t in ILP32 38372fc53bcSmarks * and expands it to a long dev_t. 38472fc53bcSmarks */ 38572fc53bcSmarks static uint64_t 38672fc53bcSmarks zfs_expldev(dev_t dev) 38772fc53bcSmarks { 38872fc53bcSmarks #ifndef _LP64 38972fc53bcSmarks major_t major = (major_t)dev >> NBITSMINOR32 & MAXMAJ32; 39072fc53bcSmarks return (((uint64_t)major << NBITSMINOR64) | 39172fc53bcSmarks ((minor_t)dev & MAXMIN32)); 39272fc53bcSmarks #else 39372fc53bcSmarks return (dev); 39472fc53bcSmarks #endif 39572fc53bcSmarks } 39672fc53bcSmarks 39772fc53bcSmarks /* 39872fc53bcSmarks * Special cmpldev for ZFS private use. 39972fc53bcSmarks * Can't use standard cmpldev since it takes 40072fc53bcSmarks * a long dev_t and compresses it to dev32_t in 40172fc53bcSmarks * LP64. We need to do a compaction of a long dev_t 40272fc53bcSmarks * to a dev32_t in ILP32. 40372fc53bcSmarks */ 40472fc53bcSmarks dev_t 40572fc53bcSmarks zfs_cmpldev(uint64_t dev) 40672fc53bcSmarks { 40772fc53bcSmarks #ifndef _LP64 40872fc53bcSmarks minor_t minor = (minor_t)dev & MAXMIN64; 40972fc53bcSmarks major_t major = (major_t)(dev >> NBITSMINOR64) & MAXMAJ64; 41072fc53bcSmarks 41172fc53bcSmarks if (major > MAXMAJ32 || minor > MAXMIN32) 41272fc53bcSmarks return (NODEV32); 41372fc53bcSmarks 41472fc53bcSmarks return (((dev32_t)major << NBITSMINOR32) | minor); 41572fc53bcSmarks #else 41672fc53bcSmarks return (dev); 41772fc53bcSmarks #endif 41872fc53bcSmarks } 41972fc53bcSmarks 4204ccbb6e7Sahrens static void 4214ccbb6e7Sahrens zfs_znode_dmu_init(znode_t *zp, dmu_buf_t *db) 4224ccbb6e7Sahrens { 4234ccbb6e7Sahrens znode_t *nzp; 4244ccbb6e7Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4254ccbb6e7Sahrens 4264ccbb6e7Sahrens ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zp))); 4274ccbb6e7Sahrens 4284ccbb6e7Sahrens mutex_enter(&zp->z_lock); 4294ccbb6e7Sahrens 4304ccbb6e7Sahrens ASSERT(zp->z_dbuf == NULL); 4314ccbb6e7Sahrens zp->z_dbuf = db; 432*874395d5Smaybee nzp = dmu_buf_set_user_ie(db, zp, &zp->z_phys, znode_evict_error); 4334ccbb6e7Sahrens 4344ccbb6e7Sahrens /* 4354ccbb6e7Sahrens * there should be no 4364ccbb6e7Sahrens * concurrent zgets on this object. 4374ccbb6e7Sahrens */ 4384ccbb6e7Sahrens if (nzp != NULL) 4394ccbb6e7Sahrens panic("existing znode %p for dbuf %p", nzp, db); 4404ccbb6e7Sahrens 4414ccbb6e7Sahrens /* 4424ccbb6e7Sahrens * Slap on VROOT if we are the root znode 4434ccbb6e7Sahrens */ 4444ccbb6e7Sahrens if (zp->z_id == zfsvfs->z_root) 4454ccbb6e7Sahrens ZTOV(zp)->v_flag |= VROOT; 4464ccbb6e7Sahrens 4474ccbb6e7Sahrens mutex_exit(&zp->z_lock); 4484ccbb6e7Sahrens vn_exists(ZTOV(zp)); 4494ccbb6e7Sahrens } 4504ccbb6e7Sahrens 451*874395d5Smaybee void 4524ccbb6e7Sahrens zfs_znode_dmu_fini(znode_t *zp) 4534ccbb6e7Sahrens { 4544ccbb6e7Sahrens dmu_buf_t *db = zp->z_dbuf; 455*874395d5Smaybee ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zp)) || 456*874395d5Smaybee RW_WRITE_HELD(&zp->z_zfsvfs->z_teardown_inactive_lock)); 4574ccbb6e7Sahrens ASSERT(zp->z_dbuf != NULL); 4584ccbb6e7Sahrens zp->z_dbuf = NULL; 459*874395d5Smaybee VERIFY(zp == dmu_buf_update_user(db, zp, NULL, NULL, NULL)); 4604ccbb6e7Sahrens dmu_buf_rele(db, NULL); 4614ccbb6e7Sahrens } 4624ccbb6e7Sahrens 463fa9e4066Sahrens /* 464fa9e4066Sahrens * Construct a new znode/vnode and intialize. 465fa9e4066Sahrens * 466fa9e4066Sahrens * This does not do a call to dmu_set_user() that is 467fa9e4066Sahrens * up to the caller to do, in case you don't want to 468fa9e4066Sahrens * return the znode 469fa9e4066Sahrens */ 470ea8dc4b6Seschrock static znode_t * 4714ccbb6e7Sahrens zfs_znode_alloc(zfsvfs_t *zfsvfs, dmu_buf_t *db, int blksz) 472fa9e4066Sahrens { 473fa9e4066Sahrens znode_t *zp; 474fa9e4066Sahrens vnode_t *vp; 475fa9e4066Sahrens 476fa9e4066Sahrens zp = kmem_cache_alloc(znode_cache, KM_SLEEP); 477fa9e4066Sahrens 478fa9e4066Sahrens ASSERT(zp->z_dirlocks == NULL); 4794ccbb6e7Sahrens ASSERT(zp->z_dbuf == NULL); 480fa9e4066Sahrens 4814ccbb6e7Sahrens zp->z_phys = NULL; 482fa9e4066Sahrens zp->z_zfsvfs = zfsvfs; 483893a6d32Sahrens zp->z_unlinked = 0; 484fa9e4066Sahrens zp->z_atime_dirty = 0; 485fa9e4066Sahrens zp->z_mapcnt = 0; 486fa9e4066Sahrens zp->z_last_itx = 0; 4874ccbb6e7Sahrens zp->z_id = db->db_object; 488fa9e4066Sahrens zp->z_blksz = blksz; 489fa9e4066Sahrens zp->z_seq = 0x7A4653; 49067bd71c6Sperrin zp->z_sync_cnt = 0; 4914ccbb6e7Sahrens 4924ccbb6e7Sahrens vp = ZTOV(zp); 4934ccbb6e7Sahrens vn_reinit(vp); 4944ccbb6e7Sahrens 4954ccbb6e7Sahrens zfs_znode_dmu_init(zp, db); 4964ccbb6e7Sahrens 497f18faf3fSek zp->z_gen = zp->z_phys->zp_gen; 498fa9e4066Sahrens 499fa9e4066Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 500fa9e4066Sahrens list_insert_tail(&zfsvfs->z_all_znodes, zp); 501fa9e4066Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 502fa9e4066Sahrens 503fa9e4066Sahrens vp->v_vfsp = zfsvfs->z_parent->z_vfs; 504fa9e4066Sahrens vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode); 505fa9e4066Sahrens 506fa9e4066Sahrens switch (vp->v_type) { 507fa9e4066Sahrens case VDIR: 508fa9e4066Sahrens if (zp->z_phys->zp_flags & ZFS_XATTR) { 509fa9e4066Sahrens vn_setops(vp, zfs_xdvnodeops); 510fa9e4066Sahrens vp->v_flag |= V_XATTRDIR; 5114ccbb6e7Sahrens } else { 512fa9e4066Sahrens vn_setops(vp, zfs_dvnodeops); 5134ccbb6e7Sahrens } 5147f6e3e7dSperrin zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */ 515fa9e4066Sahrens break; 516fa9e4066Sahrens case VBLK: 517fa9e4066Sahrens case VCHR: 51872fc53bcSmarks vp->v_rdev = zfs_cmpldev(zp->z_phys->zp_rdev); 519fa9e4066Sahrens /*FALLTHROUGH*/ 520fa9e4066Sahrens case VFIFO: 521fa9e4066Sahrens case VSOCK: 522fa9e4066Sahrens case VDOOR: 523fa9e4066Sahrens vn_setops(vp, zfs_fvnodeops); 524fa9e4066Sahrens break; 525fa9e4066Sahrens case VREG: 526fa9e4066Sahrens vp->v_flag |= VMODSORT; 527fa9e4066Sahrens vn_setops(vp, zfs_fvnodeops); 528fa9e4066Sahrens break; 529fa9e4066Sahrens case VLNK: 530fa9e4066Sahrens vn_setops(vp, zfs_symvnodeops); 531fa9e4066Sahrens break; 532fa9e4066Sahrens default: 533fa9e4066Sahrens vn_setops(vp, zfs_evnodeops); 534fa9e4066Sahrens break; 535fa9e4066Sahrens } 536fa9e4066Sahrens 537*874395d5Smaybee VFS_HOLD(zfsvfs->z_vfs); 538fa9e4066Sahrens return (zp); 539fa9e4066Sahrens } 540fa9e4066Sahrens 541fa9e4066Sahrens /* 542fa9e4066Sahrens * Create a new DMU object to hold a zfs znode. 543fa9e4066Sahrens * 544fa9e4066Sahrens * IN: dzp - parent directory for new znode 545fa9e4066Sahrens * vap - file attributes for new znode 546fa9e4066Sahrens * tx - dmu transaction id for zap operations 547fa9e4066Sahrens * cr - credentials of caller 548fa9e4066Sahrens * flag - flags: 549fa9e4066Sahrens * IS_ROOT_NODE - new object will be root 550fa9e4066Sahrens * IS_XATTR - new object is an attribute 551fa9e4066Sahrens * IS_REPLAY - intent log replay 552da6c28aaSamw * bonuslen - length of bonus buffer 553da6c28aaSamw * setaclp - File/Dir initial ACL 554da6c28aaSamw * fuidp - Tracks fuid allocation. 555fa9e4066Sahrens * 5564ccbb6e7Sahrens * OUT: zpp - allocated znode 557fa9e4066Sahrens * 558fa9e4066Sahrens */ 559fa9e4066Sahrens void 5604ccbb6e7Sahrens zfs_mknode(znode_t *dzp, vattr_t *vap, dmu_tx_t *tx, cred_t *cr, 561da6c28aaSamw uint_t flag, znode_t **zpp, int bonuslen, zfs_acl_t *setaclp, 562da6c28aaSamw zfs_fuid_info_t **fuidp) 563fa9e4066Sahrens { 5644ccbb6e7Sahrens dmu_buf_t *db; 565fa9e4066Sahrens znode_phys_t *pzp; 566fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 567fa9e4066Sahrens timestruc_t now; 5684ccbb6e7Sahrens uint64_t gen, obj; 569fa9e4066Sahrens int err; 570fa9e4066Sahrens 571fa9e4066Sahrens ASSERT(vap && (vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE)); 572fa9e4066Sahrens 573fa9e4066Sahrens if (zfsvfs->z_assign >= TXG_INITIAL) { /* ZIL replay */ 5744ccbb6e7Sahrens obj = vap->va_nodeid; 575fa9e4066Sahrens flag |= IS_REPLAY; 576fa9e4066Sahrens now = vap->va_ctime; /* see zfs_replay_create() */ 577fa9e4066Sahrens gen = vap->va_nblocks; /* ditto */ 578fa9e4066Sahrens } else { 5794ccbb6e7Sahrens obj = 0; 580fa9e4066Sahrens gethrestime(&now); 581fa9e4066Sahrens gen = dmu_tx_get_txg(tx); 582fa9e4066Sahrens } 583fa9e4066Sahrens 584fa9e4066Sahrens /* 585fa9e4066Sahrens * Create a new DMU object. 586fa9e4066Sahrens */ 587ea8dc4b6Seschrock /* 588ea8dc4b6Seschrock * There's currently no mechanism for pre-reading the blocks that will 589ea8dc4b6Seschrock * be to needed allocate a new object, so we accept the small chance 590ea8dc4b6Seschrock * that there will be an i/o error and we will fail one of the 591ea8dc4b6Seschrock * assertions below. 592ea8dc4b6Seschrock */ 593fa9e4066Sahrens if (vap->va_type == VDIR) { 594fa9e4066Sahrens if (flag & IS_REPLAY) { 5954ccbb6e7Sahrens err = zap_create_claim_norm(zfsvfs->z_os, obj, 596da6c28aaSamw zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS, 597fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 598fa9e4066Sahrens ASSERT3U(err, ==, 0); 599fa9e4066Sahrens } else { 6004ccbb6e7Sahrens obj = zap_create_norm(zfsvfs->z_os, 601da6c28aaSamw zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS, 602fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 603fa9e4066Sahrens } 604fa9e4066Sahrens } else { 605fa9e4066Sahrens if (flag & IS_REPLAY) { 6064ccbb6e7Sahrens err = dmu_object_claim(zfsvfs->z_os, obj, 607fa9e4066Sahrens DMU_OT_PLAIN_FILE_CONTENTS, 0, 608fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 609fa9e4066Sahrens ASSERT3U(err, ==, 0); 610fa9e4066Sahrens } else { 6114ccbb6e7Sahrens obj = dmu_object_alloc(zfsvfs->z_os, 612fa9e4066Sahrens DMU_OT_PLAIN_FILE_CONTENTS, 0, 613fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 614fa9e4066Sahrens } 615fa9e4066Sahrens } 6164ccbb6e7Sahrens VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, obj, NULL, &db)); 6174ccbb6e7Sahrens dmu_buf_will_dirty(db, tx); 618fa9e4066Sahrens 619fa9e4066Sahrens /* 620fa9e4066Sahrens * Initialize the znode physical data to zero. 621fa9e4066Sahrens */ 6224ccbb6e7Sahrens ASSERT(db->db_size >= sizeof (znode_phys_t)); 6234ccbb6e7Sahrens bzero(db->db_data, db->db_size); 6244ccbb6e7Sahrens pzp = db->db_data; 625fa9e4066Sahrens 626fa9e4066Sahrens /* 627fa9e4066Sahrens * If this is the root, fix up the half-initialized parent pointer 628fa9e4066Sahrens * to reference the just-allocated physical data area. 629fa9e4066Sahrens */ 630fa9e4066Sahrens if (flag & IS_ROOT_NODE) { 631*874395d5Smaybee dzp->z_dbuf = db; 632fa9e4066Sahrens dzp->z_phys = pzp; 6334ccbb6e7Sahrens dzp->z_id = obj; 634fa9e4066Sahrens } 635fa9e4066Sahrens 636fa9e4066Sahrens /* 637fa9e4066Sahrens * If parent is an xattr, so am I. 638fa9e4066Sahrens */ 639fa9e4066Sahrens if (dzp->z_phys->zp_flags & ZFS_XATTR) 640fa9e4066Sahrens flag |= IS_XATTR; 641fa9e4066Sahrens 642fa9e4066Sahrens if (vap->va_type == VBLK || vap->va_type == VCHR) { 64372fc53bcSmarks pzp->zp_rdev = zfs_expldev(vap->va_rdev); 644fa9e4066Sahrens } 645fa9e4066Sahrens 646da6c28aaSamw if (zfsvfs->z_use_fuids) 647da6c28aaSamw pzp->zp_flags = ZFS_ARCHIVE | ZFS_AV_MODIFIED; 648da6c28aaSamw 649fa9e4066Sahrens if (vap->va_type == VDIR) { 650fa9e4066Sahrens pzp->zp_size = 2; /* contents ("." and "..") */ 651fa9e4066Sahrens pzp->zp_links = (flag & (IS_ROOT_NODE | IS_XATTR)) ? 2 : 1; 652fa9e4066Sahrens } 653fa9e4066Sahrens 654fa9e4066Sahrens pzp->zp_parent = dzp->z_id; 655fa9e4066Sahrens if (flag & IS_XATTR) 656fa9e4066Sahrens pzp->zp_flags |= ZFS_XATTR; 657fa9e4066Sahrens 658fa9e4066Sahrens pzp->zp_gen = gen; 659fa9e4066Sahrens 660fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_crtime); 661fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_ctime); 662fa9e4066Sahrens 663fa9e4066Sahrens if (vap->va_mask & AT_ATIME) { 664fa9e4066Sahrens ZFS_TIME_ENCODE(&vap->va_atime, pzp->zp_atime); 665fa9e4066Sahrens } else { 666fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_atime); 667fa9e4066Sahrens } 668fa9e4066Sahrens 669fa9e4066Sahrens if (vap->va_mask & AT_MTIME) { 670fa9e4066Sahrens ZFS_TIME_ENCODE(&vap->va_mtime, pzp->zp_mtime); 671fa9e4066Sahrens } else { 672fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_mtime); 673fa9e4066Sahrens } 674fa9e4066Sahrens 675fa9e4066Sahrens pzp->zp_mode = MAKEIMODE(vap->va_type, vap->va_mode); 676*874395d5Smaybee if (!(flag & IS_ROOT_NODE)) { 677*874395d5Smaybee ZFS_OBJ_HOLD_ENTER(zfsvfs, obj) 678*874395d5Smaybee *zpp = zfs_znode_alloc(zfsvfs, db, 0); 679*874395d5Smaybee ZFS_OBJ_HOLD_EXIT(zfsvfs, obj); 680*874395d5Smaybee } else { 681*874395d5Smaybee /* 682*874395d5Smaybee * If we are creating the root node, the "parent" we 683*874395d5Smaybee * passed in is the znode for the root. 684*874395d5Smaybee */ 685*874395d5Smaybee *zpp = dzp; 686*874395d5Smaybee } 6874ccbb6e7Sahrens zfs_perm_init(*zpp, dzp, flag, vap, tx, cr, setaclp, fuidp); 688fa9e4066Sahrens } 689fa9e4066Sahrens 690da6c28aaSamw void 691da6c28aaSamw zfs_xvattr_set(znode_t *zp, xvattr_t *xvap) 692da6c28aaSamw { 693da6c28aaSamw xoptattr_t *xoap; 694da6c28aaSamw 695da6c28aaSamw xoap = xva_getxoptattr(xvap); 696da6c28aaSamw ASSERT(xoap); 697da6c28aaSamw 698da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) { 699da6c28aaSamw ZFS_TIME_ENCODE(&xoap->xoa_createtime, zp->z_phys->zp_crtime); 700da6c28aaSamw XVA_SET_RTN(xvap, XAT_CREATETIME); 701da6c28aaSamw } 702da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_READONLY)) { 703da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_READONLY, xoap->xoa_readonly); 704da6c28aaSamw XVA_SET_RTN(xvap, XAT_READONLY); 705da6c28aaSamw } 706da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) { 707da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_HIDDEN, xoap->xoa_hidden); 708da6c28aaSamw XVA_SET_RTN(xvap, XAT_HIDDEN); 709da6c28aaSamw } 710da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) { 711da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_SYSTEM, xoap->xoa_system); 712da6c28aaSamw XVA_SET_RTN(xvap, XAT_SYSTEM); 713da6c28aaSamw } 714da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) { 715da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_ARCHIVE, xoap->xoa_archive); 716da6c28aaSamw XVA_SET_RTN(xvap, XAT_ARCHIVE); 717da6c28aaSamw } 718da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) { 719da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_IMMUTABLE, xoap->xoa_immutable); 720da6c28aaSamw XVA_SET_RTN(xvap, XAT_IMMUTABLE); 721da6c28aaSamw } 722da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) { 723da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_NOUNLINK, xoap->xoa_nounlink); 724da6c28aaSamw XVA_SET_RTN(xvap, XAT_NOUNLINK); 725da6c28aaSamw } 726da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) { 727da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_APPENDONLY, xoap->xoa_appendonly); 728da6c28aaSamw XVA_SET_RTN(xvap, XAT_APPENDONLY); 729da6c28aaSamw } 730da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) { 731da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_NODUMP, xoap->xoa_nodump); 732da6c28aaSamw XVA_SET_RTN(xvap, XAT_NODUMP); 733da6c28aaSamw } 734da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) { 735da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_OPAQUE, xoap->xoa_opaque); 736da6c28aaSamw XVA_SET_RTN(xvap, XAT_OPAQUE); 737da6c28aaSamw } 738da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) { 739da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_AV_QUARANTINED, 740da6c28aaSamw xoap->xoa_av_quarantined); 741da6c28aaSamw XVA_SET_RTN(xvap, XAT_AV_QUARANTINED); 742da6c28aaSamw } 743da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) { 744da6c28aaSamw ZFS_ATTR_SET(zp, ZFS_AV_MODIFIED, xoap->xoa_av_modified); 745da6c28aaSamw XVA_SET_RTN(xvap, XAT_AV_MODIFIED); 746da6c28aaSamw } 747da6c28aaSamw if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) { 748da6c28aaSamw (void) memcpy(zp->z_phys + 1, xoap->xoa_av_scanstamp, 749da6c28aaSamw sizeof (xoap->xoa_av_scanstamp)); 750da6c28aaSamw zp->z_phys->zp_flags |= ZFS_BONUS_SCANSTAMP; 751da6c28aaSamw XVA_SET_RTN(xvap, XAT_AV_SCANSTAMP); 752da6c28aaSamw } 753da6c28aaSamw } 754da6c28aaSamw 755fa9e4066Sahrens int 756fa9e4066Sahrens zfs_zget(zfsvfs_t *zfsvfs, uint64_t obj_num, znode_t **zpp) 757fa9e4066Sahrens { 758fa9e4066Sahrens dmu_object_info_t doi; 759fa9e4066Sahrens dmu_buf_t *db; 760fa9e4066Sahrens znode_t *zp; 761ea8dc4b6Seschrock int err; 762fa9e4066Sahrens 763fa9e4066Sahrens *zpp = NULL; 764fa9e4066Sahrens 765fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num); 766fa9e4066Sahrens 767ea8dc4b6Seschrock err = dmu_bonus_hold(zfsvfs->z_os, obj_num, NULL, &db); 768ea8dc4b6Seschrock if (err) { 769fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 770ea8dc4b6Seschrock return (err); 771fa9e4066Sahrens } 772fa9e4066Sahrens 773fa9e4066Sahrens dmu_object_info_from_db(db, &doi); 774fa9e4066Sahrens if (doi.doi_bonus_type != DMU_OT_ZNODE || 775fa9e4066Sahrens doi.doi_bonus_size < sizeof (znode_phys_t)) { 776ea8dc4b6Seschrock dmu_buf_rele(db, NULL); 777fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 778fa9e4066Sahrens return (EINVAL); 779fa9e4066Sahrens } 780fa9e4066Sahrens 781fa9e4066Sahrens zp = dmu_buf_get_user(db); 782fa9e4066Sahrens if (zp != NULL) { 783fa9e4066Sahrens mutex_enter(&zp->z_lock); 784fa9e4066Sahrens 7854ccbb6e7Sahrens /* 7864ccbb6e7Sahrens * Since we do immediate eviction of the z_dbuf, we 7874ccbb6e7Sahrens * should never find a dbuf with a znode that doesn't 7884ccbb6e7Sahrens * know about the dbuf. 7894ccbb6e7Sahrens */ 7904ccbb6e7Sahrens ASSERT3P(zp->z_dbuf, ==, db); 791fa9e4066Sahrens ASSERT3U(zp->z_id, ==, obj_num); 792893a6d32Sahrens if (zp->z_unlinked) { 7934ccbb6e7Sahrens err = ENOENT; 794fa9e4066Sahrens } else { 7954ccbb6e7Sahrens VN_HOLD(ZTOV(zp)); 7964ccbb6e7Sahrens *zpp = zp; 7974ccbb6e7Sahrens err = 0; 798fa9e4066Sahrens } 7994ccbb6e7Sahrens dmu_buf_rele(db, NULL); 800fa9e4066Sahrens mutex_exit(&zp->z_lock); 801ea8dc4b6Seschrock ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 8024ccbb6e7Sahrens return (err); 803fa9e4066Sahrens } 804fa9e4066Sahrens 805fa9e4066Sahrens /* 806fa9e4066Sahrens * Not found create new znode/vnode 807fa9e4066Sahrens */ 8084ccbb6e7Sahrens zp = zfs_znode_alloc(zfsvfs, db, doi.doi_data_block_size); 809ea8dc4b6Seschrock ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 810fa9e4066Sahrens *zpp = zp; 811fa9e4066Sahrens return (0); 812fa9e4066Sahrens } 813fa9e4066Sahrens 814f18faf3fSek int 815f18faf3fSek zfs_rezget(znode_t *zp) 816f18faf3fSek { 817f18faf3fSek zfsvfs_t *zfsvfs = zp->z_zfsvfs; 818f18faf3fSek dmu_object_info_t doi; 819f18faf3fSek dmu_buf_t *db; 820f18faf3fSek uint64_t obj_num = zp->z_id; 821f18faf3fSek int err; 822f18faf3fSek 823f18faf3fSek ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num); 824f18faf3fSek 825f18faf3fSek err = dmu_bonus_hold(zfsvfs->z_os, obj_num, NULL, &db); 826f18faf3fSek if (err) { 827f18faf3fSek ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 828f18faf3fSek return (err); 829f18faf3fSek } 830f18faf3fSek 831f18faf3fSek dmu_object_info_from_db(db, &doi); 832f18faf3fSek if (doi.doi_bonus_type != DMU_OT_ZNODE || 833f18faf3fSek doi.doi_bonus_size < sizeof (znode_phys_t)) { 834f18faf3fSek dmu_buf_rele(db, NULL); 835f18faf3fSek ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 836f18faf3fSek return (EINVAL); 837f18faf3fSek } 838f18faf3fSek 839f18faf3fSek if (((znode_phys_t *)db->db_data)->zp_gen != zp->z_gen) { 840f18faf3fSek dmu_buf_rele(db, NULL); 841f18faf3fSek ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 842f18faf3fSek return (EIO); 843f18faf3fSek } 844f18faf3fSek 8454ccbb6e7Sahrens zfs_znode_dmu_init(zp, db); 846f18faf3fSek zp->z_unlinked = (zp->z_phys->zp_links == 0); 847f18faf3fSek 848f18faf3fSek ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 849f18faf3fSek 850f18faf3fSek return (0); 851f18faf3fSek } 852f18faf3fSek 853fa9e4066Sahrens void 854fa9e4066Sahrens zfs_znode_delete(znode_t *zp, dmu_tx_t *tx) 855fa9e4066Sahrens { 856fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 8574ccbb6e7Sahrens uint64_t obj = zp->z_id; 858fa9e4066Sahrens 8594ccbb6e7Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, obj); 860fa9e4066Sahrens if (zp->z_phys->zp_acl.z_acl_extern_obj) { 8614ccbb6e7Sahrens VERIFY(0 == dmu_object_free(zfsvfs->z_os, 8624ccbb6e7Sahrens zp->z_phys->zp_acl.z_acl_extern_obj, tx)); 863fa9e4066Sahrens } 8644ccbb6e7Sahrens VERIFY(0 == dmu_object_free(zfsvfs->z_os, obj, tx)); 8654ccbb6e7Sahrens zfs_znode_dmu_fini(zp); 8664ccbb6e7Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj); 867*874395d5Smaybee zfs_znode_free(zp); 868fa9e4066Sahrens } 869fa9e4066Sahrens 870fa9e4066Sahrens void 871fa9e4066Sahrens zfs_zinactive(znode_t *zp) 872fa9e4066Sahrens { 873fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 874fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 875fa9e4066Sahrens uint64_t z_id = zp->z_id; 876fa9e4066Sahrens 8774ccbb6e7Sahrens ASSERT(zp->z_dbuf && zp->z_phys); 878fa9e4066Sahrens 879fa9e4066Sahrens /* 880fa9e4066Sahrens * Don't allow a zfs_zget() while were trying to release this znode 881fa9e4066Sahrens */ 882fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, z_id); 883fa9e4066Sahrens 884fa9e4066Sahrens mutex_enter(&zp->z_lock); 885fa9e4066Sahrens mutex_enter(&vp->v_lock); 886fa9e4066Sahrens vp->v_count--; 887fa9e4066Sahrens if (vp->v_count > 0 || vn_has_cached_data(vp)) { 888fa9e4066Sahrens /* 889fa9e4066Sahrens * If the hold count is greater than zero, somebody has 890fa9e4066Sahrens * obtained a new reference on this znode while we were 891fa9e4066Sahrens * processing it here, so we are done. If we still have 892fa9e4066Sahrens * mapped pages then we are also done, since we don't 893fa9e4066Sahrens * want to inactivate the znode until the pages get pushed. 894fa9e4066Sahrens * 895fa9e4066Sahrens * XXX - if vn_has_cached_data(vp) is true, but count == 0, 896fa9e4066Sahrens * this seems like it would leave the znode hanging with 897fa9e4066Sahrens * no chance to go inactive... 898fa9e4066Sahrens */ 899fa9e4066Sahrens mutex_exit(&vp->v_lock); 900fa9e4066Sahrens mutex_exit(&zp->z_lock); 901fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 902fa9e4066Sahrens return; 903fa9e4066Sahrens } 904fa9e4066Sahrens mutex_exit(&vp->v_lock); 905fa9e4066Sahrens 906fa9e4066Sahrens /* 907fa9e4066Sahrens * If this was the last reference to a file with no links, 908fa9e4066Sahrens * remove the file from the file system. 909fa9e4066Sahrens */ 910893a6d32Sahrens if (zp->z_unlinked) { 911fa9e4066Sahrens mutex_exit(&zp->z_lock); 912fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 913893a6d32Sahrens zfs_rmnode(zp); 914fa9e4066Sahrens return; 915fa9e4066Sahrens } 916fa9e4066Sahrens mutex_exit(&zp->z_lock); 9174ccbb6e7Sahrens zfs_znode_dmu_fini(zp); 918fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 919*874395d5Smaybee zfs_znode_free(zp); 920fa9e4066Sahrens } 921fa9e4066Sahrens 922fa9e4066Sahrens void 923fa9e4066Sahrens zfs_znode_free(znode_t *zp) 924fa9e4066Sahrens { 925fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 926fa9e4066Sahrens 927*874395d5Smaybee vn_invalid(ZTOV(zp)); 928*874395d5Smaybee 929fa9e4066Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 930fa9e4066Sahrens list_remove(&zfsvfs->z_all_znodes, zp); 931fa9e4066Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 932fa9e4066Sahrens 933fa9e4066Sahrens kmem_cache_free(znode_cache, zp); 934*874395d5Smaybee 935*874395d5Smaybee VFS_RELE(zfsvfs->z_vfs); 936fa9e4066Sahrens } 937fa9e4066Sahrens 938fa9e4066Sahrens void 939fa9e4066Sahrens zfs_time_stamper_locked(znode_t *zp, uint_t flag, dmu_tx_t *tx) 940fa9e4066Sahrens { 941fa9e4066Sahrens timestruc_t now; 942fa9e4066Sahrens 943fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_lock)); 944fa9e4066Sahrens 945fa9e4066Sahrens gethrestime(&now); 946fa9e4066Sahrens 947fa9e4066Sahrens if (tx) { 948fa9e4066Sahrens dmu_buf_will_dirty(zp->z_dbuf, tx); 949fa9e4066Sahrens zp->z_atime_dirty = 0; 950fa9e4066Sahrens zp->z_seq++; 951fa9e4066Sahrens } else { 952fa9e4066Sahrens zp->z_atime_dirty = 1; 953fa9e4066Sahrens } 954fa9e4066Sahrens 955fa9e4066Sahrens if (flag & AT_ATIME) 956fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_atime); 957fa9e4066Sahrens 958da6c28aaSamw if (flag & AT_MTIME) { 959fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_mtime); 960da6c28aaSamw if (zp->z_zfsvfs->z_use_fuids) 961da6c28aaSamw zp->z_phys->zp_flags |= (ZFS_ARCHIVE | ZFS_AV_MODIFIED); 962da6c28aaSamw } 963fa9e4066Sahrens 964da6c28aaSamw if (flag & AT_CTIME) { 965fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_ctime); 966da6c28aaSamw if (zp->z_zfsvfs->z_use_fuids) 967da6c28aaSamw zp->z_phys->zp_flags |= ZFS_ARCHIVE; 968da6c28aaSamw } 969fa9e4066Sahrens } 970fa9e4066Sahrens 971fa9e4066Sahrens /* 972fa9e4066Sahrens * Update the requested znode timestamps with the current time. 973fa9e4066Sahrens * If we are in a transaction, then go ahead and mark the znode 974fa9e4066Sahrens * dirty in the transaction so the timestamps will go to disk. 975fa9e4066Sahrens * Otherwise, we will get pushed next time the znode is updated 976fa9e4066Sahrens * in a transaction, or when this znode eventually goes inactive. 977fa9e4066Sahrens * 978fa9e4066Sahrens * Why is this OK? 979fa9e4066Sahrens * 1 - Only the ACCESS time is ever updated outside of a transaction. 980fa9e4066Sahrens * 2 - Multiple consecutive updates will be collapsed into a single 981fa9e4066Sahrens * znode update by the transaction grouping semantics of the DMU. 982fa9e4066Sahrens */ 983fa9e4066Sahrens void 984fa9e4066Sahrens zfs_time_stamper(znode_t *zp, uint_t flag, dmu_tx_t *tx) 985fa9e4066Sahrens { 986fa9e4066Sahrens mutex_enter(&zp->z_lock); 987fa9e4066Sahrens zfs_time_stamper_locked(zp, flag, tx); 988fa9e4066Sahrens mutex_exit(&zp->z_lock); 989fa9e4066Sahrens } 990fa9e4066Sahrens 991fa9e4066Sahrens /* 992104e2ed7Sperrin * Grow the block size for a file. 993fa9e4066Sahrens * 994fa9e4066Sahrens * IN: zp - znode of file to free data in. 995fa9e4066Sahrens * size - requested block size 996fa9e4066Sahrens * tx - open transaction. 997fa9e4066Sahrens * 998fa9e4066Sahrens * NOTE: this function assumes that the znode is write locked. 999fa9e4066Sahrens */ 1000104e2ed7Sperrin void 1001fa9e4066Sahrens zfs_grow_blocksize(znode_t *zp, uint64_t size, dmu_tx_t *tx) 1002fa9e4066Sahrens { 1003fa9e4066Sahrens int error; 1004fa9e4066Sahrens u_longlong_t dummy; 1005fa9e4066Sahrens 1006fa9e4066Sahrens if (size <= zp->z_blksz) 1007104e2ed7Sperrin return; 1008fa9e4066Sahrens /* 1009fa9e4066Sahrens * If the file size is already greater than the current blocksize, 1010fa9e4066Sahrens * we will not grow. If there is more than one block in a file, 1011fa9e4066Sahrens * the blocksize cannot change. 1012fa9e4066Sahrens */ 1013fa9e4066Sahrens if (zp->z_blksz && zp->z_phys->zp_size > zp->z_blksz) 1014104e2ed7Sperrin return; 1015fa9e4066Sahrens 1016fa9e4066Sahrens error = dmu_object_set_blocksize(zp->z_zfsvfs->z_os, zp->z_id, 1017fa9e4066Sahrens size, 0, tx); 1018fa9e4066Sahrens if (error == ENOTSUP) 1019104e2ed7Sperrin return; 1020fa9e4066Sahrens ASSERT3U(error, ==, 0); 1021fa9e4066Sahrens 1022fa9e4066Sahrens /* What blocksize did we actually get? */ 1023fa9e4066Sahrens dmu_object_size_from_db(zp->z_dbuf, &zp->z_blksz, &dummy); 1024fa9e4066Sahrens } 1025fa9e4066Sahrens 1026fa9e4066Sahrens /* 1027fa9e4066Sahrens * This is a dummy interface used when pvn_vplist_dirty() should *not* 1028fa9e4066Sahrens * be calling back into the fs for a putpage(). E.g.: when truncating 1029fa9e4066Sahrens * a file, the pages being "thrown away* don't need to be written out. 1030fa9e4066Sahrens */ 1031fa9e4066Sahrens /* ARGSUSED */ 1032fa9e4066Sahrens static int 1033fa9e4066Sahrens zfs_no_putpage(vnode_t *vp, page_t *pp, u_offset_t *offp, size_t *lenp, 1034fa9e4066Sahrens int flags, cred_t *cr) 1035fa9e4066Sahrens { 1036fa9e4066Sahrens ASSERT(0); 1037fa9e4066Sahrens return (0); 1038fa9e4066Sahrens } 1039fa9e4066Sahrens 1040fa9e4066Sahrens /* 1041104e2ed7Sperrin * Free space in a file. 1042fa9e4066Sahrens * 1043fa9e4066Sahrens * IN: zp - znode of file to free data in. 10445730cc9aSmaybee * off - start of section to free. 1045fa9e4066Sahrens * len - length of section to free (0 => to EOF). 1046fa9e4066Sahrens * flag - current file open mode flags. 1047fa9e4066Sahrens * 1048fa9e4066Sahrens * RETURN: 0 if success 1049fa9e4066Sahrens * error code if failure 1050fa9e4066Sahrens */ 1051fa9e4066Sahrens int 10525730cc9aSmaybee zfs_freesp(znode_t *zp, uint64_t off, uint64_t len, int flag, boolean_t log) 1053fa9e4066Sahrens { 1054fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 10555730cc9aSmaybee dmu_tx_t *tx; 10565730cc9aSmaybee zfsvfs_t *zfsvfs = zp->z_zfsvfs; 10575730cc9aSmaybee zilog_t *zilog = zfsvfs->z_log; 10585730cc9aSmaybee rl_t *rl; 10595730cc9aSmaybee uint64_t end = off + len; 10605730cc9aSmaybee uint64_t size, new_blksz; 1061da6c28aaSamw uint64_t pflags = zp->z_phys->zp_flags; 1062104e2ed7Sperrin int error; 1063fa9e4066Sahrens 1064da6c28aaSamw if ((pflags & (ZFS_IMMUTABLE|ZFS_READONLY)) || 1065da6c28aaSamw off < zp->z_phys->zp_size && (pflags & ZFS_APPENDONLY)) 1066da6c28aaSamw return (EPERM); 1067da6c28aaSamw 10688ef9dde0Smarks if (ZTOV(zp)->v_type == VFIFO) 10698ef9dde0Smarks return (0); 10708ef9dde0Smarks 10715730cc9aSmaybee /* 10725730cc9aSmaybee * If we will change zp_size then lock the whole file, 10735730cc9aSmaybee * otherwise just lock the range being freed. 10745730cc9aSmaybee */ 10755730cc9aSmaybee if (len == 0 || off + len > zp->z_phys->zp_size) { 10765730cc9aSmaybee rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 10775730cc9aSmaybee } else { 10785730cc9aSmaybee rl = zfs_range_lock(zp, off, len, RL_WRITER); 10795730cc9aSmaybee /* recheck, in case zp_size changed */ 10805730cc9aSmaybee if (off + len > zp->z_phys->zp_size) { 10815730cc9aSmaybee /* lost race: file size changed, lock whole file */ 1082c5c6ffa0Smaybee zfs_range_unlock(rl); 10835730cc9aSmaybee rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 10845730cc9aSmaybee } 10855730cc9aSmaybee } 10865730cc9aSmaybee 1087fa9e4066Sahrens /* 1088fa9e4066Sahrens * Nothing to do if file already at desired length. 1089fa9e4066Sahrens */ 10905730cc9aSmaybee size = zp->z_phys->zp_size; 109175c76197Speteh if (len == 0 && size == off && off != 0) { 1092c5c6ffa0Smaybee zfs_range_unlock(rl); 1093fa9e4066Sahrens return (0); 1094fa9e4066Sahrens } 1095fa9e4066Sahrens 1096fa9e4066Sahrens /* 1097fa9e4066Sahrens * Check for any locks in the region to be freed. 1098fa9e4066Sahrens */ 1099fa9e4066Sahrens if (MANDLOCK(vp, (mode_t)zp->z_phys->zp_mode)) { 11005730cc9aSmaybee uint64_t start = off; 11015730cc9aSmaybee uint64_t extent = len; 1102fa9e4066Sahrens 11035730cc9aSmaybee if (off > size) { 1104fa9e4066Sahrens start = size; 11055730cc9aSmaybee extent += off - size; 11065730cc9aSmaybee } else if (len == 0) { 11075730cc9aSmaybee extent = size - off; 11085730cc9aSmaybee } 11095730cc9aSmaybee if (error = chklock(vp, FWRITE, start, extent, flag, NULL)) { 1110c5c6ffa0Smaybee zfs_range_unlock(rl); 1111fa9e4066Sahrens return (error); 11125730cc9aSmaybee } 1113fa9e4066Sahrens } 1114fa9e4066Sahrens 11155730cc9aSmaybee tx = dmu_tx_create(zfsvfs->z_os); 11165730cc9aSmaybee dmu_tx_hold_bonus(tx, zp->z_id); 11175730cc9aSmaybee new_blksz = 0; 11185730cc9aSmaybee if (end > size && 11195730cc9aSmaybee (!ISP2(zp->z_blksz) || zp->z_blksz < zfsvfs->z_max_blksz)) { 1120fa9e4066Sahrens /* 1121fa9e4066Sahrens * We are growing the file past the current block size. 1122fa9e4066Sahrens */ 1123fa9e4066Sahrens if (zp->z_blksz > zp->z_zfsvfs->z_max_blksz) { 1124fa9e4066Sahrens ASSERT(!ISP2(zp->z_blksz)); 1125fa9e4066Sahrens new_blksz = MIN(end, SPA_MAXBLOCKSIZE); 1126fa9e4066Sahrens } else { 1127fa9e4066Sahrens new_blksz = MIN(end, zp->z_zfsvfs->z_max_blksz); 1128fa9e4066Sahrens } 11295730cc9aSmaybee dmu_tx_hold_write(tx, zp->z_id, 0, MIN(end, new_blksz)); 11305730cc9aSmaybee } else if (off < size) { 11315730cc9aSmaybee /* 11325730cc9aSmaybee * If len == 0, we are truncating the file. 11335730cc9aSmaybee */ 11345730cc9aSmaybee dmu_tx_hold_free(tx, zp->z_id, off, len ? len : DMU_OBJECT_END); 11355730cc9aSmaybee } 11365730cc9aSmaybee 11375730cc9aSmaybee error = dmu_tx_assign(tx, zfsvfs->z_assign); 11385730cc9aSmaybee if (error) { 11398a2f1b91Sahrens if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) 11408a2f1b91Sahrens dmu_tx_wait(tx); 11415730cc9aSmaybee dmu_tx_abort(tx); 1142c5c6ffa0Smaybee zfs_range_unlock(rl); 11435730cc9aSmaybee return (error); 1144fa9e4066Sahrens } 11455730cc9aSmaybee 11465730cc9aSmaybee if (new_blksz) 11475730cc9aSmaybee zfs_grow_blocksize(zp, new_blksz, tx); 11485730cc9aSmaybee 1149fa9e4066Sahrens if (end > size || len == 0) 1150fa9e4066Sahrens zp->z_phys->zp_size = end; 11515730cc9aSmaybee 11525730cc9aSmaybee if (off < size) { 11535730cc9aSmaybee objset_t *os = zfsvfs->z_os; 11545dc8af33Smaybee uint64_t rlen = len; 11555730cc9aSmaybee 11565730cc9aSmaybee if (len == 0) 11575dc8af33Smaybee rlen = -1; 11585730cc9aSmaybee else if (end > size) 11595dc8af33Smaybee rlen = size - off; 11605dc8af33Smaybee VERIFY(0 == dmu_free_range(os, zp->z_id, off, rlen, tx)); 11615730cc9aSmaybee } 11625730cc9aSmaybee 11635730cc9aSmaybee if (log) { 11645730cc9aSmaybee zfs_time_stamper(zp, CONTENT_MODIFIED, tx); 1165b19a79ecSperrin zfs_log_truncate(zilog, tx, TX_TRUNCATE, zp, off, len); 11665730cc9aSmaybee } 11675730cc9aSmaybee 1168c5c6ffa0Smaybee zfs_range_unlock(rl); 11695730cc9aSmaybee 11705730cc9aSmaybee dmu_tx_commit(tx); 11715730cc9aSmaybee 1172fa9e4066Sahrens /* 11735730cc9aSmaybee * Clear any mapped pages in the truncated region. This has to 11745730cc9aSmaybee * happen outside of the transaction to avoid the possibility of 11755730cc9aSmaybee * a deadlock with someone trying to push a page that we are 11765730cc9aSmaybee * about to invalidate. 1177fa9e4066Sahrens */ 1178fa9e4066Sahrens rw_enter(&zp->z_map_lock, RW_WRITER); 11795730cc9aSmaybee if (off < size && vn_has_cached_data(vp)) { 1180fa9e4066Sahrens page_t *pp; 11815730cc9aSmaybee uint64_t start = off & PAGEMASK; 11825730cc9aSmaybee int poff = off & PAGEOFFSET; 1183fa9e4066Sahrens 11845730cc9aSmaybee if (poff != 0 && (pp = page_lookup(vp, start, SE_SHARED))) { 1185fa9e4066Sahrens /* 1186fa9e4066Sahrens * We need to zero a partial page. 1187fa9e4066Sahrens */ 11885730cc9aSmaybee pagezero(pp, poff, PAGESIZE - poff); 1189fa9e4066Sahrens start += PAGESIZE; 1190fa9e4066Sahrens page_unlock(pp); 1191fa9e4066Sahrens } 1192fa9e4066Sahrens error = pvn_vplist_dirty(vp, start, zfs_no_putpage, 11935730cc9aSmaybee B_INVAL | B_TRUNC, NULL); 1194fa9e4066Sahrens ASSERT(error == 0); 1195fa9e4066Sahrens } 1196fa9e4066Sahrens rw_exit(&zp->z_map_lock); 1197fa9e4066Sahrens 1198fa9e4066Sahrens return (0); 1199fa9e4066Sahrens } 1200fa9e4066Sahrens 1201fa9e4066Sahrens void 1202de8267e0Stimh zfs_create_fs(objset_t *os, cred_t *cr, nvlist_t *zplprops, dmu_tx_t *tx) 1203fa9e4066Sahrens { 1204fa9e4066Sahrens zfsvfs_t zfsvfs; 12054ccbb6e7Sahrens uint64_t moid, doid; 1206de8267e0Stimh uint64_t version = 0; 1207de8267e0Stimh uint64_t sense = ZFS_CASE_SENSITIVE; 1208de8267e0Stimh uint64_t norm = 0; 1209de8267e0Stimh nvpair_t *elem; 1210fa9e4066Sahrens int error; 1211fa9e4066Sahrens znode_t *rootzp = NULL; 1212fa9e4066Sahrens vnode_t *vp; 1213fa9e4066Sahrens vattr_t vattr; 12144ccbb6e7Sahrens znode_t *zp; 1215fa9e4066Sahrens 1216fa9e4066Sahrens /* 1217fa9e4066Sahrens * First attempt to create master node. 1218fa9e4066Sahrens */ 1219ea8dc4b6Seschrock /* 1220ea8dc4b6Seschrock * In an empty objset, there are no blocks to read and thus 1221ea8dc4b6Seschrock * there can be no i/o errors (which we assert below). 1222ea8dc4b6Seschrock */ 1223fa9e4066Sahrens moid = MASTER_NODE_OBJ; 1224fa9e4066Sahrens error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE, 1225fa9e4066Sahrens DMU_OT_NONE, 0, tx); 1226fa9e4066Sahrens ASSERT(error == 0); 1227fa9e4066Sahrens 1228fa9e4066Sahrens /* 1229fa9e4066Sahrens * Set starting attributes. 1230fa9e4066Sahrens */ 1231de8267e0Stimh elem = NULL; 1232de8267e0Stimh while ((elem = nvlist_next_nvpair(zplprops, elem)) != NULL) { 1233de8267e0Stimh /* For the moment we expect all zpl props to be uint64_ts */ 1234de8267e0Stimh uint64_t val; 1235de8267e0Stimh char *name; 1236de8267e0Stimh 1237de8267e0Stimh ASSERT(nvpair_type(elem) == DATA_TYPE_UINT64); 1238b3d911cbStimh VERIFY(nvpair_value_uint64(elem, &val) == 0); 1239de8267e0Stimh name = nvpair_name(elem); 1240de8267e0Stimh if (strcmp(name, zfs_prop_to_name(ZFS_PROP_VERSION)) == 0) { 1241de8267e0Stimh version = val; 1242de8267e0Stimh error = zap_update(os, moid, ZPL_VERSION_STR, 1243de8267e0Stimh 8, 1, &version, tx); 1244de8267e0Stimh } else { 1245de8267e0Stimh error = zap_update(os, moid, name, 8, 1, &val, tx); 1246de8267e0Stimh } 1247de8267e0Stimh ASSERT(error == 0); 1248de8267e0Stimh if (strcmp(name, zfs_prop_to_name(ZFS_PROP_NORMALIZE)) == 0) 1249de8267e0Stimh norm = val; 1250de8267e0Stimh else if (strcmp(name, zfs_prop_to_name(ZFS_PROP_CASE)) == 0) 1251de8267e0Stimh sense = val; 1252de8267e0Stimh } 1253de8267e0Stimh ASSERT(version != 0); 1254fa9e4066Sahrens 1255fa9e4066Sahrens /* 1256fa9e4066Sahrens * Create a delete queue. 1257fa9e4066Sahrens */ 1258893a6d32Sahrens doid = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx); 1259fa9e4066Sahrens 1260893a6d32Sahrens error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &doid, tx); 1261fa9e4066Sahrens ASSERT(error == 0); 1262fa9e4066Sahrens 1263fa9e4066Sahrens /* 1264fa9e4066Sahrens * Create root znode. Create minimal znode/vnode/zfsvfs 1265fa9e4066Sahrens * to allow zfs_mknode to work. 1266fa9e4066Sahrens */ 1267fa9e4066Sahrens vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE; 1268fa9e4066Sahrens vattr.va_type = VDIR; 1269fa9e4066Sahrens vattr.va_mode = S_IFDIR|0755; 1270ecd6cf80Smarks vattr.va_uid = crgetuid(cr); 1271ecd6cf80Smarks vattr.va_gid = crgetgid(cr); 1272fa9e4066Sahrens 1273fa9e4066Sahrens rootzp = kmem_cache_alloc(znode_cache, KM_SLEEP); 1274fa9e4066Sahrens rootzp->z_zfsvfs = &zfsvfs; 1275893a6d32Sahrens rootzp->z_unlinked = 0; 1276fa9e4066Sahrens rootzp->z_atime_dirty = 0; 1277fa9e4066Sahrens 1278fa9e4066Sahrens vp = ZTOV(rootzp); 1279fa9e4066Sahrens vn_reinit(vp); 1280fa9e4066Sahrens vp->v_type = VDIR; 1281fa9e4066Sahrens 1282fa9e4066Sahrens bzero(&zfsvfs, sizeof (zfsvfs_t)); 1283fa9e4066Sahrens 1284fa9e4066Sahrens zfsvfs.z_os = os; 1285fa9e4066Sahrens zfsvfs.z_assign = TXG_NOWAIT; 1286fa9e4066Sahrens zfsvfs.z_parent = &zfsvfs; 1287da6c28aaSamw zfsvfs.z_version = version; 1288da6c28aaSamw zfsvfs.z_use_fuids = USE_FUIDS(version, os); 1289da6c28aaSamw zfsvfs.z_norm = norm; 1290de8267e0Stimh /* 1291de8267e0Stimh * Fold case on file systems that are always or sometimes case 1292de8267e0Stimh * insensitive. 1293de8267e0Stimh */ 1294de8267e0Stimh if (sense == ZFS_CASE_INSENSITIVE || sense == ZFS_CASE_MIXED) 1295de8267e0Stimh zfsvfs.z_norm |= U8_TEXTPREP_TOUPPER; 1296fa9e4066Sahrens 1297fa9e4066Sahrens mutex_init(&zfsvfs.z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 1298fa9e4066Sahrens list_create(&zfsvfs.z_all_znodes, sizeof (znode_t), 1299fa9e4066Sahrens offsetof(znode_t, z_link_node)); 1300fa9e4066Sahrens 1301*874395d5Smaybee zfs_mknode(rootzp, &vattr, tx, cr, IS_ROOT_NODE, &zp, 0, NULL, NULL); 1302*874395d5Smaybee ASSERT3P(zp, ==, rootzp); 13034ccbb6e7Sahrens error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &rootzp->z_id, tx); 1304fa9e4066Sahrens ASSERT(error == 0); 1305fa9e4066Sahrens 1306fa9e4066Sahrens ZTOV(rootzp)->v_count = 0; 1307*874395d5Smaybee dmu_buf_rele(rootzp->z_dbuf, NULL); 1308*874395d5Smaybee rootzp->z_dbuf = NULL; 1309fa9e4066Sahrens kmem_cache_free(znode_cache, rootzp); 1310fa9e4066Sahrens } 131155434c77Sek 1312da6c28aaSamw #endif /* _KERNEL */ 131355434c77Sek /* 131455434c77Sek * Given an object number, return its parent object number and whether 131555434c77Sek * or not the object is an extended attribute directory. 131655434c77Sek */ 131755434c77Sek static int 131855434c77Sek zfs_obj_to_pobj(objset_t *osp, uint64_t obj, uint64_t *pobjp, int *is_xattrdir) 131955434c77Sek { 132055434c77Sek dmu_buf_t *db; 132155434c77Sek dmu_object_info_t doi; 132255434c77Sek znode_phys_t *zp; 132355434c77Sek int error; 132455434c77Sek 132555434c77Sek if ((error = dmu_bonus_hold(osp, obj, FTAG, &db)) != 0) 132655434c77Sek return (error); 132755434c77Sek 132855434c77Sek dmu_object_info_from_db(db, &doi); 132955434c77Sek if (doi.doi_bonus_type != DMU_OT_ZNODE || 133055434c77Sek doi.doi_bonus_size < sizeof (znode_phys_t)) { 133155434c77Sek dmu_buf_rele(db, FTAG); 133255434c77Sek return (EINVAL); 133355434c77Sek } 133455434c77Sek 133555434c77Sek zp = db->db_data; 133655434c77Sek *pobjp = zp->zp_parent; 133755434c77Sek *is_xattrdir = ((zp->zp_flags & ZFS_XATTR) != 0) && 133855434c77Sek S_ISDIR(zp->zp_mode); 133955434c77Sek dmu_buf_rele(db, FTAG); 134055434c77Sek 134155434c77Sek return (0); 134255434c77Sek } 134355434c77Sek 134455434c77Sek int 134555434c77Sek zfs_obj_to_path(objset_t *osp, uint64_t obj, char *buf, int len) 134655434c77Sek { 134755434c77Sek char *path = buf + len - 1; 134855434c77Sek int error; 134955434c77Sek 135055434c77Sek *path = '\0'; 135155434c77Sek 135255434c77Sek for (;;) { 135355434c77Sek uint64_t pobj; 135455434c77Sek char component[MAXNAMELEN + 2]; 135555434c77Sek size_t complen; 135655434c77Sek int is_xattrdir; 135755434c77Sek 135855434c77Sek if ((error = zfs_obj_to_pobj(osp, obj, &pobj, 135955434c77Sek &is_xattrdir)) != 0) 136055434c77Sek break; 136155434c77Sek 136255434c77Sek if (pobj == obj) { 136355434c77Sek if (path[0] != '/') 136455434c77Sek *--path = '/'; 136555434c77Sek break; 136655434c77Sek } 136755434c77Sek 136855434c77Sek component[0] = '/'; 136955434c77Sek if (is_xattrdir) { 137055434c77Sek (void) sprintf(component + 1, "<xattrdir>"); 137155434c77Sek } else { 1372e7437265Sahrens error = zap_value_search(osp, pobj, obj, 1373e7437265Sahrens ZFS_DIRENT_OBJ(-1ULL), component + 1); 137455434c77Sek if (error != 0) 137555434c77Sek break; 137655434c77Sek } 137755434c77Sek 137855434c77Sek complen = strlen(component); 137955434c77Sek path -= complen; 138055434c77Sek ASSERT(path >= buf); 138155434c77Sek bcopy(component, path, complen); 138255434c77Sek obj = pobj; 138355434c77Sek } 138455434c77Sek 138555434c77Sek if (error == 0) 138655434c77Sek (void) memmove(buf, path, buf + len - path); 138755434c77Sek return (error); 138855434c77Sek } 1389