1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26/* Portions Copyright 2007 Jeremy Teo */ 27 28#ifdef _KERNEL 29#include <sys/types.h> 30#include <sys/param.h> 31#include <sys/time.h> 32#include <sys/systm.h> 33#include <sys/sysmacros.h> 34#include <sys/resource.h> 35#include <sys/mntent.h> 36#include <sys/u8_textprep.h> 37#include <sys/dsl_dataset.h> 38#include <sys/vfs.h> 39#include <sys/vnode.h> 40#include <sys/file.h> 41#include <sys/kmem.h> 42#include <sys/errno.h> 43#include <sys/unistd.h> 44#include <sys/atomic.h> 45#include <sys/zfs_dir.h> 46#include <sys/zfs_acl.h> 47#include <sys/zfs_ioctl.h> 48#include <sys/zfs_rlock.h> 49#include <sys/zfs_fuid.h> 50#include <sys/fs/zfs.h> 51#include <sys/kidmap.h> 52#endif /* _KERNEL */ 53 54#include <sys/dmu.h> 55#include <sys/refcount.h> 56#include <sys/stat.h> 57#include <sys/zap.h> 58#include <sys/zfs_znode.h> 59 60#include "zfs_prop.h" 61 62#if defined(_KERNEL) && defined(__NetBSD__) 63#include <miscfs/specfs/specdev.h> 64static const struct genfs_ops zfs_genfsops = { 65 .gop_write = genfs_compat_gop_write, 66}; 67 68#endif 69 70extern int (**zfs_vnodeop_p)(void *); 71extern int (**zfs_fifoop_p)(void *); 72extern int (**zfs_specop_p)(void *); 73 74/* 75 * Define ZNODE_STATS to turn on statistic gathering. By default, it is only 76 * turned on when DEBUG is also defined. 77 */ 78#ifdef DEBUG 79#define ZNODE_STATS 80#endif /* DEBUG */ 81 82#ifdef ZNODE_STATS 83#define ZNODE_STAT_ADD(stat) ((stat)++) 84#else 85#define ZNODE_STAT_ADD(stat) /* nothing */ 86#endif /* ZNODE_STATS */ 87 88#define POINTER_IS_VALID(p) (!((uintptr_t)(p) & 0x3)) 89#define POINTER_INVALIDATE(pp) (*(pp) = (void *)((uintptr_t)(*(pp)) | 0x1)) 90 91/* 92 * Functions needed for userland (ie: libzpool) are not put under 93 * #ifdef_KERNEL; the rest of the functions have dependencies 94 * (such as VFS logic) that will not compile easily in userland. 95 */ 96#ifdef _KERNEL 97/* 98 * Needed to close a small window in zfs_znode_move() that allows the zfsvfs to 99 * be freed before it can be safely accessed. 100 */ 101krwlock_t zfsvfs_lock; 102 103static kmem_cache_t *znode_cache = NULL; 104 105/*ARGSUSED*/ 106static void 107znode_evict_error(dmu_buf_t *dbuf, void *user_ptr) 108{ 109 /* 110 * We should never drop all dbuf refs without first clearing 111 * the eviction callback. 112 */ 113 panic("evicting znode %p\n", user_ptr); 114} 115 116/*ARGSUSED*/ 117static int 118zfs_znode_cache_constructor(void *buf, void *arg, int kmflags) 119{ 120 znode_t *zp = arg; 121 122 ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs)); 123 124 list_link_init(&zp->z_link_node); 125 126 mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL); 127 rw_init(&zp->z_parent_lock, NULL, RW_DEFAULT, NULL); 128 rw_init(&zp->z_name_lock, NULL, RW_DEFAULT, NULL); 129 mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL); 130 131 mutex_init(&zp->z_range_lock, NULL, MUTEX_DEFAULT, NULL); 132 avl_create(&zp->z_range_avl, zfs_range_compare, 133 sizeof (rl_t), offsetof(rl_t, r_node)); 134 135 zp->z_dbuf = NULL; 136 zp->z_dirlocks = NULL; 137 zp->z_acl_cached = NULL; 138 return (0); 139} 140 141/*ARGSUSED*/ 142static void 143zfs_znode_cache_destructor(void *buf, void *arg) 144{ 145 znode_t *zp = arg; 146 147 ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs)); 148 ASSERT(ZTOV(zp) == NULL); 149 150 ASSERT(!list_link_active(&zp->z_link_node)); 151 mutex_destroy(&zp->z_lock); 152 rw_destroy(&zp->z_parent_lock); 153 rw_destroy(&zp->z_name_lock); 154 mutex_destroy(&zp->z_acl_lock); 155 avl_destroy(&zp->z_range_avl); 156 mutex_destroy(&zp->z_range_lock); 157 158 ASSERT(zp->z_dbuf == NULL); 159 ASSERT(zp->z_dirlocks == NULL); 160 ASSERT(zp->z_acl_cached == NULL); 161} 162 163#ifdef ZNODE_STATS 164static struct { 165 uint64_t zms_zfsvfs_invalid; 166 uint64_t zms_zfsvfs_recheck1; 167 uint64_t zms_zfsvfs_unmounted; 168 uint64_t zms_zfsvfs_recheck2; 169 uint64_t zms_obj_held; 170 uint64_t zms_vnode_locked; 171 uint64_t zms_not_only_dnlc; 172} znode_move_stats; 173#endif /* ZNODE_STATS */ 174 175static void 176zfs_znode_move_impl(znode_t *ozp, znode_t *nzp) 177{ 178 vnode_t *vp; 179 180 /* Copy fields. */ 181 nzp->z_zfsvfs = ozp->z_zfsvfs; 182 183 /* Swap vnodes. */ 184 vp = nzp->z_vnode; 185 nzp->z_vnode = ozp->z_vnode; 186 ozp->z_vnode = vp; /* let destructor free the overwritten vnode */ 187 ZTOV(ozp)->v_data = ozp; 188 ZTOV(nzp)->v_data = nzp; 189 190 nzp->z_id = ozp->z_id; 191 ASSERT(ozp->z_dirlocks == NULL); /* znode not in use */ 192 ASSERT(avl_numnodes(&ozp->z_range_avl) == 0); 193 nzp->z_unlinked = ozp->z_unlinked; 194 nzp->z_atime_dirty = ozp->z_atime_dirty; 195 nzp->z_zn_prefetch = ozp->z_zn_prefetch; 196 nzp->z_blksz = ozp->z_blksz; 197 nzp->z_seq = ozp->z_seq; 198 nzp->z_mapcnt = ozp->z_mapcnt; 199 nzp->z_last_itx = ozp->z_last_itx; 200 nzp->z_gen = ozp->z_gen; 201 nzp->z_sync_cnt = ozp->z_sync_cnt; 202 nzp->z_phys = ozp->z_phys; 203 nzp->z_dbuf = ozp->z_dbuf; 204 205 /* 206 * Since this is just an idle znode and kmem is already dealing with 207 * memory pressure, release any cached ACL. 208 */ 209 if (ozp->z_acl_cached) { 210 zfs_acl_free(ozp->z_acl_cached); 211 ozp->z_acl_cached = NULL; 212 } 213 214 /* Update back pointers. */ 215 (void) dmu_buf_update_user(nzp->z_dbuf, ozp, nzp, &nzp->z_phys, 216 znode_evict_error); 217 218 /* 219 * Invalidate the original znode by clearing fields that provide a 220 * pointer back to the znode. Set the low bit of the vfs pointer to 221 * ensure that zfs_znode_move() recognizes the znode as invalid in any 222 * subsequent callback. 223 */ 224 ozp->z_dbuf = NULL; 225 POINTER_INVALIDATE(&ozp->z_zfsvfs); 226} 227 228#ifndef __NetBSD__ 229/*ARGSUSED*/ 230static kmem_cbrc_t 231zfs_znode_move(void *buf, void *newbuf, size_t size, void *arg) 232{ 233 znode_t *ozp = buf, *nzp = newbuf; 234 zfsvfs_t *zfsvfs; 235 vnode_t *vp; 236 237 /* 238 * The znode is on the file system's list of known znodes if the vfs 239 * pointer is valid. We set the low bit of the vfs pointer when freeing 240 * the znode to invalidate it, and the memory patterns written by kmem 241 * (baddcafe and deadbeef) set at least one of the two low bits. A newly 242 * created znode sets the vfs pointer last of all to indicate that the 243 * znode is known and in a valid state to be moved by this function. 244 */ 245 zfsvfs = ozp->z_zfsvfs; 246 if (!POINTER_IS_VALID(zfsvfs)) { 247 ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_invalid); 248 return (KMEM_CBRC_DONT_KNOW); 249 } 250 251 /* 252 * Close a small window in which it's possible that the filesystem could 253 * be unmounted and freed, and zfsvfs, though valid in the previous 254 * statement, could point to unrelated memory by the time we try to 255 * prevent the filesystem from being unmounted. 256 */ 257 rw_enter(&zfsvfs_lock, RW_WRITER); 258 if (zfsvfs != ozp->z_zfsvfs) { 259 rw_exit(&zfsvfs_lock); 260 ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_recheck1); 261 return (KMEM_CBRC_DONT_KNOW); 262 } 263 264 /* 265 * If the znode is still valid, then so is the file system. We know that 266 * no valid file system can be freed while we hold zfsvfs_lock, so we 267 * can safely ensure that the filesystem is not and will not be 268 * unmounted. The next statement is equivalent to ZFS_ENTER(). 269 */ 270 rrw_enter(&zfsvfs->z_teardown_lock, RW_READER, FTAG); 271 if (zfsvfs->z_unmounted) { 272 ZFS_EXIT(zfsvfs); 273 rw_exit(&zfsvfs_lock); 274 ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_unmounted); 275 return (KMEM_CBRC_DONT_KNOW); 276 } 277 rw_exit(&zfsvfs_lock); 278 279 mutex_enter(&zfsvfs->z_znodes_lock); 280 /* 281 * Recheck the vfs pointer in case the znode was removed just before 282 * acquiring the lock. 283 */ 284 if (zfsvfs != ozp->z_zfsvfs) { 285 mutex_exit(&zfsvfs->z_znodes_lock); 286 ZFS_EXIT(zfsvfs); 287 ZNODE_STAT_ADD(znode_move_stats.zms_zfsvfs_recheck2); 288 return (KMEM_CBRC_DONT_KNOW); 289 } 290 291 /* 292 * At this point we know that as long as we hold z_znodes_lock, the 293 * znode cannot be freed and fields within the znode can be safely 294 * accessed. Now, prevent a race with zfs_zget(). 295 */ 296 if (ZFS_OBJ_HOLD_TRYENTER(zfsvfs, ozp->z_id) == 0) { 297 mutex_exit(&zfsvfs->z_znodes_lock); 298 ZFS_EXIT(zfsvfs); 299 ZNODE_STAT_ADD(znode_move_stats.zms_obj_held); 300 return (KMEM_CBRC_LATER); 301 } 302 303 vp = ZTOV(ozp); 304 if (mutex_tryenter(&vp->v_lock) == 0) { 305 ZFS_OBJ_HOLD_EXIT(zfsvfs, ozp->z_id); 306 mutex_exit(&zfsvfs->z_znodes_lock); 307 ZFS_EXIT(zfsvfs); 308 ZNODE_STAT_ADD(znode_move_stats.zms_vnode_locked); 309 return (KMEM_CBRC_LATER); 310 } 311 312 /* Only move znodes that are referenced _only_ by the DNLC. */ 313 if (vp->v_count != 1 || !vn_in_dnlc(vp)) { 314 mutex_exit(&vp->v_lock); 315 ZFS_OBJ_HOLD_EXIT(zfsvfs, ozp->z_id); 316 mutex_exit(&zfsvfs->z_znodes_lock); 317 ZFS_EXIT(zfsvfs); 318 ZNODE_STAT_ADD(znode_move_stats.zms_not_only_dnlc); 319 return (KMEM_CBRC_LATER); 320 } 321 322 /* 323 * The znode is known and in a valid state to move. We're holding the 324 * locks needed to execute the critical section. 325 */ 326 zfs_znode_move_impl(ozp, nzp); 327 mutex_exit(&vp->v_lock); 328 ZFS_OBJ_HOLD_EXIT(zfsvfs, ozp->z_id); 329 330 list_link_replace(&ozp->z_link_node, &nzp->z_link_node); 331 mutex_exit(&zfsvfs->z_znodes_lock); 332 ZFS_EXIT(zfsvfs); 333 334 return (KMEM_CBRC_YES); 335} 336#endif /* !__NetBSD__ */ 337 338void 339zfs_znode_init(void) 340{ 341 /* 342 * Initialize zcache 343 */ 344 rw_init(&zfsvfs_lock, NULL, RW_DEFAULT, NULL); 345 ASSERT(znode_cache == NULL); 346 znode_cache = kmem_cache_create("zfs_znode_cache", 347 sizeof (znode_t), 0, zfs_znode_cache_constructor, 348 zfs_znode_cache_destructor, NULL, NULL, NULL, 0); 349} 350 351void 352zfs_znode_fini(void) 353{ 354 355 /* 356 * Cleanup zcache 357 */ 358 if (znode_cache) 359 kmem_cache_destroy(znode_cache); 360 znode_cache = NULL; 361 rw_destroy(&zfsvfs_lock); 362} 363 364#ifndef __NetBSD__ 365struct vnodeops *zfs_dvnodeops; 366struct vnodeops *zfs_fvnodeops; 367struct vnodeops *zfs_symvnodeops; 368struct vnodeops *zfs_xdvnodeops; 369struct vnodeops *zfs_evnodeops; 370struct vnodeops *zfs_sharevnodeops; 371#endif 372 373void 374zfs_remove_op_tables() 375{ 376#ifndef __NetBSD__ 377 /* 378 * Remove vfs ops 379 */ 380 ASSERT(zfsfstype); 381 (void) vfs_freevfsops_by_type(zfsfstype); 382 zfsfstype = 0; 383 384 /* 385 * Remove vnode ops 386 */ 387 if (zfs_dvnodeops) 388 vn_freevnodeops(zfs_dvnodeops); 389 if (zfs_fvnodeops) 390 vn_freevnodeops(zfs_fvnodeops); 391 if (zfs_symvnodeops) 392 vn_freevnodeops(zfs_symvnodeops); 393 if (zfs_xdvnodeops) 394 vn_freevnodeops(zfs_xdvnodeops); 395 if (zfs_evnodeops) 396 vn_freevnodeops(zfs_evnodeops); 397 if (zfs_sharevnodeops) 398 vn_freevnodeops(zfs_sharevnodeops); 399 400 zfs_dvnodeops = NULL; 401 zfs_fvnodeops = NULL; 402 zfs_symvnodeops = NULL; 403 zfs_xdvnodeops = NULL; 404 zfs_evnodeops = NULL; 405 zfs_sharevnodeops = NULL; 406#endif 407} 408 409#ifndef __NetBSD__ 410extern const fs_operation_def_t zfs_dvnodeops_template[]; 411extern const fs_operation_def_t zfs_fvnodeops_template[]; 412extern const fs_operation_def_t zfs_xdvnodeops_template[]; 413extern const fs_operation_def_t zfs_symvnodeops_template[]; 414extern const fs_operation_def_t zfs_evnodeops_template[]; 415extern const fs_operation_def_t zfs_sharevnodeops_template[]; 416#endif 417 418int 419zfs_create_op_tables() 420{ 421#ifndef __NetBSD__ 422 int error; 423 424 /* 425 * zfs_dvnodeops can be set if mod_remove() calls mod_installfs() 426 * due to a failure to remove the the 2nd modlinkage (zfs_modldrv). 427 * In this case we just return as the ops vectors are already set up. 428 */ 429 if (zfs_dvnodeops) 430 return (0); 431 432 error = vn_make_ops(MNTTYPE_ZFS, zfs_dvnodeops_template, 433 &zfs_dvnodeops); 434 if (error) 435 return (error); 436 437 error = vn_make_ops(MNTTYPE_ZFS, zfs_fvnodeops_template, 438 &zfs_fvnodeops); 439 if (error) 440 return (error); 441 442 error = vn_make_ops(MNTTYPE_ZFS, zfs_symvnodeops_template, 443 &zfs_symvnodeops); 444 if (error) 445 return (error); 446 447 error = vn_make_ops(MNTTYPE_ZFS, zfs_xdvnodeops_template, 448 &zfs_xdvnodeops); 449 if (error) 450 return (error); 451 452 error = vn_make_ops(MNTTYPE_ZFS, zfs_evnodeops_template, 453 &zfs_evnodeops); 454 if (error) 455 return (error); 456 457 error = vn_make_ops(MNTTYPE_ZFS, zfs_sharevnodeops_template, 458 &zfs_sharevnodeops); 459 460 return (error); 461#endif 462 return 0; 463} 464 465int 466zfs_create_share_dir(zfsvfs_t *zfsvfs, dmu_tx_t *tx) 467{ 468 zfs_acl_ids_t acl_ids; 469 vattr_t vattr; 470 znode_t *sharezp; 471 vnode_t *vp; 472 znode_t *zp; 473 int error; 474 475 vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE; 476 vattr.va_type = VDIR; 477 vattr.va_mode = S_IFDIR|0555; 478 vattr.va_uid = crgetuid(kcred); 479 vattr.va_gid = crgetgid(kcred); 480 481 sharezp = kmem_cache_alloc(znode_cache, KM_SLEEP); 482 sharezp->z_unlinked = 0; 483 sharezp->z_atime_dirty = 0; 484 sharezp->z_zfsvfs = zfsvfs; 485 486 vp = ZTOV(sharezp); 487 error = getnewvnode(VT_ZFS, zfsvfs->z_parent->z_vfs, 488 zfs_vnodeop_p, NULL, &sharezp->z_vnode); 489 if (error) { 490 kmem_cache_free(znode_cache, sharezp); 491 return error; 492 } 493 vp->v_type = VDIR; 494 495 VERIFY(0 == zfs_acl_ids_create(sharezp, IS_ROOT_NODE, &vattr, 496 kcred, NULL, &acl_ids)); 497 zfs_mknode(sharezp, &vattr, tx, kcred, IS_ROOT_NODE, 498 &zp, 0, &acl_ids); 499 ASSERT3P(zp, ==, sharezp); 500 ASSERT(!vn_in_dnlc(ZTOV(sharezp))); /* not valid to move */ 501 POINTER_INVALIDATE(&sharezp->z_zfsvfs); 502 error = zap_add(zfsvfs->z_os, MASTER_NODE_OBJ, 503 ZFS_SHARES_DIR, 8, 1, &sharezp->z_id, tx); 504 zfsvfs->z_shares_dir = sharezp->z_id; 505 506 zfs_acl_ids_free(&acl_ids); 507 ZTOV(sharezp)->v_count = 0; 508 dmu_buf_rele(sharezp->z_dbuf, NULL); 509 sharezp->z_dbuf = NULL; 510 kmem_cache_free(znode_cache, sharezp); 511 512 return (error); 513} 514 515/* 516 * define a couple of values we need available 517 * for both 64 and 32 bit environments. 518 */ 519#ifndef NBITSMINOR64 520#define NBITSMINOR64 32 521#endif 522#ifndef MAXMAJ64 523#define MAXMAJ64 0xffffffffUL 524#endif 525#ifndef MAXMIN64 526#define MAXMIN64 0xffffffffUL 527#endif 528 529/* 530 * Create special expldev for ZFS private use. 531 * Can't use standard expldev since it doesn't do 532 * what we want. The standard expldev() takes a 533 * dev32_t in LP64 and expands it to a long dev_t. 534 * We need an interface that takes a dev32_t in ILP32 535 * and expands it to a long dev_t. 536 */ 537static uint64_t 538zfs_expldev(dev_t dev) 539{ 540 return ((uint64_t)major(dev) << NBITSMINOR64) | 541 (minor_t)minor(dev); 542} 543 544/* 545 * Special cmpldev for ZFS private use. 546 * Can't use standard cmpldev since it takes 547 * a long dev_t and compresses it to dev32_t in 548 * LP64. We need to do a compaction of a long dev_t 549 * to a dev32_t in ILP32. 550 */ 551dev_t 552zfs_cmpldev(uint64_t dev) 553{ 554 minor_t minor = (minor_t)dev & MAXMIN64; 555 major_t major = (major_t)(dev >> NBITSMINOR64) & MAXMAJ64; 556 557 return makedev(minor, major); 558} 559 560static void 561zfs_znode_dmu_init(zfsvfs_t *zfsvfs, znode_t *zp, dmu_buf_t *db) 562{ 563 znode_t *nzp; 564 565 ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs) || (zfsvfs == zp->z_zfsvfs)); 566 ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zfsvfs, zp->z_id))); 567 568 mutex_enter(&zp->z_lock); 569 570 ASSERT(zp->z_dbuf == NULL); 571 ASSERT(zp->z_acl_cached == NULL); 572 zp->z_dbuf = db; 573 nzp = dmu_buf_set_user_ie(db, zp, &zp->z_phys, znode_evict_error); 574 575 /* 576 * there should be no 577 * concurrent zgets on this object. 578 */ 579 if (nzp != NULL) 580 panic("existing znode %p for dbuf %p", (void *)nzp, (void *)db); 581 582 /* 583 * Slap on VROOT if we are the root znode 584 */ 585 if (zp->z_id == zfsvfs->z_root) 586 ZTOV(zp)->v_flag |= VROOT; 587 588 mutex_exit(&zp->z_lock); 589 vn_exists(ZTOV(zp)); 590} 591 592void 593zfs_znode_dmu_fini(znode_t *zp) 594{ 595 dmu_buf_t *db = zp->z_dbuf; 596 ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zp->z_zfsvfs, zp->z_id)) || 597 zp->z_unlinked || 598 RW_WRITE_HELD(&zp->z_zfsvfs->z_teardown_inactive_lock)); 599 ASSERT(zp->z_dbuf != NULL); 600 zp->z_dbuf = NULL; 601 VERIFY(zp == dmu_buf_update_user(db, zp, NULL, NULL, NULL)); 602 dmu_buf_rele(db, NULL); 603} 604 605/* 606 * Construct a new znode/vnode and intialize. 607 * 608 * This does not do a call to dmu_set_user() that is 609 * up to the caller to do, in case you don't want to 610 * return the znode 611 */ 612 613static znode_t * 614zfs_znode_alloc(zfsvfs_t *zfsvfs, dmu_buf_t *db, int blksz) 615{ 616 znode_t *zp; 617 vnode_t *vp; 618 int error; 619 620 zp = kmem_cache_alloc(znode_cache, KM_SLEEP); 621 for (;;) { 622 623 error = getnewvnode(VT_ZFS, zfsvfs->z_parent->z_vfs, 624 zfs_vnodeop_p, NULL, &zp->z_vnode); 625 if (__predict_true(error == 0)) 626 break; 627 printf("WARNING: zfs_znode_alloc: unable to get vnode, " 628 "error=%d\n", error); 629 (void)kpause("zfsnewvn", false, hz, NULL); 630 } 631 632 ASSERT(zp->z_dirlocks == NULL); 633 ASSERT(zp->z_dbuf == NULL); 634 ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs)); 635 636 /* 637 * Defer setting z_zfsvfs until the znode is ready to be a candidate for 638 * the zfs_znode_move() callback. 639 */ 640 zp->z_phys = NULL; 641 zp->z_unlinked = 0; 642 zp->z_atime_dirty = 0; 643 zp->z_mapcnt = 0; 644 zp->z_last_itx = 0; 645 zp->z_id = db->db_object; 646 zp->z_blksz = blksz; 647 zp->z_seq = 0x7A4653; 648 zp->z_sync_cnt = 0; 649 650 vp = ZTOV(zp); 651 652 zfs_znode_dmu_init(zfsvfs, zp, db); 653 654 zp->z_gen = zp->z_phys->zp_gen; 655 656 vp->v_vfsp = zfsvfs->z_parent->z_vfs; 657 vp->v_type = IFTOVT((mode_t)zp->z_phys->zp_mode); 658 vp->v_data = zp; 659 switch (vp->v_type) { 660 case VDIR: 661 zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */ 662 break; 663 case VBLK: 664 case VCHR: 665 /* XXX NetBSD vp->v_op = zfs_specop_p; */ 666 spec_node_init(vp, zfs_cmpldev(zp->z_phys->zp_rdev)); 667 break; 668 case VFIFO: 669 /* XXX NetBSD vp->v_op = zfs_fifoop_p; */ 670 break; 671 } 672 673 dprintf("zfs_znode_alloc znode %p -- vnode %p\n", zp, vp); 674 dprintf("zfs_znode_alloc z_id %ld\n", zp->z_id); 675 //cpu_Debugger(); 676 677 uvm_vnp_setsize(vp, zp->z_phys->zp_size); 678 679 mutex_enter(&zfsvfs->z_znodes_lock); 680 list_insert_tail(&zfsvfs->z_all_znodes, zp); 681 membar_producer(); 682 /* 683 * Everything else must be valid before assigning z_zfsvfs makes the 684 * znode eligible for zfs_znode_move(). 685 */ 686 zp->z_zfsvfs = zfsvfs; 687 mutex_exit(&zfsvfs->z_znodes_lock); 688 689 return (zp); 690} 691 692/* 693 * Create a new DMU object to hold a zfs znode. 694 * 695 * IN: dzp - parent directory for new znode 696 * vap - file attributes for new znode 697 * tx - dmu transaction id for zap operations 698 * cr - credentials of caller 699 * flag - flags: 700 * IS_ROOT_NODE - new object will be root 701 * IS_XATTR - new object is an attribute 702 * bonuslen - length of bonus buffer 703 * setaclp - File/Dir initial ACL 704 * fuidp - Tracks fuid allocation. 705 * 706 * OUT: zpp - allocated znode 707 * 708 */ 709void 710zfs_mknode(znode_t *dzp, vattr_t *vap, dmu_tx_t *tx, cred_t *cr, 711 uint_t flag, znode_t **zpp, int bonuslen, zfs_acl_ids_t *acl_ids) 712{ 713 dmu_buf_t *db; 714 znode_phys_t *pzp; 715 zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 716 timestruc_t now; 717 uint64_t gen, obj; 718 int err; 719 720 ASSERT(vap && (vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE)); 721 722 if (zfsvfs->z_replay) { 723 obj = vap->va_nodeid; 724 now = vap->va_ctime; /* see zfs_replay_create() */ 725 gen = vap->va_nblocks; /* ditto */ 726 } else { 727 obj = 0; 728 gethrestime(&now); 729 gen = dmu_tx_get_txg(tx); 730 } 731 732 /* 733 * Create a new DMU object. 734 */ 735 /* 736 * There's currently no mechanism for pre-reading the blocks that will 737 * be to needed allocate a new object, so we accept the small chance 738 * that there will be an i/o error and we will fail one of the 739 * assertions below. 740 */ 741 if (vap->va_type == VDIR) { 742 if (zfsvfs->z_replay) { 743 err = zap_create_claim_norm(zfsvfs->z_os, obj, 744 zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS, 745 DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 746 ASSERT3U(err, ==, 0); 747 } else { 748 obj = zap_create_norm(zfsvfs->z_os, 749 zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS, 750 DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 751 } 752 } else { 753 if (zfsvfs->z_replay) { 754 err = dmu_object_claim(zfsvfs->z_os, obj, 755 DMU_OT_PLAIN_FILE_CONTENTS, 0, 756 DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 757 ASSERT3U(err, ==, 0); 758 } else { 759 obj = dmu_object_alloc(zfsvfs->z_os, 760 DMU_OT_PLAIN_FILE_CONTENTS, 0, 761 DMU_OT_ZNODE, sizeof (znode_phys_t) + bonuslen, tx); 762 } 763 } 764 765 ZFS_OBJ_HOLD_ENTER(zfsvfs, obj); 766 VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, obj, NULL, &db)); 767 dmu_buf_will_dirty(db, tx); 768 769 /* 770 * Initialize the znode physical data to zero. 771 */ 772 ASSERT(db->db_size >= sizeof (znode_phys_t)); 773 bzero(db->db_data, db->db_size); 774 pzp = db->db_data; 775 776 /* 777 * If this is the root, fix up the half-initialized parent pointer 778 * to reference the just-allocated physical data area. 779 */ 780 if (flag & IS_ROOT_NODE) { 781 dzp->z_dbuf = db; 782 dzp->z_phys = pzp; 783 dzp->z_id = obj; 784 } 785 786 /* 787 * If parent is an xattr, so am I. 788 */ 789 if (dzp->z_phys->zp_flags & ZFS_XATTR) 790 flag |= IS_XATTR; 791 792 if (vap->va_type == VBLK || vap->va_type == VCHR) { 793 pzp->zp_rdev = zfs_expldev(vap->va_rdev); 794 } 795 796 if (zfsvfs->z_use_fuids) 797 pzp->zp_flags = ZFS_ARCHIVE | ZFS_AV_MODIFIED; 798 799 if (vap->va_type == VDIR) { 800 pzp->zp_size = 2; /* contents ("." and "..") */ 801 pzp->zp_links = (flag & (IS_ROOT_NODE | IS_XATTR)) ? 2 : 1; 802 } 803 804 pzp->zp_parent = dzp->z_id; 805 if (flag & IS_XATTR) 806 pzp->zp_flags |= ZFS_XATTR; 807 808 pzp->zp_gen = gen; 809 810 ZFS_TIME_ENCODE(&now, pzp->zp_crtime); 811 ZFS_TIME_ENCODE(&now, pzp->zp_ctime); 812 813 if (vap->va_mask & AT_ATIME) { 814 ZFS_TIME_ENCODE(&vap->va_atime, pzp->zp_atime); 815 } else { 816 ZFS_TIME_ENCODE(&now, pzp->zp_atime); 817 } 818 819 if (vap->va_mask & AT_MTIME) { 820 ZFS_TIME_ENCODE(&vap->va_mtime, pzp->zp_mtime); 821 } else { 822 ZFS_TIME_ENCODE(&now, pzp->zp_mtime); 823 } 824 pzp->zp_uid = acl_ids->z_fuid; 825 pzp->zp_gid = acl_ids->z_fgid; 826 pzp->zp_mode = acl_ids->z_mode; 827 if (!(flag & IS_ROOT_NODE)) { 828 *zpp = zfs_znode_alloc(zfsvfs, db, 0); 829 } else { 830 /* 831 * If we are creating the root node, the "parent" we 832 * passed in is the znode for the root. 833 */ 834 *zpp = dzp; 835 } 836 VERIFY(0 == zfs_aclset_common(*zpp, acl_ids->z_aclp, cr, tx)); 837 if (vap->va_mask & AT_XVATTR) 838 zfs_xvattr_set(*zpp, (xvattr_t *)vap); 839 840 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj); 841} 842 843void 844zfs_xvattr_set(znode_t *zp, xvattr_t *xvap) 845{ 846 xoptattr_t *xoap; 847 848 xoap = xva_getxoptattr(xvap); 849 ASSERT(xoap); 850 851 if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) { 852 ZFS_TIME_ENCODE(&xoap->xoa_createtime, zp->z_phys->zp_crtime); 853 XVA_SET_RTN(xvap, XAT_CREATETIME); 854 } 855 if (XVA_ISSET_REQ(xvap, XAT_READONLY)) { 856 ZFS_ATTR_SET(zp, ZFS_READONLY, xoap->xoa_readonly); 857 XVA_SET_RTN(xvap, XAT_READONLY); 858 } 859 if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) { 860 ZFS_ATTR_SET(zp, ZFS_HIDDEN, xoap->xoa_hidden); 861 XVA_SET_RTN(xvap, XAT_HIDDEN); 862 } 863 if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) { 864 ZFS_ATTR_SET(zp, ZFS_SYSTEM, xoap->xoa_system); 865 XVA_SET_RTN(xvap, XAT_SYSTEM); 866 } 867 if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) { 868 ZFS_ATTR_SET(zp, ZFS_ARCHIVE, xoap->xoa_archive); 869 XVA_SET_RTN(xvap, XAT_ARCHIVE); 870 } 871 if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) { 872 ZFS_ATTR_SET(zp, ZFS_IMMUTABLE, xoap->xoa_immutable); 873 XVA_SET_RTN(xvap, XAT_IMMUTABLE); 874 } 875 if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) { 876 ZFS_ATTR_SET(zp, ZFS_NOUNLINK, xoap->xoa_nounlink); 877 XVA_SET_RTN(xvap, XAT_NOUNLINK); 878 } 879 if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) { 880 ZFS_ATTR_SET(zp, ZFS_APPENDONLY, xoap->xoa_appendonly); 881 XVA_SET_RTN(xvap, XAT_APPENDONLY); 882 } 883 if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) { 884 ZFS_ATTR_SET(zp, ZFS_NODUMP, xoap->xoa_nodump); 885 XVA_SET_RTN(xvap, XAT_NODUMP); 886 } 887 if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) { 888 ZFS_ATTR_SET(zp, ZFS_OPAQUE, xoap->xoa_opaque); 889 XVA_SET_RTN(xvap, XAT_OPAQUE); 890 } 891 if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) { 892 ZFS_ATTR_SET(zp, ZFS_AV_QUARANTINED, 893 xoap->xoa_av_quarantined); 894 XVA_SET_RTN(xvap, XAT_AV_QUARANTINED); 895 } 896 if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) { 897 ZFS_ATTR_SET(zp, ZFS_AV_MODIFIED, xoap->xoa_av_modified); 898 XVA_SET_RTN(xvap, XAT_AV_MODIFIED); 899 } 900 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) { 901 (void) memcpy(zp->z_phys + 1, xoap->xoa_av_scanstamp, 902 sizeof (xoap->xoa_av_scanstamp)); 903 zp->z_phys->zp_flags |= ZFS_BONUS_SCANSTAMP; 904 XVA_SET_RTN(xvap, XAT_AV_SCANSTAMP); 905 } 906 if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) { 907 ZFS_ATTR_SET(zp, ZFS_REPARSE, xoap->xoa_reparse); 908 XVA_SET_RTN(xvap, XAT_REPARSE); 909 } 910} 911 912int 913zfs_zget(zfsvfs_t *zfsvfs, uint64_t obj_num, znode_t **zpp) 914{ 915 dmu_object_info_t doi; 916 dmu_buf_t *db; 917 znode_t *zp; 918 vnode_t *vp; 919 int err, first = 1; 920 921 *zpp = NULL; 922again: 923 ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num); 924 925 err = dmu_bonus_hold(zfsvfs->z_os, obj_num, NULL, &db); 926 if (err) { 927 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 928 return (err); 929 } 930 931 dmu_object_info_from_db(db, &doi); 932 if (doi.doi_bonus_type != DMU_OT_ZNODE || 933 doi.doi_bonus_size < sizeof (znode_phys_t)) { 934 dmu_buf_rele(db, NULL); 935 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 936 return (EINVAL); 937 } 938 939 zp = dmu_buf_get_user(db); 940 if (zp != NULL) { 941 mutex_enter(&zp->z_lock); 942 943 /* 944 * Since we do immediate eviction of the z_dbuf, we 945 * should never find a dbuf with a znode that doesn't 946 * know about the dbuf. 947 */ 948 ASSERT3P(zp->z_dbuf, ==, db); 949 ASSERT3U(zp->z_id, ==, obj_num); 950 if (zp->z_unlinked) { 951 err = ENOENT; 952 } else { 953 if ((vp = ZTOV(zp)) != NULL) { 954 mutex_enter(vp->v_interlock); 955 mutex_exit(&zp->z_lock); 956 if (vget(vp, 0) != 0) { 957 dmu_buf_rele(db, NULL); 958 mutex_exit(vp->v_interlock); 959 goto again; 960 } 961 mutex_enter(&zp->z_lock); 962 } else { 963 if (first) { 964 ZFS_LOG(1, "dying znode detected (zp=%p)", zp); 965 first = 0; 966 } 967 /* 968 * znode is dying so we can't reuse it, we must 969 * wait until destruction is completed. 970 */ 971 dmu_buf_rele(db, NULL); 972 mutex_exit(&zp->z_lock); 973 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 974 kpause("zcollide", 0, 1, NULL); 975 goto again; 976 } 977 *zpp = zp; 978 err = 0; 979 } 980 981 dmu_buf_rele(db, NULL); 982 mutex_exit(&zp->z_lock); 983 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 984 return (err); 985 } 986 987 /* 988 * Not found create new znode/vnode 989 * but only if file exists. 990 * 991 * There is a small window where zfs_vget() could 992 * find this object while a file create is still in 993 * progress. Since a gen number can never be zero 994 * we will check that to determine if its an allocated 995 * file. 996 */ 997 998 if (((znode_phys_t *)db->db_data)->zp_gen != 0) { 999 zp = zfs_znode_alloc(zfsvfs, db, doi.doi_data_block_size); 1000 *zpp = zp; 1001 1002 vp = ZTOV(zp); 1003 genfs_node_init(vp, &zfs_genfsops); 1004 VOP_UNLOCK(vp); 1005 1006 err = 0; 1007 } else { 1008 dmu_buf_rele(db, NULL); 1009 err = ENOENT; 1010 } 1011 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 1012 return (err); 1013} 1014 1015int 1016zfs_rezget(znode_t *zp) 1017{ 1018 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1019 dmu_object_info_t doi; 1020 dmu_buf_t *db; 1021 uint64_t obj_num = zp->z_id; 1022 int err; 1023 1024 ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num); 1025 1026 err = dmu_bonus_hold(zfsvfs->z_os, obj_num, NULL, &db); 1027 if (err) { 1028 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 1029 return (err); 1030 } 1031 1032 dmu_object_info_from_db(db, &doi); 1033 if (doi.doi_bonus_type != DMU_OT_ZNODE || 1034 doi.doi_bonus_size < sizeof (znode_phys_t)) { 1035 dmu_buf_rele(db, NULL); 1036 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 1037 return (EINVAL); 1038 } 1039 1040 if (((znode_phys_t *)db->db_data)->zp_gen != zp->z_gen) { 1041 dmu_buf_rele(db, NULL); 1042 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 1043 return (EIO); 1044 } 1045 1046 mutex_enter(&zp->z_acl_lock); 1047 if (zp->z_acl_cached) { 1048 zfs_acl_free(zp->z_acl_cached); 1049 zp->z_acl_cached = NULL; 1050 } 1051 mutex_exit(&zp->z_acl_lock); 1052 1053 zfs_znode_dmu_init(zfsvfs, zp, db); 1054 zp->z_unlinked = (zp->z_phys->zp_links == 0); 1055 zp->z_blksz = doi.doi_data_block_size; 1056 1057 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num); 1058 1059 return (0); 1060} 1061 1062void 1063zfs_znode_delete(znode_t *zp, dmu_tx_t *tx) 1064{ 1065 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1066 objset_t *os = zfsvfs->z_os; 1067 uint64_t obj = zp->z_id; 1068 uint64_t acl_obj = zp->z_phys->zp_acl.z_acl_extern_obj; 1069 1070 ZFS_OBJ_HOLD_ENTER(zfsvfs, obj); 1071 if (acl_obj) 1072 VERIFY(0 == dmu_object_free(os, acl_obj, tx)); 1073 VERIFY(0 == dmu_object_free(os, obj, tx)); 1074 zfs_znode_dmu_fini(zp); 1075 ZFS_OBJ_HOLD_EXIT(zfsvfs, obj); 1076 zfs_znode_free(zp); 1077} 1078 1079/* 1080 * zfs_zinactive must be called with ZFS_OBJ_HOLD_ENTER held. And this lock 1081 * will be released in zfs_zinactive. 1082 */ 1083void 1084zfs_zinactive(znode_t *zp) 1085{ 1086 vnode_t *vp = ZTOV(zp); 1087 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1088 uint64_t z_id = zp->z_id; 1089 1090 ASSERT(zp->z_dbuf && zp->z_phys); 1091 1092 /* 1093 * Don't allow a zfs_zget() while were trying to release this znode 1094 */ 1095 ZFS_OBJ_HOLD_ENTER(zfsvfs, z_id); 1096 1097 mutex_enter(&zp->z_lock); 1098 /* 1099 * If this was the last reference to a file with no links, 1100 * remove the file from the file system. 1101 */ 1102 if (zp->z_unlinked) { 1103 mutex_exit(&zp->z_lock); 1104 ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 1105 zfs_rmnode(zp); 1106 return; 1107 } 1108 1109 mutex_exit(&zp->z_lock); 1110 /* XXX why disabled zfs_znode_dmu_fini(zp); */ 1111 ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id); 1112 zfs_znode_free(zp); 1113} 1114 1115void 1116zfs_znode_free(znode_t *zp) 1117{ 1118 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1119 ASSERT(ZTOV(zp) == NULL); 1120 1121 dprintf("destroying znode %p\n", zp); 1122 //cpu_Debugger(); 1123 mutex_enter(&zfsvfs->z_znodes_lock); 1124 POINTER_INVALIDATE(&zp->z_zfsvfs); 1125 list_remove(&zfsvfs->z_all_znodes, zp); 1126 mutex_exit(&zfsvfs->z_znodes_lock); 1127 1128 if (zp->z_acl_cached) { 1129 zfs_acl_free(zp->z_acl_cached); 1130 zp->z_acl_cached = NULL; 1131 } 1132 1133 kmem_cache_free(znode_cache, zp); 1134 1135 VFS_RELE(zfsvfs->z_vfs); 1136} 1137 1138void 1139zfs_time_stamper_locked(znode_t *zp, uint_t flag, dmu_tx_t *tx) 1140{ 1141 timestruc_t now; 1142 1143 ASSERT(MUTEX_HELD(&zp->z_lock)); 1144 1145 gethrestime(&now); 1146 1147 if (tx) { 1148 dmu_buf_will_dirty(zp->z_dbuf, tx); 1149 zp->z_atime_dirty = 0; 1150 zp->z_seq++; 1151 } else { 1152 zp->z_atime_dirty = 1; 1153 } 1154 1155 if (flag & AT_ATIME) 1156 ZFS_TIME_ENCODE(&now, zp->z_phys->zp_atime); 1157 1158 if (flag & AT_MTIME) { 1159 ZFS_TIME_ENCODE(&now, zp->z_phys->zp_mtime); 1160 if (zp->z_zfsvfs->z_use_fuids) 1161 zp->z_phys->zp_flags |= (ZFS_ARCHIVE | ZFS_AV_MODIFIED); 1162 } 1163 1164 if (flag & AT_CTIME) { 1165 ZFS_TIME_ENCODE(&now, zp->z_phys->zp_ctime); 1166 if (zp->z_zfsvfs->z_use_fuids) 1167 zp->z_phys->zp_flags |= ZFS_ARCHIVE; 1168 } 1169} 1170 1171/* 1172 * Update the requested znode timestamps with the current time. 1173 * If we are in a transaction, then go ahead and mark the znode 1174 * dirty in the transaction so the timestamps will go to disk. 1175 * Otherwise, we will get pushed next time the znode is updated 1176 * in a transaction, or when this znode eventually goes inactive. 1177 * 1178 * Why is this OK? 1179 * 1 - Only the ACCESS time is ever updated outside of a transaction. 1180 * 2 - Multiple consecutive updates will be collapsed into a single 1181 * znode update by the transaction grouping semantics of the DMU. 1182 */ 1183void 1184zfs_time_stamper(znode_t *zp, uint_t flag, dmu_tx_t *tx) 1185{ 1186 mutex_enter(&zp->z_lock); 1187 zfs_time_stamper_locked(zp, flag, tx); 1188 mutex_exit(&zp->z_lock); 1189} 1190 1191/* 1192 * Grow the block size for a file. 1193 * 1194 * IN: zp - znode of file to free data in. 1195 * size - requested block size 1196 * tx - open transaction. 1197 * 1198 * NOTE: this function assumes that the znode is write locked. 1199 */ 1200void 1201zfs_grow_blocksize(znode_t *zp, uint64_t size, dmu_tx_t *tx) 1202{ 1203 int error; 1204 u_longlong_t dummy; 1205 1206 if (size <= zp->z_blksz) 1207 return; 1208 /* 1209 * If the file size is already greater than the current blocksize, 1210 * we will not grow. If there is more than one block in a file, 1211 * the blocksize cannot change. 1212 */ 1213 if (zp->z_blksz && zp->z_phys->zp_size > zp->z_blksz) 1214 return; 1215 1216 error = dmu_object_set_blocksize(zp->z_zfsvfs->z_os, zp->z_id, 1217 size, 0, tx); 1218 if (error == ENOTSUP) 1219 return; 1220 ASSERT3U(error, ==, 0); 1221 1222 /* What blocksize did we actually get? */ 1223 dmu_object_size_from_db(zp->z_dbuf, &zp->z_blksz, &dummy); 1224} 1225 1226/* 1227 * Increase the file length 1228 * 1229 * IN: zp - znode of file to free data in. 1230 * end - new end-of-file 1231 * 1232 * RETURN: 0 if success 1233 * error code if failure 1234 */ 1235static int 1236zfs_extend(znode_t *zp, uint64_t end) 1237{ 1238 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1239 dmu_tx_t *tx; 1240 rl_t *rl; 1241 uint64_t newblksz; 1242 int error; 1243 1244 /* 1245 * We will change zp_size, lock the whole file. 1246 */ 1247 rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 1248 1249 /* 1250 * Nothing to do if file already at desired length. 1251 */ 1252 if (end <= zp->z_phys->zp_size) { 1253 zfs_range_unlock(rl); 1254 return (0); 1255 } 1256top: 1257 tx = dmu_tx_create(zfsvfs->z_os); 1258 dmu_tx_hold_bonus(tx, zp->z_id); 1259 if (end > zp->z_blksz && 1260 (!ISP2(zp->z_blksz) || zp->z_blksz < zfsvfs->z_max_blksz)) { 1261 /* 1262 * We are growing the file past the current block size. 1263 */ 1264 if (zp->z_blksz > zp->z_zfsvfs->z_max_blksz) { 1265 ASSERT(!ISP2(zp->z_blksz)); 1266 newblksz = MIN(end, SPA_MAXBLOCKSIZE); 1267 } else { 1268 newblksz = MIN(end, zp->z_zfsvfs->z_max_blksz); 1269 } 1270 dmu_tx_hold_write(tx, zp->z_id, 0, newblksz); 1271 } else { 1272 newblksz = 0; 1273 } 1274 1275 error = dmu_tx_assign(tx, TXG_NOWAIT); 1276 if (error) { 1277 if (error == ERESTART) { 1278 dmu_tx_wait(tx); 1279 dmu_tx_abort(tx); 1280 goto top; 1281 } 1282 dmu_tx_abort(tx); 1283 zfs_range_unlock(rl); 1284 return (error); 1285 } 1286 dmu_buf_will_dirty(zp->z_dbuf, tx); 1287 1288 if (newblksz) 1289 zfs_grow_blocksize(zp, newblksz, tx); 1290 1291 zp->z_phys->zp_size = end; 1292 1293 zfs_range_unlock(rl); 1294 1295 dmu_tx_commit(tx); 1296 1297 uvm_vnp_setsize(ZTOV(zp), end); 1298 1299 return (0); 1300} 1301 1302/* 1303 * Free space in a file. 1304 * 1305 * IN: zp - znode of file to free data in. 1306 * off - start of section to free. 1307 * len - length of section to free. 1308 * 1309 * RETURN: 0 if success 1310 * error code if failure 1311 */ 1312static int 1313zfs_free_range(znode_t *zp, uint64_t off, uint64_t len) 1314{ 1315 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1316 rl_t *rl; 1317 int error; 1318 1319 /* 1320 * Lock the range being freed. 1321 */ 1322 rl = zfs_range_lock(zp, off, len, RL_WRITER); 1323 1324 /* 1325 * Nothing to do if file already at desired length. 1326 */ 1327 if (off >= zp->z_phys->zp_size) { 1328 zfs_range_unlock(rl); 1329 return (0); 1330 } 1331 1332 if (off + len > zp->z_phys->zp_size) 1333 len = zp->z_phys->zp_size - off; 1334 1335 error = dmu_free_long_range(zfsvfs->z_os, zp->z_id, off, len); 1336 1337 if (error == 0) { 1338 /* 1339 * In NetBSD we cannot free block in the middle of a file, 1340 * but only at the end of a file. 1341 */ 1342 uvm_vnp_setsize(ZTOV(zp), off); 1343 } 1344 1345 zfs_range_unlock(rl); 1346 1347 return (error); 1348} 1349 1350/* 1351 * Truncate a file 1352 * 1353 * IN: zp - znode of file to free data in. 1354 * end - new end-of-file. 1355 * 1356 * RETURN: 0 if success 1357 * error code if failure 1358 */ 1359static int 1360zfs_trunc(znode_t *zp, uint64_t end) 1361{ 1362 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1363 vnode_t *vp = ZTOV(zp); 1364 dmu_tx_t *tx; 1365 rl_t *rl; 1366 int error; 1367 1368 /* 1369 * We will change zp_size, lock the whole file. 1370 */ 1371 rl = zfs_range_lock(zp, 0, UINT64_MAX, RL_WRITER); 1372 1373 /* 1374 * Nothing to do if file already at desired length. 1375 */ 1376 if (end >= zp->z_phys->zp_size) { 1377 zfs_range_unlock(rl); 1378 return (0); 1379 } 1380 1381 error = dmu_free_long_range(zfsvfs->z_os, zp->z_id, end, -1); 1382 if (error) { 1383 zfs_range_unlock(rl); 1384 return (error); 1385 } 1386top: 1387 tx = dmu_tx_create(zfsvfs->z_os); 1388 dmu_tx_hold_bonus(tx, zp->z_id); 1389 error = dmu_tx_assign(tx, TXG_NOWAIT); 1390 if (error) { 1391 if (error == ERESTART) { 1392 dmu_tx_wait(tx); 1393 dmu_tx_abort(tx); 1394 goto top; 1395 } 1396 dmu_tx_abort(tx); 1397 zfs_range_unlock(rl); 1398 return (error); 1399 } 1400 dmu_buf_will_dirty(zp->z_dbuf, tx); 1401 1402 zp->z_phys->zp_size = end; 1403 1404 dmu_tx_commit(tx); 1405 1406 /* 1407 * Clear any mapped pages in the truncated region. This has to 1408 * happen outside of the transaction to avoid the possibility of 1409 * a deadlock with someone trying to push a page that we are 1410 * about to invalidate. 1411 */ 1412 1413 uvm_vnp_setsize(vp, end); 1414 1415 return (0); 1416} 1417 1418/* 1419 * Free space in a file 1420 * 1421 * IN: zp - znode of file to free data in. 1422 * off - start of range 1423 * len - end of range (0 => EOF) 1424 * flag - current file open mode flags. 1425 * log - TRUE if this action should be logged 1426 * 1427 * RETURN: 0 if success 1428 * error code if failure 1429 */ 1430int 1431zfs_freesp(znode_t *zp, uint64_t off, uint64_t len, int flag, boolean_t log) 1432{ 1433 vnode_t *vp = ZTOV(zp); 1434 dmu_tx_t *tx; 1435 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1436 zilog_t *zilog = zfsvfs->z_log; 1437 int error; 1438 1439 if (off > zp->z_phys->zp_size) { 1440 error = zfs_extend(zp, off+len); 1441 if (error == 0 && log) 1442 goto log; 1443 else 1444 return (error); 1445 } 1446 1447 if (len == 0) { 1448 error = zfs_trunc(zp, off); 1449 } else { 1450 if ((error = zfs_free_range(zp, off, len)) == 0 && 1451 off + len > zp->z_phys->zp_size) 1452 error = zfs_extend(zp, off+len); 1453 } 1454 if (error || !log) 1455 return (error); 1456log: 1457 tx = dmu_tx_create(zfsvfs->z_os); 1458 dmu_tx_hold_bonus(tx, zp->z_id); 1459 error = dmu_tx_assign(tx, TXG_NOWAIT); 1460 if (error) { 1461 if (error == ERESTART) { 1462 dmu_tx_wait(tx); 1463 dmu_tx_abort(tx); 1464 goto log; 1465 } 1466 dmu_tx_abort(tx); 1467 return (error); 1468 } 1469 1470 zfs_time_stamper(zp, CONTENT_MODIFIED, tx); 1471 zfs_log_truncate(zilog, tx, TX_TRUNCATE, zp, off, len); 1472 1473 dmu_tx_commit(tx); 1474 return (0); 1475} 1476 1477void 1478zfs_create_fs(objset_t *os, cred_t *cr, nvlist_t *zplprops, dmu_tx_t *tx) 1479{ 1480 zfsvfs_t zfsvfs; 1481 uint64_t moid, obj, version; 1482 uint64_t sense = ZFS_CASE_SENSITIVE; 1483 uint64_t norm = 0; 1484 nvpair_t *elem; 1485 int error; 1486 int i; 1487 znode_t *rootzp = NULL; 1488 vnode_t *vp; 1489 vattr_t vattr; 1490 znode_t *zp; 1491 zfs_acl_ids_t acl_ids; 1492 1493 /* 1494 * First attempt to create master node. 1495 */ 1496 /* 1497 * In an empty objset, there are no blocks to read and thus 1498 * there can be no i/o errors (which we assert below). 1499 */ 1500 moid = MASTER_NODE_OBJ; 1501 error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE, 1502 DMU_OT_NONE, 0, tx); 1503 ASSERT(error == 0); 1504 1505 /* 1506 * Set starting attributes. 1507 */ 1508 if (spa_version(dmu_objset_spa(os)) >= SPA_VERSION_USERSPACE) 1509 version = ZPL_VERSION; 1510 else if (spa_version(dmu_objset_spa(os)) >= SPA_VERSION_FUID) 1511 version = ZPL_VERSION_USERSPACE - 1; 1512 else 1513 version = ZPL_VERSION_FUID - 1; 1514 elem = NULL; 1515 while ((elem = nvlist_next_nvpair(zplprops, elem)) != NULL) { 1516 /* For the moment we expect all zpl props to be uint64_ts */ 1517 uint64_t val; 1518 char *name; 1519 1520 ASSERT(nvpair_type(elem) == DATA_TYPE_UINT64); 1521 VERIFY(nvpair_value_uint64(elem, &val) == 0); 1522 name = nvpair_name(elem); 1523 if (strcmp(name, zfs_prop_to_name(ZFS_PROP_VERSION)) == 0) { 1524 if (val < version) 1525 version = val; 1526 } else { 1527 error = zap_update(os, moid, name, 8, 1, &val, tx); 1528 } 1529 ASSERT(error == 0); 1530 if (strcmp(name, zfs_prop_to_name(ZFS_PROP_NORMALIZE)) == 0) 1531 norm = val; 1532 else if (strcmp(name, zfs_prop_to_name(ZFS_PROP_CASE)) == 0) 1533 sense = val; 1534 } 1535 ASSERT(version != 0); 1536 error = zap_update(os, moid, ZPL_VERSION_STR, 8, 1, &version, tx); 1537 1538 /* 1539 * Create a delete queue. 1540 */ 1541 obj = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx); 1542 1543 error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &obj, tx); 1544 ASSERT(error == 0); 1545 1546 /* 1547 * Create root znode. Create minimal znode/vnode/zfsvfs 1548 * to allow zfs_mknode to work. 1549 */ 1550 vattr_null(&vattr); 1551 vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE; 1552 vattr.va_type = VDIR; 1553 vattr.va_mode = S_IFDIR|0755; 1554 vattr.va_uid = crgetuid(cr); 1555 vattr.va_gid = crgetgid(cr); 1556 1557 rootzp = kmem_cache_alloc(znode_cache, KM_SLEEP); 1558 rootzp->z_unlinked = 0; 1559 rootzp->z_atime_dirty = 0; 1560 1561 for (;;) { 1562 error = getnewvnode(VT_ZFS, NULL, zfs_vnodeop_p, 1563 NULL, &rootzp->z_vnode); 1564 if (error == 0) 1565 break; 1566 printf("WARNING: zfs_create_fs: unable to get vnode, " 1567 "error=%d\n", error); 1568 kpause("zfsvn", false, hz, NULL); 1569 } 1570 1571 vp = ZTOV(rootzp); 1572 vp->v_type = VDIR; 1573 1574 bzero(&zfsvfs, sizeof (zfsvfs_t)); 1575 1576 zfsvfs.z_os = os; 1577 zfsvfs.z_parent = &zfsvfs; 1578 zfsvfs.z_version = version; 1579 zfsvfs.z_use_fuids = USE_FUIDS(version, os); 1580 zfsvfs.z_norm = norm; 1581 /* 1582 * Fold case on file systems that are always or sometimes case 1583 * insensitive. 1584 */ 1585 if (sense == ZFS_CASE_INSENSITIVE || sense == ZFS_CASE_MIXED) 1586 zfsvfs.z_norm |= U8_TEXTPREP_TOUPPER; 1587 1588 mutex_init(&zfsvfs.z_znodes_lock, NULL, MUTEX_DEFAULT, NULL); 1589 list_create(&zfsvfs.z_all_znodes, sizeof (znode_t), 1590 offsetof(znode_t, z_link_node)); 1591 1592 for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 1593 mutex_init(&zfsvfs.z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL); 1594 1595 ASSERT(!POINTER_IS_VALID(rootzp->z_zfsvfs)); 1596 rootzp->z_zfsvfs = &zfsvfs; 1597 VERIFY(0 == zfs_acl_ids_create(rootzp, IS_ROOT_NODE, &vattr, 1598 cr, NULL, &acl_ids)); 1599 zfs_mknode(rootzp, &vattr, tx, cr, IS_ROOT_NODE, &zp, 0, &acl_ids); 1600 ASSERT3P(zp, ==, rootzp); 1601 error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &rootzp->z_id, tx); 1602 ASSERT(error == 0); 1603 zfs_acl_ids_free(&acl_ids); 1604 POINTER_INVALIDATE(&rootzp->z_zfsvfs); 1605 1606 dmu_buf_rele(rootzp->z_dbuf, NULL); 1607 rootzp->z_dbuf = NULL; 1608 ungetnewvnode(vp); 1609 kmem_cache_free(znode_cache, rootzp); 1610 1611 /* 1612 * Create shares directory 1613 */ 1614 1615 error = zfs_create_share_dir(&zfsvfs, tx); 1616 1617 ASSERT(error == 0); 1618 1619 for (i = 0; i != ZFS_OBJ_MTX_SZ; i++) 1620 mutex_destroy(&zfsvfs.z_hold_mtx[i]); 1621} 1622 1623#endif /* _KERNEL */ 1624/* 1625 * Given an object number, return its parent object number and whether 1626 * or not the object is an extended attribute directory. 1627 */ 1628static int 1629zfs_obj_to_pobj(objset_t *osp, uint64_t obj, uint64_t *pobjp, int *is_xattrdir) 1630{ 1631 dmu_buf_t *db; 1632 dmu_object_info_t doi; 1633 znode_phys_t *zp; 1634 int error; 1635 1636 if ((error = dmu_bonus_hold(osp, obj, FTAG, &db)) != 0) 1637 return (error); 1638 1639 dmu_object_info_from_db(db, &doi); 1640 if (doi.doi_bonus_type != DMU_OT_ZNODE || 1641 doi.doi_bonus_size < sizeof (znode_phys_t)) { 1642 dmu_buf_rele(db, FTAG); 1643 return (EINVAL); 1644 } 1645 1646 zp = db->db_data; 1647 *pobjp = zp->zp_parent; 1648 *is_xattrdir = ((zp->zp_flags & ZFS_XATTR) != 0) && 1649 S_ISDIR(zp->zp_mode); 1650 dmu_buf_rele(db, FTAG); 1651 1652 return (0); 1653} 1654 1655int 1656zfs_obj_to_path(objset_t *osp, uint64_t obj, char *buf, int len) 1657{ 1658 char *path = buf + len - 1; 1659 int error; 1660 1661 *path = '\0'; 1662 1663 for (;;) { 1664 uint64_t pobj; 1665 char component[MAXNAMELEN + 2]; 1666 size_t complen; 1667 int is_xattrdir; 1668 1669 if ((error = zfs_obj_to_pobj(osp, obj, &pobj, 1670 &is_xattrdir)) != 0) 1671 break; 1672 1673 if (pobj == obj) { 1674 if (path[0] != '/') 1675 *--path = '/'; 1676 break; 1677 } 1678 1679 component[0] = '/'; 1680 if (is_xattrdir) { 1681 (void) sprintf(component + 1, "<xattrdir>"); 1682 } else { 1683 error = zap_value_search(osp, pobj, obj, 1684 ZFS_DIRENT_OBJ(-1ULL), component + 1); 1685 if (error != 0) 1686 break; 1687 } 1688 1689 complen = strlen(component); 1690 path -= complen; 1691 ASSERT(path >= buf); 1692 bcopy(component, path, complen); 1693 obj = pobj; 1694 } 1695 1696 if (error == 0) 1697 (void) memmove(buf, path, buf + len - path); 1698 return (error); 1699} 1700