1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5fa9e4066Sahrens * Common Development and Distribution License, Version 1.0 only 6fa9e4066Sahrens * (the "License"). You may not use this file except in compliance 7fa9e4066Sahrens * with the License. 8fa9e4066Sahrens * 9fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 11fa9e4066Sahrens * See the License for the specific language governing permissions 12fa9e4066Sahrens * and limitations under the License. 13fa9e4066Sahrens * 14fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 15fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 17fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 18fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 19fa9e4066Sahrens * 20fa9e4066Sahrens * CDDL HEADER END 21fa9e4066Sahrens */ 22fa9e4066Sahrens /* 23*8ef9dde0Smarks * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24fa9e4066Sahrens * Use is subject to license terms. 25fa9e4066Sahrens */ 26fa9e4066Sahrens 27fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 28fa9e4066Sahrens 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> 36fa9e4066Sahrens #include <sys/vfs.h> 37fa9e4066Sahrens #include <sys/vnode.h> 38fa9e4066Sahrens #include <sys/file.h> 39fa9e4066Sahrens #include <sys/kmem.h> 40fa9e4066Sahrens #include <sys/cmn_err.h> 41fa9e4066Sahrens #include <sys/errno.h> 42fa9e4066Sahrens #include <sys/unistd.h> 43fa9e4066Sahrens #include <sys/stat.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> 51fa9e4066Sahrens #include <sys/zfs_znode.h> 52fa9e4066Sahrens #include <sys/zap.h> 53fa9e4066Sahrens #include <sys/dmu.h> 54fa9e4066Sahrens #include <sys/fs/zfs.h> 55fa9e4066Sahrens 56fa9e4066Sahrens struct kmem_cache *znode_cache = NULL; 57fa9e4066Sahrens 58fa9e4066Sahrens /* 59fa9e4066Sahrens * Note that znodes can be on one of 2 states: 60fa9e4066Sahrens * ZCACHE_mru - recently used, currently cached 61fa9e4066Sahrens * ZCACHE_mfu - frequently used, currently cached 62fa9e4066Sahrens * When there are no active references to the znode, they 63fa9e4066Sahrens * are linked onto one of the lists in zcache. These are the 64fa9e4066Sahrens * only znodes that can be evicted. 65fa9e4066Sahrens */ 66fa9e4066Sahrens 67fa9e4066Sahrens typedef struct zcache_state { 68fa9e4066Sahrens list_t list; /* linked list of evictable znodes in state */ 69fa9e4066Sahrens uint64_t lcnt; /* total number of znodes in the linked list */ 70fa9e4066Sahrens uint64_t cnt; /* total number of all znodes in this state */ 71fa9e4066Sahrens uint64_t hits; 72fa9e4066Sahrens kmutex_t mtx; 73fa9e4066Sahrens } zcache_state_t; 74fa9e4066Sahrens 75fa9e4066Sahrens /* The 2 states: */ 76fa9e4066Sahrens static zcache_state_t ZCACHE_mru; 77fa9e4066Sahrens static zcache_state_t ZCACHE_mfu; 78fa9e4066Sahrens 79fa9e4066Sahrens static struct zcache { 80fa9e4066Sahrens zcache_state_t *mru; 81fa9e4066Sahrens zcache_state_t *mfu; 82fa9e4066Sahrens uint64_t p; /* Target size of mru */ 83fa9e4066Sahrens uint64_t c; /* Target size of cache */ 84fa9e4066Sahrens uint64_t c_max; /* Maximum target cache size */ 85fa9e4066Sahrens 86fa9e4066Sahrens /* performance stats */ 87fa9e4066Sahrens uint64_t missed; 88fa9e4066Sahrens uint64_t evicted; 89fa9e4066Sahrens uint64_t skipped; 90fa9e4066Sahrens } zcache; 91fa9e4066Sahrens 92fa9e4066Sahrens void zcache_kmem_reclaim(void); 93fa9e4066Sahrens 94fa9e4066Sahrens #define ZCACHE_MINTIME (hz>>4) /* 62 ms */ 95fa9e4066Sahrens 96fa9e4066Sahrens /* 97fa9e4066Sahrens * Move the supplied znode to the indicated state. The mutex 98fa9e4066Sahrens * for the znode must be held by the caller. 99fa9e4066Sahrens */ 100fa9e4066Sahrens static void 101fa9e4066Sahrens zcache_change_state(zcache_state_t *new_state, znode_t *zp) 102fa9e4066Sahrens { 103fa9e4066Sahrens /* ASSERT(MUTEX_HELD(hash_mtx)); */ 104fa9e4066Sahrens ASSERT(zp->z_active); 105fa9e4066Sahrens 106fa9e4066Sahrens if (zp->z_zcache_state) { 107fa9e4066Sahrens ASSERT3U(zp->z_zcache_state->cnt, >=, 1); 108fa9e4066Sahrens atomic_add_64(&zp->z_zcache_state->cnt, -1); 109fa9e4066Sahrens } 110fa9e4066Sahrens atomic_add_64(&new_state->cnt, 1); 111fa9e4066Sahrens zp->z_zcache_state = new_state; 112fa9e4066Sahrens } 113fa9e4066Sahrens 114fa9e4066Sahrens static void 115fa9e4066Sahrens zfs_zcache_evict(znode_t *zp, kmutex_t *hash_mtx) 116fa9e4066Sahrens { 117fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 118fa9e4066Sahrens 119fa9e4066Sahrens ASSERT(zp->z_phys); 120fa9e4066Sahrens ASSERT(zp->z_dbuf_held); 121fa9e4066Sahrens 122fa9e4066Sahrens zp->z_dbuf_held = 0; 123fa9e4066Sahrens mutex_exit(&zp->z_lock); 124fa9e4066Sahrens dmu_buf_rele(zp->z_dbuf); 125fa9e4066Sahrens mutex_exit(hash_mtx); 126fa9e4066Sahrens VFS_RELE(zfsvfs->z_vfs); 127fa9e4066Sahrens } 128fa9e4066Sahrens 129fa9e4066Sahrens /* 130fa9e4066Sahrens * Evict znodes from list until we've removed the specified number 131fa9e4066Sahrens */ 132fa9e4066Sahrens static void 133fa9e4066Sahrens zcache_evict_state(zcache_state_t *state, int64_t cnt, zfsvfs_t *zfsvfs) 134fa9e4066Sahrens { 135fa9e4066Sahrens int znodes_evicted = 0; 136fa9e4066Sahrens znode_t *zp, *zp_prev; 137fa9e4066Sahrens kmutex_t *hash_mtx; 138fa9e4066Sahrens 139fa9e4066Sahrens ASSERT(state == zcache.mru || state == zcache.mfu); 140fa9e4066Sahrens 141fa9e4066Sahrens mutex_enter(&state->mtx); 142fa9e4066Sahrens 143fa9e4066Sahrens for (zp = list_tail(&state->list); zp; zp = zp_prev) { 144fa9e4066Sahrens zp_prev = list_prev(&state->list, zp); 145fa9e4066Sahrens if (zfsvfs && zp->z_zfsvfs != zfsvfs) 146fa9e4066Sahrens continue; 147fa9e4066Sahrens hash_mtx = ZFS_OBJ_MUTEX(zp); 148fa9e4066Sahrens if (mutex_tryenter(hash_mtx)) { 149fa9e4066Sahrens mutex_enter(&zp->z_lock); 150fa9e4066Sahrens list_remove(&zp->z_zcache_state->list, zp); 151fa9e4066Sahrens zp->z_zcache_state->lcnt -= 1; 152fa9e4066Sahrens ASSERT3U(zp->z_zcache_state->cnt, >=, 1); 153fa9e4066Sahrens atomic_add_64(&zp->z_zcache_state->cnt, -1); 154fa9e4066Sahrens zp->z_zcache_state = NULL; 155fa9e4066Sahrens zp->z_zcache_access = 0; 156fa9e4066Sahrens /* drops z_lock and hash_mtx */ 157fa9e4066Sahrens zfs_zcache_evict(zp, hash_mtx); 158fa9e4066Sahrens znodes_evicted += 1; 159fa9e4066Sahrens atomic_add_64(&zcache.evicted, 1); 160fa9e4066Sahrens if (znodes_evicted >= cnt) 161fa9e4066Sahrens break; 162fa9e4066Sahrens } else { 163fa9e4066Sahrens atomic_add_64(&zcache.skipped, 1); 164fa9e4066Sahrens } 165fa9e4066Sahrens } 166fa9e4066Sahrens mutex_exit(&state->mtx); 167fa9e4066Sahrens 168fa9e4066Sahrens if (znodes_evicted < cnt) 169fa9e4066Sahrens dprintf("only evicted %lld znodes from %x", 170fa9e4066Sahrens (longlong_t)znodes_evicted, state); 171fa9e4066Sahrens } 172fa9e4066Sahrens 173fa9e4066Sahrens static void 174fa9e4066Sahrens zcache_adjust(void) 175fa9e4066Sahrens { 176fa9e4066Sahrens uint64_t mrucnt = zcache.mru->lcnt; 177fa9e4066Sahrens uint64_t mfucnt = zcache.mfu->lcnt; 178fa9e4066Sahrens uint64_t p = zcache.p; 179fa9e4066Sahrens uint64_t c = zcache.c; 180fa9e4066Sahrens 181fa9e4066Sahrens if (mrucnt > p) 182fa9e4066Sahrens zcache_evict_state(zcache.mru, mrucnt - p, NULL); 183fa9e4066Sahrens 184fa9e4066Sahrens if (mfucnt > 0 && mrucnt + mfucnt > c) { 185fa9e4066Sahrens int64_t toevict = MIN(mfucnt, mrucnt + mfucnt - c); 186fa9e4066Sahrens zcache_evict_state(zcache.mfu, toevict, NULL); 187fa9e4066Sahrens } 188fa9e4066Sahrens } 189fa9e4066Sahrens 190fa9e4066Sahrens /* 191fa9e4066Sahrens * Flush all *evictable* data from the cache. 192fa9e4066Sahrens * NOTE: this will not touch "active" (i.e. referenced) data. 193fa9e4066Sahrens */ 194fa9e4066Sahrens void 195fa9e4066Sahrens zfs_zcache_flush(zfsvfs_t *zfsvfs) 196fa9e4066Sahrens { 197fa9e4066Sahrens zcache_evict_state(zcache.mru, zcache.mru->lcnt, zfsvfs); 198fa9e4066Sahrens zcache_evict_state(zcache.mfu, zcache.mfu->lcnt, zfsvfs); 199fa9e4066Sahrens } 200fa9e4066Sahrens 201fa9e4066Sahrens static void 202fa9e4066Sahrens zcache_try_grow(int64_t cnt) 203fa9e4066Sahrens { 204fa9e4066Sahrens int64_t size; 205fa9e4066Sahrens /* 206fa9e4066Sahrens * If we're almost to the current target cache size, 207fa9e4066Sahrens * increment the target cache size 208fa9e4066Sahrens */ 209fa9e4066Sahrens size = zcache.mru->lcnt + zcache.mfu->lcnt; 210fa9e4066Sahrens if ((zcache.c - size) <= 1) { 211fa9e4066Sahrens atomic_add_64(&zcache.c, cnt); 212fa9e4066Sahrens if (zcache.c > zcache.c_max) 213fa9e4066Sahrens zcache.c = zcache.c_max; 214fa9e4066Sahrens else if (zcache.p + cnt < zcache.c) 215fa9e4066Sahrens atomic_add_64(&zcache.p, cnt); 216fa9e4066Sahrens } 217fa9e4066Sahrens } 218fa9e4066Sahrens 219fa9e4066Sahrens /* 220fa9e4066Sahrens * This routine is called whenever a znode is accessed. 221fa9e4066Sahrens */ 222fa9e4066Sahrens static void 223fa9e4066Sahrens zcache_access(znode_t *zp, kmutex_t *hash_mtx) 224fa9e4066Sahrens { 225fa9e4066Sahrens ASSERT(MUTEX_HELD(hash_mtx)); 226fa9e4066Sahrens 227fa9e4066Sahrens if (zp->z_zcache_state == NULL) { 228fa9e4066Sahrens /* 229fa9e4066Sahrens * This znode is not in the cache. 230fa9e4066Sahrens * Add the new znode to the MRU state. 231fa9e4066Sahrens */ 232fa9e4066Sahrens 233fa9e4066Sahrens zcache_try_grow(1); 234fa9e4066Sahrens 235fa9e4066Sahrens ASSERT(zp->z_zcache_access == 0); 236fa9e4066Sahrens zp->z_zcache_access = lbolt; 237fa9e4066Sahrens zcache_change_state(zcache.mru, zp); 238fa9e4066Sahrens mutex_exit(hash_mtx); 239fa9e4066Sahrens 240fa9e4066Sahrens /* 241fa9e4066Sahrens * If we are using less than 2/3 of our total target 242fa9e4066Sahrens * cache size, bump up the target size for the MRU 243fa9e4066Sahrens * list. 244fa9e4066Sahrens */ 245fa9e4066Sahrens if (zcache.mru->lcnt + zcache.mfu->lcnt < zcache.c*2/3) { 246fa9e4066Sahrens zcache.p = zcache.mru->lcnt + zcache.c/6; 247fa9e4066Sahrens } 248fa9e4066Sahrens 249fa9e4066Sahrens zcache_adjust(); 250fa9e4066Sahrens 251fa9e4066Sahrens atomic_add_64(&zcache.missed, 1); 252fa9e4066Sahrens } else if (zp->z_zcache_state == zcache.mru) { 253fa9e4066Sahrens /* 254fa9e4066Sahrens * This znode has been "accessed" only once so far, 255fa9e4066Sahrens * Move it to the MFU state. 256fa9e4066Sahrens */ 257fa9e4066Sahrens if (lbolt > zp->z_zcache_access + ZCACHE_MINTIME) { 258fa9e4066Sahrens /* 259fa9e4066Sahrens * More than 125ms have passed since we 260fa9e4066Sahrens * instantiated this buffer. Move it to the 261fa9e4066Sahrens * most frequently used state. 262fa9e4066Sahrens */ 263fa9e4066Sahrens zp->z_zcache_access = lbolt; 264fa9e4066Sahrens zcache_change_state(zcache.mfu, zp); 265fa9e4066Sahrens } 266fa9e4066Sahrens atomic_add_64(&zcache.mru->hits, 1); 267fa9e4066Sahrens mutex_exit(hash_mtx); 268fa9e4066Sahrens } else { 269fa9e4066Sahrens ASSERT(zp->z_zcache_state == zcache.mfu); 270fa9e4066Sahrens /* 271fa9e4066Sahrens * This buffer has been accessed more than once. 272fa9e4066Sahrens * Keep it in the MFU state. 273fa9e4066Sahrens */ 274fa9e4066Sahrens atomic_add_64(&zcache.mfu->hits, 1); 275fa9e4066Sahrens mutex_exit(hash_mtx); 276fa9e4066Sahrens } 277fa9e4066Sahrens } 278fa9e4066Sahrens 279fa9e4066Sahrens static void 280fa9e4066Sahrens zcache_init(void) 281fa9e4066Sahrens { 282fa9e4066Sahrens zcache.c = 20; 283fa9e4066Sahrens zcache.c_max = 50; 284fa9e4066Sahrens 285fa9e4066Sahrens zcache.mru = &ZCACHE_mru; 286fa9e4066Sahrens zcache.mfu = &ZCACHE_mfu; 287fa9e4066Sahrens 288fa9e4066Sahrens list_create(&zcache.mru->list, sizeof (znode_t), 289fa9e4066Sahrens offsetof(znode_t, z_zcache_node)); 290fa9e4066Sahrens list_create(&zcache.mfu->list, sizeof (znode_t), 291fa9e4066Sahrens offsetof(znode_t, z_zcache_node)); 292fa9e4066Sahrens } 293fa9e4066Sahrens 294fa9e4066Sahrens static void 295fa9e4066Sahrens zcache_fini(void) 296fa9e4066Sahrens { 297fa9e4066Sahrens zfs_zcache_flush(NULL); 298fa9e4066Sahrens 299fa9e4066Sahrens list_destroy(&zcache.mru->list); 300fa9e4066Sahrens list_destroy(&zcache.mfu->list); 301fa9e4066Sahrens } 302fa9e4066Sahrens 303fa9e4066Sahrens /*ARGSUSED*/ 304fa9e4066Sahrens static void 305fa9e4066Sahrens znode_pageout_func(dmu_buf_t *dbuf, void *user_ptr) 306fa9e4066Sahrens { 307fa9e4066Sahrens znode_t *zp = user_ptr; 308fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 309fa9e4066Sahrens 310fa9e4066Sahrens if (vp->v_count == 0) { 311fa9e4066Sahrens vn_invalid(vp); 312fa9e4066Sahrens zfs_znode_free(zp); 313fa9e4066Sahrens } 314fa9e4066Sahrens } 315fa9e4066Sahrens 316fa9e4066Sahrens /*ARGSUSED*/ 317fa9e4066Sahrens static int 318fa9e4066Sahrens zfs_znode_cache_constructor(void *buf, void *cdrarg, int kmflags) 319fa9e4066Sahrens { 320fa9e4066Sahrens znode_t *zp = buf; 321fa9e4066Sahrens 322fa9e4066Sahrens zp->z_vnode = vn_alloc(KM_SLEEP); 323fa9e4066Sahrens zp->z_vnode->v_data = (caddr_t)zp; 324fa9e4066Sahrens mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL); 325fa9e4066Sahrens rw_init(&zp->z_map_lock, NULL, RW_DEFAULT, NULL); 326fa9e4066Sahrens rw_init(&zp->z_grow_lock, NULL, RW_DEFAULT, NULL); 327fa9e4066Sahrens rw_init(&zp->z_append_lock, NULL, RW_DEFAULT, NULL); 328fa9e4066Sahrens mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL); 329fa9e4066Sahrens zp->z_dbuf_held = 0; 330fa9e4066Sahrens zp->z_dirlocks = 0; 331fa9e4066Sahrens return (0); 332fa9e4066Sahrens } 333fa9e4066Sahrens 334fa9e4066Sahrens /*ARGSUSED*/ 335fa9e4066Sahrens static void 336fa9e4066Sahrens zfs_znode_cache_destructor(void *buf, void *cdarg) 337fa9e4066Sahrens { 338fa9e4066Sahrens znode_t *zp = buf; 339fa9e4066Sahrens 340fa9e4066Sahrens ASSERT(zp->z_dirlocks == 0); 341fa9e4066Sahrens mutex_destroy(&zp->z_lock); 342fa9e4066Sahrens rw_destroy(&zp->z_map_lock); 343fa9e4066Sahrens rw_destroy(&zp->z_grow_lock); 344fa9e4066Sahrens rw_destroy(&zp->z_append_lock); 345fa9e4066Sahrens mutex_destroy(&zp->z_acl_lock); 346fa9e4066Sahrens 347fa9e4066Sahrens ASSERT(zp->z_dbuf_held == 0); 348fa9e4066Sahrens ASSERT(ZTOV(zp)->v_count == 0); 349fa9e4066Sahrens vn_free(ZTOV(zp)); 350fa9e4066Sahrens } 351fa9e4066Sahrens 352fa9e4066Sahrens void 353fa9e4066Sahrens zfs_znode_init(void) 354fa9e4066Sahrens { 355fa9e4066Sahrens /* 356fa9e4066Sahrens * Initialize zcache 357fa9e4066Sahrens */ 358fa9e4066Sahrens ASSERT(znode_cache == NULL); 359fa9e4066Sahrens znode_cache = kmem_cache_create("zfs_znode_cache", 360fa9e4066Sahrens sizeof (znode_t), 0, zfs_znode_cache_constructor, 361fa9e4066Sahrens zfs_znode_cache_destructor, NULL, NULL, NULL, 0); 362fa9e4066Sahrens 363fa9e4066Sahrens zcache_init(); 364fa9e4066Sahrens } 365fa9e4066Sahrens 366fa9e4066Sahrens void 367fa9e4066Sahrens zfs_znode_fini(void) 368fa9e4066Sahrens { 369fa9e4066Sahrens zcache_fini(); 370fa9e4066Sahrens 371fa9e4066Sahrens /* 372fa9e4066Sahrens * Cleanup vfs & vnode ops 373fa9e4066Sahrens */ 374fa9e4066Sahrens zfs_remove_op_tables(); 375fa9e4066Sahrens 376fa9e4066Sahrens /* 377fa9e4066Sahrens * Cleanup zcache 378fa9e4066Sahrens */ 379fa9e4066Sahrens if (znode_cache) 380fa9e4066Sahrens kmem_cache_destroy(znode_cache); 381fa9e4066Sahrens znode_cache = NULL; 382fa9e4066Sahrens } 383fa9e4066Sahrens 384fa9e4066Sahrens struct vnodeops *zfs_dvnodeops; 385fa9e4066Sahrens struct vnodeops *zfs_fvnodeops; 386fa9e4066Sahrens struct vnodeops *zfs_symvnodeops; 387fa9e4066Sahrens struct vnodeops *zfs_xdvnodeops; 388fa9e4066Sahrens struct vnodeops *zfs_evnodeops; 389fa9e4066Sahrens 390fa9e4066Sahrens void 391fa9e4066Sahrens zfs_remove_op_tables() 392fa9e4066Sahrens { 393fa9e4066Sahrens /* 394fa9e4066Sahrens * Remove vfs ops 395fa9e4066Sahrens */ 396fa9e4066Sahrens ASSERT(zfsfstype); 397fa9e4066Sahrens (void) vfs_freevfsops_by_type(zfsfstype); 398fa9e4066Sahrens zfsfstype = 0; 399fa9e4066Sahrens 400fa9e4066Sahrens /* 401fa9e4066Sahrens * Remove vnode ops 402fa9e4066Sahrens */ 403fa9e4066Sahrens if (zfs_dvnodeops) 404fa9e4066Sahrens vn_freevnodeops(zfs_dvnodeops); 405fa9e4066Sahrens if (zfs_fvnodeops) 406fa9e4066Sahrens vn_freevnodeops(zfs_fvnodeops); 407fa9e4066Sahrens if (zfs_symvnodeops) 408fa9e4066Sahrens vn_freevnodeops(zfs_symvnodeops); 409fa9e4066Sahrens if (zfs_xdvnodeops) 410fa9e4066Sahrens vn_freevnodeops(zfs_xdvnodeops); 411fa9e4066Sahrens if (zfs_evnodeops) 412fa9e4066Sahrens vn_freevnodeops(zfs_evnodeops); 413fa9e4066Sahrens 414fa9e4066Sahrens zfs_dvnodeops = NULL; 415fa9e4066Sahrens zfs_fvnodeops = NULL; 416fa9e4066Sahrens zfs_symvnodeops = NULL; 417fa9e4066Sahrens zfs_xdvnodeops = NULL; 418fa9e4066Sahrens zfs_evnodeops = NULL; 419fa9e4066Sahrens } 420fa9e4066Sahrens 421fa9e4066Sahrens extern const fs_operation_def_t zfs_dvnodeops_template[]; 422fa9e4066Sahrens extern const fs_operation_def_t zfs_fvnodeops_template[]; 423fa9e4066Sahrens extern const fs_operation_def_t zfs_xdvnodeops_template[]; 424fa9e4066Sahrens extern const fs_operation_def_t zfs_symvnodeops_template[]; 425fa9e4066Sahrens extern const fs_operation_def_t zfs_evnodeops_template[]; 426fa9e4066Sahrens 427fa9e4066Sahrens int 428fa9e4066Sahrens zfs_create_op_tables() 429fa9e4066Sahrens { 430fa9e4066Sahrens int error; 431fa9e4066Sahrens 432fa9e4066Sahrens /* 433fa9e4066Sahrens * zfs_dvnodeops can be set if mod_remove() calls mod_installfs() 434fa9e4066Sahrens * due to a failure to remove the the 2nd modlinkage (zfs_modldrv). 435fa9e4066Sahrens * In this case we just return as the ops vectors are already set up. 436fa9e4066Sahrens */ 437fa9e4066Sahrens if (zfs_dvnodeops) 438fa9e4066Sahrens return (0); 439fa9e4066Sahrens 440fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_dvnodeops_template, 441fa9e4066Sahrens &zfs_dvnodeops); 442fa9e4066Sahrens if (error) 443fa9e4066Sahrens return (error); 444fa9e4066Sahrens 445fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_fvnodeops_template, 446fa9e4066Sahrens &zfs_fvnodeops); 447fa9e4066Sahrens if (error) 448fa9e4066Sahrens return (error); 449fa9e4066Sahrens 450fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_symvnodeops_template, 451fa9e4066Sahrens &zfs_symvnodeops); 452fa9e4066Sahrens if (error) 453fa9e4066Sahrens return (error); 454fa9e4066Sahrens 455fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_xdvnodeops_template, 456fa9e4066Sahrens &zfs_xdvnodeops); 457fa9e4066Sahrens if (error) 458fa9e4066Sahrens return (error); 459fa9e4066Sahrens 460fa9e4066Sahrens error = vn_make_ops(MNTTYPE_ZFS, zfs_evnodeops_template, 461fa9e4066Sahrens &zfs_evnodeops); 462fa9e4066Sahrens 463fa9e4066Sahrens return (error); 464fa9e4066Sahrens } 465fa9e4066Sahrens 466fa9e4066Sahrens /* 467fa9e4066Sahrens * zfs_init_fs - Initialize the zfsvfs struct and the file system 468fa9e4066Sahrens * incore "master" object. Verify version compatibility. 469fa9e4066Sahrens */ 470fa9e4066Sahrens int 471fa9e4066Sahrens zfs_init_fs(zfsvfs_t *zfsvfs, znode_t **zpp, cred_t *cr) 472fa9e4066Sahrens { 473fa9e4066Sahrens extern int zfsfstype; 474fa9e4066Sahrens 475fa9e4066Sahrens objset_t *os = zfsvfs->z_os; 476fa9e4066Sahrens uint64_t zoid; 477fa9e4066Sahrens uint64_t version = ZFS_VERSION; 478fa9e4066Sahrens int i, error; 479fa9e4066Sahrens dmu_object_info_t doi; 480fa9e4066Sahrens dmu_objset_stats_t *stats; 481fa9e4066Sahrens 482fa9e4066Sahrens *zpp = NULL; 483fa9e4066Sahrens 484fa9e4066Sahrens /* 485fa9e4066Sahrens * XXX - hack to auto-create the pool root filesystem at 486fa9e4066Sahrens * the first attempted mount. 487fa9e4066Sahrens */ 488fa9e4066Sahrens if (dmu_object_info(os, MASTER_NODE_OBJ, &doi) == ENOENT) { 489fa9e4066Sahrens dmu_tx_t *tx = dmu_tx_create(os); 490fa9e4066Sahrens 491fa9e4066Sahrens dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, 3); /* master node */ 492fa9e4066Sahrens dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, 1); /* delete queue */ 493fa9e4066Sahrens dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT); /* root node */ 494fa9e4066Sahrens error = dmu_tx_assign(tx, TXG_WAIT); 495fa9e4066Sahrens ASSERT3U(error, ==, 0); 496fa9e4066Sahrens zfs_create_fs(os, cr, tx); 497fa9e4066Sahrens dmu_tx_commit(tx); 498fa9e4066Sahrens } 499fa9e4066Sahrens 500fa9e4066Sahrens if (zap_lookup(os, MASTER_NODE_OBJ, ZFS_VERSION_OBJ, 8, 1, &version)) { 501fa9e4066Sahrens return (EINVAL); 502fa9e4066Sahrens } else if (version != ZFS_VERSION) { 503fa9e4066Sahrens (void) printf("Mismatched versions: File system " 504fa9e4066Sahrens "is version %lld on-disk format, which is " 505fa9e4066Sahrens "incompatible with this software version %lld!", 506fa9e4066Sahrens (u_longlong_t)version, ZFS_VERSION); 507fa9e4066Sahrens return (ENOTSUP); 508fa9e4066Sahrens } 509fa9e4066Sahrens 510fa9e4066Sahrens /* 511fa9e4066Sahrens * The fsid is 64 bits, composed of an 8-bit fs type, which 512fa9e4066Sahrens * separates our fsid from any other filesystem types, and a 513fa9e4066Sahrens * 56-bit objset unique ID. The objset unique ID is unique to 514fa9e4066Sahrens * all objsets open on this system, provided by unique_create(). 515fa9e4066Sahrens * The 8-bit fs type must be put in the low bits of fsid[1] 516fa9e4066Sahrens * because that's where other Solaris filesystems put it. 517fa9e4066Sahrens */ 518fa9e4066Sahrens stats = kmem_alloc(sizeof (dmu_objset_stats_t), KM_SLEEP); 519fa9e4066Sahrens dmu_objset_stats(os, stats); 520fa9e4066Sahrens ASSERT((stats->dds_fsid_guid & ~((1ULL<<56)-1)) == 0); 521fa9e4066Sahrens zfsvfs->z_vfs->vfs_fsid.val[0] = stats->dds_fsid_guid; 522fa9e4066Sahrens zfsvfs->z_vfs->vfs_fsid.val[1] = ((stats->dds_fsid_guid>>32) << 8) | 523fa9e4066Sahrens zfsfstype & 0xFF; 524fa9e4066Sahrens kmem_free(stats, sizeof (dmu_objset_stats_t)); 525fa9e4066Sahrens stats = NULL; 526fa9e4066Sahrens 527fa9e4066Sahrens if (zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, &zoid)) { 528fa9e4066Sahrens return (EINVAL); 529fa9e4066Sahrens } 530fa9e4066Sahrens ASSERT(zoid != 0); 531fa9e4066Sahrens zfsvfs->z_root = zoid; 532fa9e4066Sahrens 533fa9e4066Sahrens /* 534fa9e4066Sahrens * Create the per mount vop tables. 535fa9e4066Sahrens */ 536fa9e4066Sahrens 537fa9e4066Sahrens /* 538fa9e4066Sahrens * Initialize zget mutex's 539fa9e4066Sahrens */ 540fa9e4066Sahrens for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 541fa9e4066Sahrens mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL); 542fa9e4066Sahrens 543fa9e4066Sahrens error = zfs_zget(zfsvfs, zoid, zpp); 544fa9e4066Sahrens if (error) 545fa9e4066Sahrens return (error); 546fa9e4066Sahrens ASSERT3U((*zpp)->z_id, ==, zoid); 547fa9e4066Sahrens 548fa9e4066Sahrens if (zap_lookup(os, MASTER_NODE_OBJ, ZFS_DELETE_QUEUE, 8, 1, &zoid)) { 549fa9e4066Sahrens return (EINVAL); 550fa9e4066Sahrens } 551fa9e4066Sahrens 552fa9e4066Sahrens zfsvfs->z_dqueue = zoid; 553fa9e4066Sahrens 554fa9e4066Sahrens /* 555fa9e4066Sahrens * Initialize delete head structure 556fa9e4066Sahrens * Thread(s) will be started/stopped via 557fa9e4066Sahrens * readonly_changed_cb() depending 558fa9e4066Sahrens * on whether this is rw/ro mount. 559fa9e4066Sahrens */ 560fa9e4066Sahrens list_create(&zfsvfs->z_delete_head.z_znodes, 561fa9e4066Sahrens sizeof (znode_t), offsetof(znode_t, z_list_node)); 562fa9e4066Sahrens 563fa9e4066Sahrens return (0); 564fa9e4066Sahrens } 565fa9e4066Sahrens 566fa9e4066Sahrens /* 567fa9e4066Sahrens * Construct a new znode/vnode and intialize. 568fa9e4066Sahrens * 569fa9e4066Sahrens * This does not do a call to dmu_set_user() that is 570fa9e4066Sahrens * up to the caller to do, in case you don't want to 571fa9e4066Sahrens * return the znode 572fa9e4066Sahrens */ 573fa9e4066Sahrens znode_t * 574fa9e4066Sahrens zfs_znode_alloc(zfsvfs_t *zfsvfs, dmu_buf_t *db, uint64_t obj_num, int blksz) 575fa9e4066Sahrens { 576fa9e4066Sahrens znode_t *zp; 577fa9e4066Sahrens vnode_t *vp; 578fa9e4066Sahrens 579fa9e4066Sahrens zp = kmem_cache_alloc(znode_cache, KM_SLEEP); 580fa9e4066Sahrens 581fa9e4066Sahrens ASSERT(zp->z_dirlocks == NULL); 582fa9e4066Sahrens 583fa9e4066Sahrens zp->z_phys = db->db_data; 584fa9e4066Sahrens zp->z_zfsvfs = zfsvfs; 585fa9e4066Sahrens zp->z_active = 1; 586fa9e4066Sahrens zp->z_reap = 0; 587fa9e4066Sahrens zp->z_atime_dirty = 0; 588fa9e4066Sahrens zp->z_dbuf_held = 0; 589fa9e4066Sahrens zp->z_mapcnt = 0; 590fa9e4066Sahrens zp->z_last_itx = 0; 591fa9e4066Sahrens zp->z_dbuf = db; 592fa9e4066Sahrens zp->z_id = obj_num; 593fa9e4066Sahrens zp->z_blksz = blksz; 594fa9e4066Sahrens zp->z_seq = 0x7A4653; 595fa9e4066Sahrens 596fa9e4066Sahrens bzero(&zp->z_zcache_node, sizeof (list_node_t)); 597fa9e4066Sahrens 598fa9e4066Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 599fa9e4066Sahrens list_insert_tail(&zfsvfs->z_all_znodes, zp); 600fa9e4066Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 601fa9e4066Sahrens 602fa9e4066Sahrens vp = ZTOV(zp); 603fa9e4066Sahrens vn_reinit(vp); 604fa9e4066Sahrens 605fa9e4066Sahrens vp->v_vfsp = zfsvfs->z_parent->z_vfs; 606fa9e4066Sahrens vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode); 607fa9e4066Sahrens 608fa9e4066Sahrens switch (vp->v_type) { 609fa9e4066Sahrens case VDIR: 610fa9e4066Sahrens if (zp->z_phys->zp_flags & ZFS_XATTR) { 611fa9e4066Sahrens vn_setops(vp, zfs_xdvnodeops); 612fa9e4066Sahrens vp->v_flag |= V_XATTRDIR; 613fa9e4066Sahrens } else 614fa9e4066Sahrens vn_setops(vp, zfs_dvnodeops); 6157f6e3e7dSperrin zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */ 616fa9e4066Sahrens break; 617fa9e4066Sahrens case VBLK: 618fa9e4066Sahrens case VCHR: 619fa9e4066Sahrens vp->v_rdev = (dev_t)zp->z_phys->zp_rdev; 620fa9e4066Sahrens /*FALLTHROUGH*/ 621fa9e4066Sahrens case VFIFO: 622fa9e4066Sahrens case VSOCK: 623fa9e4066Sahrens case VDOOR: 624fa9e4066Sahrens vn_setops(vp, zfs_fvnodeops); 625fa9e4066Sahrens break; 626fa9e4066Sahrens case VREG: 627fa9e4066Sahrens vp->v_flag |= VMODSORT; 628fa9e4066Sahrens vn_setops(vp, zfs_fvnodeops); 629fa9e4066Sahrens break; 630fa9e4066Sahrens case VLNK: 631fa9e4066Sahrens vn_setops(vp, zfs_symvnodeops); 632fa9e4066Sahrens break; 633fa9e4066Sahrens default: 634fa9e4066Sahrens vn_setops(vp, zfs_evnodeops); 635fa9e4066Sahrens break; 636fa9e4066Sahrens } 637fa9e4066Sahrens 638fa9e4066Sahrens return (zp); 639fa9e4066Sahrens } 640fa9e4066Sahrens 641fa9e4066Sahrens static void 642fa9e4066Sahrens zfs_znode_dmu_init(znode_t *zp) 643fa9e4066Sahrens { 644fa9e4066Sahrens znode_t *nzp; 645fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 646fa9e4066Sahrens dmu_buf_t *db = zp->z_dbuf; 647fa9e4066Sahrens 648fa9e4066Sahrens mutex_enter(&zp->z_lock); 649fa9e4066Sahrens 650fa9e4066Sahrens nzp = dmu_buf_set_user(db, zp, &zp->z_phys, znode_pageout_func); 651fa9e4066Sahrens 652fa9e4066Sahrens /* 653fa9e4066Sahrens * there should be no 654fa9e4066Sahrens * concurrent zgets on this object. 655fa9e4066Sahrens */ 656fa9e4066Sahrens ASSERT3P(nzp, ==, NULL); 657fa9e4066Sahrens 658fa9e4066Sahrens /* 659fa9e4066Sahrens * Slap on VROOT if we are the root znode 660fa9e4066Sahrens */ 661fa9e4066Sahrens if (zp->z_id == zfsvfs->z_root) { 662fa9e4066Sahrens ZTOV(zp)->v_flag |= VROOT; 663fa9e4066Sahrens } 664fa9e4066Sahrens 665fa9e4066Sahrens zp->z_zcache_state = NULL; 666fa9e4066Sahrens zp->z_zcache_access = 0; 667fa9e4066Sahrens 668fa9e4066Sahrens ASSERT(zp->z_dbuf_held == 0); 669fa9e4066Sahrens zp->z_dbuf_held = 1; 670fa9e4066Sahrens VFS_HOLD(zfsvfs->z_vfs); 671fa9e4066Sahrens mutex_exit(&zp->z_lock); 672fa9e4066Sahrens vn_exists(ZTOV(zp)); 673fa9e4066Sahrens } 674fa9e4066Sahrens 675fa9e4066Sahrens /* 676fa9e4066Sahrens * Create a new DMU object to hold a zfs znode. 677fa9e4066Sahrens * 678fa9e4066Sahrens * IN: dzp - parent directory for new znode 679fa9e4066Sahrens * vap - file attributes for new znode 680fa9e4066Sahrens * tx - dmu transaction id for zap operations 681fa9e4066Sahrens * cr - credentials of caller 682fa9e4066Sahrens * flag - flags: 683fa9e4066Sahrens * IS_ROOT_NODE - new object will be root 684fa9e4066Sahrens * IS_XATTR - new object is an attribute 685fa9e4066Sahrens * IS_REPLAY - intent log replay 686fa9e4066Sahrens * 687fa9e4066Sahrens * OUT: oid - ID of created object 688fa9e4066Sahrens * 689fa9e4066Sahrens */ 690fa9e4066Sahrens void 691fa9e4066Sahrens zfs_mknode(znode_t *dzp, vattr_t *vap, uint64_t *oid, dmu_tx_t *tx, cred_t *cr, 692fa9e4066Sahrens uint_t flag, znode_t **zpp, int bonuslen) 693fa9e4066Sahrens { 694fa9e4066Sahrens dmu_buf_t *dbp; 695fa9e4066Sahrens znode_phys_t *pzp; 696fa9e4066Sahrens znode_t *zp; 697fa9e4066Sahrens zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 698fa9e4066Sahrens timestruc_t now; 699fa9e4066Sahrens uint64_t gen; 700fa9e4066Sahrens int err; 701fa9e4066Sahrens 702fa9e4066Sahrens ASSERT(vap && (vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE)); 703fa9e4066Sahrens 704fa9e4066Sahrens if (zfsvfs->z_assign >= TXG_INITIAL) { /* ZIL replay */ 705fa9e4066Sahrens *oid = vap->va_nodeid; 706fa9e4066Sahrens flag |= IS_REPLAY; 707fa9e4066Sahrens now = vap->va_ctime; /* see zfs_replay_create() */ 708fa9e4066Sahrens gen = vap->va_nblocks; /* ditto */ 709fa9e4066Sahrens } else { 710fa9e4066Sahrens *oid = 0; 711fa9e4066Sahrens gethrestime(&now); 712fa9e4066Sahrens gen = dmu_tx_get_txg(tx); 713fa9e4066Sahrens } 714fa9e4066Sahrens 715fa9e4066Sahrens /* 716fa9e4066Sahrens * Create a new DMU object. 717fa9e4066Sahrens */ 718fa9e4066Sahrens if (vap->va_type == VDIR) { 719fa9e4066Sahrens if (flag & IS_REPLAY) { 720fa9e4066Sahrens err = zap_create_claim(zfsvfs->z_os, *oid, 721fa9e4066Sahrens DMU_OT_DIRECTORY_CONTENTS, 722fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 723fa9e4066Sahrens ASSERT3U(err, ==, 0); 724fa9e4066Sahrens } else { 725fa9e4066Sahrens *oid = zap_create(zfsvfs->z_os, 726fa9e4066Sahrens DMU_OT_DIRECTORY_CONTENTS, 727fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 728fa9e4066Sahrens } 729fa9e4066Sahrens } else { 730fa9e4066Sahrens if (flag & IS_REPLAY) { 731fa9e4066Sahrens err = dmu_object_claim(zfsvfs->z_os, *oid, 732fa9e4066Sahrens DMU_OT_PLAIN_FILE_CONTENTS, 0, 733fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 734fa9e4066Sahrens ASSERT3U(err, ==, 0); 735fa9e4066Sahrens } else { 736fa9e4066Sahrens *oid = dmu_object_alloc(zfsvfs->z_os, 737fa9e4066Sahrens DMU_OT_PLAIN_FILE_CONTENTS, 0, 738fa9e4066Sahrens DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 739fa9e4066Sahrens } 740fa9e4066Sahrens } 741fa9e4066Sahrens dbp = dmu_bonus_hold(zfsvfs->z_os, *oid); 742fa9e4066Sahrens dmu_buf_will_dirty(dbp, tx); 743fa9e4066Sahrens 744fa9e4066Sahrens /* 745fa9e4066Sahrens * Initialize the znode physical data to zero. 746fa9e4066Sahrens */ 747fa9e4066Sahrens ASSERT(dbp->db_size >= sizeof (znode_phys_t)); 748fa9e4066Sahrens bzero(dbp->db_data, dbp->db_size); 749fa9e4066Sahrens pzp = dbp->db_data; 750fa9e4066Sahrens 751fa9e4066Sahrens /* 752fa9e4066Sahrens * If this is the root, fix up the half-initialized parent pointer 753fa9e4066Sahrens * to reference the just-allocated physical data area. 754fa9e4066Sahrens */ 755fa9e4066Sahrens if (flag & IS_ROOT_NODE) { 756fa9e4066Sahrens dzp->z_phys = pzp; 757fa9e4066Sahrens dzp->z_id = *oid; 758fa9e4066Sahrens } 759fa9e4066Sahrens 760fa9e4066Sahrens /* 761fa9e4066Sahrens * If parent is an xattr, so am I. 762fa9e4066Sahrens */ 763fa9e4066Sahrens if (dzp->z_phys->zp_flags & ZFS_XATTR) 764fa9e4066Sahrens flag |= IS_XATTR; 765fa9e4066Sahrens 766fa9e4066Sahrens if (vap->va_type == VBLK || vap->va_type == VCHR) { 767fa9e4066Sahrens pzp->zp_rdev = vap->va_rdev; 768fa9e4066Sahrens } 769fa9e4066Sahrens 770fa9e4066Sahrens if (vap->va_type == VDIR) { 771fa9e4066Sahrens pzp->zp_size = 2; /* contents ("." and "..") */ 772fa9e4066Sahrens pzp->zp_links = (flag & (IS_ROOT_NODE | IS_XATTR)) ? 2 : 1; 773fa9e4066Sahrens } 774fa9e4066Sahrens 775fa9e4066Sahrens pzp->zp_parent = dzp->z_id; 776fa9e4066Sahrens if (flag & IS_XATTR) 777fa9e4066Sahrens pzp->zp_flags |= ZFS_XATTR; 778fa9e4066Sahrens 779fa9e4066Sahrens pzp->zp_gen = gen; 780fa9e4066Sahrens 781fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_crtime); 782fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_ctime); 783fa9e4066Sahrens 784fa9e4066Sahrens if (vap->va_mask & AT_ATIME) { 785fa9e4066Sahrens ZFS_TIME_ENCODE(&vap->va_atime, pzp->zp_atime); 786fa9e4066Sahrens } else { 787fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_atime); 788fa9e4066Sahrens } 789fa9e4066Sahrens 790fa9e4066Sahrens if (vap->va_mask & AT_MTIME) { 791fa9e4066Sahrens ZFS_TIME_ENCODE(&vap->va_mtime, pzp->zp_mtime); 792fa9e4066Sahrens } else { 793fa9e4066Sahrens ZFS_TIME_ENCODE(&now, pzp->zp_mtime); 794fa9e4066Sahrens } 795fa9e4066Sahrens 796fa9e4066Sahrens pzp->zp_mode = MAKEIMODE(vap->va_type, vap->va_mode); 797fa9e4066Sahrens zp = zfs_znode_alloc(zfsvfs, dbp, *oid, 0); 798fa9e4066Sahrens 799fa9e4066Sahrens zfs_perm_init(zp, dzp, flag, vap, tx, cr); 800fa9e4066Sahrens 801fa9e4066Sahrens if (zpp) { 802fa9e4066Sahrens kmutex_t *hash_mtx = ZFS_OBJ_MUTEX(zp); 803fa9e4066Sahrens 804fa9e4066Sahrens mutex_enter(hash_mtx); 805fa9e4066Sahrens zfs_znode_dmu_init(zp); 806fa9e4066Sahrens zcache_access(zp, hash_mtx); 807fa9e4066Sahrens *zpp = zp; 808fa9e4066Sahrens } else { 809fa9e4066Sahrens ZTOV(zp)->v_count = 0; 810fa9e4066Sahrens dmu_buf_rele(dbp); 811fa9e4066Sahrens zfs_znode_free(zp); 812fa9e4066Sahrens } 813fa9e4066Sahrens } 814fa9e4066Sahrens 815fa9e4066Sahrens int 816fa9e4066Sahrens zfs_zget(zfsvfs_t *zfsvfs, uint64_t obj_num, znode_t **zpp) 817fa9e4066Sahrens { 818fa9e4066Sahrens dmu_object_info_t doi; 819fa9e4066Sahrens dmu_buf_t *db; 820fa9e4066Sahrens znode_t *zp; 821fa9e4066Sahrens 822fa9e4066Sahrens *zpp = NULL; 823fa9e4066Sahrens 824fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num); 825fa9e4066Sahrens 826fa9e4066Sahrens db = dmu_bonus_hold(zfsvfs->z_os, obj_num); 827fa9e4066Sahrens if (db == NULL) { 828fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 829fa9e4066Sahrens return (ENOENT); 830fa9e4066Sahrens } 831fa9e4066Sahrens 832fa9e4066Sahrens dmu_object_info_from_db(db, &doi); 833fa9e4066Sahrens if (doi.doi_bonus_type != DMU_OT_ZNODE || 834fa9e4066Sahrens doi.doi_bonus_size < sizeof (znode_phys_t)) { 835fa9e4066Sahrens dmu_buf_rele(db); 836fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 837fa9e4066Sahrens return (EINVAL); 838fa9e4066Sahrens } 839fa9e4066Sahrens dmu_buf_read(db); 840fa9e4066Sahrens 841fa9e4066Sahrens ASSERT(db->db_object == obj_num); 842fa9e4066Sahrens ASSERT(db->db_offset == -1); 843fa9e4066Sahrens ASSERT(db->db_data != NULL); 844fa9e4066Sahrens 845fa9e4066Sahrens zp = dmu_buf_get_user(db); 846fa9e4066Sahrens 847fa9e4066Sahrens if (zp != NULL) { 848fa9e4066Sahrens mutex_enter(&zp->z_lock); 849fa9e4066Sahrens 850fa9e4066Sahrens ASSERT3U(zp->z_id, ==, obj_num); 851fa9e4066Sahrens if (zp->z_reap) { 852fa9e4066Sahrens dmu_buf_rele(db); 853fa9e4066Sahrens mutex_exit(&zp->z_lock); 854fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 855fa9e4066Sahrens return (ENOENT); 856fa9e4066Sahrens } else if (zp->z_dbuf_held) { 857fa9e4066Sahrens dmu_buf_rele(db); 858fa9e4066Sahrens } else { 859fa9e4066Sahrens zp->z_dbuf_held = 1; 860fa9e4066Sahrens VFS_HOLD(zfsvfs->z_vfs); 861fa9e4066Sahrens } 862fa9e4066Sahrens 863fa9e4066Sahrens if (zp->z_active == 0) { 864fa9e4066Sahrens zp->z_active = 1; 865fa9e4066Sahrens if (list_link_active(&zp->z_zcache_node)) { 866fa9e4066Sahrens mutex_enter(&zp->z_zcache_state->mtx); 867fa9e4066Sahrens list_remove(&zp->z_zcache_state->list, zp); 868fa9e4066Sahrens zp->z_zcache_state->lcnt -= 1; 869fa9e4066Sahrens mutex_exit(&zp->z_zcache_state->mtx); 870fa9e4066Sahrens } 871fa9e4066Sahrens } 872fa9e4066Sahrens VN_HOLD(ZTOV(zp)); 873fa9e4066Sahrens mutex_exit(&zp->z_lock); 874fa9e4066Sahrens zcache_access(zp, ZFS_OBJ_MUTEX(zp)); 875fa9e4066Sahrens *zpp = zp; 876fa9e4066Sahrens return (0); 877fa9e4066Sahrens } 878fa9e4066Sahrens 879fa9e4066Sahrens /* 880fa9e4066Sahrens * Not found create new znode/vnode 881fa9e4066Sahrens */ 882fa9e4066Sahrens zp = zfs_znode_alloc(zfsvfs, db, obj_num, doi.doi_data_block_size); 883fa9e4066Sahrens ASSERT3U(zp->z_id, ==, obj_num); 884fa9e4066Sahrens zfs_znode_dmu_init(zp); 885fa9e4066Sahrens zcache_access(zp, ZFS_OBJ_MUTEX(zp)); 886fa9e4066Sahrens *zpp = zp; 887fa9e4066Sahrens return (0); 888fa9e4066Sahrens } 889fa9e4066Sahrens 890fa9e4066Sahrens void 891fa9e4066Sahrens zfs_znode_delete(znode_t *zp, dmu_tx_t *tx) 892fa9e4066Sahrens { 893fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 894fa9e4066Sahrens int error; 895fa9e4066Sahrens 896fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, zp->z_id); 897fa9e4066Sahrens if (zp->z_phys->zp_acl.z_acl_extern_obj) { 898fa9e4066Sahrens error = dmu_object_free(zfsvfs->z_os, 899fa9e4066Sahrens zp->z_phys->zp_acl.z_acl_extern_obj, tx); 900fa9e4066Sahrens ASSERT3U(error, ==, 0); 901fa9e4066Sahrens } 902fa9e4066Sahrens if (zp->z_zcache_state) { 903fa9e4066Sahrens ASSERT3U(zp->z_zcache_state->cnt, >=, 1); 904fa9e4066Sahrens atomic_add_64(&zp->z_zcache_state->cnt, -1); 905fa9e4066Sahrens } 906fa9e4066Sahrens error = dmu_object_free(zfsvfs->z_os, zp->z_id, tx); 907fa9e4066Sahrens ASSERT3U(error, ==, 0); 908fa9e4066Sahrens zp->z_dbuf_held = 0; 909fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, zp->z_id); 910fa9e4066Sahrens dmu_buf_rele(zp->z_dbuf); 911fa9e4066Sahrens } 912fa9e4066Sahrens 913fa9e4066Sahrens void 914fa9e4066Sahrens zfs_zinactive(znode_t *zp) 915fa9e4066Sahrens { 916fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 917fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 918fa9e4066Sahrens uint64_t z_id = zp->z_id; 919fa9e4066Sahrens 920fa9e4066Sahrens ASSERT(zp->z_dbuf_held && zp->z_phys); 921fa9e4066Sahrens 922fa9e4066Sahrens /* 923fa9e4066Sahrens * Don't allow a zfs_zget() while were trying to release this znode 924fa9e4066Sahrens */ 925fa9e4066Sahrens ZFS_OBJ_HOLD_ENTER(zfsvfs, z_id); 926fa9e4066Sahrens 927fa9e4066Sahrens mutex_enter(&zp->z_lock); 928fa9e4066Sahrens mutex_enter(&vp->v_lock); 929fa9e4066Sahrens vp->v_count--; 930fa9e4066Sahrens if (vp->v_count > 0 || vn_has_cached_data(vp)) { 931fa9e4066Sahrens /* 932fa9e4066Sahrens * If the hold count is greater than zero, somebody has 933fa9e4066Sahrens * obtained a new reference on this znode while we were 934fa9e4066Sahrens * processing it here, so we are done. If we still have 935fa9e4066Sahrens * mapped pages then we are also done, since we don't 936fa9e4066Sahrens * want to inactivate the znode until the pages get pushed. 937fa9e4066Sahrens * 938fa9e4066Sahrens * XXX - if vn_has_cached_data(vp) is true, but count == 0, 939fa9e4066Sahrens * this seems like it would leave the znode hanging with 940fa9e4066Sahrens * no chance to go inactive... 941fa9e4066Sahrens */ 942fa9e4066Sahrens mutex_exit(&vp->v_lock); 943fa9e4066Sahrens mutex_exit(&zp->z_lock); 944fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 945fa9e4066Sahrens return; 946fa9e4066Sahrens } 947fa9e4066Sahrens mutex_exit(&vp->v_lock); 948fa9e4066Sahrens zp->z_active = 0; 949fa9e4066Sahrens 950fa9e4066Sahrens /* 951fa9e4066Sahrens * If this was the last reference to a file with no links, 952fa9e4066Sahrens * remove the file from the file system. 953fa9e4066Sahrens */ 954fa9e4066Sahrens if (zp->z_reap) { 955fa9e4066Sahrens mutex_exit(&zp->z_lock); 956fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 957fa9e4066Sahrens ASSERT3U(zp->z_zcache_state->cnt, >=, 1); 958fa9e4066Sahrens atomic_add_64(&zp->z_zcache_state->cnt, -1); 959fa9e4066Sahrens zp->z_zcache_state = NULL; 960fa9e4066Sahrens /* XATTR files are not put on the delete queue */ 961fa9e4066Sahrens if (zp->z_phys->zp_flags & ZFS_XATTR) { 962fa9e4066Sahrens zfs_rmnode(zp); 963fa9e4066Sahrens } else { 964fa9e4066Sahrens mutex_enter(&zfsvfs->z_delete_head.z_mutex); 965fa9e4066Sahrens list_insert_tail(&zfsvfs->z_delete_head.z_znodes, zp); 966fa9e4066Sahrens zfsvfs->z_delete_head.z_znode_count++; 967fa9e4066Sahrens cv_broadcast(&zfsvfs->z_delete_head.z_cv); 968fa9e4066Sahrens mutex_exit(&zfsvfs->z_delete_head.z_mutex); 969fa9e4066Sahrens } 970fa9e4066Sahrens VFS_RELE(zfsvfs->z_vfs); 971fa9e4066Sahrens return; 972fa9e4066Sahrens } 973fa9e4066Sahrens 974fa9e4066Sahrens /* 975fa9e4066Sahrens * If the file system for this znode is no longer mounted, 976fa9e4066Sahrens * evict the znode now, don't put it in the cache. 977fa9e4066Sahrens */ 978fa9e4066Sahrens if (zfsvfs->z_unmounted1) { 979fa9e4066Sahrens zfs_zcache_evict(zp, ZFS_OBJ_MUTEX(zp)); 980fa9e4066Sahrens return; 981fa9e4066Sahrens } 982fa9e4066Sahrens 983fa9e4066Sahrens /* put znode on evictable list */ 984fa9e4066Sahrens mutex_enter(&zp->z_zcache_state->mtx); 985fa9e4066Sahrens list_insert_head(&zp->z_zcache_state->list, zp); 986fa9e4066Sahrens zp->z_zcache_state->lcnt += 1; 987fa9e4066Sahrens mutex_exit(&zp->z_zcache_state->mtx); 988fa9e4066Sahrens mutex_exit(&zp->z_lock); 989fa9e4066Sahrens ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 990fa9e4066Sahrens } 991fa9e4066Sahrens 992fa9e4066Sahrens void 993fa9e4066Sahrens zfs_znode_free(znode_t *zp) 994fa9e4066Sahrens { 995fa9e4066Sahrens zfsvfs_t *zfsvfs = zp->z_zfsvfs; 996fa9e4066Sahrens 997fa9e4066Sahrens mutex_enter(&zfsvfs->z_znodes_lock); 998fa9e4066Sahrens list_remove(&zfsvfs->z_all_znodes, zp); 999fa9e4066Sahrens mutex_exit(&zfsvfs->z_znodes_lock); 1000fa9e4066Sahrens 1001fa9e4066Sahrens kmem_cache_free(znode_cache, zp); 1002fa9e4066Sahrens } 1003fa9e4066Sahrens 1004fa9e4066Sahrens void 1005fa9e4066Sahrens zfs_time_stamper_locked(znode_t *zp, uint_t flag, dmu_tx_t *tx) 1006fa9e4066Sahrens { 1007fa9e4066Sahrens timestruc_t now; 1008fa9e4066Sahrens 1009fa9e4066Sahrens ASSERT(MUTEX_HELD(&zp->z_lock)); 1010fa9e4066Sahrens 1011fa9e4066Sahrens gethrestime(&now); 1012fa9e4066Sahrens 1013fa9e4066Sahrens if (tx) { 1014fa9e4066Sahrens dmu_buf_will_dirty(zp->z_dbuf, tx); 1015fa9e4066Sahrens zp->z_atime_dirty = 0; 1016fa9e4066Sahrens zp->z_seq++; 1017fa9e4066Sahrens } else { 1018fa9e4066Sahrens zp->z_atime_dirty = 1; 1019fa9e4066Sahrens } 1020fa9e4066Sahrens 1021fa9e4066Sahrens if (flag & AT_ATIME) 1022fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_atime); 1023fa9e4066Sahrens 1024fa9e4066Sahrens if (flag & AT_MTIME) 1025fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_mtime); 1026fa9e4066Sahrens 1027fa9e4066Sahrens if (flag & AT_CTIME) 1028fa9e4066Sahrens ZFS_TIME_ENCODE(&now, zp->z_phys->zp_ctime); 1029fa9e4066Sahrens } 1030fa9e4066Sahrens 1031fa9e4066Sahrens /* 1032fa9e4066Sahrens * Update the requested znode timestamps with the current time. 1033fa9e4066Sahrens * If we are in a transaction, then go ahead and mark the znode 1034fa9e4066Sahrens * dirty in the transaction so the timestamps will go to disk. 1035fa9e4066Sahrens * Otherwise, we will get pushed next time the znode is updated 1036fa9e4066Sahrens * in a transaction, or when this znode eventually goes inactive. 1037fa9e4066Sahrens * 1038fa9e4066Sahrens * Why is this OK? 1039fa9e4066Sahrens * 1 - Only the ACCESS time is ever updated outside of a transaction. 1040fa9e4066Sahrens * 2 - Multiple consecutive updates will be collapsed into a single 1041fa9e4066Sahrens * znode update by the transaction grouping semantics of the DMU. 1042fa9e4066Sahrens */ 1043fa9e4066Sahrens void 1044fa9e4066Sahrens zfs_time_stamper(znode_t *zp, uint_t flag, dmu_tx_t *tx) 1045fa9e4066Sahrens { 1046fa9e4066Sahrens mutex_enter(&zp->z_lock); 1047fa9e4066Sahrens zfs_time_stamper_locked(zp, flag, tx); 1048fa9e4066Sahrens mutex_exit(&zp->z_lock); 1049fa9e4066Sahrens } 1050fa9e4066Sahrens 1051fa9e4066Sahrens /* 1052fa9e4066Sahrens * Grow the block size for a file. This may involve migrating data 1053fa9e4066Sahrens * from the bonus buffer into a data block (when we grow beyond the 1054fa9e4066Sahrens * bonus buffer data area). 1055fa9e4066Sahrens * 1056fa9e4066Sahrens * IN: zp - znode of file to free data in. 1057fa9e4066Sahrens * size - requested block size 1058fa9e4066Sahrens * tx - open transaction. 1059fa9e4066Sahrens * 1060fa9e4066Sahrens * RETURN: 0 if success 1061fa9e4066Sahrens * error code if failure 1062fa9e4066Sahrens * 1063fa9e4066Sahrens * NOTE: this function assumes that the znode is write locked. 1064fa9e4066Sahrens */ 1065fa9e4066Sahrens int 1066fa9e4066Sahrens zfs_grow_blocksize(znode_t *zp, uint64_t size, dmu_tx_t *tx) 1067fa9e4066Sahrens { 1068fa9e4066Sahrens int error; 1069fa9e4066Sahrens u_longlong_t dummy; 1070fa9e4066Sahrens 1071fa9e4066Sahrens ASSERT(rw_write_held(&zp->z_grow_lock)); 1072fa9e4066Sahrens 1073fa9e4066Sahrens if (size <= zp->z_blksz) 1074fa9e4066Sahrens return (0); 1075fa9e4066Sahrens /* 1076fa9e4066Sahrens * If the file size is already greater than the current blocksize, 1077fa9e4066Sahrens * we will not grow. If there is more than one block in a file, 1078fa9e4066Sahrens * the blocksize cannot change. 1079fa9e4066Sahrens */ 1080fa9e4066Sahrens if (zp->z_blksz && zp->z_phys->zp_size > zp->z_blksz) 1081fa9e4066Sahrens return (0); 1082fa9e4066Sahrens 1083fa9e4066Sahrens error = dmu_object_set_blocksize(zp->z_zfsvfs->z_os, zp->z_id, 1084fa9e4066Sahrens size, 0, tx); 1085fa9e4066Sahrens if (error == ENOTSUP) 1086fa9e4066Sahrens return (0); 1087fa9e4066Sahrens ASSERT3U(error, ==, 0); 1088fa9e4066Sahrens 1089fa9e4066Sahrens /* What blocksize did we actually get? */ 1090fa9e4066Sahrens dmu_object_size_from_db(zp->z_dbuf, &zp->z_blksz, &dummy); 1091fa9e4066Sahrens 1092fa9e4066Sahrens return (0); 1093fa9e4066Sahrens } 1094fa9e4066Sahrens 1095fa9e4066Sahrens /* 1096fa9e4066Sahrens * This is a dummy interface used when pvn_vplist_dirty() should *not* 1097fa9e4066Sahrens * be calling back into the fs for a putpage(). E.g.: when truncating 1098fa9e4066Sahrens * a file, the pages being "thrown away* don't need to be written out. 1099fa9e4066Sahrens */ 1100fa9e4066Sahrens /* ARGSUSED */ 1101fa9e4066Sahrens static int 1102fa9e4066Sahrens zfs_no_putpage(vnode_t *vp, page_t *pp, u_offset_t *offp, size_t *lenp, 1103fa9e4066Sahrens int flags, cred_t *cr) 1104fa9e4066Sahrens { 1105fa9e4066Sahrens ASSERT(0); 1106fa9e4066Sahrens return (0); 1107fa9e4066Sahrens } 1108fa9e4066Sahrens 1109fa9e4066Sahrens /* 1110fa9e4066Sahrens * Free space in a file. Currently, this function only 1111fa9e4066Sahrens * supports freeing space at the end of the file. 1112fa9e4066Sahrens * 1113fa9e4066Sahrens * IN: zp - znode of file to free data in. 1114fa9e4066Sahrens * from - start of section to free. 1115fa9e4066Sahrens * len - length of section to free (0 => to EOF). 1116fa9e4066Sahrens * flag - current file open mode flags. 1117fa9e4066Sahrens * tx - open transaction. 1118fa9e4066Sahrens * 1119fa9e4066Sahrens * RETURN: 0 if success 1120fa9e4066Sahrens * error code if failure 1121fa9e4066Sahrens */ 1122fa9e4066Sahrens int 1123fa9e4066Sahrens zfs_freesp(znode_t *zp, uint64_t from, uint64_t len, int flag, dmu_tx_t *tx, 1124fa9e4066Sahrens cred_t *cr) 1125fa9e4066Sahrens { 1126fa9e4066Sahrens vnode_t *vp = ZTOV(zp); 1127fa9e4066Sahrens uint64_t size = zp->z_phys->zp_size; 1128fa9e4066Sahrens uint64_t end = from + len; 1129fa9e4066Sahrens int have_grow_lock, error; 1130fa9e4066Sahrens 1131*8ef9dde0Smarks if (ZTOV(zp)->v_type == VFIFO) 1132*8ef9dde0Smarks return (0); 1133*8ef9dde0Smarks 1134fa9e4066Sahrens have_grow_lock = RW_WRITE_HELD(&zp->z_grow_lock); 1135fa9e4066Sahrens 1136fa9e4066Sahrens /* 1137fa9e4066Sahrens * Nothing to do if file already at desired length. 1138fa9e4066Sahrens */ 1139fa9e4066Sahrens if (len == 0 && size == from) { 1140fa9e4066Sahrens return (0); 1141fa9e4066Sahrens } 1142fa9e4066Sahrens 1143fa9e4066Sahrens /* 1144fa9e4066Sahrens * Check for any locks in the region to be freed. 1145fa9e4066Sahrens */ 1146fa9e4066Sahrens if (MANDLOCK(vp, (mode_t)zp->z_phys->zp_mode)) { 1147fa9e4066Sahrens uint64_t start; 1148fa9e4066Sahrens 1149fa9e4066Sahrens if (size > from) 1150fa9e4066Sahrens start = from; 1151fa9e4066Sahrens else 1152fa9e4066Sahrens start = size; 1153fa9e4066Sahrens if (error = chklock(vp, FWRITE, start, 0, flag, NULL)) 1154fa9e4066Sahrens return (error); 1155fa9e4066Sahrens } 1156fa9e4066Sahrens 1157fa9e4066Sahrens if (end > zp->z_blksz && (!ISP2(zp->z_blksz) || 1158fa9e4066Sahrens zp->z_blksz < zp->z_zfsvfs->z_max_blksz)) { 1159fa9e4066Sahrens uint64_t new_blksz; 1160fa9e4066Sahrens /* 1161fa9e4066Sahrens * We are growing the file past the current block size. 1162fa9e4066Sahrens */ 1163fa9e4066Sahrens if (zp->z_blksz > zp->z_zfsvfs->z_max_blksz) { 1164fa9e4066Sahrens ASSERT(!ISP2(zp->z_blksz)); 1165fa9e4066Sahrens new_blksz = MIN(end, SPA_MAXBLOCKSIZE); 1166fa9e4066Sahrens } else { 1167fa9e4066Sahrens new_blksz = MIN(end, zp->z_zfsvfs->z_max_blksz); 1168fa9e4066Sahrens } 1169fa9e4066Sahrens error = zfs_grow_blocksize(zp, new_blksz, tx); 1170fa9e4066Sahrens ASSERT(error == 0); 1171fa9e4066Sahrens } 1172fa9e4066Sahrens if (end > size || len == 0) 1173fa9e4066Sahrens zp->z_phys->zp_size = end; 1174fa9e4066Sahrens if (from > size) 1175fa9e4066Sahrens return (0); 1176fa9e4066Sahrens 1177fa9e4066Sahrens if (have_grow_lock) 1178fa9e4066Sahrens rw_downgrade(&zp->z_grow_lock); 1179fa9e4066Sahrens /* 1180fa9e4066Sahrens * Clear any mapped pages in the truncated region. 1181fa9e4066Sahrens */ 1182fa9e4066Sahrens rw_enter(&zp->z_map_lock, RW_WRITER); 1183fa9e4066Sahrens if (vn_has_cached_data(vp)) { 1184fa9e4066Sahrens page_t *pp; 1185fa9e4066Sahrens uint64_t start = from & PAGEMASK; 1186fa9e4066Sahrens int off = from & PAGEOFFSET; 1187fa9e4066Sahrens 1188fa9e4066Sahrens if (off != 0 && (pp = page_lookup(vp, start, SE_SHARED))) { 1189fa9e4066Sahrens /* 1190fa9e4066Sahrens * We need to zero a partial page. 1191fa9e4066Sahrens */ 1192fa9e4066Sahrens pagezero(pp, off, PAGESIZE - off); 1193fa9e4066Sahrens start += PAGESIZE; 1194fa9e4066Sahrens page_unlock(pp); 1195fa9e4066Sahrens } 1196fa9e4066Sahrens error = pvn_vplist_dirty(vp, start, zfs_no_putpage, 1197fa9e4066Sahrens B_INVAL | B_TRUNC, cr); 1198fa9e4066Sahrens ASSERT(error == 0); 1199fa9e4066Sahrens } 1200fa9e4066Sahrens rw_exit(&zp->z_map_lock); 1201fa9e4066Sahrens 1202fa9e4066Sahrens if (!have_grow_lock) 1203fa9e4066Sahrens rw_enter(&zp->z_grow_lock, RW_READER); 1204fa9e4066Sahrens 1205fa9e4066Sahrens if (len == 0) 1206fa9e4066Sahrens len = -1; 1207fa9e4066Sahrens else if (end > size) 1208fa9e4066Sahrens len = size - from; 1209fa9e4066Sahrens dmu_free_range(zp->z_zfsvfs->z_os, zp->z_id, from, len, tx); 1210fa9e4066Sahrens 1211fa9e4066Sahrens if (!have_grow_lock) 1212fa9e4066Sahrens rw_exit(&zp->z_grow_lock); 1213fa9e4066Sahrens 1214fa9e4066Sahrens return (0); 1215fa9e4066Sahrens } 1216fa9e4066Sahrens 1217fa9e4066Sahrens 1218fa9e4066Sahrens void 1219fa9e4066Sahrens zfs_create_fs(objset_t *os, cred_t *cr, dmu_tx_t *tx) 1220fa9e4066Sahrens { 1221fa9e4066Sahrens zfsvfs_t zfsvfs; 1222fa9e4066Sahrens uint64_t moid, doid, roid = 0; 1223fa9e4066Sahrens uint64_t version = ZFS_VERSION; 1224fa9e4066Sahrens int error; 1225fa9e4066Sahrens znode_t *rootzp = NULL; 1226fa9e4066Sahrens vnode_t *vp; 1227fa9e4066Sahrens vattr_t vattr; 1228fa9e4066Sahrens 1229fa9e4066Sahrens /* 1230fa9e4066Sahrens * First attempt to create master node. 1231fa9e4066Sahrens */ 1232fa9e4066Sahrens moid = MASTER_NODE_OBJ; 1233fa9e4066Sahrens error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE, 1234fa9e4066Sahrens DMU_OT_NONE, 0, tx); 1235fa9e4066Sahrens ASSERT(error == 0); 1236fa9e4066Sahrens 1237fa9e4066Sahrens /* 1238fa9e4066Sahrens * Set starting attributes. 1239fa9e4066Sahrens */ 1240fa9e4066Sahrens 1241fa9e4066Sahrens error = zap_update(os, moid, ZFS_VERSION_OBJ, 8, 1, &version, tx); 1242fa9e4066Sahrens ASSERT(error == 0); 1243fa9e4066Sahrens 1244fa9e4066Sahrens /* 1245fa9e4066Sahrens * Create a delete queue. 1246fa9e4066Sahrens */ 1247fa9e4066Sahrens doid = zap_create(os, DMU_OT_DELETE_QUEUE, DMU_OT_NONE, 0, tx); 1248fa9e4066Sahrens 1249fa9e4066Sahrens error = zap_add(os, moid, ZFS_DELETE_QUEUE, 8, 1, &doid, tx); 1250fa9e4066Sahrens ASSERT(error == 0); 1251fa9e4066Sahrens 1252fa9e4066Sahrens /* 1253fa9e4066Sahrens * Create root znode. Create minimal znode/vnode/zfsvfs 1254fa9e4066Sahrens * to allow zfs_mknode to work. 1255fa9e4066Sahrens */ 1256fa9e4066Sahrens vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE; 1257fa9e4066Sahrens vattr.va_type = VDIR; 1258fa9e4066Sahrens vattr.va_mode = S_IFDIR|0755; 1259fa9e4066Sahrens vattr.va_uid = 0; 1260fa9e4066Sahrens vattr.va_gid = 3; 1261fa9e4066Sahrens 1262fa9e4066Sahrens rootzp = kmem_cache_alloc(znode_cache, KM_SLEEP); 1263fa9e4066Sahrens rootzp->z_zfsvfs = &zfsvfs; 1264fa9e4066Sahrens rootzp->z_active = 1; 1265fa9e4066Sahrens rootzp->z_reap = 0; 1266fa9e4066Sahrens rootzp->z_atime_dirty = 0; 1267fa9e4066Sahrens rootzp->z_dbuf_held = 0; 1268fa9e4066Sahrens 1269fa9e4066Sahrens vp = ZTOV(rootzp); 1270fa9e4066Sahrens vn_reinit(vp); 1271fa9e4066Sahrens vp->v_type = VDIR; 1272fa9e4066Sahrens 1273fa9e4066Sahrens bzero(&zfsvfs, sizeof (zfsvfs_t)); 1274fa9e4066Sahrens 1275fa9e4066Sahrens zfsvfs.z_os = os; 1276fa9e4066Sahrens zfsvfs.z_assign = TXG_NOWAIT; 1277fa9e4066Sahrens zfsvfs.z_parent = &zfsvfs; 1278fa9e4066Sahrens 1279fa9e4066Sahrens mutex_init(&zfsvfs.z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 1280fa9e4066Sahrens list_create(&zfsvfs.z_all_znodes, sizeof (znode_t), 1281fa9e4066Sahrens offsetof(znode_t, z_link_node)); 1282fa9e4066Sahrens 1283fa9e4066Sahrens zfs_mknode(rootzp, &vattr, &roid, tx, cr, IS_ROOT_NODE, NULL, 0); 1284fa9e4066Sahrens ASSERT3U(rootzp->z_id, ==, roid); 1285fa9e4066Sahrens error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &roid, tx); 1286fa9e4066Sahrens ASSERT(error == 0); 1287fa9e4066Sahrens 1288fa9e4066Sahrens ZTOV(rootzp)->v_count = 0; 1289fa9e4066Sahrens kmem_cache_free(znode_cache, rootzp); 1290fa9e4066Sahrens } 1291