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 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 2855434c77Sek #ifdef _KERNEL 29fa9e4066Sahrens #include <sys/types.h> 30fa9e4066Sahrens #include <sys/param.h> 31fa9e4066Sahrens #include <sys/time.h> 32fa9e4066Sahrens #include <sys/systm.h> 33fa9e4066Sahrens #include <sys/sysmacros.h> 34fa9e4066Sahrens #include <sys/resource.h> 35fa9e4066Sahrens #include <sys/mntent.h> 3672fc53bcSmarks #include <sys/mkdev.h> 37fa9e4066Sahrens #include <sys/vfs.h> 38fa9e4066Sahrens #include <sys/vnode.h> 39fa9e4066Sahrens #include <sys/file.h> 40fa9e4066Sahrens #include <sys/kmem.h> 41fa9e4066Sahrens #include <sys/cmn_err.h> 42fa9e4066Sahrens #include <sys/errno.h> 43fa9e4066Sahrens #include <sys/unistd.h> 44fa9e4066Sahrens #include <sys/mode.h> 45fa9e4066Sahrens #include <sys/atomic.h> 46fa9e4066Sahrens #include <vm/pvn.h> 47fa9e4066Sahrens #include "fs/fs_subr.h" 48fa9e4066Sahrens #include <sys/zfs_dir.h> 49fa9e4066Sahrens #include <sys/zfs_acl.h> 50fa9e4066Sahrens #include <sys/zfs_ioctl.h> 51104e2ed7Sperrin #include <sys/zfs_rlock.h> 52fa9e4066Sahrens #include <sys/fs/zfs.h> 5355434c77Sek #endif /* _KERNEL */ 5455434c77Sek 5555434c77Sek #include <sys/dmu.h> 5655434c77Sek #include <sys/refcount.h> 5755434c77Sek #include <sys/stat.h> 5855434c77Sek #include <sys/zap.h> 5955434c77Sek #include <sys/zfs_znode.h> 60fa9e4066Sahrens 6155434c77Sek /* 6255434c77Sek * Functions needed for userland (ie: libzpool) are not put under 6355434c77Sek * #ifdef_KERNEL; the rest of the functions have dependencies 6455434c77Sek * (such as VFS logic) that will not compile easily in userland. 6555434c77Sek */ 6655434c77Sek #ifdef _KERNEL 67fa9e4066Sahrens struct kmem_cache *znode_cache = NULL; 68fa9e4066Sahrens 69fa9e4066Sahrens /*ARGSUSED*/ 70fa9e4066Sahrens static void 71fa9e4066Sahrens znode_pageout_func(dmu_buf_t *dbuf, void *user_ptr) 72fa9e4066Sahrens { 73fa9e4066Sahrens znode_t *zp = user_ptr; 74fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 75fa9e4066Sahrens 76ea8dc4b6Seschrock mutex_enter(&zp->z_lock); 77fa9e4066Sahrens if (vp->v_count == 0) { 78ea8dc4b6Seschrock mutex_exit(&zp->z_lock); 79fa9e4066Sahrens vn_invalid(vp); 80fa9e4066Sahrens zfs_znode_free(zp); 81ea8dc4b6Seschrock } else { 82ea8dc4b6Seschrock /* signal force unmount that this znode can be freed */ 83ea8dc4b6Seschrock zp->z_dbuf = NULL; 84ea8dc4b6Seschrock mutex_exit(&zp->z_lock); 85fa9e4066Sahrens } 86fa9e4066Sahrens } 87fa9e4066Sahrens 88fa9e4066Sahrens /*ARGSUSED*/ 89fa9e4066Sahrens static int 90fa9e4066Sahrens zfs_znode_cache_constructor(void *buf, void *cdrarg, int kmflags) 91fa9e4066Sahrens { 92fa9e4066Sahrens znode_t *zp = buf; 93fa9e4066Sahrens 94fa9e4066Sahrens zp->z_vnode = vn_alloc(KM_SLEEP); 95fa9e4066Sahrens zp->z_vnode->v_data = (caddr_t)zp; 96fa9e4066Sahrens mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL); 97fa9e4066Sahrens rw_init(&zp->z_map_lock, NULL, RW_DEFAULT, NULL); 98104e2ed7Sperrin rw_init(&zp->z_parent_lock, NULL, RW_DEFAULT, NULL); 99*af2c4821Smaybee rw_init(&zp->z_name_lock, NULL, RW_DEFAULT, NULL); 100fa9e4066Sahrens mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL); 101104e2ed7Sperrin 102104e2ed7Sperrin mutex_init(&zp->z_range_lock, NULL, MUTEX_DEFAULT, NULL); 103104e2ed7Sperrin avl_create(&zp->z_range_avl, zfs_range_compare, 104104e2ed7Sperrin sizeof (rl_t), offsetof(rl_t, r_node)); 105104e2ed7Sperrin 106fa9e4066Sahrens zp->z_dbuf_held = 0; 107fa9e4066Sahrens zp->z_dirlocks = 0; 108fa9e4066Sahrens return (0); 109fa9e4066Sahrens } 110fa9e4066Sahrens 111fa9e4066Sahrens /*ARGSUSED*/ 112fa9e4066Sahrens static void 113fa9e4066Sahrens zfs_znode_cache_destructor(void *buf, void *cdarg) 114fa9e4066Sahrens { 115fa9e4066Sahrens znode_t *zp = buf; 116fa9e4066Sahrens 117fa9e4066Sahrens ASSERT(zp->z_dirlocks == 0); 118fa9e4066Sahrens mutex_destroy(&zp->z_lock); 119fa9e4066Sahrens rw_destroy(&zp->z_map_lock); 120104e2ed7Sperrin rw_destroy(&zp->z_parent_lock); 121*af2c4821Smaybee rw_destroy(&zp->z_name_lock); 122fa9e4066Sahrens mutex_destroy(&zp->z_acl_lock); 123104e2ed7Sperrin avl_destroy(&zp->z_range_avl); 124fa9e4066Sahrens 125fa9e4066Sahrens ASSERT(zp->z_dbuf_held == 0); 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; 250eaca9bbdSeschrock uint64_t version = ZPL_VERSION; 251fa9e4066Sahrens int i, error; 252fa9e4066Sahrens dmu_object_info_t doi; 253a2eea2e1Sahrens uint64_t fsid_guid; 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); 263fa9e4066Sahrens 264ea8dc4b6Seschrock dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* master */ 265ea8dc4b6Seschrock dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, TRUE, NULL); /* del queue */ 266fa9e4066Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); /* root node */ 267fa9e4066Sahrens error = dmu_tx_assign(tx, TXG_WAIT); 268fa9e4066Sahrens ASSERT3U(error, ==, 0); 269fa9e4066Sahrens zfs_create_fs(os, cr, tx); 270fa9e4066Sahrens dmu_tx_commit(tx); 271fa9e4066Sahrens } 272fa9e4066Sahrens 273eaca9bbdSeschrock error = zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_OBJ, 8, 1, 274ea8dc4b6Seschrock &version); 275ea8dc4b6Seschrock if (error) { 276ea8dc4b6Seschrock return (error); 277eaca9bbdSeschrock } else if (version != ZPL_VERSION) { 278fa9e4066Sahrens (void) printf("Mismatched versions: File system " 279fa9e4066Sahrens "is version %lld on-disk format, which is " 280fa9e4066Sahrens "incompatible with this software version %lld!", 281eaca9bbdSeschrock (u_longlong_t)version, ZPL_VERSION); 282fa9e4066Sahrens return (ENOTSUP); 283fa9e4066Sahrens } 284fa9e4066Sahrens 285fa9e4066Sahrens /* 286fa9e4066Sahrens * The fsid is 64 bits, composed of an 8-bit fs type, which 287fa9e4066Sahrens * separates our fsid from any other filesystem types, and a 288fa9e4066Sahrens * 56-bit objset unique ID. The objset unique ID is unique to 289fa9e4066Sahrens * all objsets open on this system, provided by unique_create(). 290fa9e4066Sahrens * The 8-bit fs type must be put in the low bits of fsid[1] 291fa9e4066Sahrens * because that's where other Solaris filesystems put it. 292fa9e4066Sahrens */ 293a2eea2e1Sahrens fsid_guid = dmu_objset_fsid_guid(os); 294a2eea2e1Sahrens ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0); 295a2eea2e1Sahrens zfsvfs->z_vfs->vfs_fsid.val[0] = fsid_guid; 296a2eea2e1Sahrens zfsvfs->z_vfs->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) | 297fa9e4066Sahrens zfsfstype & 0xFF; 298fa9e4066Sahrens 299893a6d32Sahrens error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, 300893a6d32Sahrens &zfsvfs->z_root); 301ea8dc4b6Seschrock if (error) 302ea8dc4b6Seschrock return (error); 303893a6d32Sahrens ASSERT(zfsvfs->z_root != 0); 304fa9e4066Sahrens 305fa9e4066Sahrens /* 306fa9e4066Sahrens * Create the per mount vop tables. 307fa9e4066Sahrens */ 308fa9e4066Sahrens 309fa9e4066Sahrens /* 310fa9e4066Sahrens * Initialize zget mutex's 311fa9e4066Sahrens */ 312fa9e4066Sahrens for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 313fa9e4066Sahrens mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL); 314fa9e4066Sahrens 315893a6d32Sahrens error = zfs_zget(zfsvfs, zfsvfs->z_root, zpp); 316fa9e4066Sahrens if (error) 317fa9e4066Sahrens return (error); 318893a6d32Sahrens ASSERT3U((*zpp)->z_id, ==, zfsvfs->z_root); 319fa9e4066Sahrens 320893a6d32Sahrens error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1, 321893a6d32Sahrens &zfsvfs->z_unlinkedobj); 322ea8dc4b6Seschrock if (error) 323ea8dc4b6Seschrock return (error); 324fa9e4066Sahrens 325fa9e4066Sahrens return (0); 326fa9e4066Sahrens } 327fa9e4066Sahrens 32872fc53bcSmarks /* 32972fc53bcSmarks * define a couple of values we need available 33072fc53bcSmarks * for both 64 and 32 bit environments. 33172fc53bcSmarks */ 33272fc53bcSmarks #ifndef NBITSMINOR64 33372fc53bcSmarks #define NBITSMINOR64 32 33472fc53bcSmarks #endif 33572fc53bcSmarks #ifndef MAXMAJ64 33672fc53bcSmarks #define MAXMAJ64 0xffffffffUL 33772fc53bcSmarks #endif 33872fc53bcSmarks #ifndef MAXMIN64 33972fc53bcSmarks #define MAXMIN64 0xffffffffUL 34072fc53bcSmarks #endif 34172fc53bcSmarks 34272fc53bcSmarks /* 34372fc53bcSmarks * Create special expldev for ZFS private use. 34472fc53bcSmarks * Can't use standard expldev since it doesn't do 34572fc53bcSmarks * what we want. The standard expldev() takes a 34672fc53bcSmarks * dev32_t in LP64 and expands it to a long dev_t. 34772fc53bcSmarks * We need an interface that takes a dev32_t in ILP32 34872fc53bcSmarks * and expands it to a long dev_t. 34972fc53bcSmarks */ 35072fc53bcSmarks static uint64_t 35172fc53bcSmarks zfs_expldev(dev_t dev) 35272fc53bcSmarks { 35372fc53bcSmarks #ifndef _LP64 35472fc53bcSmarks major_t major = (major_t)dev >> NBITSMINOR32 & MAXMAJ32; 35572fc53bcSmarks return (((uint64_t)major << NBITSMINOR64) | 35672fc53bcSmarks ((minor_t)dev & MAXMIN32)); 35772fc53bcSmarks #else 35872fc53bcSmarks return (dev); 35972fc53bcSmarks #endif 36072fc53bcSmarks } 36172fc53bcSmarks 36272fc53bcSmarks /* 36372fc53bcSmarks * Special cmpldev for ZFS private use. 36472fc53bcSmarks * Can't use standard cmpldev since it takes 36572fc53bcSmarks * a long dev_t and compresses it to dev32_t in 36672fc53bcSmarks * LP64. We need to do a compaction of a long dev_t 36772fc53bcSmarks * to a dev32_t in ILP32. 36872fc53bcSmarks */ 36972fc53bcSmarks dev_t 37072fc53bcSmarks zfs_cmpldev(uint64_t dev) 37172fc53bcSmarks { 37272fc53bcSmarks #ifndef _LP64 37372fc53bcSmarks minor_t minor = (minor_t)dev & MAXMIN64; 37472fc53bcSmarks major_t major = (major_t)(dev >> NBITSMINOR64) & MAXMAJ64; 37572fc53bcSmarks 37672fc53bcSmarks if (major > MAXMAJ32 || minor > MAXMIN32) 37772fc53bcSmarks return (NODEV32); 37872fc53bcSmarks 37972fc53bcSmarks return (((dev32_t)major << NBITSMINOR32) | minor); 38072fc53bcSmarks #else 38172fc53bcSmarks return (dev); 38272fc53bcSmarks #endif 38372fc53bcSmarks } 38472fc53bcSmarks 385fa9e4066Sahrens /* 386fa9e4066Sahrens * Construct a new znode/vnode and intialize. 387fa9e4066Sahrens * 388fa9e4066Sahrens * This does not do a call to dmu_set_user() that is 389fa9e4066Sahrens * up to the caller to do, in case you don't want to 390fa9e4066Sahrens * return the znode 391fa9e4066Sahrens */ 392ea8dc4b6Seschrock static znode_t * 393fa9e4066Sahrens zfs_znode_alloc(zfsvfs_t *zfsvfs, dmu_buf_t *db, uint64_t obj_num, int blksz) 394fa9e4066Sahrens { 395fa9e4066Sahrens znode_t *zp; 396fa9e4066Sahrens vnode_t *vp; 397fa9e4066Sahrens 398fa9e4066Sahrens zp = kmem_cache_alloc(znode_cache, KM_SLEEP); 399fa9e4066Sahrens 400fa9e4066Sahrens ASSERT(zp->z_dirlocks == NULL); 401fa9e4066Sahrens 402fa9e4066Sahrens zp->z_phys = db->db_data; 403fa9e4066Sahrens zp->z_zfsvfs = zfsvfs; 404893a6d32Sahrens zp->z_unlinked = 0; 405fa9e4066Sahrens zp->z_atime_dirty = 0; 406fa9e4066Sahrens zp->z_dbuf_held = 0; 407fa9e4066Sahrens zp->z_mapcnt = 0; 408fa9e4066Sahrens zp->z_last_itx = 0; 409fa9e4066Sahrens zp->z_dbuf = db; 410fa9e4066Sahrens zp->z_id = obj_num; 411fa9e4066Sahrens zp->z_blksz = blksz; 412fa9e4066Sahrens zp->z_seq = 0x7A4653; 41367bd71c6Sperrin zp->z_sync_cnt = 0; 414fa9e4066Sahrens 415fa9e4066Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 416fa9e4066Sahrens list_insert_tail(&zfsvfs->z_all_znodes, zp); 417fa9e4066Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 418fa9e4066Sahrens 419fa9e4066Sahrens vp = ZTOV(zp); 420fa9e4066Sahrens vn_reinit(vp); 421fa9e4066Sahrens 422fa9e4066Sahrens vp->v_vfsp = zfsvfs->z_parent->z_vfs; 423fa9e4066Sahrens vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode); 424fa9e4066Sahrens 425fa9e4066Sahrens switch (vp->v_type) { 426fa9e4066Sahrens case VDIR: 427fa9e4066Sahrens if (zp->z_phys->zp_flags & ZFS_XATTR) { 428fa9e4066Sahrens vn_setops(vp, zfs_xdvnodeops); 429fa9e4066Sahrens vp->v_flag |= V_XATTRDIR; 430fa9e4066Sahrens } else 431fa9e4066Sahrens vn_setops(vp, zfs_dvnodeops); 4327f6e3e7dSperrin zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */ 433fa9e4066Sahrens break; 434fa9e4066Sahrens case VBLK: 435fa9e4066Sahrens case VCHR: 43672fc53bcSmarks vp->v_rdev = zfs_cmpldev(zp->z_phys->zp_rdev); 437fa9e4066Sahrens /*FALLTHROUGH*/ 438fa9e4066Sahrens case VFIFO: 439fa9e4066Sahrens case VSOCK: 440fa9e4066Sahrens case VDOOR: 441fa9e4066Sahrens vn_setops(vp, zfs_fvnodeops); 442fa9e4066Sahrens break; 443fa9e4066Sahrens case VREG: 444fa9e4066Sahrens vp->v_flag |= VMODSORT; 445fa9e4066Sahrens vn_setops(vp, zfs_fvnodeops); 446fa9e4066Sahrens break; 447fa9e4066Sahrens case VLNK: 448fa9e4066Sahrens vn_setops(vp, zfs_symvnodeops); 449fa9e4066Sahrens break; 450fa9e4066Sahrens default: 451fa9e4066Sahrens vn_setops(vp, zfs_evnodeops); 452fa9e4066Sahrens break; 453fa9e4066Sahrens } 454fa9e4066Sahrens 455fa9e4066Sahrens return (zp); 456fa9e4066Sahrens } 457fa9e4066Sahrens 458fa9e4066Sahrens static void 459fa9e4066Sahrens zfs_znode_dmu_init(znode_t *zp) 460fa9e4066Sahrens { 461fa9e4066Sahrens znode_t *nzp; 462fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 463fa9e4066Sahrens dmu_buf_t *db = zp->z_dbuf; 464fa9e4066Sahrens 465fa9e4066Sahrens mutex_enter(&zp->z_lock); 466fa9e4066Sahrens 467fa9e4066Sahrens nzp = dmu_buf_set_user(db, zp, &zp->z_phys, znode_pageout_func); 468fa9e4066Sahrens 469fa9e4066Sahrens /* 470fa9e4066Sahrens * there should be no 471fa9e4066Sahrens * concurrent zgets on this object. 472fa9e4066Sahrens */ 473fa9e4066Sahrens ASSERT3P(nzp, ==, NULL); 474fa9e4066Sahrens 475fa9e4066Sahrens /* 476fa9e4066Sahrens * Slap on VROOT if we are the root znode 477fa9e4066Sahrens */ 478fa9e4066Sahrens if (zp->z_id == zfsvfs->z_root) { 479fa9e4066Sahrens ZTOV(zp)->v_flag |= VROOT; 480fa9e4066Sahrens } 481fa9e4066Sahrens 482fa9e4066Sahrens ASSERT(zp->z_dbuf_held == 0); 483fa9e4066Sahrens zp->z_dbuf_held = 1; 484fa9e4066Sahrens VFS_HOLD(zfsvfs->z_vfs); 485fa9e4066Sahrens mutex_exit(&zp->z_lock); 486fa9e4066Sahrens vn_exists(ZTOV(zp)); 487fa9e4066Sahrens } 488fa9e4066Sahrens 489fa9e4066Sahrens /* 490fa9e4066Sahrens * Create a new DMU object to hold a zfs znode. 491fa9e4066Sahrens * 492fa9e4066Sahrens * IN: dzp - parent directory for new znode 493fa9e4066Sahrens * vap - file attributes for new znode 494fa9e4066Sahrens * tx - dmu transaction id for zap operations 495fa9e4066Sahrens * cr - credentials of caller 496fa9e4066Sahrens * flag - flags: 497fa9e4066Sahrens * IS_ROOT_NODE - new object will be root 498fa9e4066Sahrens * IS_XATTR - new object is an attribute 499fa9e4066Sahrens * IS_REPLAY - intent log replay 500fa9e4066Sahrens * 501fa9e4066Sahrens * OUT: oid - ID of created object 502fa9e4066Sahrens * 503fa9e4066Sahrens */ 504fa9e4066Sahrens void 505fa9e4066Sahrens zfs_mknode(znode_t *dzp, vattr_t *vap, uint64_t *oid, dmu_tx_t *tx, cred_t *cr, 506fa9e4066Sahrens uint_t flag, znode_t **zpp, int bonuslen) 507fa9e4066Sahrens { 508fa9e4066Sahrens dmu_buf_t *dbp; 509fa9e4066Sahrens znode_phys_t *pzp; 510fa9e4066Sahrens znode_t *zp; 511fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 512fa9e4066Sahrens timestruc_t now; 513fa9e4066Sahrens uint64_t gen; 514fa9e4066Sahrens int err; 515fa9e4066Sahrens 516fa9e4066Sahrens ASSERT(vap && (vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE)); 517fa9e4066Sahrens 518fa9e4066Sahrens if (zfsvfs->z_assign >= TXG_INITIAL) { /* ZIL replay */ 519fa9e4066Sahrens *oid = vap->va_nodeid; 520fa9e4066Sahrens flag |= IS_REPLAY; 521fa9e4066Sahrens now = vap->va_ctime; /* see zfs_replay_create() */ 522fa9e4066Sahrens gen = vap->va_nblocks; /* ditto */ 523fa9e4066Sahrens } else { 524fa9e4066Sahrens *oid = 0; 525fa9e4066Sahrens gethrestime(&now); 526fa9e4066Sahrens gen = dmu_tx_get_txg(tx); 527fa9e4066Sahrens } 528fa9e4066Sahrens 529fa9e4066Sahrens /* 530fa9e4066Sahrens * Create a new DMU object. 531fa9e4066Sahrens */ 532ea8dc4b6Seschrock /* 533ea8dc4b6Seschrock * There's currently no mechanism for pre-reading the blocks that will 534ea8dc4b6Seschrock * be to needed allocate a new object, so we accept the small chance 535ea8dc4b6Seschrock * that there will be an i/o error and we will fail one of the 536ea8dc4b6Seschrock * assertions below. 537ea8dc4b6Seschrock */ 538fa9e4066Sahrens if (vap->va_type == VDIR) { 539fa9e4066Sahrens if (flag & IS_REPLAY) { 540fa9e4066Sahrens err = zap_create_claim(zfsvfs->z_os, *oid, 541fa9e4066Sahrens DMU_OT_DIRECTORY_CONTENTS, 542fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 543fa9e4066Sahrens ASSERT3U(err, ==, 0); 544fa9e4066Sahrens } else { 545fa9e4066Sahrens *oid = zap_create(zfsvfs->z_os, 546fa9e4066Sahrens DMU_OT_DIRECTORY_CONTENTS, 547fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 548fa9e4066Sahrens } 549fa9e4066Sahrens } else { 550fa9e4066Sahrens if (flag & IS_REPLAY) { 551fa9e4066Sahrens err = dmu_object_claim(zfsvfs->z_os, *oid, 552fa9e4066Sahrens DMU_OT_PLAIN_FILE_CONTENTS, 0, 553fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 554fa9e4066Sahrens ASSERT3U(err, ==, 0); 555fa9e4066Sahrens } else { 556fa9e4066Sahrens *oid = dmu_object_alloc(zfsvfs->z_os, 557fa9e4066Sahrens DMU_OT_PLAIN_FILE_CONTENTS, 0, 558fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 559fa9e4066Sahrens } 560fa9e4066Sahrens } 561ea8dc4b6Seschrock VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, *oid, NULL, &dbp)); 562fa9e4066Sahrens dmu_buf_will_dirty(dbp, tx); 563fa9e4066Sahrens 564fa9e4066Sahrens /* 565fa9e4066Sahrens * Initialize the znode physical data to zero. 566fa9e4066Sahrens */ 567fa9e4066Sahrens ASSERT(dbp->db_size >= sizeof (znode_phys_t)); 568fa9e4066Sahrens bzero(dbp->db_data, dbp->db_size); 569fa9e4066Sahrens pzp = dbp->db_data; 570fa9e4066Sahrens 571fa9e4066Sahrens /* 572fa9e4066Sahrens * If this is the root, fix up the half-initialized parent pointer 573fa9e4066Sahrens * to reference the just-allocated physical data area. 574fa9e4066Sahrens */ 575fa9e4066Sahrens if (flag & IS_ROOT_NODE) { 576fa9e4066Sahrens dzp->z_phys = pzp; 577fa9e4066Sahrens dzp->z_id = *oid; 578fa9e4066Sahrens } 579fa9e4066Sahrens 580fa9e4066Sahrens /* 581fa9e4066Sahrens * If parent is an xattr, so am I. 582fa9e4066Sahrens */ 583fa9e4066Sahrens if (dzp->z_phys->zp_flags & ZFS_XATTR) 584fa9e4066Sahrens flag |= IS_XATTR; 585fa9e4066Sahrens 586fa9e4066Sahrens if (vap->va_type == VBLK || vap->va_type == VCHR) { 58772fc53bcSmarks pzp->zp_rdev = zfs_expldev(vap->va_rdev); 588fa9e4066Sahrens } 589fa9e4066Sahrens 590fa9e4066Sahrens if (vap->va_type == VDIR) { 591fa9e4066Sahrens pzp->zp_size = 2; /* contents ("." and "..") */ 592fa9e4066Sahrens pzp->zp_links = (flag & (IS_ROOT_NODE | IS_XATTR)) ? 2 : 1; 593fa9e4066Sahrens } 594fa9e4066Sahrens 595fa9e4066Sahrens pzp->zp_parent = dzp->z_id; 596fa9e4066Sahrens if (flag & IS_XATTR) 597fa9e4066Sahrens pzp->zp_flags |= ZFS_XATTR; 598fa9e4066Sahrens 599fa9e4066Sahrens pzp->zp_gen = gen; 600fa9e4066Sahrens 601fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_crtime); 602fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_ctime); 603fa9e4066Sahrens 604fa9e4066Sahrens if (vap->va_mask & AT_ATIME) { 605fa9e4066Sahrens ZFS_TIME_ENCODE(&vap->va_atime, pzp->zp_atime); 606fa9e4066Sahrens } else { 607fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_atime); 608fa9e4066Sahrens } 609fa9e4066Sahrens 610fa9e4066Sahrens if (vap->va_mask & AT_MTIME) { 611fa9e4066Sahrens ZFS_TIME_ENCODE(&vap->va_mtime, pzp->zp_mtime); 612fa9e4066Sahrens } else { 613fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_mtime); 614fa9e4066Sahrens } 615fa9e4066Sahrens 616fa9e4066Sahrens pzp->zp_mode = MAKEIMODE(vap->va_type, vap->va_mode); 617fa9e4066Sahrens zp = zfs_znode_alloc(zfsvfs, dbp, *oid, 0); 618fa9e4066Sahrens 619fa9e4066Sahrens zfs_perm_init(zp, dzp, flag, vap, tx, cr); 620fa9e4066Sahrens 621fa9e4066Sahrens if (zpp) { 622fa9e4066Sahrens kmutex_t *hash_mtx = ZFS_OBJ_MUTEX(zp); 623fa9e4066Sahrens 624fa9e4066Sahrens mutex_enter(hash_mtx); 625fa9e4066Sahrens zfs_znode_dmu_init(zp); 626ea8dc4b6Seschrock mutex_exit(hash_mtx); 627ea8dc4b6Seschrock 628fa9e4066Sahrens *zpp = zp; 629fa9e4066Sahrens } else { 630fa9e4066Sahrens ZTOV(zp)->v_count = 0; 631ea8dc4b6Seschrock dmu_buf_rele(dbp, NULL); 632fa9e4066Sahrens zfs_znode_free(zp); 633fa9e4066Sahrens } 634fa9e4066Sahrens } 635fa9e4066Sahrens 636fa9e4066Sahrens int 637fa9e4066Sahrens zfs_zget(zfsvfs_t *zfsvfs, uint64_t obj_num, znode_t **zpp) 638fa9e4066Sahrens { 639fa9e4066Sahrens dmu_object_info_t doi; 640fa9e4066Sahrens dmu_buf_t *db; 641fa9e4066Sahrens znode_t *zp; 642ea8dc4b6Seschrock int err; 643fa9e4066Sahrens 644fa9e4066Sahrens *zpp = NULL; 645fa9e4066Sahrens 646fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num); 647fa9e4066Sahrens 648ea8dc4b6Seschrock err = dmu_bonus_hold(zfsvfs->z_os, obj_num, NULL, &db); 649ea8dc4b6Seschrock if (err) { 650fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 651ea8dc4b6Seschrock return (err); 652fa9e4066Sahrens } 653fa9e4066Sahrens 654fa9e4066Sahrens dmu_object_info_from_db(db, &doi); 655fa9e4066Sahrens if (doi.doi_bonus_type != DMU_OT_ZNODE || 656fa9e4066Sahrens doi.doi_bonus_size < sizeof (znode_phys_t)) { 657ea8dc4b6Seschrock dmu_buf_rele(db, NULL); 658fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 659fa9e4066Sahrens return (EINVAL); 660fa9e4066Sahrens } 661fa9e4066Sahrens 662fa9e4066Sahrens ASSERT(db->db_object == obj_num); 663fa9e4066Sahrens ASSERT(db->db_offset == -1); 664fa9e4066Sahrens ASSERT(db->db_data != NULL); 665fa9e4066Sahrens 666fa9e4066Sahrens zp = dmu_buf_get_user(db); 667fa9e4066Sahrens 668fa9e4066Sahrens if (zp != NULL) { 669fa9e4066Sahrens mutex_enter(&zp->z_lock); 670fa9e4066Sahrens 671fa9e4066Sahrens ASSERT3U(zp->z_id, ==, obj_num); 672893a6d32Sahrens if (zp->z_unlinked) { 673ea8dc4b6Seschrock dmu_buf_rele(db, NULL); 674fa9e4066Sahrens mutex_exit(&zp->z_lock); 675fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 676fa9e4066Sahrens return (ENOENT); 677fa9e4066Sahrens } else if (zp->z_dbuf_held) { 678ea8dc4b6Seschrock dmu_buf_rele(db, NULL); 679fa9e4066Sahrens } else { 680fa9e4066Sahrens zp->z_dbuf_held = 1; 681fa9e4066Sahrens VFS_HOLD(zfsvfs->z_vfs); 682fa9e4066Sahrens } 683fa9e4066Sahrens 684ea8dc4b6Seschrock 685fa9e4066Sahrens VN_HOLD(ZTOV(zp)); 686fa9e4066Sahrens mutex_exit(&zp->z_lock); 687ea8dc4b6Seschrock ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 688fa9e4066Sahrens *zpp = zp; 689fa9e4066Sahrens return (0); 690fa9e4066Sahrens } 691fa9e4066Sahrens 692fa9e4066Sahrens /* 693fa9e4066Sahrens * Not found create new znode/vnode 694fa9e4066Sahrens */ 695fa9e4066Sahrens zp = zfs_znode_alloc(zfsvfs, db, obj_num, doi.doi_data_block_size); 696fa9e4066Sahrens ASSERT3U(zp->z_id, ==, obj_num); 697fa9e4066Sahrens zfs_znode_dmu_init(zp); 698ea8dc4b6Seschrock ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 699fa9e4066Sahrens *zpp = zp; 700fa9e4066Sahrens return (0); 701fa9e4066Sahrens } 702fa9e4066Sahrens 703fa9e4066Sahrens void 704fa9e4066Sahrens zfs_znode_delete(znode_t *zp, dmu_tx_t *tx) 705fa9e4066Sahrens { 706fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 707fa9e4066Sahrens int error; 708fa9e4066Sahrens 709fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, zp->z_id); 710fa9e4066Sahrens if (zp->z_phys->zp_acl.z_acl_extern_obj) { 711fa9e4066Sahrens error = dmu_object_free(zfsvfs->z_os, 712fa9e4066Sahrens zp->z_phys->zp_acl.z_acl_extern_obj, tx); 713fa9e4066Sahrens ASSERT3U(error, ==, 0); 714fa9e4066Sahrens } 715fa9e4066Sahrens error = dmu_object_free(zfsvfs->z_os, zp->z_id, tx); 716fa9e4066Sahrens ASSERT3U(error, ==, 0); 717fa9e4066Sahrens zp->z_dbuf_held = 0; 718fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, zp->z_id); 719ea8dc4b6Seschrock dmu_buf_rele(zp->z_dbuf, NULL); 720fa9e4066Sahrens } 721fa9e4066Sahrens 722fa9e4066Sahrens void 723fa9e4066Sahrens zfs_zinactive(znode_t *zp) 724fa9e4066Sahrens { 725fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 726fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 727fa9e4066Sahrens uint64_t z_id = zp->z_id; 728fa9e4066Sahrens 729fa9e4066Sahrens ASSERT(zp->z_dbuf_held && zp->z_phys); 730fa9e4066Sahrens 731fa9e4066Sahrens /* 732fa9e4066Sahrens * Don't allow a zfs_zget() while were trying to release this znode 733fa9e4066Sahrens */ 734fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, z_id); 735fa9e4066Sahrens 736fa9e4066Sahrens mutex_enter(&zp->z_lock); 737fa9e4066Sahrens mutex_enter(&vp->v_lock); 738fa9e4066Sahrens vp->v_count--; 739fa9e4066Sahrens if (vp->v_count > 0 || vn_has_cached_data(vp)) { 740fa9e4066Sahrens /* 741fa9e4066Sahrens * If the hold count is greater than zero, somebody has 742fa9e4066Sahrens * obtained a new reference on this znode while we were 743fa9e4066Sahrens * processing it here, so we are done. If we still have 744fa9e4066Sahrens * mapped pages then we are also done, since we don't 745fa9e4066Sahrens * want to inactivate the znode until the pages get pushed. 746fa9e4066Sahrens * 747fa9e4066Sahrens * XXX - if vn_has_cached_data(vp) is true, but count == 0, 748fa9e4066Sahrens * this seems like it would leave the znode hanging with 749fa9e4066Sahrens * no chance to go inactive... 750fa9e4066Sahrens */ 751fa9e4066Sahrens mutex_exit(&vp->v_lock); 752fa9e4066Sahrens mutex_exit(&zp->z_lock); 753fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 754fa9e4066Sahrens return; 755fa9e4066Sahrens } 756fa9e4066Sahrens mutex_exit(&vp->v_lock); 757fa9e4066Sahrens 758fa9e4066Sahrens /* 759fa9e4066Sahrens * If this was the last reference to a file with no links, 760fa9e4066Sahrens * remove the file from the file system. 761fa9e4066Sahrens */ 762893a6d32Sahrens if (zp->z_unlinked) { 763fa9e4066Sahrens mutex_exit(&zp->z_lock); 764fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 765893a6d32Sahrens zfs_rmnode(zp); 766fa9e4066Sahrens VFS_RELE(zfsvfs->z_vfs); 767fa9e4066Sahrens return; 768fa9e4066Sahrens } 769ea8dc4b6Seschrock ASSERT(zp->z_phys); 770ea8dc4b6Seschrock ASSERT(zp->z_dbuf_held); 771fa9e4066Sahrens 772ea8dc4b6Seschrock zp->z_dbuf_held = 0; 773fa9e4066Sahrens mutex_exit(&zp->z_lock); 774ea8dc4b6Seschrock dmu_buf_rele(zp->z_dbuf, NULL); 775fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 776ea8dc4b6Seschrock VFS_RELE(zfsvfs->z_vfs); 777fa9e4066Sahrens } 778fa9e4066Sahrens 779fa9e4066Sahrens void 780fa9e4066Sahrens zfs_znode_free(znode_t *zp) 781fa9e4066Sahrens { 782fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 783fa9e4066Sahrens 784fa9e4066Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 785fa9e4066Sahrens list_remove(&zfsvfs->z_all_znodes, zp); 786fa9e4066Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 787fa9e4066Sahrens 788fa9e4066Sahrens kmem_cache_free(znode_cache, zp); 789fa9e4066Sahrens } 790fa9e4066Sahrens 791fa9e4066Sahrens void 792fa9e4066Sahrens zfs_time_stamper_locked(znode_t *zp, uint_t flag, dmu_tx_t *tx) 793fa9e4066Sahrens { 794fa9e4066Sahrens timestruc_t now; 795fa9e4066Sahrens 796fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_lock)); 797fa9e4066Sahrens 798fa9e4066Sahrens gethrestime(&now); 799fa9e4066Sahrens 800fa9e4066Sahrens if (tx) { 801fa9e4066Sahrens dmu_buf_will_dirty(zp->z_dbuf, tx); 802fa9e4066Sahrens zp->z_atime_dirty = 0; 803fa9e4066Sahrens zp->z_seq++; 804fa9e4066Sahrens } else { 805fa9e4066Sahrens zp->z_atime_dirty = 1; 806fa9e4066Sahrens } 807fa9e4066Sahrens 808fa9e4066Sahrens if (flag & AT_ATIME) 809fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_atime); 810fa9e4066Sahrens 811fa9e4066Sahrens if (flag & AT_MTIME) 812fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_mtime); 813fa9e4066Sahrens 814fa9e4066Sahrens if (flag & AT_CTIME) 815fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_ctime); 816fa9e4066Sahrens } 817fa9e4066Sahrens 818fa9e4066Sahrens /* 819fa9e4066Sahrens * Update the requested znode timestamps with the current time. 820fa9e4066Sahrens * If we are in a transaction, then go ahead and mark the znode 821fa9e4066Sahrens * dirty in the transaction so the timestamps will go to disk. 822fa9e4066Sahrens * Otherwise, we will get pushed next time the znode is updated 823fa9e4066Sahrens * in a transaction, or when this znode eventually goes inactive. 824fa9e4066Sahrens * 825fa9e4066Sahrens * Why is this OK? 826fa9e4066Sahrens * 1 - Only the ACCESS time is ever updated outside of a transaction. 827fa9e4066Sahrens * 2 - Multiple consecutive updates will be collapsed into a single 828fa9e4066Sahrens * znode update by the transaction grouping semantics of the DMU. 829fa9e4066Sahrens */ 830fa9e4066Sahrens void 831fa9e4066Sahrens zfs_time_stamper(znode_t *zp, uint_t flag, dmu_tx_t *tx) 832fa9e4066Sahrens { 833fa9e4066Sahrens mutex_enter(&zp->z_lock); 834fa9e4066Sahrens zfs_time_stamper_locked(zp, flag, tx); 835fa9e4066Sahrens mutex_exit(&zp->z_lock); 836fa9e4066Sahrens } 837fa9e4066Sahrens 838fa9e4066Sahrens /* 839104e2ed7Sperrin * Grow the block size for a file. 840fa9e4066Sahrens * 841fa9e4066Sahrens * IN: zp - znode of file to free data in. 842fa9e4066Sahrens * size - requested block size 843fa9e4066Sahrens * tx - open transaction. 844fa9e4066Sahrens * 845fa9e4066Sahrens * NOTE: this function assumes that the znode is write locked. 846fa9e4066Sahrens */ 847104e2ed7Sperrin void 848fa9e4066Sahrens zfs_grow_blocksize(znode_t *zp, uint64_t size, dmu_tx_t *tx) 849fa9e4066Sahrens { 850fa9e4066Sahrens int error; 851fa9e4066Sahrens u_longlong_t dummy; 852fa9e4066Sahrens 853fa9e4066Sahrens if (size <= zp->z_blksz) 854104e2ed7Sperrin return; 855fa9e4066Sahrens /* 856fa9e4066Sahrens * If the file size is already greater than the current blocksize, 857fa9e4066Sahrens * we will not grow. If there is more than one block in a file, 858fa9e4066Sahrens * the blocksize cannot change. 859fa9e4066Sahrens */ 860fa9e4066Sahrens if (zp->z_blksz && zp->z_phys->zp_size > zp->z_blksz) 861104e2ed7Sperrin return; 862fa9e4066Sahrens 863fa9e4066Sahrens error = dmu_object_set_blocksize(zp->z_zfsvfs->z_os, zp->z_id, 864fa9e4066Sahrens size, 0, tx); 865fa9e4066Sahrens if (error == ENOTSUP) 866104e2ed7Sperrin return; 867fa9e4066Sahrens ASSERT3U(error, ==, 0); 868fa9e4066Sahrens 869fa9e4066Sahrens /* What blocksize did we actually get? */ 870fa9e4066Sahrens dmu_object_size_from_db(zp->z_dbuf, &zp->z_blksz, &dummy); 871fa9e4066Sahrens } 872fa9e4066Sahrens 873fa9e4066Sahrens /* 874fa9e4066Sahrens * This is a dummy interface used when pvn_vplist_dirty() should *not* 875fa9e4066Sahrens * be calling back into the fs for a putpage(). E.g.: when truncating 876fa9e4066Sahrens * a file, the pages being "thrown away* don't need to be written out. 877fa9e4066Sahrens */ 878fa9e4066Sahrens /* ARGSUSED */ 879fa9e4066Sahrens static int 880fa9e4066Sahrens zfs_no_putpage(vnode_t *vp, page_t *pp, u_offset_t *offp, size_t *lenp, 881fa9e4066Sahrens int flags, cred_t *cr) 882fa9e4066Sahrens { 883fa9e4066Sahrens ASSERT(0); 884fa9e4066Sahrens return (0); 885fa9e4066Sahrens } 886fa9e4066Sahrens 887fa9e4066Sahrens /* 888104e2ed7Sperrin * Free space in a file. 889fa9e4066Sahrens * 890fa9e4066Sahrens * IN: zp - znode of file to free data in. 8915730cc9aSmaybee * off - start of section to free. 892fa9e4066Sahrens * len - length of section to free (0 => to EOF). 893fa9e4066Sahrens * flag - current file open mode flags. 894fa9e4066Sahrens * 895fa9e4066Sahrens * RETURN: 0 if success 896fa9e4066Sahrens * error code if failure 897fa9e4066Sahrens */ 898fa9e4066Sahrens int 8995730cc9aSmaybee zfs_freesp(znode_t *zp, uint64_t off, uint64_t len, int flag, boolean_t log) 900fa9e4066Sahrens { 901fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 9025730cc9aSmaybee dmu_tx_t *tx; 9035730cc9aSmaybee zfsvfs_t *zfsvfs = zp->z_zfsvfs; 9045730cc9aSmaybee zilog_t *zilog = zfsvfs->z_log; 9055730cc9aSmaybee rl_t *rl; 9065730cc9aSmaybee uint64_t end = off + len; 9075730cc9aSmaybee uint64_t size, new_blksz; 908104e2ed7Sperrin int error; 909fa9e4066Sahrens 9108ef9dde0Smarks if (ZTOV(zp)->v_type == VFIFO) 9118ef9dde0Smarks return (0); 9128ef9dde0Smarks 9135730cc9aSmaybee /* 9145730cc9aSmaybee * If we will change zp_size then lock the whole file, 9155730cc9aSmaybee * otherwise just lock the range being freed. 9165730cc9aSmaybee */ 9175730cc9aSmaybee if (len == 0 || off + len > zp->z_phys->zp_size) { 9185730cc9aSmaybee rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 9195730cc9aSmaybee } else { 9205730cc9aSmaybee rl = zfs_range_lock(zp, off, len, RL_WRITER); 9215730cc9aSmaybee /* recheck, in case zp_size changed */ 9225730cc9aSmaybee if (off + len > zp->z_phys->zp_size) { 9235730cc9aSmaybee /* lost race: file size changed, lock whole file */ 924c5c6ffa0Smaybee zfs_range_unlock(rl); 9255730cc9aSmaybee rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 9265730cc9aSmaybee } 9275730cc9aSmaybee } 9285730cc9aSmaybee 929fa9e4066Sahrens /* 930fa9e4066Sahrens * Nothing to do if file already at desired length. 931fa9e4066Sahrens */ 9325730cc9aSmaybee size = zp->z_phys->zp_size; 9335730cc9aSmaybee if (len == 0 && size == off) { 934c5c6ffa0Smaybee zfs_range_unlock(rl); 935fa9e4066Sahrens return (0); 936fa9e4066Sahrens } 937fa9e4066Sahrens 938fa9e4066Sahrens /* 939fa9e4066Sahrens * Check for any locks in the region to be freed. 940fa9e4066Sahrens */ 941fa9e4066Sahrens if (MANDLOCK(vp, (mode_t)zp->z_phys->zp_mode)) { 9425730cc9aSmaybee uint64_t start = off; 9435730cc9aSmaybee uint64_t extent = len; 944fa9e4066Sahrens 9455730cc9aSmaybee if (off > size) { 946fa9e4066Sahrens start = size; 9475730cc9aSmaybee extent += off - size; 9485730cc9aSmaybee } else if (len == 0) { 9495730cc9aSmaybee extent = size - off; 9505730cc9aSmaybee } 9515730cc9aSmaybee if (error = chklock(vp, FWRITE, start, extent, flag, NULL)) { 952c5c6ffa0Smaybee zfs_range_unlock(rl); 953fa9e4066Sahrens return (error); 9545730cc9aSmaybee } 955fa9e4066Sahrens } 956fa9e4066Sahrens 9575730cc9aSmaybee tx = dmu_tx_create(zfsvfs->z_os); 9585730cc9aSmaybee dmu_tx_hold_bonus(tx, zp->z_id); 9595730cc9aSmaybee new_blksz = 0; 9605730cc9aSmaybee if (end > size && 9615730cc9aSmaybee (!ISP2(zp->z_blksz) || zp->z_blksz < zfsvfs->z_max_blksz)) { 962fa9e4066Sahrens /* 963fa9e4066Sahrens * We are growing the file past the current block size. 964fa9e4066Sahrens */ 965fa9e4066Sahrens if (zp->z_blksz > zp->z_zfsvfs->z_max_blksz) { 966fa9e4066Sahrens ASSERT(!ISP2(zp->z_blksz)); 967fa9e4066Sahrens new_blksz = MIN(end, SPA_MAXBLOCKSIZE); 968fa9e4066Sahrens } else { 969fa9e4066Sahrens new_blksz = MIN(end, zp->z_zfsvfs->z_max_blksz); 970fa9e4066Sahrens } 9715730cc9aSmaybee dmu_tx_hold_write(tx, zp->z_id, 0, MIN(end, new_blksz)); 9725730cc9aSmaybee } else if (off < size) { 9735730cc9aSmaybee /* 9745730cc9aSmaybee * If len == 0, we are truncating the file. 9755730cc9aSmaybee */ 9765730cc9aSmaybee dmu_tx_hold_free(tx, zp->z_id, off, len ? len : DMU_OBJECT_END); 9775730cc9aSmaybee } 9785730cc9aSmaybee 9795730cc9aSmaybee error = dmu_tx_assign(tx, zfsvfs->z_assign); 9805730cc9aSmaybee if (error) { 9818a2f1b91Sahrens if (error == ERESTART && zfsvfs->z_assign == TXG_NOWAIT) 9828a2f1b91Sahrens dmu_tx_wait(tx); 9835730cc9aSmaybee dmu_tx_abort(tx); 984c5c6ffa0Smaybee zfs_range_unlock(rl); 9855730cc9aSmaybee return (error); 986fa9e4066Sahrens } 9875730cc9aSmaybee 9885730cc9aSmaybee if (new_blksz) 9895730cc9aSmaybee zfs_grow_blocksize(zp, new_blksz, tx); 9905730cc9aSmaybee 991fa9e4066Sahrens if (end > size || len == 0) 992fa9e4066Sahrens zp->z_phys->zp_size = end; 9935730cc9aSmaybee 9945730cc9aSmaybee if (off < size) { 9955730cc9aSmaybee objset_t *os = zfsvfs->z_os; 9965dc8af33Smaybee uint64_t rlen = len; 9975730cc9aSmaybee 9985730cc9aSmaybee if (len == 0) 9995dc8af33Smaybee rlen = -1; 10005730cc9aSmaybee else if (end > size) 10015dc8af33Smaybee rlen = size - off; 10025dc8af33Smaybee VERIFY(0 == dmu_free_range(os, zp->z_id, off, rlen, tx)); 10035730cc9aSmaybee } 10045730cc9aSmaybee 10055730cc9aSmaybee if (log) { 10065730cc9aSmaybee zfs_time_stamper(zp, CONTENT_MODIFIED, tx); 1007b19a79ecSperrin zfs_log_truncate(zilog, tx, TX_TRUNCATE, zp, off, len); 10085730cc9aSmaybee } 10095730cc9aSmaybee 1010c5c6ffa0Smaybee zfs_range_unlock(rl); 10115730cc9aSmaybee 10125730cc9aSmaybee dmu_tx_commit(tx); 10135730cc9aSmaybee 1014fa9e4066Sahrens /* 10155730cc9aSmaybee * Clear any mapped pages in the truncated region. This has to 10165730cc9aSmaybee * happen outside of the transaction to avoid the possibility of 10175730cc9aSmaybee * a deadlock with someone trying to push a page that we are 10185730cc9aSmaybee * about to invalidate. 1019fa9e4066Sahrens */ 1020fa9e4066Sahrens rw_enter(&zp->z_map_lock, RW_WRITER); 10215730cc9aSmaybee if (off < size && vn_has_cached_data(vp)) { 1022fa9e4066Sahrens page_t *pp; 10235730cc9aSmaybee uint64_t start = off & PAGEMASK; 10245730cc9aSmaybee int poff = off & PAGEOFFSET; 1025fa9e4066Sahrens 10265730cc9aSmaybee if (poff != 0 && (pp = page_lookup(vp, start, SE_SHARED))) { 1027fa9e4066Sahrens /* 1028fa9e4066Sahrens * We need to zero a partial page. 1029fa9e4066Sahrens */ 10305730cc9aSmaybee pagezero(pp, poff, PAGESIZE - poff); 1031fa9e4066Sahrens start += PAGESIZE; 1032fa9e4066Sahrens page_unlock(pp); 1033fa9e4066Sahrens } 1034fa9e4066Sahrens error = pvn_vplist_dirty(vp, start, zfs_no_putpage, 10355730cc9aSmaybee B_INVAL | B_TRUNC, NULL); 1036fa9e4066Sahrens ASSERT(error == 0); 1037fa9e4066Sahrens } 1038fa9e4066Sahrens rw_exit(&zp->z_map_lock); 1039fa9e4066Sahrens 1040fa9e4066Sahrens return (0); 1041fa9e4066Sahrens } 1042fa9e4066Sahrens 1043fa9e4066Sahrens void 1044fa9e4066Sahrens zfs_create_fs(objset_t *os, cred_t *cr, dmu_tx_t *tx) 1045fa9e4066Sahrens { 1046fa9e4066Sahrens zfsvfs_t zfsvfs; 1047fa9e4066Sahrens uint64_t moid, doid, roid = 0; 1048eaca9bbdSeschrock uint64_t version = ZPL_VERSION; 1049fa9e4066Sahrens int error; 1050fa9e4066Sahrens znode_t *rootzp = NULL; 1051fa9e4066Sahrens vnode_t *vp; 1052fa9e4066Sahrens vattr_t vattr; 1053fa9e4066Sahrens 1054fa9e4066Sahrens /* 1055fa9e4066Sahrens * First attempt to create master node. 1056fa9e4066Sahrens */ 1057ea8dc4b6Seschrock /* 1058ea8dc4b6Seschrock * In an empty objset, there are no blocks to read and thus 1059ea8dc4b6Seschrock * there can be no i/o errors (which we assert below). 1060ea8dc4b6Seschrock */ 1061fa9e4066Sahrens moid = MASTER_NODE_OBJ; 1062fa9e4066Sahrens error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE, 1063fa9e4066Sahrens DMU_OT_NONE, 0, tx); 1064fa9e4066Sahrens ASSERT(error == 0); 1065fa9e4066Sahrens 1066fa9e4066Sahrens /* 1067fa9e4066Sahrens * Set starting attributes. 1068fa9e4066Sahrens */ 1069fa9e4066Sahrens 1070eaca9bbdSeschrock error = zap_update(os, moid, ZPL_VERSION_OBJ, 8, 1, &version, tx); 1071fa9e4066Sahrens ASSERT(error == 0); 1072fa9e4066Sahrens 1073fa9e4066Sahrens /* 1074fa9e4066Sahrens * Create a delete queue. 1075fa9e4066Sahrens */ 1076893a6d32Sahrens doid = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx); 1077fa9e4066Sahrens 1078893a6d32Sahrens error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &doid, tx); 1079fa9e4066Sahrens ASSERT(error == 0); 1080fa9e4066Sahrens 1081fa9e4066Sahrens /* 1082fa9e4066Sahrens * Create root znode. Create minimal znode/vnode/zfsvfs 1083fa9e4066Sahrens * to allow zfs_mknode to work. 1084fa9e4066Sahrens */ 1085fa9e4066Sahrens vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE; 1086fa9e4066Sahrens vattr.va_type = VDIR; 1087fa9e4066Sahrens vattr.va_mode = S_IFDIR|0755; 1088fa9e4066Sahrens vattr.va_uid = 0; 1089fa9e4066Sahrens vattr.va_gid = 3; 1090fa9e4066Sahrens 1091fa9e4066Sahrens rootzp = kmem_cache_alloc(znode_cache, KM_SLEEP); 1092fa9e4066Sahrens rootzp->z_zfsvfs = &zfsvfs; 1093893a6d32Sahrens rootzp->z_unlinked = 0; 1094fa9e4066Sahrens rootzp->z_atime_dirty = 0; 1095fa9e4066Sahrens rootzp->z_dbuf_held = 0; 1096fa9e4066Sahrens 1097fa9e4066Sahrens vp = ZTOV(rootzp); 1098fa9e4066Sahrens vn_reinit(vp); 1099fa9e4066Sahrens vp->v_type = VDIR; 1100fa9e4066Sahrens 1101fa9e4066Sahrens bzero(&zfsvfs, sizeof (zfsvfs_t)); 1102fa9e4066Sahrens 1103fa9e4066Sahrens zfsvfs.z_os = os; 1104fa9e4066Sahrens zfsvfs.z_assign = TXG_NOWAIT; 1105fa9e4066Sahrens zfsvfs.z_parent = &zfsvfs; 1106fa9e4066Sahrens 1107fa9e4066Sahrens mutex_init(&zfsvfs.z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 1108fa9e4066Sahrens list_create(&zfsvfs.z_all_znodes, sizeof (znode_t), 1109fa9e4066Sahrens offsetof(znode_t, z_link_node)); 1110fa9e4066Sahrens 1111fa9e4066Sahrens zfs_mknode(rootzp, &vattr, &roid, tx, cr, IS_ROOT_NODE, NULL, 0); 1112fa9e4066Sahrens ASSERT3U(rootzp->z_id, ==, roid); 1113fa9e4066Sahrens error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &roid, tx); 1114fa9e4066Sahrens ASSERT(error == 0); 1115fa9e4066Sahrens 1116fa9e4066Sahrens ZTOV(rootzp)->v_count = 0; 1117fa9e4066Sahrens kmem_cache_free(znode_cache, rootzp); 1118fa9e4066Sahrens } 111955434c77Sek #endif /* _KERNEL */ 112055434c77Sek 112155434c77Sek /* 112255434c77Sek * Given an object number, return its parent object number and whether 112355434c77Sek * or not the object is an extended attribute directory. 112455434c77Sek */ 112555434c77Sek static int 112655434c77Sek zfs_obj_to_pobj(objset_t *osp, uint64_t obj, uint64_t *pobjp, int *is_xattrdir) 112755434c77Sek { 112855434c77Sek dmu_buf_t *db; 112955434c77Sek dmu_object_info_t doi; 113055434c77Sek znode_phys_t *zp; 113155434c77Sek int error; 113255434c77Sek 113355434c77Sek if ((error = dmu_bonus_hold(osp, obj, FTAG, &db)) != 0) 113455434c77Sek return (error); 113555434c77Sek 113655434c77Sek dmu_object_info_from_db(db, &doi); 113755434c77Sek if (doi.doi_bonus_type != DMU_OT_ZNODE || 113855434c77Sek doi.doi_bonus_size < sizeof (znode_phys_t)) { 113955434c77Sek dmu_buf_rele(db, FTAG); 114055434c77Sek return (EINVAL); 114155434c77Sek } 114255434c77Sek 114355434c77Sek zp = db->db_data; 114455434c77Sek *pobjp = zp->zp_parent; 114555434c77Sek *is_xattrdir = ((zp->zp_flags & ZFS_XATTR) != 0) && 114655434c77Sek S_ISDIR(zp->zp_mode); 114755434c77Sek dmu_buf_rele(db, FTAG); 114855434c77Sek 114955434c77Sek return (0); 115055434c77Sek } 115155434c77Sek 115255434c77Sek int 115355434c77Sek zfs_obj_to_path(objset_t *osp, uint64_t obj, char *buf, int len) 115455434c77Sek { 115555434c77Sek char *path = buf + len - 1; 115655434c77Sek int error; 115755434c77Sek 115855434c77Sek *path = '\0'; 115955434c77Sek 116055434c77Sek for (;;) { 116155434c77Sek uint64_t pobj; 116255434c77Sek char component[MAXNAMELEN + 2]; 116355434c77Sek size_t complen; 116455434c77Sek int is_xattrdir; 116555434c77Sek 116655434c77Sek if ((error = zfs_obj_to_pobj(osp, obj, &pobj, 116755434c77Sek &is_xattrdir)) != 0) 116855434c77Sek break; 116955434c77Sek 117055434c77Sek if (pobj == obj) { 117155434c77Sek if (path[0] != '/') 117255434c77Sek *--path = '/'; 117355434c77Sek break; 117455434c77Sek } 117555434c77Sek 117655434c77Sek component[0] = '/'; 117755434c77Sek if (is_xattrdir) { 117855434c77Sek (void) sprintf(component + 1, "<xattrdir>"); 117955434c77Sek } else { 118055434c77Sek error = zap_value_search(osp, pobj, obj, component + 1); 118155434c77Sek if (error != 0) 118255434c77Sek break; 118355434c77Sek } 118455434c77Sek 118555434c77Sek complen = strlen(component); 118655434c77Sek path -= complen; 118755434c77Sek ASSERT(path >= buf); 118855434c77Sek bcopy(component, path, complen); 118955434c77Sek obj = pobj; 119055434c77Sek } 119155434c77Sek 119255434c77Sek if (error == 0) 119355434c77Sek (void) memmove(buf, path, buf + len - path); 119455434c77Sek return (error); 119555434c77Sek } 1196