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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2012 by Delphix. All rights reserved. 24 */ 25 26 /* Portions Copyright 2007 Jeremy Teo */ 27 /* Portions Copyright 2010 Robert Milkowski */ 28 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/vfs.h> 36 #include <sys/vfs_opreg.h> 37 #include <sys/vnode.h> 38 #include <sys/file.h> 39 #include <sys/stat.h> 40 #include <sys/kmem.h> 41 #include <sys/taskq.h> 42 #include <sys/uio.h> 43 #include <sys/vmsystm.h> 44 #include <sys/atomic.h> 45 #include <sys/vm.h> 46 #include <vm/seg_vn.h> 47 #include <vm/pvn.h> 48 #include <vm/as.h> 49 #include <vm/kpm.h> 50 #include <vm/seg_kpm.h> 51 #include <sys/mman.h> 52 #include <sys/pathname.h> 53 #include <sys/cmn_err.h> 54 #include <sys/errno.h> 55 #include <sys/unistd.h> 56 #include <sys/zfs_dir.h> 57 #include <sys/zfs_acl.h> 58 #include <sys/zfs_ioctl.h> 59 #include <sys/fs/zfs.h> 60 #include <sys/dmu.h> 61 #include <sys/dmu_objset.h> 62 #include <sys/spa.h> 63 #include <sys/txg.h> 64 #include <sys/dbuf.h> 65 #include <sys/zap.h> 66 #include <sys/sa.h> 67 #include <sys/dirent.h> 68 #include <sys/policy.h> 69 #include <sys/sunddi.h> 70 #include <sys/filio.h> 71 #include <sys/sid.h> 72 #include "fs/fs_subr.h" 73 #include <sys/zfs_ctldir.h> 74 #include <sys/zfs_fuid.h> 75 #include <sys/zfs_sa.h> 76 #include <sys/dnlc.h> 77 #include <sys/zfs_rlock.h> 78 #include <sys/extdirent.h> 79 #include <sys/kidmap.h> 80 #include <sys/cred.h> 81 #include <sys/attr.h> 82 83 /* 84 * Programming rules. 85 * 86 * Each vnode op performs some logical unit of work. To do this, the ZPL must 87 * properly lock its in-core state, create a DMU transaction, do the work, 88 * record this work in the intent log (ZIL), commit the DMU transaction, 89 * and wait for the intent log to commit if it is a synchronous operation. 90 * Moreover, the vnode ops must work in both normal and log replay context. 91 * The ordering of events is important to avoid deadlocks and references 92 * to freed memory. The example below illustrates the following Big Rules: 93 * 94 * (1) A check must be made in each zfs thread for a mounted file system. 95 * This is done avoiding races using ZFS_ENTER(zfsvfs). 96 * A ZFS_EXIT(zfsvfs) is needed before all returns. Any znodes 97 * must be checked with ZFS_VERIFY_ZP(zp). Both of these macros 98 * can return EIO from the calling function. 99 * 100 * (2) VN_RELE() should always be the last thing except for zil_commit() 101 * (if necessary) and ZFS_EXIT(). This is for 3 reasons: 102 * First, if it's the last reference, the vnode/znode 103 * can be freed, so the zp may point to freed memory. Second, the last 104 * reference will call zfs_zinactive(), which may induce a lot of work -- 105 * pushing cached pages (which acquires range locks) and syncing out 106 * cached atime changes. Third, zfs_zinactive() may require a new tx, 107 * which could deadlock the system if you were already holding one. 108 * If you must call VN_RELE() within a tx then use VN_RELE_ASYNC(). 109 * 110 * (3) All range locks must be grabbed before calling dmu_tx_assign(), 111 * as they can span dmu_tx_assign() calls. 112 * 113 * (4) Always pass TXG_NOWAIT as the second argument to dmu_tx_assign(). 114 * This is critical because we don't want to block while holding locks. 115 * Note, in particular, that if a lock is sometimes acquired before 116 * the tx assigns, and sometimes after (e.g. z_lock), then failing to 117 * use a non-blocking assign can deadlock the system. The scenario: 118 * 119 * Thread A has grabbed a lock before calling dmu_tx_assign(). 120 * Thread B is in an already-assigned tx, and blocks for this lock. 121 * Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open() 122 * forever, because the previous txg can't quiesce until B's tx commits. 123 * 124 * If dmu_tx_assign() returns ERESTART and zfsvfs->z_assign is TXG_NOWAIT, 125 * then drop all locks, call dmu_tx_wait(), and try again. 126 * 127 * (5) If the operation succeeded, generate the intent log entry for it 128 * before dropping locks. This ensures that the ordering of events 129 * in the intent log matches the order in which they actually occurred. 130 * During ZIL replay the zfs_log_* functions will update the sequence 131 * number to indicate the zil transaction has replayed. 132 * 133 * (6) At the end of each vnode op, the DMU tx must always commit, 134 * regardless of whether there were any errors. 135 * 136 * (7) After dropping all locks, invoke zil_commit(zilog, foid) 137 * to ensure that synchronous semantics are provided when necessary. 138 * 139 * In general, this is how things should be ordered in each vnode op: 140 * 141 * ZFS_ENTER(zfsvfs); // exit if unmounted 142 * top: 143 * zfs_dirent_lock(&dl, ...) // lock directory entry (may VN_HOLD()) 144 * rw_enter(...); // grab any other locks you need 145 * tx = dmu_tx_create(...); // get DMU tx 146 * dmu_tx_hold_*(); // hold each object you might modify 147 * error = dmu_tx_assign(tx, TXG_NOWAIT); // try to assign 148 * if (error) { 149 * rw_exit(...); // drop locks 150 * zfs_dirent_unlock(dl); // unlock directory entry 151 * VN_RELE(...); // release held vnodes 152 * if (error == ERESTART) { 153 * dmu_tx_wait(tx); 154 * dmu_tx_abort(tx); 155 * goto top; 156 * } 157 * dmu_tx_abort(tx); // abort DMU tx 158 * ZFS_EXIT(zfsvfs); // finished in zfs 159 * return (error); // really out of space 160 * } 161 * error = do_real_work(); // do whatever this VOP does 162 * if (error == 0) 163 * zfs_log_*(...); // on success, make ZIL entry 164 * dmu_tx_commit(tx); // commit DMU tx -- error or not 165 * rw_exit(...); // drop locks 166 * zfs_dirent_unlock(dl); // unlock directory entry 167 * VN_RELE(...); // release held vnodes 168 * zil_commit(zilog, foid); // synchronous when necessary 169 * ZFS_EXIT(zfsvfs); // finished in zfs 170 * return (error); // done, report error 171 */ 172 173 /* ARGSUSED */ 174 static int 175 zfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct) 176 { 177 znode_t *zp = VTOZ(*vpp); 178 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 179 180 ZFS_ENTER(zfsvfs); 181 ZFS_VERIFY_ZP(zp); 182 183 if ((flag & FWRITE) && (zp->z_pflags & ZFS_APPENDONLY) && 184 ((flag & FAPPEND) == 0)) { 185 ZFS_EXIT(zfsvfs); 186 return (EPERM); 187 } 188 189 if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan && 190 ZTOV(zp)->v_type == VREG && 191 !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0) { 192 if (fs_vscan(*vpp, cr, 0) != 0) { 193 ZFS_EXIT(zfsvfs); 194 return (EACCES); 195 } 196 } 197 198 /* Keep a count of the synchronous opens in the znode */ 199 if (flag & (FSYNC | FDSYNC)) 200 atomic_inc_32(&zp->z_sync_cnt); 201 202 ZFS_EXIT(zfsvfs); 203 return (0); 204 } 205 206 /* ARGSUSED */ 207 static int 208 zfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr, 209 caller_context_t *ct) 210 { 211 znode_t *zp = VTOZ(vp); 212 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 213 214 /* 215 * Clean up any locks held by this process on the vp. 216 */ 217 cleanlocks(vp, ddi_get_pid(), 0); 218 cleanshares(vp, ddi_get_pid()); 219 220 ZFS_ENTER(zfsvfs); 221 ZFS_VERIFY_ZP(zp); 222 223 /* Decrement the synchronous opens in the znode */ 224 if ((flag & (FSYNC | FDSYNC)) && (count == 1)) 225 atomic_dec_32(&zp->z_sync_cnt); 226 227 if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan && 228 ZTOV(zp)->v_type == VREG && 229 !(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0) 230 VERIFY(fs_vscan(vp, cr, 1) == 0); 231 232 ZFS_EXIT(zfsvfs); 233 return (0); 234 } 235 236 /* 237 * Lseek support for finding holes (cmd == _FIO_SEEK_HOLE) and 238 * data (cmd == _FIO_SEEK_DATA). "off" is an in/out parameter. 239 */ 240 static int 241 zfs_holey(vnode_t *vp, int cmd, offset_t *off) 242 { 243 znode_t *zp = VTOZ(vp); 244 uint64_t noff = (uint64_t)*off; /* new offset */ 245 uint64_t file_sz; 246 int error; 247 boolean_t hole; 248 249 file_sz = zp->z_size; 250 if (noff >= file_sz) { 251 return (ENXIO); 252 } 253 254 if (cmd == _FIO_SEEK_HOLE) 255 hole = B_TRUE; 256 else 257 hole = B_FALSE; 258 259 error = dmu_offset_next(zp->z_zfsvfs->z_os, zp->z_id, hole, &noff); 260 261 /* end of file? */ 262 if ((error == ESRCH) || (noff > file_sz)) { 263 /* 264 * Handle the virtual hole at the end of file. 265 */ 266 if (hole) { 267 *off = file_sz; 268 return (0); 269 } 270 return (ENXIO); 271 } 272 273 if (noff < *off) 274 return (error); 275 *off = noff; 276 return (error); 277 } 278 279 /* ARGSUSED */ 280 static int 281 zfs_ioctl(vnode_t *vp, int com, intptr_t data, int flag, cred_t *cred, 282 int *rvalp, caller_context_t *ct) 283 { 284 offset_t off; 285 int error; 286 zfsvfs_t *zfsvfs; 287 znode_t *zp; 288 289 switch (com) { 290 case _FIOFFS: 291 return (zfs_sync(vp->v_vfsp, 0, cred)); 292 293 /* 294 * The following two ioctls are used by bfu. Faking out, 295 * necessary to avoid bfu errors. 296 */ 297 case _FIOGDIO: 298 case _FIOSDIO: 299 return (0); 300 301 case _FIO_SEEK_DATA: 302 case _FIO_SEEK_HOLE: 303 if (ddi_copyin((void *)data, &off, sizeof (off), flag)) 304 return (EFAULT); 305 306 zp = VTOZ(vp); 307 zfsvfs = zp->z_zfsvfs; 308 ZFS_ENTER(zfsvfs); 309 ZFS_VERIFY_ZP(zp); 310 311 /* offset parameter is in/out */ 312 error = zfs_holey(vp, com, &off); 313 ZFS_EXIT(zfsvfs); 314 if (error) 315 return (error); 316 if (ddi_copyout(&off, (void *)data, sizeof (off), flag)) 317 return (EFAULT); 318 return (0); 319 } 320 return (ENOTTY); 321 } 322 323 /* 324 * Utility functions to map and unmap a single physical page. These 325 * are used to manage the mappable copies of ZFS file data, and therefore 326 * do not update ref/mod bits. 327 */ 328 caddr_t 329 zfs_map_page(page_t *pp, enum seg_rw rw) 330 { 331 if (kpm_enable) 332 return (hat_kpm_mapin(pp, 0)); 333 ASSERT(rw == S_READ || rw == S_WRITE); 334 return (ppmapin(pp, PROT_READ | ((rw == S_WRITE) ? PROT_WRITE : 0), 335 (caddr_t)-1)); 336 } 337 338 void 339 zfs_unmap_page(page_t *pp, caddr_t addr) 340 { 341 if (kpm_enable) { 342 hat_kpm_mapout(pp, 0, addr); 343 } else { 344 ppmapout(addr); 345 } 346 } 347 348 /* 349 * When a file is memory mapped, we must keep the IO data synchronized 350 * between the DMU cache and the memory mapped pages. What this means: 351 * 352 * On Write: If we find a memory mapped page, we write to *both* 353 * the page and the dmu buffer. 354 */ 355 static void 356 update_pages(vnode_t *vp, int64_t start, int len, objset_t *os, uint64_t oid) 357 { 358 int64_t off; 359 360 off = start & PAGEOFFSET; 361 for (start &= PAGEMASK; len > 0; start += PAGESIZE) { 362 page_t *pp; 363 uint64_t nbytes = MIN(PAGESIZE - off, len); 364 365 if (pp = page_lookup(vp, start, SE_SHARED)) { 366 caddr_t va; 367 368 va = zfs_map_page(pp, S_WRITE); 369 (void) dmu_read(os, oid, start+off, nbytes, va+off, 370 DMU_READ_PREFETCH); 371 zfs_unmap_page(pp, va); 372 page_unlock(pp); 373 } 374 len -= nbytes; 375 off = 0; 376 } 377 } 378 379 /* 380 * When a file is memory mapped, we must keep the IO data synchronized 381 * between the DMU cache and the memory mapped pages. What this means: 382 * 383 * On Read: We "read" preferentially from memory mapped pages, 384 * else we default from the dmu buffer. 385 * 386 * NOTE: We will always "break up" the IO into PAGESIZE uiomoves when 387 * the file is memory mapped. 388 */ 389 static int 390 mappedread(vnode_t *vp, int nbytes, uio_t *uio) 391 { 392 znode_t *zp = VTOZ(vp); 393 objset_t *os = zp->z_zfsvfs->z_os; 394 int64_t start, off; 395 int len = nbytes; 396 int error = 0; 397 398 start = uio->uio_loffset; 399 off = start & PAGEOFFSET; 400 for (start &= PAGEMASK; len > 0; start += PAGESIZE) { 401 page_t *pp; 402 uint64_t bytes = MIN(PAGESIZE - off, len); 403 404 if (pp = page_lookup(vp, start, SE_SHARED)) { 405 caddr_t va; 406 407 va = zfs_map_page(pp, S_READ); 408 error = uiomove(va + off, bytes, UIO_READ, uio); 409 zfs_unmap_page(pp, va); 410 page_unlock(pp); 411 } else { 412 error = dmu_read_uio(os, zp->z_id, uio, bytes); 413 } 414 len -= bytes; 415 off = 0; 416 if (error) 417 break; 418 } 419 return (error); 420 } 421 422 offset_t zfs_read_chunk_size = 1024 * 1024; /* Tunable */ 423 424 /* 425 * Read bytes from specified file into supplied buffer. 426 * 427 * IN: vp - vnode of file to be read from. 428 * uio - structure supplying read location, range info, 429 * and return buffer. 430 * ioflag - SYNC flags; used to provide FRSYNC semantics. 431 * cr - credentials of caller. 432 * ct - caller context 433 * 434 * OUT: uio - updated offset and range, buffer filled. 435 * 436 * RETURN: 0 if success 437 * error code if failure 438 * 439 * Side Effects: 440 * vp - atime updated if byte count > 0 441 */ 442 /* ARGSUSED */ 443 static int 444 zfs_read(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr, caller_context_t *ct) 445 { 446 znode_t *zp = VTOZ(vp); 447 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 448 objset_t *os; 449 ssize_t n, nbytes; 450 int error; 451 rl_t *rl; 452 xuio_t *xuio = NULL; 453 454 ZFS_ENTER(zfsvfs); 455 ZFS_VERIFY_ZP(zp); 456 os = zfsvfs->z_os; 457 458 if (zp->z_pflags & ZFS_AV_QUARANTINED) { 459 ZFS_EXIT(zfsvfs); 460 return (EACCES); 461 } 462 463 /* 464 * Validate file offset 465 */ 466 if (uio->uio_loffset < (offset_t)0) { 467 ZFS_EXIT(zfsvfs); 468 return (EINVAL); 469 } 470 471 /* 472 * Fasttrack empty reads 473 */ 474 if (uio->uio_resid == 0) { 475 ZFS_EXIT(zfsvfs); 476 return (0); 477 } 478 479 /* 480 * Check for mandatory locks 481 */ 482 if (MANDMODE(zp->z_mode)) { 483 if (error = chklock(vp, FREAD, 484 uio->uio_loffset, uio->uio_resid, uio->uio_fmode, ct)) { 485 ZFS_EXIT(zfsvfs); 486 return (error); 487 } 488 } 489 490 /* 491 * If we're in FRSYNC mode, sync out this znode before reading it. 492 */ 493 if (ioflag & FRSYNC || zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 494 zil_commit(zfsvfs->z_log, zp->z_id); 495 496 /* 497 * Lock the range against changes. 498 */ 499 rl = zfs_range_lock(zp, uio->uio_loffset, uio->uio_resid, RL_READER); 500 501 /* 502 * If we are reading past end-of-file we can skip 503 * to the end; but we might still need to set atime. 504 */ 505 if (uio->uio_loffset >= zp->z_size) { 506 error = 0; 507 goto out; 508 } 509 510 ASSERT(uio->uio_loffset < zp->z_size); 511 n = MIN(uio->uio_resid, zp->z_size - uio->uio_loffset); 512 513 if ((uio->uio_extflg == UIO_XUIO) && 514 (((xuio_t *)uio)->xu_type == UIOTYPE_ZEROCOPY)) { 515 int nblk; 516 int blksz = zp->z_blksz; 517 uint64_t offset = uio->uio_loffset; 518 519 xuio = (xuio_t *)uio; 520 if ((ISP2(blksz))) { 521 nblk = (P2ROUNDUP(offset + n, blksz) - P2ALIGN(offset, 522 blksz)) / blksz; 523 } else { 524 ASSERT(offset + n <= blksz); 525 nblk = 1; 526 } 527 (void) dmu_xuio_init(xuio, nblk); 528 529 if (vn_has_cached_data(vp)) { 530 /* 531 * For simplicity, we always allocate a full buffer 532 * even if we only expect to read a portion of a block. 533 */ 534 while (--nblk >= 0) { 535 (void) dmu_xuio_add(xuio, 536 dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl), 537 blksz), 0, blksz); 538 } 539 } 540 } 541 542 while (n > 0) { 543 nbytes = MIN(n, zfs_read_chunk_size - 544 P2PHASE(uio->uio_loffset, zfs_read_chunk_size)); 545 546 if (vn_has_cached_data(vp)) 547 error = mappedread(vp, nbytes, uio); 548 else 549 error = dmu_read_uio(os, zp->z_id, uio, nbytes); 550 if (error) { 551 /* convert checksum errors into IO errors */ 552 if (error == ECKSUM) 553 error = EIO; 554 break; 555 } 556 557 n -= nbytes; 558 } 559 out: 560 zfs_range_unlock(rl); 561 562 ZFS_ACCESSTIME_STAMP(zfsvfs, zp); 563 ZFS_EXIT(zfsvfs); 564 return (error); 565 } 566 567 /* 568 * Write the bytes to a file. 569 * 570 * IN: vp - vnode of file to be written to. 571 * uio - structure supplying write location, range info, 572 * and data buffer. 573 * ioflag - FAPPEND flag set if in append mode. 574 * cr - credentials of caller. 575 * ct - caller context (NFS/CIFS fem monitor only) 576 * 577 * OUT: uio - updated offset and range. 578 * 579 * RETURN: 0 if success 580 * error code if failure 581 * 582 * Timestamps: 583 * vp - ctime|mtime updated if byte count > 0 584 */ 585 586 /* ARGSUSED */ 587 static int 588 zfs_write(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr, caller_context_t *ct) 589 { 590 znode_t *zp = VTOZ(vp); 591 rlim64_t limit = uio->uio_llimit; 592 ssize_t start_resid = uio->uio_resid; 593 ssize_t tx_bytes; 594 uint64_t end_size; 595 dmu_tx_t *tx; 596 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 597 zilog_t *zilog; 598 offset_t woff; 599 ssize_t n, nbytes; 600 rl_t *rl; 601 int max_blksz = zfsvfs->z_max_blksz; 602 int error; 603 arc_buf_t *abuf; 604 iovec_t *aiov; 605 xuio_t *xuio = NULL; 606 int i_iov = 0; 607 int iovcnt = uio->uio_iovcnt; 608 iovec_t *iovp = uio->uio_iov; 609 int write_eof; 610 int count = 0; 611 sa_bulk_attr_t bulk[4]; 612 uint64_t mtime[2], ctime[2]; 613 614 /* 615 * Fasttrack empty write 616 */ 617 n = start_resid; 618 if (n == 0) 619 return (0); 620 621 if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T) 622 limit = MAXOFFSET_T; 623 624 ZFS_ENTER(zfsvfs); 625 ZFS_VERIFY_ZP(zp); 626 627 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16); 628 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16); 629 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL, 630 &zp->z_size, 8); 631 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL, 632 &zp->z_pflags, 8); 633 634 /* 635 * If immutable or not appending then return EPERM 636 */ 637 if ((zp->z_pflags & (ZFS_IMMUTABLE | ZFS_READONLY)) || 638 ((zp->z_pflags & ZFS_APPENDONLY) && !(ioflag & FAPPEND) && 639 (uio->uio_loffset < zp->z_size))) { 640 ZFS_EXIT(zfsvfs); 641 return (EPERM); 642 } 643 644 zilog = zfsvfs->z_log; 645 646 /* 647 * Validate file offset 648 */ 649 woff = ioflag & FAPPEND ? zp->z_size : uio->uio_loffset; 650 if (woff < 0) { 651 ZFS_EXIT(zfsvfs); 652 return (EINVAL); 653 } 654 655 /* 656 * Check for mandatory locks before calling zfs_range_lock() 657 * in order to prevent a deadlock with locks set via fcntl(). 658 */ 659 if (MANDMODE((mode_t)zp->z_mode) && 660 (error = chklock(vp, FWRITE, woff, n, uio->uio_fmode, ct)) != 0) { 661 ZFS_EXIT(zfsvfs); 662 return (error); 663 } 664 665 /* 666 * Pre-fault the pages to ensure slow (eg NFS) pages 667 * don't hold up txg. 668 * Skip this if uio contains loaned arc_buf. 669 */ 670 if ((uio->uio_extflg == UIO_XUIO) && 671 (((xuio_t *)uio)->xu_type == UIOTYPE_ZEROCOPY)) 672 xuio = (xuio_t *)uio; 673 else 674 uio_prefaultpages(MIN(n, max_blksz), uio); 675 676 /* 677 * If in append mode, set the io offset pointer to eof. 678 */ 679 if (ioflag & FAPPEND) { 680 /* 681 * Obtain an appending range lock to guarantee file append 682 * semantics. We reset the write offset once we have the lock. 683 */ 684 rl = zfs_range_lock(zp, 0, n, RL_APPEND); 685 woff = rl->r_off; 686 if (rl->r_len == UINT64_MAX) { 687 /* 688 * We overlocked the file because this write will cause 689 * the file block size to increase. 690 * Note that zp_size cannot change with this lock held. 691 */ 692 woff = zp->z_size; 693 } 694 uio->uio_loffset = woff; 695 } else { 696 /* 697 * Note that if the file block size will change as a result of 698 * this write, then this range lock will lock the entire file 699 * so that we can re-write the block safely. 700 */ 701 rl = zfs_range_lock(zp, woff, n, RL_WRITER); 702 } 703 704 if (woff >= limit) { 705 zfs_range_unlock(rl); 706 ZFS_EXIT(zfsvfs); 707 return (EFBIG); 708 } 709 710 if ((woff + n) > limit || woff > (limit - n)) 711 n = limit - woff; 712 713 /* Will this write extend the file length? */ 714 write_eof = (woff + n > zp->z_size); 715 716 end_size = MAX(zp->z_size, woff + n); 717 718 /* 719 * Write the file in reasonable size chunks. Each chunk is written 720 * in a separate transaction; this keeps the intent log records small 721 * and allows us to do more fine-grained space accounting. 722 */ 723 while (n > 0) { 724 abuf = NULL; 725 woff = uio->uio_loffset; 726 again: 727 if (zfs_owner_overquota(zfsvfs, zp, B_FALSE) || 728 zfs_owner_overquota(zfsvfs, zp, B_TRUE)) { 729 if (abuf != NULL) 730 dmu_return_arcbuf(abuf); 731 error = EDQUOT; 732 break; 733 } 734 735 if (xuio && abuf == NULL) { 736 ASSERT(i_iov < iovcnt); 737 aiov = &iovp[i_iov]; 738 abuf = dmu_xuio_arcbuf(xuio, i_iov); 739 dmu_xuio_clear(xuio, i_iov); 740 DTRACE_PROBE3(zfs_cp_write, int, i_iov, 741 iovec_t *, aiov, arc_buf_t *, abuf); 742 ASSERT((aiov->iov_base == abuf->b_data) || 743 ((char *)aiov->iov_base - (char *)abuf->b_data + 744 aiov->iov_len == arc_buf_size(abuf))); 745 i_iov++; 746 } else if (abuf == NULL && n >= max_blksz && 747 woff >= zp->z_size && 748 P2PHASE(woff, max_blksz) == 0 && 749 zp->z_blksz == max_blksz) { 750 /* 751 * This write covers a full block. "Borrow" a buffer 752 * from the dmu so that we can fill it before we enter 753 * a transaction. This avoids the possibility of 754 * holding up the transaction if the data copy hangs 755 * up on a pagefault (e.g., from an NFS server mapping). 756 */ 757 size_t cbytes; 758 759 abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl), 760 max_blksz); 761 ASSERT(abuf != NULL); 762 ASSERT(arc_buf_size(abuf) == max_blksz); 763 if (error = uiocopy(abuf->b_data, max_blksz, 764 UIO_WRITE, uio, &cbytes)) { 765 dmu_return_arcbuf(abuf); 766 break; 767 } 768 ASSERT(cbytes == max_blksz); 769 } 770 771 /* 772 * Start a transaction. 773 */ 774 tx = dmu_tx_create(zfsvfs->z_os); 775 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE); 776 dmu_tx_hold_write(tx, zp->z_id, woff, MIN(n, max_blksz)); 777 zfs_sa_upgrade_txholds(tx, zp); 778 error = dmu_tx_assign(tx, TXG_NOWAIT); 779 if (error) { 780 if (error == ERESTART) { 781 dmu_tx_wait(tx); 782 dmu_tx_abort(tx); 783 goto again; 784 } 785 dmu_tx_abort(tx); 786 if (abuf != NULL) 787 dmu_return_arcbuf(abuf); 788 break; 789 } 790 791 /* 792 * If zfs_range_lock() over-locked we grow the blocksize 793 * and then reduce the lock range. This will only happen 794 * on the first iteration since zfs_range_reduce() will 795 * shrink down r_len to the appropriate size. 796 */ 797 if (rl->r_len == UINT64_MAX) { 798 uint64_t new_blksz; 799 800 if (zp->z_blksz > max_blksz) { 801 ASSERT(!ISP2(zp->z_blksz)); 802 new_blksz = MIN(end_size, SPA_MAXBLOCKSIZE); 803 } else { 804 new_blksz = MIN(end_size, max_blksz); 805 } 806 zfs_grow_blocksize(zp, new_blksz, tx); 807 zfs_range_reduce(rl, woff, n); 808 } 809 810 /* 811 * XXX - should we really limit each write to z_max_blksz? 812 * Perhaps we should use SPA_MAXBLOCKSIZE chunks? 813 */ 814 nbytes = MIN(n, max_blksz - P2PHASE(woff, max_blksz)); 815 816 if (abuf == NULL) { 817 tx_bytes = uio->uio_resid; 818 error = dmu_write_uio_dbuf(sa_get_db(zp->z_sa_hdl), 819 uio, nbytes, tx); 820 tx_bytes -= uio->uio_resid; 821 } else { 822 tx_bytes = nbytes; 823 ASSERT(xuio == NULL || tx_bytes == aiov->iov_len); 824 /* 825 * If this is not a full block write, but we are 826 * extending the file past EOF and this data starts 827 * block-aligned, use assign_arcbuf(). Otherwise, 828 * write via dmu_write(). 829 */ 830 if (tx_bytes < max_blksz && (!write_eof || 831 aiov->iov_base != abuf->b_data)) { 832 ASSERT(xuio); 833 dmu_write(zfsvfs->z_os, zp->z_id, woff, 834 aiov->iov_len, aiov->iov_base, tx); 835 dmu_return_arcbuf(abuf); 836 xuio_stat_wbuf_copied(); 837 } else { 838 ASSERT(xuio || tx_bytes == max_blksz); 839 dmu_assign_arcbuf(sa_get_db(zp->z_sa_hdl), 840 woff, abuf, tx); 841 } 842 ASSERT(tx_bytes <= uio->uio_resid); 843 uioskip(uio, tx_bytes); 844 } 845 if (tx_bytes && vn_has_cached_data(vp)) { 846 update_pages(vp, woff, 847 tx_bytes, zfsvfs->z_os, zp->z_id); 848 } 849 850 /* 851 * If we made no progress, we're done. If we made even 852 * partial progress, update the znode and ZIL accordingly. 853 */ 854 if (tx_bytes == 0) { 855 (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs), 856 (void *)&zp->z_size, sizeof (uint64_t), tx); 857 dmu_tx_commit(tx); 858 ASSERT(error != 0); 859 break; 860 } 861 862 /* 863 * Clear Set-UID/Set-GID bits on successful write if not 864 * privileged and at least one of the excute bits is set. 865 * 866 * It would be nice to to this after all writes have 867 * been done, but that would still expose the ISUID/ISGID 868 * to another app after the partial write is committed. 869 * 870 * Note: we don't call zfs_fuid_map_id() here because 871 * user 0 is not an ephemeral uid. 872 */ 873 mutex_enter(&zp->z_acl_lock); 874 if ((zp->z_mode & (S_IXUSR | (S_IXUSR >> 3) | 875 (S_IXUSR >> 6))) != 0 && 876 (zp->z_mode & (S_ISUID | S_ISGID)) != 0 && 877 secpolicy_vnode_setid_retain(cr, 878 (zp->z_mode & S_ISUID) != 0 && zp->z_uid == 0) != 0) { 879 uint64_t newmode; 880 zp->z_mode &= ~(S_ISUID | S_ISGID); 881 newmode = zp->z_mode; 882 (void) sa_update(zp->z_sa_hdl, SA_ZPL_MODE(zfsvfs), 883 (void *)&newmode, sizeof (uint64_t), tx); 884 } 885 mutex_exit(&zp->z_acl_lock); 886 887 zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime, 888 B_TRUE); 889 890 /* 891 * Update the file size (zp_size) if it has changed; 892 * account for possible concurrent updates. 893 */ 894 while ((end_size = zp->z_size) < uio->uio_loffset) { 895 (void) atomic_cas_64(&zp->z_size, end_size, 896 uio->uio_loffset); 897 ASSERT(error == 0); 898 } 899 /* 900 * If we are replaying and eof is non zero then force 901 * the file size to the specified eof. Note, there's no 902 * concurrency during replay. 903 */ 904 if (zfsvfs->z_replay && zfsvfs->z_replay_eof != 0) 905 zp->z_size = zfsvfs->z_replay_eof; 906 907 error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx); 908 909 zfs_log_write(zilog, tx, TX_WRITE, zp, woff, tx_bytes, ioflag); 910 dmu_tx_commit(tx); 911 912 if (error != 0) 913 break; 914 ASSERT(tx_bytes == nbytes); 915 n -= nbytes; 916 917 if (!xuio && n > 0) 918 uio_prefaultpages(MIN(n, max_blksz), uio); 919 } 920 921 zfs_range_unlock(rl); 922 923 /* 924 * If we're in replay mode, or we made no progress, return error. 925 * Otherwise, it's at least a partial write, so it's successful. 926 */ 927 if (zfsvfs->z_replay || uio->uio_resid == start_resid) { 928 ZFS_EXIT(zfsvfs); 929 return (error); 930 } 931 932 if (ioflag & (FSYNC | FDSYNC) || 933 zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 934 zil_commit(zilog, zp->z_id); 935 936 ZFS_EXIT(zfsvfs); 937 return (0); 938 } 939 940 void 941 zfs_get_done(zgd_t *zgd, int error) 942 { 943 znode_t *zp = zgd->zgd_private; 944 objset_t *os = zp->z_zfsvfs->z_os; 945 946 if (zgd->zgd_db) 947 dmu_buf_rele(zgd->zgd_db, zgd); 948 949 zfs_range_unlock(zgd->zgd_rl); 950 951 /* 952 * Release the vnode asynchronously as we currently have the 953 * txg stopped from syncing. 954 */ 955 VN_RELE_ASYNC(ZTOV(zp), dsl_pool_vnrele_taskq(dmu_objset_pool(os))); 956 957 if (error == 0 && zgd->zgd_bp) 958 zil_add_block(zgd->zgd_zilog, zgd->zgd_bp); 959 960 kmem_free(zgd, sizeof (zgd_t)); 961 } 962 963 #ifdef DEBUG 964 static int zil_fault_io = 0; 965 #endif 966 967 /* 968 * Get data to generate a TX_WRITE intent log record. 969 */ 970 int 971 zfs_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio) 972 { 973 zfsvfs_t *zfsvfs = arg; 974 objset_t *os = zfsvfs->z_os; 975 znode_t *zp; 976 uint64_t object = lr->lr_foid; 977 uint64_t offset = lr->lr_offset; 978 uint64_t size = lr->lr_length; 979 blkptr_t *bp = &lr->lr_blkptr; 980 dmu_buf_t *db; 981 zgd_t *zgd; 982 int error = 0; 983 984 ASSERT(zio != NULL); 985 ASSERT(size != 0); 986 987 /* 988 * Nothing to do if the file has been removed 989 */ 990 if (zfs_zget(zfsvfs, object, &zp) != 0) 991 return (ENOENT); 992 if (zp->z_unlinked) { 993 /* 994 * Release the vnode asynchronously as we currently have the 995 * txg stopped from syncing. 996 */ 997 VN_RELE_ASYNC(ZTOV(zp), 998 dsl_pool_vnrele_taskq(dmu_objset_pool(os))); 999 return (ENOENT); 1000 } 1001 1002 zgd = (zgd_t *)kmem_zalloc(sizeof (zgd_t), KM_SLEEP); 1003 zgd->zgd_zilog = zfsvfs->z_log; 1004 zgd->zgd_private = zp; 1005 1006 /* 1007 * Write records come in two flavors: immediate and indirect. 1008 * For small writes it's cheaper to store the data with the 1009 * log record (immediate); for large writes it's cheaper to 1010 * sync the data and get a pointer to it (indirect) so that 1011 * we don't have to write the data twice. 1012 */ 1013 if (buf != NULL) { /* immediate write */ 1014 zgd->zgd_rl = zfs_range_lock(zp, offset, size, RL_READER); 1015 /* test for truncation needs to be done while range locked */ 1016 if (offset >= zp->z_size) { 1017 error = ENOENT; 1018 } else { 1019 error = dmu_read(os, object, offset, size, buf, 1020 DMU_READ_NO_PREFETCH); 1021 } 1022 ASSERT(error == 0 || error == ENOENT); 1023 } else { /* indirect write */ 1024 /* 1025 * Have to lock the whole block to ensure when it's 1026 * written out and it's checksum is being calculated 1027 * that no one can change the data. We need to re-check 1028 * blocksize after we get the lock in case it's changed! 1029 */ 1030 for (;;) { 1031 uint64_t blkoff; 1032 size = zp->z_blksz; 1033 blkoff = ISP2(size) ? P2PHASE(offset, size) : offset; 1034 offset -= blkoff; 1035 zgd->zgd_rl = zfs_range_lock(zp, offset, size, 1036 RL_READER); 1037 if (zp->z_blksz == size) 1038 break; 1039 offset += blkoff; 1040 zfs_range_unlock(zgd->zgd_rl); 1041 } 1042 /* test for truncation needs to be done while range locked */ 1043 if (lr->lr_offset >= zp->z_size) 1044 error = ENOENT; 1045 #ifdef DEBUG 1046 if (zil_fault_io) { 1047 error = EIO; 1048 zil_fault_io = 0; 1049 } 1050 #endif 1051 if (error == 0) 1052 error = dmu_buf_hold(os, object, offset, zgd, &db, 1053 DMU_READ_NO_PREFETCH); 1054 1055 if (error == 0) { 1056 zgd->zgd_db = db; 1057 zgd->zgd_bp = bp; 1058 1059 ASSERT(db->db_offset == offset); 1060 ASSERT(db->db_size == size); 1061 1062 error = dmu_sync(zio, lr->lr_common.lrc_txg, 1063 zfs_get_done, zgd); 1064 ASSERT(error || lr->lr_length <= zp->z_blksz); 1065 1066 /* 1067 * On success, we need to wait for the write I/O 1068 * initiated by dmu_sync() to complete before we can 1069 * release this dbuf. We will finish everything up 1070 * in the zfs_get_done() callback. 1071 */ 1072 if (error == 0) 1073 return (0); 1074 1075 if (error == EALREADY) { 1076 lr->lr_common.lrc_txtype = TX_WRITE2; 1077 error = 0; 1078 } 1079 } 1080 } 1081 1082 zfs_get_done(zgd, error); 1083 1084 return (error); 1085 } 1086 1087 /*ARGSUSED*/ 1088 static int 1089 zfs_access(vnode_t *vp, int mode, int flag, cred_t *cr, 1090 caller_context_t *ct) 1091 { 1092 znode_t *zp = VTOZ(vp); 1093 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1094 int error; 1095 1096 ZFS_ENTER(zfsvfs); 1097 ZFS_VERIFY_ZP(zp); 1098 1099 if (flag & V_ACE_MASK) 1100 error = zfs_zaccess(zp, mode, flag, B_FALSE, cr); 1101 else 1102 error = zfs_zaccess_rwx(zp, mode, flag, cr); 1103 1104 ZFS_EXIT(zfsvfs); 1105 return (error); 1106 } 1107 1108 /* 1109 * If vnode is for a device return a specfs vnode instead. 1110 */ 1111 static int 1112 specvp_check(vnode_t **vpp, cred_t *cr) 1113 { 1114 int error = 0; 1115 1116 if (IS_DEVVP(*vpp)) { 1117 struct vnode *svp; 1118 1119 svp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cr); 1120 VN_RELE(*vpp); 1121 if (svp == NULL) 1122 error = ENOSYS; 1123 *vpp = svp; 1124 } 1125 return (error); 1126 } 1127 1128 1129 /* 1130 * Lookup an entry in a directory, or an extended attribute directory. 1131 * If it exists, return a held vnode reference for it. 1132 * 1133 * IN: dvp - vnode of directory to search. 1134 * nm - name of entry to lookup. 1135 * pnp - full pathname to lookup [UNUSED]. 1136 * flags - LOOKUP_XATTR set if looking for an attribute. 1137 * rdir - root directory vnode [UNUSED]. 1138 * cr - credentials of caller. 1139 * ct - caller context 1140 * direntflags - directory lookup flags 1141 * realpnp - returned pathname. 1142 * 1143 * OUT: vpp - vnode of located entry, NULL if not found. 1144 * 1145 * RETURN: 0 if success 1146 * error code if failure 1147 * 1148 * Timestamps: 1149 * NA 1150 */ 1151 /* ARGSUSED */ 1152 static int 1153 zfs_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, struct pathname *pnp, 1154 int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct, 1155 int *direntflags, pathname_t *realpnp) 1156 { 1157 znode_t *zdp = VTOZ(dvp); 1158 zfsvfs_t *zfsvfs = zdp->z_zfsvfs; 1159 int error = 0; 1160 1161 /* fast path */ 1162 if (!(flags & (LOOKUP_XATTR | FIGNORECASE))) { 1163 1164 if (dvp->v_type != VDIR) { 1165 return (ENOTDIR); 1166 } else if (zdp->z_sa_hdl == NULL) { 1167 return (EIO); 1168 } 1169 1170 if (nm[0] == 0 || (nm[0] == '.' && nm[1] == '\0')) { 1171 error = zfs_fastaccesschk_execute(zdp, cr); 1172 if (!error) { 1173 *vpp = dvp; 1174 VN_HOLD(*vpp); 1175 return (0); 1176 } 1177 return (error); 1178 } else { 1179 vnode_t *tvp = dnlc_lookup(dvp, nm); 1180 1181 if (tvp) { 1182 error = zfs_fastaccesschk_execute(zdp, cr); 1183 if (error) { 1184 VN_RELE(tvp); 1185 return (error); 1186 } 1187 if (tvp == DNLC_NO_VNODE) { 1188 VN_RELE(tvp); 1189 return (ENOENT); 1190 } else { 1191 *vpp = tvp; 1192 return (specvp_check(vpp, cr)); 1193 } 1194 } 1195 } 1196 } 1197 1198 DTRACE_PROBE2(zfs__fastpath__lookup__miss, vnode_t *, dvp, char *, nm); 1199 1200 ZFS_ENTER(zfsvfs); 1201 ZFS_VERIFY_ZP(zdp); 1202 1203 *vpp = NULL; 1204 1205 if (flags & LOOKUP_XATTR) { 1206 /* 1207 * If the xattr property is off, refuse the lookup request. 1208 */ 1209 if (!(zfsvfs->z_vfs->vfs_flag & VFS_XATTR)) { 1210 ZFS_EXIT(zfsvfs); 1211 return (EINVAL); 1212 } 1213 1214 /* 1215 * We don't allow recursive attributes.. 1216 * Maybe someday we will. 1217 */ 1218 if (zdp->z_pflags & ZFS_XATTR) { 1219 ZFS_EXIT(zfsvfs); 1220 return (EINVAL); 1221 } 1222 1223 if (error = zfs_get_xattrdir(VTOZ(dvp), vpp, cr, flags)) { 1224 ZFS_EXIT(zfsvfs); 1225 return (error); 1226 } 1227 1228 /* 1229 * Do we have permission to get into attribute directory? 1230 */ 1231 1232 if (error = zfs_zaccess(VTOZ(*vpp), ACE_EXECUTE, 0, 1233 B_FALSE, cr)) { 1234 VN_RELE(*vpp); 1235 *vpp = NULL; 1236 } 1237 1238 ZFS_EXIT(zfsvfs); 1239 return (error); 1240 } 1241 1242 if (dvp->v_type != VDIR) { 1243 ZFS_EXIT(zfsvfs); 1244 return (ENOTDIR); 1245 } 1246 1247 /* 1248 * Check accessibility of directory. 1249 */ 1250 1251 if (error = zfs_zaccess(zdp, ACE_EXECUTE, 0, B_FALSE, cr)) { 1252 ZFS_EXIT(zfsvfs); 1253 return (error); 1254 } 1255 1256 if (zfsvfs->z_utf8 && u8_validate(nm, strlen(nm), 1257 NULL, U8_VALIDATE_ENTIRE, &error) < 0) { 1258 ZFS_EXIT(zfsvfs); 1259 return (EILSEQ); 1260 } 1261 1262 error = zfs_dirlook(zdp, nm, vpp, flags, direntflags, realpnp); 1263 if (error == 0) 1264 error = specvp_check(vpp, cr); 1265 1266 ZFS_EXIT(zfsvfs); 1267 return (error); 1268 } 1269 1270 /* 1271 * Attempt to create a new entry in a directory. If the entry 1272 * already exists, truncate the file if permissible, else return 1273 * an error. Return the vp of the created or trunc'd file. 1274 * 1275 * IN: dvp - vnode of directory to put new file entry in. 1276 * name - name of new file entry. 1277 * vap - attributes of new file. 1278 * excl - flag indicating exclusive or non-exclusive mode. 1279 * mode - mode to open file with. 1280 * cr - credentials of caller. 1281 * flag - large file flag [UNUSED]. 1282 * ct - caller context 1283 * vsecp - ACL to be set 1284 * 1285 * OUT: vpp - vnode of created or trunc'd entry. 1286 * 1287 * RETURN: 0 if success 1288 * error code if failure 1289 * 1290 * Timestamps: 1291 * dvp - ctime|mtime updated if new entry created 1292 * vp - ctime|mtime always, atime if new 1293 */ 1294 1295 /* ARGSUSED */ 1296 static int 1297 zfs_create(vnode_t *dvp, char *name, vattr_t *vap, vcexcl_t excl, 1298 int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct, 1299 vsecattr_t *vsecp) 1300 { 1301 znode_t *zp, *dzp = VTOZ(dvp); 1302 zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 1303 zilog_t *zilog; 1304 objset_t *os; 1305 zfs_dirlock_t *dl; 1306 dmu_tx_t *tx; 1307 int error; 1308 ksid_t *ksid; 1309 uid_t uid; 1310 gid_t gid = crgetgid(cr); 1311 zfs_acl_ids_t acl_ids; 1312 boolean_t fuid_dirtied; 1313 boolean_t have_acl = B_FALSE; 1314 1315 /* 1316 * If we have an ephemeral id, ACL, or XVATTR then 1317 * make sure file system is at proper version 1318 */ 1319 1320 ksid = crgetsid(cr, KSID_OWNER); 1321 if (ksid) 1322 uid = ksid_getid(ksid); 1323 else 1324 uid = crgetuid(cr); 1325 1326 if (zfsvfs->z_use_fuids == B_FALSE && 1327 (vsecp || (vap->va_mask & AT_XVATTR) || 1328 IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid))) 1329 return (EINVAL); 1330 1331 ZFS_ENTER(zfsvfs); 1332 ZFS_VERIFY_ZP(dzp); 1333 os = zfsvfs->z_os; 1334 zilog = zfsvfs->z_log; 1335 1336 if (zfsvfs->z_utf8 && u8_validate(name, strlen(name), 1337 NULL, U8_VALIDATE_ENTIRE, &error) < 0) { 1338 ZFS_EXIT(zfsvfs); 1339 return (EILSEQ); 1340 } 1341 1342 if (vap->va_mask & AT_XVATTR) { 1343 if ((error = secpolicy_xvattr((xvattr_t *)vap, 1344 crgetuid(cr), cr, vap->va_type)) != 0) { 1345 ZFS_EXIT(zfsvfs); 1346 return (error); 1347 } 1348 } 1349 top: 1350 *vpp = NULL; 1351 1352 if ((vap->va_mode & VSVTX) && secpolicy_vnode_stky_modify(cr)) 1353 vap->va_mode &= ~VSVTX; 1354 1355 if (*name == '\0') { 1356 /* 1357 * Null component name refers to the directory itself. 1358 */ 1359 VN_HOLD(dvp); 1360 zp = dzp; 1361 dl = NULL; 1362 error = 0; 1363 } else { 1364 /* possible VN_HOLD(zp) */ 1365 int zflg = 0; 1366 1367 if (flag & FIGNORECASE) 1368 zflg |= ZCILOOK; 1369 1370 error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, 1371 NULL, NULL); 1372 if (error) { 1373 if (have_acl) 1374 zfs_acl_ids_free(&acl_ids); 1375 if (strcmp(name, "..") == 0) 1376 error = EISDIR; 1377 ZFS_EXIT(zfsvfs); 1378 return (error); 1379 } 1380 } 1381 1382 if (zp == NULL) { 1383 uint64_t txtype; 1384 1385 /* 1386 * Create a new file object and update the directory 1387 * to reference it. 1388 */ 1389 if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) { 1390 if (have_acl) 1391 zfs_acl_ids_free(&acl_ids); 1392 goto out; 1393 } 1394 1395 /* 1396 * We only support the creation of regular files in 1397 * extended attribute directories. 1398 */ 1399 1400 if ((dzp->z_pflags & ZFS_XATTR) && 1401 (vap->va_type != VREG)) { 1402 if (have_acl) 1403 zfs_acl_ids_free(&acl_ids); 1404 error = EINVAL; 1405 goto out; 1406 } 1407 1408 if (!have_acl && (error = zfs_acl_ids_create(dzp, 0, vap, 1409 cr, vsecp, &acl_ids)) != 0) 1410 goto out; 1411 have_acl = B_TRUE; 1412 1413 if (zfs_acl_ids_overquota(zfsvfs, &acl_ids)) { 1414 zfs_acl_ids_free(&acl_ids); 1415 error = EDQUOT; 1416 goto out; 1417 } 1418 1419 tx = dmu_tx_create(os); 1420 1421 dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes + 1422 ZFS_SA_BASE_ATTR_SIZE); 1423 1424 fuid_dirtied = zfsvfs->z_fuid_dirty; 1425 if (fuid_dirtied) 1426 zfs_fuid_txhold(zfsvfs, tx); 1427 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name); 1428 dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE); 1429 if (!zfsvfs->z_use_sa && 1430 acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) { 1431 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 1432 0, acl_ids.z_aclp->z_acl_bytes); 1433 } 1434 error = dmu_tx_assign(tx, TXG_NOWAIT); 1435 if (error) { 1436 zfs_dirent_unlock(dl); 1437 if (error == ERESTART) { 1438 dmu_tx_wait(tx); 1439 dmu_tx_abort(tx); 1440 goto top; 1441 } 1442 zfs_acl_ids_free(&acl_ids); 1443 dmu_tx_abort(tx); 1444 ZFS_EXIT(zfsvfs); 1445 return (error); 1446 } 1447 zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids); 1448 1449 if (fuid_dirtied) 1450 zfs_fuid_sync(zfsvfs, tx); 1451 1452 (void) zfs_link_create(dl, zp, tx, ZNEW); 1453 txtype = zfs_log_create_txtype(Z_FILE, vsecp, vap); 1454 if (flag & FIGNORECASE) 1455 txtype |= TX_CI; 1456 zfs_log_create(zilog, tx, txtype, dzp, zp, name, 1457 vsecp, acl_ids.z_fuidp, vap); 1458 zfs_acl_ids_free(&acl_ids); 1459 dmu_tx_commit(tx); 1460 } else { 1461 int aflags = (flag & FAPPEND) ? V_APPEND : 0; 1462 1463 if (have_acl) 1464 zfs_acl_ids_free(&acl_ids); 1465 have_acl = B_FALSE; 1466 1467 /* 1468 * A directory entry already exists for this name. 1469 */ 1470 /* 1471 * Can't truncate an existing file if in exclusive mode. 1472 */ 1473 if (excl == EXCL) { 1474 error = EEXIST; 1475 goto out; 1476 } 1477 /* 1478 * Can't open a directory for writing. 1479 */ 1480 if ((ZTOV(zp)->v_type == VDIR) && (mode & S_IWRITE)) { 1481 error = EISDIR; 1482 goto out; 1483 } 1484 /* 1485 * Verify requested access to file. 1486 */ 1487 if (mode && (error = zfs_zaccess_rwx(zp, mode, aflags, cr))) { 1488 goto out; 1489 } 1490 1491 mutex_enter(&dzp->z_lock); 1492 dzp->z_seq++; 1493 mutex_exit(&dzp->z_lock); 1494 1495 /* 1496 * Truncate regular files if requested. 1497 */ 1498 if ((ZTOV(zp)->v_type == VREG) && 1499 (vap->va_mask & AT_SIZE) && (vap->va_size == 0)) { 1500 /* we can't hold any locks when calling zfs_freesp() */ 1501 zfs_dirent_unlock(dl); 1502 dl = NULL; 1503 error = zfs_freesp(zp, 0, 0, mode, TRUE); 1504 if (error == 0) { 1505 vnevent_create(ZTOV(zp), ct); 1506 } 1507 } 1508 } 1509 out: 1510 1511 if (dl) 1512 zfs_dirent_unlock(dl); 1513 1514 if (error) { 1515 if (zp) 1516 VN_RELE(ZTOV(zp)); 1517 } else { 1518 *vpp = ZTOV(zp); 1519 error = specvp_check(vpp, cr); 1520 } 1521 1522 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 1523 zil_commit(zilog, 0); 1524 1525 ZFS_EXIT(zfsvfs); 1526 return (error); 1527 } 1528 1529 /* 1530 * Remove an entry from a directory. 1531 * 1532 * IN: dvp - vnode of directory to remove entry from. 1533 * name - name of entry to remove. 1534 * cr - credentials of caller. 1535 * ct - caller context 1536 * flags - case flags 1537 * 1538 * RETURN: 0 if success 1539 * error code if failure 1540 * 1541 * Timestamps: 1542 * dvp - ctime|mtime 1543 * vp - ctime (if nlink > 0) 1544 */ 1545 1546 uint64_t null_xattr = 0; 1547 1548 /*ARGSUSED*/ 1549 static int 1550 zfs_remove(vnode_t *dvp, char *name, cred_t *cr, caller_context_t *ct, 1551 int flags) 1552 { 1553 znode_t *zp, *dzp = VTOZ(dvp); 1554 znode_t *xzp; 1555 vnode_t *vp; 1556 zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 1557 zilog_t *zilog; 1558 uint64_t acl_obj, xattr_obj; 1559 uint64_t xattr_obj_unlinked = 0; 1560 uint64_t obj = 0; 1561 zfs_dirlock_t *dl; 1562 dmu_tx_t *tx; 1563 boolean_t may_delete_now, delete_now = FALSE; 1564 boolean_t unlinked, toobig = FALSE; 1565 uint64_t txtype; 1566 pathname_t *realnmp = NULL; 1567 pathname_t realnm; 1568 int error; 1569 int zflg = ZEXISTS; 1570 1571 ZFS_ENTER(zfsvfs); 1572 ZFS_VERIFY_ZP(dzp); 1573 zilog = zfsvfs->z_log; 1574 1575 if (flags & FIGNORECASE) { 1576 zflg |= ZCILOOK; 1577 pn_alloc(&realnm); 1578 realnmp = &realnm; 1579 } 1580 1581 top: 1582 xattr_obj = 0; 1583 xzp = NULL; 1584 /* 1585 * Attempt to lock directory; fail if entry doesn't exist. 1586 */ 1587 if (error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, 1588 NULL, realnmp)) { 1589 if (realnmp) 1590 pn_free(realnmp); 1591 ZFS_EXIT(zfsvfs); 1592 return (error); 1593 } 1594 1595 vp = ZTOV(zp); 1596 1597 if (error = zfs_zaccess_delete(dzp, zp, cr)) { 1598 goto out; 1599 } 1600 1601 /* 1602 * Need to use rmdir for removing directories. 1603 */ 1604 if (vp->v_type == VDIR) { 1605 error = EPERM; 1606 goto out; 1607 } 1608 1609 vnevent_remove(vp, dvp, name, ct); 1610 1611 if (realnmp) 1612 dnlc_remove(dvp, realnmp->pn_buf); 1613 else 1614 dnlc_remove(dvp, name); 1615 1616 mutex_enter(&vp->v_lock); 1617 may_delete_now = vp->v_count == 1 && !vn_has_cached_data(vp); 1618 mutex_exit(&vp->v_lock); 1619 1620 /* 1621 * We may delete the znode now, or we may put it in the unlinked set; 1622 * it depends on whether we're the last link, and on whether there are 1623 * other holds on the vnode. So we dmu_tx_hold() the right things to 1624 * allow for either case. 1625 */ 1626 obj = zp->z_id; 1627 tx = dmu_tx_create(zfsvfs->z_os); 1628 dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name); 1629 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE); 1630 zfs_sa_upgrade_txholds(tx, zp); 1631 zfs_sa_upgrade_txholds(tx, dzp); 1632 if (may_delete_now) { 1633 toobig = 1634 zp->z_size > zp->z_blksz * DMU_MAX_DELETEBLKCNT; 1635 /* if the file is too big, only hold_free a token amount */ 1636 dmu_tx_hold_free(tx, zp->z_id, 0, 1637 (toobig ? DMU_MAX_ACCESS : DMU_OBJECT_END)); 1638 } 1639 1640 /* are there any extended attributes? */ 1641 error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), 1642 &xattr_obj, sizeof (xattr_obj)); 1643 if (error == 0 && xattr_obj) { 1644 error = zfs_zget(zfsvfs, xattr_obj, &xzp); 1645 ASSERT0(error); 1646 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE); 1647 dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE); 1648 } 1649 1650 mutex_enter(&zp->z_lock); 1651 if ((acl_obj = zfs_external_acl(zp)) != 0 && may_delete_now) 1652 dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END); 1653 mutex_exit(&zp->z_lock); 1654 1655 /* charge as an update -- would be nice not to charge at all */ 1656 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL); 1657 1658 error = dmu_tx_assign(tx, TXG_NOWAIT); 1659 if (error) { 1660 zfs_dirent_unlock(dl); 1661 VN_RELE(vp); 1662 if (xzp) 1663 VN_RELE(ZTOV(xzp)); 1664 if (error == ERESTART) { 1665 dmu_tx_wait(tx); 1666 dmu_tx_abort(tx); 1667 goto top; 1668 } 1669 if (realnmp) 1670 pn_free(realnmp); 1671 dmu_tx_abort(tx); 1672 ZFS_EXIT(zfsvfs); 1673 return (error); 1674 } 1675 1676 /* 1677 * Remove the directory entry. 1678 */ 1679 error = zfs_link_destroy(dl, zp, tx, zflg, &unlinked); 1680 1681 if (error) { 1682 dmu_tx_commit(tx); 1683 goto out; 1684 } 1685 1686 if (unlinked) { 1687 1688 /* 1689 * Hold z_lock so that we can make sure that the ACL obj 1690 * hasn't changed. Could have been deleted due to 1691 * zfs_sa_upgrade(). 1692 */ 1693 mutex_enter(&zp->z_lock); 1694 mutex_enter(&vp->v_lock); 1695 (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), 1696 &xattr_obj_unlinked, sizeof (xattr_obj_unlinked)); 1697 delete_now = may_delete_now && !toobig && 1698 vp->v_count == 1 && !vn_has_cached_data(vp) && 1699 xattr_obj == xattr_obj_unlinked && zfs_external_acl(zp) == 1700 acl_obj; 1701 mutex_exit(&vp->v_lock); 1702 } 1703 1704 if (delete_now) { 1705 if (xattr_obj_unlinked) { 1706 ASSERT3U(xzp->z_links, ==, 2); 1707 mutex_enter(&xzp->z_lock); 1708 xzp->z_unlinked = 1; 1709 xzp->z_links = 0; 1710 error = sa_update(xzp->z_sa_hdl, SA_ZPL_LINKS(zfsvfs), 1711 &xzp->z_links, sizeof (xzp->z_links), tx); 1712 ASSERT3U(error, ==, 0); 1713 mutex_exit(&xzp->z_lock); 1714 zfs_unlinked_add(xzp, tx); 1715 1716 if (zp->z_is_sa) 1717 error = sa_remove(zp->z_sa_hdl, 1718 SA_ZPL_XATTR(zfsvfs), tx); 1719 else 1720 error = sa_update(zp->z_sa_hdl, 1721 SA_ZPL_XATTR(zfsvfs), &null_xattr, 1722 sizeof (uint64_t), tx); 1723 ASSERT0(error); 1724 } 1725 mutex_enter(&vp->v_lock); 1726 vp->v_count--; 1727 ASSERT0(vp->v_count); 1728 mutex_exit(&vp->v_lock); 1729 mutex_exit(&zp->z_lock); 1730 zfs_znode_delete(zp, tx); 1731 } else if (unlinked) { 1732 mutex_exit(&zp->z_lock); 1733 zfs_unlinked_add(zp, tx); 1734 } 1735 1736 txtype = TX_REMOVE; 1737 if (flags & FIGNORECASE) 1738 txtype |= TX_CI; 1739 zfs_log_remove(zilog, tx, txtype, dzp, name, obj); 1740 1741 dmu_tx_commit(tx); 1742 out: 1743 if (realnmp) 1744 pn_free(realnmp); 1745 1746 zfs_dirent_unlock(dl); 1747 1748 if (!delete_now) 1749 VN_RELE(vp); 1750 if (xzp) 1751 VN_RELE(ZTOV(xzp)); 1752 1753 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 1754 zil_commit(zilog, 0); 1755 1756 ZFS_EXIT(zfsvfs); 1757 return (error); 1758 } 1759 1760 /* 1761 * Create a new directory and insert it into dvp using the name 1762 * provided. Return a pointer to the inserted directory. 1763 * 1764 * IN: dvp - vnode of directory to add subdir to. 1765 * dirname - name of new directory. 1766 * vap - attributes of new directory. 1767 * cr - credentials of caller. 1768 * ct - caller context 1769 * vsecp - ACL to be set 1770 * 1771 * OUT: vpp - vnode of created directory. 1772 * 1773 * RETURN: 0 if success 1774 * error code if failure 1775 * 1776 * Timestamps: 1777 * dvp - ctime|mtime updated 1778 * vp - ctime|mtime|atime updated 1779 */ 1780 /*ARGSUSED*/ 1781 static int 1782 zfs_mkdir(vnode_t *dvp, char *dirname, vattr_t *vap, vnode_t **vpp, cred_t *cr, 1783 caller_context_t *ct, int flags, vsecattr_t *vsecp) 1784 { 1785 znode_t *zp, *dzp = VTOZ(dvp); 1786 zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 1787 zilog_t *zilog; 1788 zfs_dirlock_t *dl; 1789 uint64_t txtype; 1790 dmu_tx_t *tx; 1791 int error; 1792 int zf = ZNEW; 1793 ksid_t *ksid; 1794 uid_t uid; 1795 gid_t gid = crgetgid(cr); 1796 zfs_acl_ids_t acl_ids; 1797 boolean_t fuid_dirtied; 1798 1799 ASSERT(vap->va_type == VDIR); 1800 1801 /* 1802 * If we have an ephemeral id, ACL, or XVATTR then 1803 * make sure file system is at proper version 1804 */ 1805 1806 ksid = crgetsid(cr, KSID_OWNER); 1807 if (ksid) 1808 uid = ksid_getid(ksid); 1809 else 1810 uid = crgetuid(cr); 1811 if (zfsvfs->z_use_fuids == B_FALSE && 1812 (vsecp || (vap->va_mask & AT_XVATTR) || 1813 IS_EPHEMERAL(uid) || IS_EPHEMERAL(gid))) 1814 return (EINVAL); 1815 1816 ZFS_ENTER(zfsvfs); 1817 ZFS_VERIFY_ZP(dzp); 1818 zilog = zfsvfs->z_log; 1819 1820 if (dzp->z_pflags & ZFS_XATTR) { 1821 ZFS_EXIT(zfsvfs); 1822 return (EINVAL); 1823 } 1824 1825 if (zfsvfs->z_utf8 && u8_validate(dirname, 1826 strlen(dirname), NULL, U8_VALIDATE_ENTIRE, &error) < 0) { 1827 ZFS_EXIT(zfsvfs); 1828 return (EILSEQ); 1829 } 1830 if (flags & FIGNORECASE) 1831 zf |= ZCILOOK; 1832 1833 if (vap->va_mask & AT_XVATTR) { 1834 if ((error = secpolicy_xvattr((xvattr_t *)vap, 1835 crgetuid(cr), cr, vap->va_type)) != 0) { 1836 ZFS_EXIT(zfsvfs); 1837 return (error); 1838 } 1839 } 1840 1841 if ((error = zfs_acl_ids_create(dzp, 0, vap, cr, 1842 vsecp, &acl_ids)) != 0) { 1843 ZFS_EXIT(zfsvfs); 1844 return (error); 1845 } 1846 /* 1847 * First make sure the new directory doesn't exist. 1848 * 1849 * Existence is checked first to make sure we don't return 1850 * EACCES instead of EEXIST which can cause some applications 1851 * to fail. 1852 */ 1853 top: 1854 *vpp = NULL; 1855 1856 if (error = zfs_dirent_lock(&dl, dzp, dirname, &zp, zf, 1857 NULL, NULL)) { 1858 zfs_acl_ids_free(&acl_ids); 1859 ZFS_EXIT(zfsvfs); 1860 return (error); 1861 } 1862 1863 if (error = zfs_zaccess(dzp, ACE_ADD_SUBDIRECTORY, 0, B_FALSE, cr)) { 1864 zfs_acl_ids_free(&acl_ids); 1865 zfs_dirent_unlock(dl); 1866 ZFS_EXIT(zfsvfs); 1867 return (error); 1868 } 1869 1870 if (zfs_acl_ids_overquota(zfsvfs, &acl_ids)) { 1871 zfs_acl_ids_free(&acl_ids); 1872 zfs_dirent_unlock(dl); 1873 ZFS_EXIT(zfsvfs); 1874 return (EDQUOT); 1875 } 1876 1877 /* 1878 * Add a new entry to the directory. 1879 */ 1880 tx = dmu_tx_create(zfsvfs->z_os); 1881 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, dirname); 1882 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL); 1883 fuid_dirtied = zfsvfs->z_fuid_dirty; 1884 if (fuid_dirtied) 1885 zfs_fuid_txhold(zfsvfs, tx); 1886 if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) { 1887 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 1888 acl_ids.z_aclp->z_acl_bytes); 1889 } 1890 1891 dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes + 1892 ZFS_SA_BASE_ATTR_SIZE); 1893 1894 error = dmu_tx_assign(tx, TXG_NOWAIT); 1895 if (error) { 1896 zfs_dirent_unlock(dl); 1897 if (error == ERESTART) { 1898 dmu_tx_wait(tx); 1899 dmu_tx_abort(tx); 1900 goto top; 1901 } 1902 zfs_acl_ids_free(&acl_ids); 1903 dmu_tx_abort(tx); 1904 ZFS_EXIT(zfsvfs); 1905 return (error); 1906 } 1907 1908 /* 1909 * Create new node. 1910 */ 1911 zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids); 1912 1913 if (fuid_dirtied) 1914 zfs_fuid_sync(zfsvfs, tx); 1915 1916 /* 1917 * Now put new name in parent dir. 1918 */ 1919 (void) zfs_link_create(dl, zp, tx, ZNEW); 1920 1921 *vpp = ZTOV(zp); 1922 1923 txtype = zfs_log_create_txtype(Z_DIR, vsecp, vap); 1924 if (flags & FIGNORECASE) 1925 txtype |= TX_CI; 1926 zfs_log_create(zilog, tx, txtype, dzp, zp, dirname, vsecp, 1927 acl_ids.z_fuidp, vap); 1928 1929 zfs_acl_ids_free(&acl_ids); 1930 1931 dmu_tx_commit(tx); 1932 1933 zfs_dirent_unlock(dl); 1934 1935 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 1936 zil_commit(zilog, 0); 1937 1938 ZFS_EXIT(zfsvfs); 1939 return (0); 1940 } 1941 1942 /* 1943 * Remove a directory subdir entry. If the current working 1944 * directory is the same as the subdir to be removed, the 1945 * remove will fail. 1946 * 1947 * IN: dvp - vnode of directory to remove from. 1948 * name - name of directory to be removed. 1949 * cwd - vnode of current working directory. 1950 * cr - credentials of caller. 1951 * ct - caller context 1952 * flags - case flags 1953 * 1954 * RETURN: 0 if success 1955 * error code if failure 1956 * 1957 * Timestamps: 1958 * dvp - ctime|mtime updated 1959 */ 1960 /*ARGSUSED*/ 1961 static int 1962 zfs_rmdir(vnode_t *dvp, char *name, vnode_t *cwd, cred_t *cr, 1963 caller_context_t *ct, int flags) 1964 { 1965 znode_t *dzp = VTOZ(dvp); 1966 znode_t *zp; 1967 vnode_t *vp; 1968 zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 1969 zilog_t *zilog; 1970 zfs_dirlock_t *dl; 1971 dmu_tx_t *tx; 1972 int error; 1973 int zflg = ZEXISTS; 1974 1975 ZFS_ENTER(zfsvfs); 1976 ZFS_VERIFY_ZP(dzp); 1977 zilog = zfsvfs->z_log; 1978 1979 if (flags & FIGNORECASE) 1980 zflg |= ZCILOOK; 1981 top: 1982 zp = NULL; 1983 1984 /* 1985 * Attempt to lock directory; fail if entry doesn't exist. 1986 */ 1987 if (error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, 1988 NULL, NULL)) { 1989 ZFS_EXIT(zfsvfs); 1990 return (error); 1991 } 1992 1993 vp = ZTOV(zp); 1994 1995 if (error = zfs_zaccess_delete(dzp, zp, cr)) { 1996 goto out; 1997 } 1998 1999 if (vp->v_type != VDIR) { 2000 error = ENOTDIR; 2001 goto out; 2002 } 2003 2004 if (vp == cwd) { 2005 error = EINVAL; 2006 goto out; 2007 } 2008 2009 vnevent_rmdir(vp, dvp, name, ct); 2010 2011 /* 2012 * Grab a lock on the directory to make sure that noone is 2013 * trying to add (or lookup) entries while we are removing it. 2014 */ 2015 rw_enter(&zp->z_name_lock, RW_WRITER); 2016 2017 /* 2018 * Grab a lock on the parent pointer to make sure we play well 2019 * with the treewalk and directory rename code. 2020 */ 2021 rw_enter(&zp->z_parent_lock, RW_WRITER); 2022 2023 tx = dmu_tx_create(zfsvfs->z_os); 2024 dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name); 2025 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE); 2026 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL); 2027 zfs_sa_upgrade_txholds(tx, zp); 2028 zfs_sa_upgrade_txholds(tx, dzp); 2029 error = dmu_tx_assign(tx, TXG_NOWAIT); 2030 if (error) { 2031 rw_exit(&zp->z_parent_lock); 2032 rw_exit(&zp->z_name_lock); 2033 zfs_dirent_unlock(dl); 2034 VN_RELE(vp); 2035 if (error == ERESTART) { 2036 dmu_tx_wait(tx); 2037 dmu_tx_abort(tx); 2038 goto top; 2039 } 2040 dmu_tx_abort(tx); 2041 ZFS_EXIT(zfsvfs); 2042 return (error); 2043 } 2044 2045 error = zfs_link_destroy(dl, zp, tx, zflg, NULL); 2046 2047 if (error == 0) { 2048 uint64_t txtype = TX_RMDIR; 2049 if (flags & FIGNORECASE) 2050 txtype |= TX_CI; 2051 zfs_log_remove(zilog, tx, txtype, dzp, name, ZFS_NO_OBJECT); 2052 } 2053 2054 dmu_tx_commit(tx); 2055 2056 rw_exit(&zp->z_parent_lock); 2057 rw_exit(&zp->z_name_lock); 2058 out: 2059 zfs_dirent_unlock(dl); 2060 2061 VN_RELE(vp); 2062 2063 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 2064 zil_commit(zilog, 0); 2065 2066 ZFS_EXIT(zfsvfs); 2067 return (error); 2068 } 2069 2070 /* 2071 * Read as many directory entries as will fit into the provided 2072 * buffer from the given directory cursor position (specified in 2073 * the uio structure. 2074 * 2075 * IN: vp - vnode of directory to read. 2076 * uio - structure supplying read location, range info, 2077 * and return buffer. 2078 * cr - credentials of caller. 2079 * ct - caller context 2080 * flags - case flags 2081 * 2082 * OUT: uio - updated offset and range, buffer filled. 2083 * eofp - set to true if end-of-file detected. 2084 * 2085 * RETURN: 0 if success 2086 * error code if failure 2087 * 2088 * Timestamps: 2089 * vp - atime updated 2090 * 2091 * Note that the low 4 bits of the cookie returned by zap is always zero. 2092 * This allows us to use the low range for "special" directory entries: 2093 * We use 0 for '.', and 1 for '..'. If this is the root of the filesystem, 2094 * we use the offset 2 for the '.zfs' directory. 2095 */ 2096 /* ARGSUSED */ 2097 static int 2098 zfs_readdir(vnode_t *vp, uio_t *uio, cred_t *cr, int *eofp, 2099 caller_context_t *ct, int flags) 2100 { 2101 znode_t *zp = VTOZ(vp); 2102 iovec_t *iovp; 2103 edirent_t *eodp; 2104 dirent64_t *odp; 2105 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2106 objset_t *os; 2107 caddr_t outbuf; 2108 size_t bufsize; 2109 zap_cursor_t zc; 2110 zap_attribute_t zap; 2111 uint_t bytes_wanted; 2112 uint64_t offset; /* must be unsigned; checks for < 1 */ 2113 uint64_t parent; 2114 int local_eof; 2115 int outcount; 2116 int error; 2117 uint8_t prefetch; 2118 boolean_t check_sysattrs; 2119 2120 ZFS_ENTER(zfsvfs); 2121 ZFS_VERIFY_ZP(zp); 2122 2123 if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs), 2124 &parent, sizeof (parent))) != 0) { 2125 ZFS_EXIT(zfsvfs); 2126 return (error); 2127 } 2128 2129 /* 2130 * If we are not given an eof variable, 2131 * use a local one. 2132 */ 2133 if (eofp == NULL) 2134 eofp = &local_eof; 2135 2136 /* 2137 * Check for valid iov_len. 2138 */ 2139 if (uio->uio_iov->iov_len <= 0) { 2140 ZFS_EXIT(zfsvfs); 2141 return (EINVAL); 2142 } 2143 2144 /* 2145 * Quit if directory has been removed (posix) 2146 */ 2147 if ((*eofp = zp->z_unlinked) != 0) { 2148 ZFS_EXIT(zfsvfs); 2149 return (0); 2150 } 2151 2152 error = 0; 2153 os = zfsvfs->z_os; 2154 offset = uio->uio_loffset; 2155 prefetch = zp->z_zn_prefetch; 2156 2157 /* 2158 * Initialize the iterator cursor. 2159 */ 2160 if (offset <= 3) { 2161 /* 2162 * Start iteration from the beginning of the directory. 2163 */ 2164 zap_cursor_init(&zc, os, zp->z_id); 2165 } else { 2166 /* 2167 * The offset is a serialized cursor. 2168 */ 2169 zap_cursor_init_serialized(&zc, os, zp->z_id, offset); 2170 } 2171 2172 /* 2173 * Get space to change directory entries into fs independent format. 2174 */ 2175 iovp = uio->uio_iov; 2176 bytes_wanted = iovp->iov_len; 2177 if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1) { 2178 bufsize = bytes_wanted; 2179 outbuf = kmem_alloc(bufsize, KM_SLEEP); 2180 odp = (struct dirent64 *)outbuf; 2181 } else { 2182 bufsize = bytes_wanted; 2183 odp = (struct dirent64 *)iovp->iov_base; 2184 } 2185 eodp = (struct edirent *)odp; 2186 2187 /* 2188 * If this VFS supports the system attribute view interface; and 2189 * we're looking at an extended attribute directory; and we care 2190 * about normalization conflicts on this vfs; then we must check 2191 * for normalization conflicts with the sysattr name space. 2192 */ 2193 check_sysattrs = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) && 2194 (vp->v_flag & V_XATTRDIR) && zfsvfs->z_norm && 2195 (flags & V_RDDIR_ENTFLAGS); 2196 2197 /* 2198 * Transform to file-system independent format 2199 */ 2200 outcount = 0; 2201 while (outcount < bytes_wanted) { 2202 ino64_t objnum; 2203 ushort_t reclen; 2204 off64_t *next = NULL; 2205 2206 /* 2207 * Special case `.', `..', and `.zfs'. 2208 */ 2209 if (offset == 0) { 2210 (void) strcpy(zap.za_name, "."); 2211 zap.za_normalization_conflict = 0; 2212 objnum = zp->z_id; 2213 } else if (offset == 1) { 2214 (void) strcpy(zap.za_name, ".."); 2215 zap.za_normalization_conflict = 0; 2216 objnum = parent; 2217 } else if (offset == 2 && zfs_show_ctldir(zp)) { 2218 (void) strcpy(zap.za_name, ZFS_CTLDIR_NAME); 2219 zap.za_normalization_conflict = 0; 2220 objnum = ZFSCTL_INO_ROOT; 2221 } else { 2222 /* 2223 * Grab next entry. 2224 */ 2225 if (error = zap_cursor_retrieve(&zc, &zap)) { 2226 if ((*eofp = (error == ENOENT)) != 0) 2227 break; 2228 else 2229 goto update; 2230 } 2231 2232 if (zap.za_integer_length != 8 || 2233 zap.za_num_integers != 1) { 2234 cmn_err(CE_WARN, "zap_readdir: bad directory " 2235 "entry, obj = %lld, offset = %lld\n", 2236 (u_longlong_t)zp->z_id, 2237 (u_longlong_t)offset); 2238 error = ENXIO; 2239 goto update; 2240 } 2241 2242 objnum = ZFS_DIRENT_OBJ(zap.za_first_integer); 2243 /* 2244 * MacOS X can extract the object type here such as: 2245 * uint8_t type = ZFS_DIRENT_TYPE(zap.za_first_integer); 2246 */ 2247 2248 if (check_sysattrs && !zap.za_normalization_conflict) { 2249 zap.za_normalization_conflict = 2250 xattr_sysattr_casechk(zap.za_name); 2251 } 2252 } 2253 2254 if (flags & V_RDDIR_ACCFILTER) { 2255 /* 2256 * If we have no access at all, don't include 2257 * this entry in the returned information 2258 */ 2259 znode_t *ezp; 2260 if (zfs_zget(zp->z_zfsvfs, objnum, &ezp) != 0) 2261 goto skip_entry; 2262 if (!zfs_has_access(ezp, cr)) { 2263 VN_RELE(ZTOV(ezp)); 2264 goto skip_entry; 2265 } 2266 VN_RELE(ZTOV(ezp)); 2267 } 2268 2269 if (flags & V_RDDIR_ENTFLAGS) 2270 reclen = EDIRENT_RECLEN(strlen(zap.za_name)); 2271 else 2272 reclen = DIRENT64_RECLEN(strlen(zap.za_name)); 2273 2274 /* 2275 * Will this entry fit in the buffer? 2276 */ 2277 if (outcount + reclen > bufsize) { 2278 /* 2279 * Did we manage to fit anything in the buffer? 2280 */ 2281 if (!outcount) { 2282 error = EINVAL; 2283 goto update; 2284 } 2285 break; 2286 } 2287 if (flags & V_RDDIR_ENTFLAGS) { 2288 /* 2289 * Add extended flag entry: 2290 */ 2291 eodp->ed_ino = objnum; 2292 eodp->ed_reclen = reclen; 2293 /* NOTE: ed_off is the offset for the *next* entry */ 2294 next = &(eodp->ed_off); 2295 eodp->ed_eflags = zap.za_normalization_conflict ? 2296 ED_CASE_CONFLICT : 0; 2297 (void) strncpy(eodp->ed_name, zap.za_name, 2298 EDIRENT_NAMELEN(reclen)); 2299 eodp = (edirent_t *)((intptr_t)eodp + reclen); 2300 } else { 2301 /* 2302 * Add normal entry: 2303 */ 2304 odp->d_ino = objnum; 2305 odp->d_reclen = reclen; 2306 /* NOTE: d_off is the offset for the *next* entry */ 2307 next = &(odp->d_off); 2308 (void) strncpy(odp->d_name, zap.za_name, 2309 DIRENT64_NAMELEN(reclen)); 2310 odp = (dirent64_t *)((intptr_t)odp + reclen); 2311 } 2312 outcount += reclen; 2313 2314 ASSERT(outcount <= bufsize); 2315 2316 /* Prefetch znode */ 2317 if (prefetch) 2318 dmu_prefetch(os, objnum, 0, 0); 2319 2320 skip_entry: 2321 /* 2322 * Move to the next entry, fill in the previous offset. 2323 */ 2324 if (offset > 2 || (offset == 2 && !zfs_show_ctldir(zp))) { 2325 zap_cursor_advance(&zc); 2326 offset = zap_cursor_serialize(&zc); 2327 } else { 2328 offset += 1; 2329 } 2330 if (next) 2331 *next = offset; 2332 } 2333 zp->z_zn_prefetch = B_FALSE; /* a lookup will re-enable pre-fetching */ 2334 2335 if (uio->uio_segflg == UIO_SYSSPACE && uio->uio_iovcnt == 1) { 2336 iovp->iov_base += outcount; 2337 iovp->iov_len -= outcount; 2338 uio->uio_resid -= outcount; 2339 } else if (error = uiomove(outbuf, (long)outcount, UIO_READ, uio)) { 2340 /* 2341 * Reset the pointer. 2342 */ 2343 offset = uio->uio_loffset; 2344 } 2345 2346 update: 2347 zap_cursor_fini(&zc); 2348 if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1) 2349 kmem_free(outbuf, bufsize); 2350 2351 if (error == ENOENT) 2352 error = 0; 2353 2354 ZFS_ACCESSTIME_STAMP(zfsvfs, zp); 2355 2356 uio->uio_loffset = offset; 2357 ZFS_EXIT(zfsvfs); 2358 return (error); 2359 } 2360 2361 ulong_t zfs_fsync_sync_cnt = 4; 2362 2363 static int 2364 zfs_fsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct) 2365 { 2366 znode_t *zp = VTOZ(vp); 2367 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2368 2369 /* 2370 * Regardless of whether this is required for standards conformance, 2371 * this is the logical behavior when fsync() is called on a file with 2372 * dirty pages. We use B_ASYNC since the ZIL transactions are already 2373 * going to be pushed out as part of the zil_commit(). 2374 */ 2375 if (vn_has_cached_data(vp) && !(syncflag & FNODSYNC) && 2376 (vp->v_type == VREG) && !(IS_SWAPVP(vp))) 2377 (void) VOP_PUTPAGE(vp, (offset_t)0, (size_t)0, B_ASYNC, cr, ct); 2378 2379 (void) tsd_set(zfs_fsyncer_key, (void *)zfs_fsync_sync_cnt); 2380 2381 if (zfsvfs->z_os->os_sync != ZFS_SYNC_DISABLED) { 2382 ZFS_ENTER(zfsvfs); 2383 ZFS_VERIFY_ZP(zp); 2384 zil_commit(zfsvfs->z_log, zp->z_id); 2385 ZFS_EXIT(zfsvfs); 2386 } 2387 return (0); 2388 } 2389 2390 2391 /* 2392 * Get the requested file attributes and place them in the provided 2393 * vattr structure. 2394 * 2395 * IN: vp - vnode of file. 2396 * vap - va_mask identifies requested attributes. 2397 * If AT_XVATTR set, then optional attrs are requested 2398 * flags - ATTR_NOACLCHECK (CIFS server context) 2399 * cr - credentials of caller. 2400 * ct - caller context 2401 * 2402 * OUT: vap - attribute values. 2403 * 2404 * RETURN: 0 (always succeeds) 2405 */ 2406 /* ARGSUSED */ 2407 static int 2408 zfs_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 2409 caller_context_t *ct) 2410 { 2411 znode_t *zp = VTOZ(vp); 2412 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2413 int error = 0; 2414 uint64_t links; 2415 uint64_t mtime[2], ctime[2]; 2416 xvattr_t *xvap = (xvattr_t *)vap; /* vap may be an xvattr_t * */ 2417 xoptattr_t *xoap = NULL; 2418 boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE; 2419 sa_bulk_attr_t bulk[2]; 2420 int count = 0; 2421 2422 ZFS_ENTER(zfsvfs); 2423 ZFS_VERIFY_ZP(zp); 2424 2425 zfs_fuid_map_ids(zp, cr, &vap->va_uid, &vap->va_gid); 2426 2427 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16); 2428 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16); 2429 2430 if ((error = sa_bulk_lookup(zp->z_sa_hdl, bulk, count)) != 0) { 2431 ZFS_EXIT(zfsvfs); 2432 return (error); 2433 } 2434 2435 /* 2436 * If ACL is trivial don't bother looking for ACE_READ_ATTRIBUTES. 2437 * Also, if we are the owner don't bother, since owner should 2438 * always be allowed to read basic attributes of file. 2439 */ 2440 if (!(zp->z_pflags & ZFS_ACL_TRIVIAL) && 2441 (vap->va_uid != crgetuid(cr))) { 2442 if (error = zfs_zaccess(zp, ACE_READ_ATTRIBUTES, 0, 2443 skipaclchk, cr)) { 2444 ZFS_EXIT(zfsvfs); 2445 return (error); 2446 } 2447 } 2448 2449 /* 2450 * Return all attributes. It's cheaper to provide the answer 2451 * than to determine whether we were asked the question. 2452 */ 2453 2454 mutex_enter(&zp->z_lock); 2455 vap->va_type = vp->v_type; 2456 vap->va_mode = zp->z_mode & MODEMASK; 2457 vap->va_fsid = zp->z_zfsvfs->z_vfs->vfs_dev; 2458 vap->va_nodeid = zp->z_id; 2459 if ((vp->v_flag & VROOT) && zfs_show_ctldir(zp)) 2460 links = zp->z_links + 1; 2461 else 2462 links = zp->z_links; 2463 vap->va_nlink = MIN(links, UINT32_MAX); /* nlink_t limit! */ 2464 vap->va_size = zp->z_size; 2465 vap->va_rdev = vp->v_rdev; 2466 vap->va_seq = zp->z_seq; 2467 2468 /* 2469 * Add in any requested optional attributes and the create time. 2470 * Also set the corresponding bits in the returned attribute bitmap. 2471 */ 2472 if ((xoap = xva_getxoptattr(xvap)) != NULL && zfsvfs->z_use_fuids) { 2473 if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) { 2474 xoap->xoa_archive = 2475 ((zp->z_pflags & ZFS_ARCHIVE) != 0); 2476 XVA_SET_RTN(xvap, XAT_ARCHIVE); 2477 } 2478 2479 if (XVA_ISSET_REQ(xvap, XAT_READONLY)) { 2480 xoap->xoa_readonly = 2481 ((zp->z_pflags & ZFS_READONLY) != 0); 2482 XVA_SET_RTN(xvap, XAT_READONLY); 2483 } 2484 2485 if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) { 2486 xoap->xoa_system = 2487 ((zp->z_pflags & ZFS_SYSTEM) != 0); 2488 XVA_SET_RTN(xvap, XAT_SYSTEM); 2489 } 2490 2491 if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) { 2492 xoap->xoa_hidden = 2493 ((zp->z_pflags & ZFS_HIDDEN) != 0); 2494 XVA_SET_RTN(xvap, XAT_HIDDEN); 2495 } 2496 2497 if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) { 2498 xoap->xoa_nounlink = 2499 ((zp->z_pflags & ZFS_NOUNLINK) != 0); 2500 XVA_SET_RTN(xvap, XAT_NOUNLINK); 2501 } 2502 2503 if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) { 2504 xoap->xoa_immutable = 2505 ((zp->z_pflags & ZFS_IMMUTABLE) != 0); 2506 XVA_SET_RTN(xvap, XAT_IMMUTABLE); 2507 } 2508 2509 if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) { 2510 xoap->xoa_appendonly = 2511 ((zp->z_pflags & ZFS_APPENDONLY) != 0); 2512 XVA_SET_RTN(xvap, XAT_APPENDONLY); 2513 } 2514 2515 if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) { 2516 xoap->xoa_nodump = 2517 ((zp->z_pflags & ZFS_NODUMP) != 0); 2518 XVA_SET_RTN(xvap, XAT_NODUMP); 2519 } 2520 2521 if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) { 2522 xoap->xoa_opaque = 2523 ((zp->z_pflags & ZFS_OPAQUE) != 0); 2524 XVA_SET_RTN(xvap, XAT_OPAQUE); 2525 } 2526 2527 if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) { 2528 xoap->xoa_av_quarantined = 2529 ((zp->z_pflags & ZFS_AV_QUARANTINED) != 0); 2530 XVA_SET_RTN(xvap, XAT_AV_QUARANTINED); 2531 } 2532 2533 if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) { 2534 xoap->xoa_av_modified = 2535 ((zp->z_pflags & ZFS_AV_MODIFIED) != 0); 2536 XVA_SET_RTN(xvap, XAT_AV_MODIFIED); 2537 } 2538 2539 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) && 2540 vp->v_type == VREG) { 2541 zfs_sa_get_scanstamp(zp, xvap); 2542 } 2543 2544 if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) { 2545 uint64_t times[2]; 2546 2547 (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_CRTIME(zfsvfs), 2548 times, sizeof (times)); 2549 ZFS_TIME_DECODE(&xoap->xoa_createtime, times); 2550 XVA_SET_RTN(xvap, XAT_CREATETIME); 2551 } 2552 2553 if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) { 2554 xoap->xoa_reparse = ((zp->z_pflags & ZFS_REPARSE) != 0); 2555 XVA_SET_RTN(xvap, XAT_REPARSE); 2556 } 2557 if (XVA_ISSET_REQ(xvap, XAT_GEN)) { 2558 xoap->xoa_generation = zp->z_gen; 2559 XVA_SET_RTN(xvap, XAT_GEN); 2560 } 2561 2562 if (XVA_ISSET_REQ(xvap, XAT_OFFLINE)) { 2563 xoap->xoa_offline = 2564 ((zp->z_pflags & ZFS_OFFLINE) != 0); 2565 XVA_SET_RTN(xvap, XAT_OFFLINE); 2566 } 2567 2568 if (XVA_ISSET_REQ(xvap, XAT_SPARSE)) { 2569 xoap->xoa_sparse = 2570 ((zp->z_pflags & ZFS_SPARSE) != 0); 2571 XVA_SET_RTN(xvap, XAT_SPARSE); 2572 } 2573 } 2574 2575 ZFS_TIME_DECODE(&vap->va_atime, zp->z_atime); 2576 ZFS_TIME_DECODE(&vap->va_mtime, mtime); 2577 ZFS_TIME_DECODE(&vap->va_ctime, ctime); 2578 2579 mutex_exit(&zp->z_lock); 2580 2581 sa_object_size(zp->z_sa_hdl, &vap->va_blksize, &vap->va_nblocks); 2582 2583 if (zp->z_blksz == 0) { 2584 /* 2585 * Block size hasn't been set; suggest maximal I/O transfers. 2586 */ 2587 vap->va_blksize = zfsvfs->z_max_blksz; 2588 } 2589 2590 ZFS_EXIT(zfsvfs); 2591 return (0); 2592 } 2593 2594 /* 2595 * Set the file attributes to the values contained in the 2596 * vattr structure. 2597 * 2598 * IN: vp - vnode of file to be modified. 2599 * vap - new attribute values. 2600 * If AT_XVATTR set, then optional attrs are being set 2601 * flags - ATTR_UTIME set if non-default time values provided. 2602 * - ATTR_NOACLCHECK (CIFS context only). 2603 * cr - credentials of caller. 2604 * ct - caller context 2605 * 2606 * RETURN: 0 if success 2607 * error code if failure 2608 * 2609 * Timestamps: 2610 * vp - ctime updated, mtime updated if size changed. 2611 */ 2612 /* ARGSUSED */ 2613 static int 2614 zfs_setattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 2615 caller_context_t *ct) 2616 { 2617 znode_t *zp = VTOZ(vp); 2618 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 2619 zilog_t *zilog; 2620 dmu_tx_t *tx; 2621 vattr_t oldva; 2622 xvattr_t tmpxvattr; 2623 uint_t mask = vap->va_mask; 2624 uint_t saved_mask; 2625 int trim_mask = 0; 2626 uint64_t new_mode; 2627 uint64_t new_uid, new_gid; 2628 uint64_t xattr_obj; 2629 uint64_t mtime[2], ctime[2]; 2630 znode_t *attrzp; 2631 int need_policy = FALSE; 2632 int err, err2; 2633 zfs_fuid_info_t *fuidp = NULL; 2634 xvattr_t *xvap = (xvattr_t *)vap; /* vap may be an xvattr_t * */ 2635 xoptattr_t *xoap; 2636 zfs_acl_t *aclp; 2637 boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE; 2638 boolean_t fuid_dirtied = B_FALSE; 2639 sa_bulk_attr_t bulk[7], xattr_bulk[7]; 2640 int count = 0, xattr_count = 0; 2641 2642 if (mask == 0) 2643 return (0); 2644 2645 if (mask & AT_NOSET) 2646 return (EINVAL); 2647 2648 ZFS_ENTER(zfsvfs); 2649 ZFS_VERIFY_ZP(zp); 2650 2651 zilog = zfsvfs->z_log; 2652 2653 /* 2654 * Make sure that if we have ephemeral uid/gid or xvattr specified 2655 * that file system is at proper version level 2656 */ 2657 2658 if (zfsvfs->z_use_fuids == B_FALSE && 2659 (((mask & AT_UID) && IS_EPHEMERAL(vap->va_uid)) || 2660 ((mask & AT_GID) && IS_EPHEMERAL(vap->va_gid)) || 2661 (mask & AT_XVATTR))) { 2662 ZFS_EXIT(zfsvfs); 2663 return (EINVAL); 2664 } 2665 2666 if (mask & AT_SIZE && vp->v_type == VDIR) { 2667 ZFS_EXIT(zfsvfs); 2668 return (EISDIR); 2669 } 2670 2671 if (mask & AT_SIZE && vp->v_type != VREG && vp->v_type != VFIFO) { 2672 ZFS_EXIT(zfsvfs); 2673 return (EINVAL); 2674 } 2675 2676 /* 2677 * If this is an xvattr_t, then get a pointer to the structure of 2678 * optional attributes. If this is NULL, then we have a vattr_t. 2679 */ 2680 xoap = xva_getxoptattr(xvap); 2681 2682 xva_init(&tmpxvattr); 2683 2684 /* 2685 * Immutable files can only alter immutable bit and atime 2686 */ 2687 if ((zp->z_pflags & ZFS_IMMUTABLE) && 2688 ((mask & (AT_SIZE|AT_UID|AT_GID|AT_MTIME|AT_MODE)) || 2689 ((mask & AT_XVATTR) && XVA_ISSET_REQ(xvap, XAT_CREATETIME)))) { 2690 ZFS_EXIT(zfsvfs); 2691 return (EPERM); 2692 } 2693 2694 if ((mask & AT_SIZE) && (zp->z_pflags & ZFS_READONLY)) { 2695 ZFS_EXIT(zfsvfs); 2696 return (EPERM); 2697 } 2698 2699 /* 2700 * Verify timestamps doesn't overflow 32 bits. 2701 * ZFS can handle large timestamps, but 32bit syscalls can't 2702 * handle times greater than 2039. This check should be removed 2703 * once large timestamps are fully supported. 2704 */ 2705 if (mask & (AT_ATIME | AT_MTIME)) { 2706 if (((mask & AT_ATIME) && TIMESPEC_OVERFLOW(&vap->va_atime)) || 2707 ((mask & AT_MTIME) && TIMESPEC_OVERFLOW(&vap->va_mtime))) { 2708 ZFS_EXIT(zfsvfs); 2709 return (EOVERFLOW); 2710 } 2711 } 2712 2713 top: 2714 attrzp = NULL; 2715 aclp = NULL; 2716 2717 /* Can this be moved to before the top label? */ 2718 if (zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) { 2719 ZFS_EXIT(zfsvfs); 2720 return (EROFS); 2721 } 2722 2723 /* 2724 * First validate permissions 2725 */ 2726 2727 if (mask & AT_SIZE) { 2728 err = zfs_zaccess(zp, ACE_WRITE_DATA, 0, skipaclchk, cr); 2729 if (err) { 2730 ZFS_EXIT(zfsvfs); 2731 return (err); 2732 } 2733 /* 2734 * XXX - Note, we are not providing any open 2735 * mode flags here (like FNDELAY), so we may 2736 * block if there are locks present... this 2737 * should be addressed in openat(). 2738 */ 2739 /* XXX - would it be OK to generate a log record here? */ 2740 err = zfs_freesp(zp, vap->va_size, 0, 0, FALSE); 2741 if (err) { 2742 ZFS_EXIT(zfsvfs); 2743 return (err); 2744 } 2745 } 2746 2747 if (mask & (AT_ATIME|AT_MTIME) || 2748 ((mask & AT_XVATTR) && (XVA_ISSET_REQ(xvap, XAT_HIDDEN) || 2749 XVA_ISSET_REQ(xvap, XAT_READONLY) || 2750 XVA_ISSET_REQ(xvap, XAT_ARCHIVE) || 2751 XVA_ISSET_REQ(xvap, XAT_OFFLINE) || 2752 XVA_ISSET_REQ(xvap, XAT_SPARSE) || 2753 XVA_ISSET_REQ(xvap, XAT_CREATETIME) || 2754 XVA_ISSET_REQ(xvap, XAT_SYSTEM)))) { 2755 need_policy = zfs_zaccess(zp, ACE_WRITE_ATTRIBUTES, 0, 2756 skipaclchk, cr); 2757 } 2758 2759 if (mask & (AT_UID|AT_GID)) { 2760 int idmask = (mask & (AT_UID|AT_GID)); 2761 int take_owner; 2762 int take_group; 2763 2764 /* 2765 * NOTE: even if a new mode is being set, 2766 * we may clear S_ISUID/S_ISGID bits. 2767 */ 2768 2769 if (!(mask & AT_MODE)) 2770 vap->va_mode = zp->z_mode; 2771 2772 /* 2773 * Take ownership or chgrp to group we are a member of 2774 */ 2775 2776 take_owner = (mask & AT_UID) && (vap->va_uid == crgetuid(cr)); 2777 take_group = (mask & AT_GID) && 2778 zfs_groupmember(zfsvfs, vap->va_gid, cr); 2779 2780 /* 2781 * If both AT_UID and AT_GID are set then take_owner and 2782 * take_group must both be set in order to allow taking 2783 * ownership. 2784 * 2785 * Otherwise, send the check through secpolicy_vnode_setattr() 2786 * 2787 */ 2788 2789 if (((idmask == (AT_UID|AT_GID)) && take_owner && take_group) || 2790 ((idmask == AT_UID) && take_owner) || 2791 ((idmask == AT_GID) && take_group)) { 2792 if (zfs_zaccess(zp, ACE_WRITE_OWNER, 0, 2793 skipaclchk, cr) == 0) { 2794 /* 2795 * Remove setuid/setgid for non-privileged users 2796 */ 2797 secpolicy_setid_clear(vap, cr); 2798 trim_mask = (mask & (AT_UID|AT_GID)); 2799 } else { 2800 need_policy = TRUE; 2801 } 2802 } else { 2803 need_policy = TRUE; 2804 } 2805 } 2806 2807 mutex_enter(&zp->z_lock); 2808 oldva.va_mode = zp->z_mode; 2809 zfs_fuid_map_ids(zp, cr, &oldva.va_uid, &oldva.va_gid); 2810 if (mask & AT_XVATTR) { 2811 /* 2812 * Update xvattr mask to include only those attributes 2813 * that are actually changing. 2814 * 2815 * the bits will be restored prior to actually setting 2816 * the attributes so the caller thinks they were set. 2817 */ 2818 if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) { 2819 if (xoap->xoa_appendonly != 2820 ((zp->z_pflags & ZFS_APPENDONLY) != 0)) { 2821 need_policy = TRUE; 2822 } else { 2823 XVA_CLR_REQ(xvap, XAT_APPENDONLY); 2824 XVA_SET_REQ(&tmpxvattr, XAT_APPENDONLY); 2825 } 2826 } 2827 2828 if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) { 2829 if (xoap->xoa_nounlink != 2830 ((zp->z_pflags & ZFS_NOUNLINK) != 0)) { 2831 need_policy = TRUE; 2832 } else { 2833 XVA_CLR_REQ(xvap, XAT_NOUNLINK); 2834 XVA_SET_REQ(&tmpxvattr, XAT_NOUNLINK); 2835 } 2836 } 2837 2838 if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) { 2839 if (xoap->xoa_immutable != 2840 ((zp->z_pflags & ZFS_IMMUTABLE) != 0)) { 2841 need_policy = TRUE; 2842 } else { 2843 XVA_CLR_REQ(xvap, XAT_IMMUTABLE); 2844 XVA_SET_REQ(&tmpxvattr, XAT_IMMUTABLE); 2845 } 2846 } 2847 2848 if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) { 2849 if (xoap->xoa_nodump != 2850 ((zp->z_pflags & ZFS_NODUMP) != 0)) { 2851 need_policy = TRUE; 2852 } else { 2853 XVA_CLR_REQ(xvap, XAT_NODUMP); 2854 XVA_SET_REQ(&tmpxvattr, XAT_NODUMP); 2855 } 2856 } 2857 2858 if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) { 2859 if (xoap->xoa_av_modified != 2860 ((zp->z_pflags & ZFS_AV_MODIFIED) != 0)) { 2861 need_policy = TRUE; 2862 } else { 2863 XVA_CLR_REQ(xvap, XAT_AV_MODIFIED); 2864 XVA_SET_REQ(&tmpxvattr, XAT_AV_MODIFIED); 2865 } 2866 } 2867 2868 if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) { 2869 if ((vp->v_type != VREG && 2870 xoap->xoa_av_quarantined) || 2871 xoap->xoa_av_quarantined != 2872 ((zp->z_pflags & ZFS_AV_QUARANTINED) != 0)) { 2873 need_policy = TRUE; 2874 } else { 2875 XVA_CLR_REQ(xvap, XAT_AV_QUARANTINED); 2876 XVA_SET_REQ(&tmpxvattr, XAT_AV_QUARANTINED); 2877 } 2878 } 2879 2880 if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) { 2881 mutex_exit(&zp->z_lock); 2882 ZFS_EXIT(zfsvfs); 2883 return (EPERM); 2884 } 2885 2886 if (need_policy == FALSE && 2887 (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) || 2888 XVA_ISSET_REQ(xvap, XAT_OPAQUE))) { 2889 need_policy = TRUE; 2890 } 2891 } 2892 2893 mutex_exit(&zp->z_lock); 2894 2895 if (mask & AT_MODE) { 2896 if (zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr) == 0) { 2897 err = secpolicy_setid_setsticky_clear(vp, vap, 2898 &oldva, cr); 2899 if (err) { 2900 ZFS_EXIT(zfsvfs); 2901 return (err); 2902 } 2903 trim_mask |= AT_MODE; 2904 } else { 2905 need_policy = TRUE; 2906 } 2907 } 2908 2909 if (need_policy) { 2910 /* 2911 * If trim_mask is set then take ownership 2912 * has been granted or write_acl is present and user 2913 * has the ability to modify mode. In that case remove 2914 * UID|GID and or MODE from mask so that 2915 * secpolicy_vnode_setattr() doesn't revoke it. 2916 */ 2917 2918 if (trim_mask) { 2919 saved_mask = vap->va_mask; 2920 vap->va_mask &= ~trim_mask; 2921 } 2922 err = secpolicy_vnode_setattr(cr, vp, vap, &oldva, flags, 2923 (int (*)(void *, int, cred_t *))zfs_zaccess_unix, zp); 2924 if (err) { 2925 ZFS_EXIT(zfsvfs); 2926 return (err); 2927 } 2928 2929 if (trim_mask) 2930 vap->va_mask |= saved_mask; 2931 } 2932 2933 /* 2934 * secpolicy_vnode_setattr, or take ownership may have 2935 * changed va_mask 2936 */ 2937 mask = vap->va_mask; 2938 2939 if ((mask & (AT_UID | AT_GID))) { 2940 err = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), 2941 &xattr_obj, sizeof (xattr_obj)); 2942 2943 if (err == 0 && xattr_obj) { 2944 err = zfs_zget(zp->z_zfsvfs, xattr_obj, &attrzp); 2945 if (err) 2946 goto out2; 2947 } 2948 if (mask & AT_UID) { 2949 new_uid = zfs_fuid_create(zfsvfs, 2950 (uint64_t)vap->va_uid, cr, ZFS_OWNER, &fuidp); 2951 if (new_uid != zp->z_uid && 2952 zfs_fuid_overquota(zfsvfs, B_FALSE, new_uid)) { 2953 if (attrzp) 2954 VN_RELE(ZTOV(attrzp)); 2955 err = EDQUOT; 2956 goto out2; 2957 } 2958 } 2959 2960 if (mask & AT_GID) { 2961 new_gid = zfs_fuid_create(zfsvfs, (uint64_t)vap->va_gid, 2962 cr, ZFS_GROUP, &fuidp); 2963 if (new_gid != zp->z_gid && 2964 zfs_fuid_overquota(zfsvfs, B_TRUE, new_gid)) { 2965 if (attrzp) 2966 VN_RELE(ZTOV(attrzp)); 2967 err = EDQUOT; 2968 goto out2; 2969 } 2970 } 2971 } 2972 tx = dmu_tx_create(zfsvfs->z_os); 2973 2974 if (mask & AT_MODE) { 2975 uint64_t pmode = zp->z_mode; 2976 uint64_t acl_obj; 2977 new_mode = (pmode & S_IFMT) | (vap->va_mode & ~S_IFMT); 2978 2979 if (err = zfs_acl_chmod_setattr(zp, &aclp, new_mode)) 2980 goto out; 2981 2982 mutex_enter(&zp->z_lock); 2983 if (!zp->z_is_sa && ((acl_obj = zfs_external_acl(zp)) != 0)) { 2984 /* 2985 * Are we upgrading ACL from old V0 format 2986 * to V1 format? 2987 */ 2988 if (zfsvfs->z_version >= ZPL_VERSION_FUID && 2989 zfs_znode_acl_version(zp) == 2990 ZFS_ACL_VERSION_INITIAL) { 2991 dmu_tx_hold_free(tx, acl_obj, 0, 2992 DMU_OBJECT_END); 2993 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 2994 0, aclp->z_acl_bytes); 2995 } else { 2996 dmu_tx_hold_write(tx, acl_obj, 0, 2997 aclp->z_acl_bytes); 2998 } 2999 } else if (!zp->z_is_sa && aclp->z_acl_bytes > ZFS_ACE_SPACE) { 3000 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 3001 0, aclp->z_acl_bytes); 3002 } 3003 mutex_exit(&zp->z_lock); 3004 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE); 3005 } else { 3006 if ((mask & AT_XVATTR) && 3007 XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) 3008 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE); 3009 else 3010 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE); 3011 } 3012 3013 if (attrzp) { 3014 dmu_tx_hold_sa(tx, attrzp->z_sa_hdl, B_FALSE); 3015 } 3016 3017 fuid_dirtied = zfsvfs->z_fuid_dirty; 3018 if (fuid_dirtied) 3019 zfs_fuid_txhold(zfsvfs, tx); 3020 3021 zfs_sa_upgrade_txholds(tx, zp); 3022 3023 err = dmu_tx_assign(tx, TXG_NOWAIT); 3024 if (err) { 3025 if (err == ERESTART) 3026 dmu_tx_wait(tx); 3027 goto out; 3028 } 3029 3030 count = 0; 3031 /* 3032 * Set each attribute requested. 3033 * We group settings according to the locks they need to acquire. 3034 * 3035 * Note: you cannot set ctime directly, although it will be 3036 * updated as a side-effect of calling this function. 3037 */ 3038 3039 3040 if (mask & (AT_UID|AT_GID|AT_MODE)) 3041 mutex_enter(&zp->z_acl_lock); 3042 mutex_enter(&zp->z_lock); 3043 3044 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL, 3045 &zp->z_pflags, sizeof (zp->z_pflags)); 3046 3047 if (attrzp) { 3048 if (mask & (AT_UID|AT_GID|AT_MODE)) 3049 mutex_enter(&attrzp->z_acl_lock); 3050 mutex_enter(&attrzp->z_lock); 3051 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count, 3052 SA_ZPL_FLAGS(zfsvfs), NULL, &attrzp->z_pflags, 3053 sizeof (attrzp->z_pflags)); 3054 } 3055 3056 if (mask & (AT_UID|AT_GID)) { 3057 3058 if (mask & AT_UID) { 3059 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL, 3060 &new_uid, sizeof (new_uid)); 3061 zp->z_uid = new_uid; 3062 if (attrzp) { 3063 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count, 3064 SA_ZPL_UID(zfsvfs), NULL, &new_uid, 3065 sizeof (new_uid)); 3066 attrzp->z_uid = new_uid; 3067 } 3068 } 3069 3070 if (mask & AT_GID) { 3071 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), 3072 NULL, &new_gid, sizeof (new_gid)); 3073 zp->z_gid = new_gid; 3074 if (attrzp) { 3075 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count, 3076 SA_ZPL_GID(zfsvfs), NULL, &new_gid, 3077 sizeof (new_gid)); 3078 attrzp->z_gid = new_gid; 3079 } 3080 } 3081 if (!(mask & AT_MODE)) { 3082 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), 3083 NULL, &new_mode, sizeof (new_mode)); 3084 new_mode = zp->z_mode; 3085 } 3086 err = zfs_acl_chown_setattr(zp); 3087 ASSERT(err == 0); 3088 if (attrzp) { 3089 err = zfs_acl_chown_setattr(attrzp); 3090 ASSERT(err == 0); 3091 } 3092 } 3093 3094 if (mask & AT_MODE) { 3095 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL, 3096 &new_mode, sizeof (new_mode)); 3097 zp->z_mode = new_mode; 3098 ASSERT3U((uintptr_t)aclp, !=, NULL); 3099 err = zfs_aclset_common(zp, aclp, cr, tx); 3100 ASSERT0(err); 3101 if (zp->z_acl_cached) 3102 zfs_acl_free(zp->z_acl_cached); 3103 zp->z_acl_cached = aclp; 3104 aclp = NULL; 3105 } 3106 3107 3108 if (mask & AT_ATIME) { 3109 ZFS_TIME_ENCODE(&vap->va_atime, zp->z_atime); 3110 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL, 3111 &zp->z_atime, sizeof (zp->z_atime)); 3112 } 3113 3114 if (mask & AT_MTIME) { 3115 ZFS_TIME_ENCODE(&vap->va_mtime, mtime); 3116 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, 3117 mtime, sizeof (mtime)); 3118 } 3119 3120 /* XXX - shouldn't this be done *before* the ATIME/MTIME checks? */ 3121 if (mask & AT_SIZE && !(mask & AT_MTIME)) { 3122 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), 3123 NULL, mtime, sizeof (mtime)); 3124 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, 3125 &ctime, sizeof (ctime)); 3126 zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime, 3127 B_TRUE); 3128 } else if (mask != 0) { 3129 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, 3130 &ctime, sizeof (ctime)); 3131 zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime, 3132 B_TRUE); 3133 if (attrzp) { 3134 SA_ADD_BULK_ATTR(xattr_bulk, xattr_count, 3135 SA_ZPL_CTIME(zfsvfs), NULL, 3136 &ctime, sizeof (ctime)); 3137 zfs_tstamp_update_setup(attrzp, STATE_CHANGED, 3138 mtime, ctime, B_TRUE); 3139 } 3140 } 3141 /* 3142 * Do this after setting timestamps to prevent timestamp 3143 * update from toggling bit 3144 */ 3145 3146 if (xoap && (mask & AT_XVATTR)) { 3147 3148 /* 3149 * restore trimmed off masks 3150 * so that return masks can be set for caller. 3151 */ 3152 3153 if (XVA_ISSET_REQ(&tmpxvattr, XAT_APPENDONLY)) { 3154 XVA_SET_REQ(xvap, XAT_APPENDONLY); 3155 } 3156 if (XVA_ISSET_REQ(&tmpxvattr, XAT_NOUNLINK)) { 3157 XVA_SET_REQ(xvap, XAT_NOUNLINK); 3158 } 3159 if (XVA_ISSET_REQ(&tmpxvattr, XAT_IMMUTABLE)) { 3160 XVA_SET_REQ(xvap, XAT_IMMUTABLE); 3161 } 3162 if (XVA_ISSET_REQ(&tmpxvattr, XAT_NODUMP)) { 3163 XVA_SET_REQ(xvap, XAT_NODUMP); 3164 } 3165 if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_MODIFIED)) { 3166 XVA_SET_REQ(xvap, XAT_AV_MODIFIED); 3167 } 3168 if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_QUARANTINED)) { 3169 XVA_SET_REQ(xvap, XAT_AV_QUARANTINED); 3170 } 3171 3172 if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) 3173 ASSERT(vp->v_type == VREG); 3174 3175 zfs_xvattr_set(zp, xvap, tx); 3176 } 3177 3178 if (fuid_dirtied) 3179 zfs_fuid_sync(zfsvfs, tx); 3180 3181 if (mask != 0) 3182 zfs_log_setattr(zilog, tx, TX_SETATTR, zp, vap, mask, fuidp); 3183 3184 mutex_exit(&zp->z_lock); 3185 if (mask & (AT_UID|AT_GID|AT_MODE)) 3186 mutex_exit(&zp->z_acl_lock); 3187 3188 if (attrzp) { 3189 if (mask & (AT_UID|AT_GID|AT_MODE)) 3190 mutex_exit(&attrzp->z_acl_lock); 3191 mutex_exit(&attrzp->z_lock); 3192 } 3193 out: 3194 if (err == 0 && attrzp) { 3195 err2 = sa_bulk_update(attrzp->z_sa_hdl, xattr_bulk, 3196 xattr_count, tx); 3197 ASSERT(err2 == 0); 3198 } 3199 3200 if (attrzp) 3201 VN_RELE(ZTOV(attrzp)); 3202 if (aclp) 3203 zfs_acl_free(aclp); 3204 3205 if (fuidp) { 3206 zfs_fuid_info_free(fuidp); 3207 fuidp = NULL; 3208 } 3209 3210 if (err) { 3211 dmu_tx_abort(tx); 3212 if (err == ERESTART) 3213 goto top; 3214 } else { 3215 err2 = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx); 3216 dmu_tx_commit(tx); 3217 } 3218 3219 out2: 3220 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 3221 zil_commit(zilog, 0); 3222 3223 ZFS_EXIT(zfsvfs); 3224 return (err); 3225 } 3226 3227 typedef struct zfs_zlock { 3228 krwlock_t *zl_rwlock; /* lock we acquired */ 3229 znode_t *zl_znode; /* znode we held */ 3230 struct zfs_zlock *zl_next; /* next in list */ 3231 } zfs_zlock_t; 3232 3233 /* 3234 * Drop locks and release vnodes that were held by zfs_rename_lock(). 3235 */ 3236 static void 3237 zfs_rename_unlock(zfs_zlock_t **zlpp) 3238 { 3239 zfs_zlock_t *zl; 3240 3241 while ((zl = *zlpp) != NULL) { 3242 if (zl->zl_znode != NULL) 3243 VN_RELE(ZTOV(zl->zl_znode)); 3244 rw_exit(zl->zl_rwlock); 3245 *zlpp = zl->zl_next; 3246 kmem_free(zl, sizeof (*zl)); 3247 } 3248 } 3249 3250 /* 3251 * Search back through the directory tree, using the ".." entries. 3252 * Lock each directory in the chain to prevent concurrent renames. 3253 * Fail any attempt to move a directory into one of its own descendants. 3254 * XXX - z_parent_lock can overlap with map or grow locks 3255 */ 3256 static int 3257 zfs_rename_lock(znode_t *szp, znode_t *tdzp, znode_t *sdzp, zfs_zlock_t **zlpp) 3258 { 3259 zfs_zlock_t *zl; 3260 znode_t *zp = tdzp; 3261 uint64_t rootid = zp->z_zfsvfs->z_root; 3262 uint64_t oidp = zp->z_id; 3263 krwlock_t *rwlp = &szp->z_parent_lock; 3264 krw_t rw = RW_WRITER; 3265 3266 /* 3267 * First pass write-locks szp and compares to zp->z_id. 3268 * Later passes read-lock zp and compare to zp->z_parent. 3269 */ 3270 do { 3271 if (!rw_tryenter(rwlp, rw)) { 3272 /* 3273 * Another thread is renaming in this path. 3274 * Note that if we are a WRITER, we don't have any 3275 * parent_locks held yet. 3276 */ 3277 if (rw == RW_READER && zp->z_id > szp->z_id) { 3278 /* 3279 * Drop our locks and restart 3280 */ 3281 zfs_rename_unlock(&zl); 3282 *zlpp = NULL; 3283 zp = tdzp; 3284 oidp = zp->z_id; 3285 rwlp = &szp->z_parent_lock; 3286 rw = RW_WRITER; 3287 continue; 3288 } else { 3289 /* 3290 * Wait for other thread to drop its locks 3291 */ 3292 rw_enter(rwlp, rw); 3293 } 3294 } 3295 3296 zl = kmem_alloc(sizeof (*zl), KM_SLEEP); 3297 zl->zl_rwlock = rwlp; 3298 zl->zl_znode = NULL; 3299 zl->zl_next = *zlpp; 3300 *zlpp = zl; 3301 3302 if (oidp == szp->z_id) /* We're a descendant of szp */ 3303 return (EINVAL); 3304 3305 if (oidp == rootid) /* We've hit the top */ 3306 return (0); 3307 3308 if (rw == RW_READER) { /* i.e. not the first pass */ 3309 int error = zfs_zget(zp->z_zfsvfs, oidp, &zp); 3310 if (error) 3311 return (error); 3312 zl->zl_znode = zp; 3313 } 3314 (void) sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zp->z_zfsvfs), 3315 &oidp, sizeof (oidp)); 3316 rwlp = &zp->z_parent_lock; 3317 rw = RW_READER; 3318 3319 } while (zp->z_id != sdzp->z_id); 3320 3321 return (0); 3322 } 3323 3324 /* 3325 * Move an entry from the provided source directory to the target 3326 * directory. Change the entry name as indicated. 3327 * 3328 * IN: sdvp - Source directory containing the "old entry". 3329 * snm - Old entry name. 3330 * tdvp - Target directory to contain the "new entry". 3331 * tnm - New entry name. 3332 * cr - credentials of caller. 3333 * ct - caller context 3334 * flags - case flags 3335 * 3336 * RETURN: 0 if success 3337 * error code if failure 3338 * 3339 * Timestamps: 3340 * sdvp,tdvp - ctime|mtime updated 3341 */ 3342 /*ARGSUSED*/ 3343 static int 3344 zfs_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm, cred_t *cr, 3345 caller_context_t *ct, int flags) 3346 { 3347 znode_t *tdzp, *szp, *tzp; 3348 znode_t *sdzp = VTOZ(sdvp); 3349 zfsvfs_t *zfsvfs = sdzp->z_zfsvfs; 3350 zilog_t *zilog; 3351 vnode_t *realvp; 3352 zfs_dirlock_t *sdl, *tdl; 3353 dmu_tx_t *tx; 3354 zfs_zlock_t *zl; 3355 int cmp, serr, terr; 3356 int error = 0; 3357 int zflg = 0; 3358 3359 ZFS_ENTER(zfsvfs); 3360 ZFS_VERIFY_ZP(sdzp); 3361 zilog = zfsvfs->z_log; 3362 3363 /* 3364 * Make sure we have the real vp for the target directory. 3365 */ 3366 if (VOP_REALVP(tdvp, &realvp, ct) == 0) 3367 tdvp = realvp; 3368 3369 if (tdvp->v_vfsp != sdvp->v_vfsp || zfsctl_is_node(tdvp)) { 3370 ZFS_EXIT(zfsvfs); 3371 return (EXDEV); 3372 } 3373 3374 tdzp = VTOZ(tdvp); 3375 ZFS_VERIFY_ZP(tdzp); 3376 if (zfsvfs->z_utf8 && u8_validate(tnm, 3377 strlen(tnm), NULL, U8_VALIDATE_ENTIRE, &error) < 0) { 3378 ZFS_EXIT(zfsvfs); 3379 return (EILSEQ); 3380 } 3381 3382 if (flags & FIGNORECASE) 3383 zflg |= ZCILOOK; 3384 3385 top: 3386 szp = NULL; 3387 tzp = NULL; 3388 zl = NULL; 3389 3390 /* 3391 * This is to prevent the creation of links into attribute space 3392 * by renaming a linked file into/outof an attribute directory. 3393 * See the comment in zfs_link() for why this is considered bad. 3394 */ 3395 if ((tdzp->z_pflags & ZFS_XATTR) != (sdzp->z_pflags & ZFS_XATTR)) { 3396 ZFS_EXIT(zfsvfs); 3397 return (EINVAL); 3398 } 3399 3400 /* 3401 * Lock source and target directory entries. To prevent deadlock, 3402 * a lock ordering must be defined. We lock the directory with 3403 * the smallest object id first, or if it's a tie, the one with 3404 * the lexically first name. 3405 */ 3406 if (sdzp->z_id < tdzp->z_id) { 3407 cmp = -1; 3408 } else if (sdzp->z_id > tdzp->z_id) { 3409 cmp = 1; 3410 } else { 3411 /* 3412 * First compare the two name arguments without 3413 * considering any case folding. 3414 */ 3415 int nofold = (zfsvfs->z_norm & ~U8_TEXTPREP_TOUPPER); 3416 3417 cmp = u8_strcmp(snm, tnm, 0, nofold, U8_UNICODE_LATEST, &error); 3418 ASSERT(error == 0 || !zfsvfs->z_utf8); 3419 if (cmp == 0) { 3420 /* 3421 * POSIX: "If the old argument and the new argument 3422 * both refer to links to the same existing file, 3423 * the rename() function shall return successfully 3424 * and perform no other action." 3425 */ 3426 ZFS_EXIT(zfsvfs); 3427 return (0); 3428 } 3429 /* 3430 * If the file system is case-folding, then we may 3431 * have some more checking to do. A case-folding file 3432 * system is either supporting mixed case sensitivity 3433 * access or is completely case-insensitive. Note 3434 * that the file system is always case preserving. 3435 * 3436 * In mixed sensitivity mode case sensitive behavior 3437 * is the default. FIGNORECASE must be used to 3438 * explicitly request case insensitive behavior. 3439 * 3440 * If the source and target names provided differ only 3441 * by case (e.g., a request to rename 'tim' to 'Tim'), 3442 * we will treat this as a special case in the 3443 * case-insensitive mode: as long as the source name 3444 * is an exact match, we will allow this to proceed as 3445 * a name-change request. 3446 */ 3447 if ((zfsvfs->z_case == ZFS_CASE_INSENSITIVE || 3448 (zfsvfs->z_case == ZFS_CASE_MIXED && 3449 flags & FIGNORECASE)) && 3450 u8_strcmp(snm, tnm, 0, zfsvfs->z_norm, U8_UNICODE_LATEST, 3451 &error) == 0) { 3452 /* 3453 * case preserving rename request, require exact 3454 * name matches 3455 */ 3456 zflg |= ZCIEXACT; 3457 zflg &= ~ZCILOOK; 3458 } 3459 } 3460 3461 /* 3462 * If the source and destination directories are the same, we should 3463 * grab the z_name_lock of that directory only once. 3464 */ 3465 if (sdzp == tdzp) { 3466 zflg |= ZHAVELOCK; 3467 rw_enter(&sdzp->z_name_lock, RW_READER); 3468 } 3469 3470 if (cmp < 0) { 3471 serr = zfs_dirent_lock(&sdl, sdzp, snm, &szp, 3472 ZEXISTS | zflg, NULL, NULL); 3473 terr = zfs_dirent_lock(&tdl, 3474 tdzp, tnm, &tzp, ZRENAMING | zflg, NULL, NULL); 3475 } else { 3476 terr = zfs_dirent_lock(&tdl, 3477 tdzp, tnm, &tzp, zflg, NULL, NULL); 3478 serr = zfs_dirent_lock(&sdl, 3479 sdzp, snm, &szp, ZEXISTS | ZRENAMING | zflg, 3480 NULL, NULL); 3481 } 3482 3483 if (serr) { 3484 /* 3485 * Source entry invalid or not there. 3486 */ 3487 if (!terr) { 3488 zfs_dirent_unlock(tdl); 3489 if (tzp) 3490 VN_RELE(ZTOV(tzp)); 3491 } 3492 3493 if (sdzp == tdzp) 3494 rw_exit(&sdzp->z_name_lock); 3495 3496 if (strcmp(snm, "..") == 0) 3497 serr = EINVAL; 3498 ZFS_EXIT(zfsvfs); 3499 return (serr); 3500 } 3501 if (terr) { 3502 zfs_dirent_unlock(sdl); 3503 VN_RELE(ZTOV(szp)); 3504 3505 if (sdzp == tdzp) 3506 rw_exit(&sdzp->z_name_lock); 3507 3508 if (strcmp(tnm, "..") == 0) 3509 terr = EINVAL; 3510 ZFS_EXIT(zfsvfs); 3511 return (terr); 3512 } 3513 3514 /* 3515 * Must have write access at the source to remove the old entry 3516 * and write access at the target to create the new entry. 3517 * Note that if target and source are the same, this can be 3518 * done in a single check. 3519 */ 3520 3521 if (error = zfs_zaccess_rename(sdzp, szp, tdzp, tzp, cr)) 3522 goto out; 3523 3524 if (ZTOV(szp)->v_type == VDIR) { 3525 /* 3526 * Check to make sure rename is valid. 3527 * Can't do a move like this: /usr/a/b to /usr/a/b/c/d 3528 */ 3529 if (error = zfs_rename_lock(szp, tdzp, sdzp, &zl)) 3530 goto out; 3531 } 3532 3533 /* 3534 * Does target exist? 3535 */ 3536 if (tzp) { 3537 /* 3538 * Source and target must be the same type. 3539 */ 3540 if (ZTOV(szp)->v_type == VDIR) { 3541 if (ZTOV(tzp)->v_type != VDIR) { 3542 error = ENOTDIR; 3543 goto out; 3544 } 3545 } else { 3546 if (ZTOV(tzp)->v_type == VDIR) { 3547 error = EISDIR; 3548 goto out; 3549 } 3550 } 3551 /* 3552 * POSIX dictates that when the source and target 3553 * entries refer to the same file object, rename 3554 * must do nothing and exit without error. 3555 */ 3556 if (szp->z_id == tzp->z_id) { 3557 error = 0; 3558 goto out; 3559 } 3560 } 3561 3562 vnevent_rename_src(ZTOV(szp), sdvp, snm, ct); 3563 if (tzp) 3564 vnevent_rename_dest(ZTOV(tzp), tdvp, tnm, ct); 3565 3566 /* 3567 * notify the target directory if it is not the same 3568 * as source directory. 3569 */ 3570 if (tdvp != sdvp) { 3571 vnevent_rename_dest_dir(tdvp, ct); 3572 } 3573 3574 tx = dmu_tx_create(zfsvfs->z_os); 3575 dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE); 3576 dmu_tx_hold_sa(tx, sdzp->z_sa_hdl, B_FALSE); 3577 dmu_tx_hold_zap(tx, sdzp->z_id, FALSE, snm); 3578 dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, tnm); 3579 if (sdzp != tdzp) { 3580 dmu_tx_hold_sa(tx, tdzp->z_sa_hdl, B_FALSE); 3581 zfs_sa_upgrade_txholds(tx, tdzp); 3582 } 3583 if (tzp) { 3584 dmu_tx_hold_sa(tx, tzp->z_sa_hdl, B_FALSE); 3585 zfs_sa_upgrade_txholds(tx, tzp); 3586 } 3587 3588 zfs_sa_upgrade_txholds(tx, szp); 3589 dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL); 3590 error = dmu_tx_assign(tx, TXG_NOWAIT); 3591 if (error) { 3592 if (zl != NULL) 3593 zfs_rename_unlock(&zl); 3594 zfs_dirent_unlock(sdl); 3595 zfs_dirent_unlock(tdl); 3596 3597 if (sdzp == tdzp) 3598 rw_exit(&sdzp->z_name_lock); 3599 3600 VN_RELE(ZTOV(szp)); 3601 if (tzp) 3602 VN_RELE(ZTOV(tzp)); 3603 if (error == ERESTART) { 3604 dmu_tx_wait(tx); 3605 dmu_tx_abort(tx); 3606 goto top; 3607 } 3608 dmu_tx_abort(tx); 3609 ZFS_EXIT(zfsvfs); 3610 return (error); 3611 } 3612 3613 if (tzp) /* Attempt to remove the existing target */ 3614 error = zfs_link_destroy(tdl, tzp, tx, zflg, NULL); 3615 3616 if (error == 0) { 3617 error = zfs_link_create(tdl, szp, tx, ZRENAMING); 3618 if (error == 0) { 3619 szp->z_pflags |= ZFS_AV_MODIFIED; 3620 3621 error = sa_update(szp->z_sa_hdl, SA_ZPL_FLAGS(zfsvfs), 3622 (void *)&szp->z_pflags, sizeof (uint64_t), tx); 3623 ASSERT0(error); 3624 3625 error = zfs_link_destroy(sdl, szp, tx, ZRENAMING, NULL); 3626 if (error == 0) { 3627 zfs_log_rename(zilog, tx, TX_RENAME | 3628 (flags & FIGNORECASE ? TX_CI : 0), sdzp, 3629 sdl->dl_name, tdzp, tdl->dl_name, szp); 3630 3631 /* 3632 * Update path information for the target vnode 3633 */ 3634 vn_renamepath(tdvp, ZTOV(szp), tnm, 3635 strlen(tnm)); 3636 } else { 3637 /* 3638 * At this point, we have successfully created 3639 * the target name, but have failed to remove 3640 * the source name. Since the create was done 3641 * with the ZRENAMING flag, there are 3642 * complications; for one, the link count is 3643 * wrong. The easiest way to deal with this 3644 * is to remove the newly created target, and 3645 * return the original error. This must 3646 * succeed; fortunately, it is very unlikely to 3647 * fail, since we just created it. 3648 */ 3649 VERIFY3U(zfs_link_destroy(tdl, szp, tx, 3650 ZRENAMING, NULL), ==, 0); 3651 } 3652 } 3653 } 3654 3655 dmu_tx_commit(tx); 3656 out: 3657 if (zl != NULL) 3658 zfs_rename_unlock(&zl); 3659 3660 zfs_dirent_unlock(sdl); 3661 zfs_dirent_unlock(tdl); 3662 3663 if (sdzp == tdzp) 3664 rw_exit(&sdzp->z_name_lock); 3665 3666 3667 VN_RELE(ZTOV(szp)); 3668 if (tzp) 3669 VN_RELE(ZTOV(tzp)); 3670 3671 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 3672 zil_commit(zilog, 0); 3673 3674 ZFS_EXIT(zfsvfs); 3675 return (error); 3676 } 3677 3678 /* 3679 * Insert the indicated symbolic reference entry into the directory. 3680 * 3681 * IN: dvp - Directory to contain new symbolic link. 3682 * link - Name for new symlink entry. 3683 * vap - Attributes of new entry. 3684 * target - Target path of new symlink. 3685 * cr - credentials of caller. 3686 * ct - caller context 3687 * flags - case flags 3688 * 3689 * RETURN: 0 if success 3690 * error code if failure 3691 * 3692 * Timestamps: 3693 * dvp - ctime|mtime updated 3694 */ 3695 /*ARGSUSED*/ 3696 static int 3697 zfs_symlink(vnode_t *dvp, char *name, vattr_t *vap, char *link, cred_t *cr, 3698 caller_context_t *ct, int flags) 3699 { 3700 znode_t *zp, *dzp = VTOZ(dvp); 3701 zfs_dirlock_t *dl; 3702 dmu_tx_t *tx; 3703 zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 3704 zilog_t *zilog; 3705 uint64_t len = strlen(link); 3706 int error; 3707 int zflg = ZNEW; 3708 zfs_acl_ids_t acl_ids; 3709 boolean_t fuid_dirtied; 3710 uint64_t txtype = TX_SYMLINK; 3711 3712 ASSERT(vap->va_type == VLNK); 3713 3714 ZFS_ENTER(zfsvfs); 3715 ZFS_VERIFY_ZP(dzp); 3716 zilog = zfsvfs->z_log; 3717 3718 if (zfsvfs->z_utf8 && u8_validate(name, strlen(name), 3719 NULL, U8_VALIDATE_ENTIRE, &error) < 0) { 3720 ZFS_EXIT(zfsvfs); 3721 return (EILSEQ); 3722 } 3723 if (flags & FIGNORECASE) 3724 zflg |= ZCILOOK; 3725 3726 if (len > MAXPATHLEN) { 3727 ZFS_EXIT(zfsvfs); 3728 return (ENAMETOOLONG); 3729 } 3730 3731 if ((error = zfs_acl_ids_create(dzp, 0, 3732 vap, cr, NULL, &acl_ids)) != 0) { 3733 ZFS_EXIT(zfsvfs); 3734 return (error); 3735 } 3736 top: 3737 /* 3738 * Attempt to lock directory; fail if entry already exists. 3739 */ 3740 error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, NULL, NULL); 3741 if (error) { 3742 zfs_acl_ids_free(&acl_ids); 3743 ZFS_EXIT(zfsvfs); 3744 return (error); 3745 } 3746 3747 if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) { 3748 zfs_acl_ids_free(&acl_ids); 3749 zfs_dirent_unlock(dl); 3750 ZFS_EXIT(zfsvfs); 3751 return (error); 3752 } 3753 3754 if (zfs_acl_ids_overquota(zfsvfs, &acl_ids)) { 3755 zfs_acl_ids_free(&acl_ids); 3756 zfs_dirent_unlock(dl); 3757 ZFS_EXIT(zfsvfs); 3758 return (EDQUOT); 3759 } 3760 tx = dmu_tx_create(zfsvfs->z_os); 3761 fuid_dirtied = zfsvfs->z_fuid_dirty; 3762 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, MAX(1, len)); 3763 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name); 3764 dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes + 3765 ZFS_SA_BASE_ATTR_SIZE + len); 3766 dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE); 3767 if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) { 3768 dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 3769 acl_ids.z_aclp->z_acl_bytes); 3770 } 3771 if (fuid_dirtied) 3772 zfs_fuid_txhold(zfsvfs, tx); 3773 error = dmu_tx_assign(tx, TXG_NOWAIT); 3774 if (error) { 3775 zfs_dirent_unlock(dl); 3776 if (error == ERESTART) { 3777 dmu_tx_wait(tx); 3778 dmu_tx_abort(tx); 3779 goto top; 3780 } 3781 zfs_acl_ids_free(&acl_ids); 3782 dmu_tx_abort(tx); 3783 ZFS_EXIT(zfsvfs); 3784 return (error); 3785 } 3786 3787 /* 3788 * Create a new object for the symlink. 3789 * for version 4 ZPL datsets the symlink will be an SA attribute 3790 */ 3791 zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids); 3792 3793 if (fuid_dirtied) 3794 zfs_fuid_sync(zfsvfs, tx); 3795 3796 mutex_enter(&zp->z_lock); 3797 if (zp->z_is_sa) 3798 error = sa_update(zp->z_sa_hdl, SA_ZPL_SYMLINK(zfsvfs), 3799 link, len, tx); 3800 else 3801 zfs_sa_symlink(zp, link, len, tx); 3802 mutex_exit(&zp->z_lock); 3803 3804 zp->z_size = len; 3805 (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs), 3806 &zp->z_size, sizeof (zp->z_size), tx); 3807 /* 3808 * Insert the new object into the directory. 3809 */ 3810 (void) zfs_link_create(dl, zp, tx, ZNEW); 3811 3812 if (flags & FIGNORECASE) 3813 txtype |= TX_CI; 3814 zfs_log_symlink(zilog, tx, txtype, dzp, zp, name, link); 3815 3816 zfs_acl_ids_free(&acl_ids); 3817 3818 dmu_tx_commit(tx); 3819 3820 zfs_dirent_unlock(dl); 3821 3822 VN_RELE(ZTOV(zp)); 3823 3824 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 3825 zil_commit(zilog, 0); 3826 3827 ZFS_EXIT(zfsvfs); 3828 return (error); 3829 } 3830 3831 /* 3832 * Return, in the buffer contained in the provided uio structure, 3833 * the symbolic path referred to by vp. 3834 * 3835 * IN: vp - vnode of symbolic link. 3836 * uoip - structure to contain the link path. 3837 * cr - credentials of caller. 3838 * ct - caller context 3839 * 3840 * OUT: uio - structure to contain the link path. 3841 * 3842 * RETURN: 0 if success 3843 * error code if failure 3844 * 3845 * Timestamps: 3846 * vp - atime updated 3847 */ 3848 /* ARGSUSED */ 3849 static int 3850 zfs_readlink(vnode_t *vp, uio_t *uio, cred_t *cr, caller_context_t *ct) 3851 { 3852 znode_t *zp = VTOZ(vp); 3853 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 3854 int error; 3855 3856 ZFS_ENTER(zfsvfs); 3857 ZFS_VERIFY_ZP(zp); 3858 3859 mutex_enter(&zp->z_lock); 3860 if (zp->z_is_sa) 3861 error = sa_lookup_uio(zp->z_sa_hdl, 3862 SA_ZPL_SYMLINK(zfsvfs), uio); 3863 else 3864 error = zfs_sa_readlink(zp, uio); 3865 mutex_exit(&zp->z_lock); 3866 3867 ZFS_ACCESSTIME_STAMP(zfsvfs, zp); 3868 3869 ZFS_EXIT(zfsvfs); 3870 return (error); 3871 } 3872 3873 /* 3874 * Insert a new entry into directory tdvp referencing svp. 3875 * 3876 * IN: tdvp - Directory to contain new entry. 3877 * svp - vnode of new entry. 3878 * name - name of new entry. 3879 * cr - credentials of caller. 3880 * ct - caller context 3881 * 3882 * RETURN: 0 if success 3883 * error code if failure 3884 * 3885 * Timestamps: 3886 * tdvp - ctime|mtime updated 3887 * svp - ctime updated 3888 */ 3889 /* ARGSUSED */ 3890 static int 3891 zfs_link(vnode_t *tdvp, vnode_t *svp, char *name, cred_t *cr, 3892 caller_context_t *ct, int flags) 3893 { 3894 znode_t *dzp = VTOZ(tdvp); 3895 znode_t *tzp, *szp; 3896 zfsvfs_t *zfsvfs = dzp->z_zfsvfs; 3897 zilog_t *zilog; 3898 zfs_dirlock_t *dl; 3899 dmu_tx_t *tx; 3900 vnode_t *realvp; 3901 int error; 3902 int zf = ZNEW; 3903 uint64_t parent; 3904 uid_t owner; 3905 3906 ASSERT(tdvp->v_type == VDIR); 3907 3908 ZFS_ENTER(zfsvfs); 3909 ZFS_VERIFY_ZP(dzp); 3910 zilog = zfsvfs->z_log; 3911 3912 if (VOP_REALVP(svp, &realvp, ct) == 0) 3913 svp = realvp; 3914 3915 /* 3916 * POSIX dictates that we return EPERM here. 3917 * Better choices include ENOTSUP or EISDIR. 3918 */ 3919 if (svp->v_type == VDIR) { 3920 ZFS_EXIT(zfsvfs); 3921 return (EPERM); 3922 } 3923 3924 if (svp->v_vfsp != tdvp->v_vfsp || zfsctl_is_node(svp)) { 3925 ZFS_EXIT(zfsvfs); 3926 return (EXDEV); 3927 } 3928 3929 szp = VTOZ(svp); 3930 ZFS_VERIFY_ZP(szp); 3931 3932 /* Prevent links to .zfs/shares files */ 3933 3934 if ((error = sa_lookup(szp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs), 3935 &parent, sizeof (uint64_t))) != 0) { 3936 ZFS_EXIT(zfsvfs); 3937 return (error); 3938 } 3939 if (parent == zfsvfs->z_shares_dir) { 3940 ZFS_EXIT(zfsvfs); 3941 return (EPERM); 3942 } 3943 3944 if (zfsvfs->z_utf8 && u8_validate(name, 3945 strlen(name), NULL, U8_VALIDATE_ENTIRE, &error) < 0) { 3946 ZFS_EXIT(zfsvfs); 3947 return (EILSEQ); 3948 } 3949 if (flags & FIGNORECASE) 3950 zf |= ZCILOOK; 3951 3952 /* 3953 * We do not support links between attributes and non-attributes 3954 * because of the potential security risk of creating links 3955 * into "normal" file space in order to circumvent restrictions 3956 * imposed in attribute space. 3957 */ 3958 if ((szp->z_pflags & ZFS_XATTR) != (dzp->z_pflags & ZFS_XATTR)) { 3959 ZFS_EXIT(zfsvfs); 3960 return (EINVAL); 3961 } 3962 3963 3964 owner = zfs_fuid_map_id(zfsvfs, szp->z_uid, cr, ZFS_OWNER); 3965 if (owner != crgetuid(cr) && secpolicy_basic_link(cr) != 0) { 3966 ZFS_EXIT(zfsvfs); 3967 return (EPERM); 3968 } 3969 3970 if (error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr)) { 3971 ZFS_EXIT(zfsvfs); 3972 return (error); 3973 } 3974 3975 top: 3976 /* 3977 * Attempt to lock directory; fail if entry already exists. 3978 */ 3979 error = zfs_dirent_lock(&dl, dzp, name, &tzp, zf, NULL, NULL); 3980 if (error) { 3981 ZFS_EXIT(zfsvfs); 3982 return (error); 3983 } 3984 3985 tx = dmu_tx_create(zfsvfs->z_os); 3986 dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE); 3987 dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name); 3988 zfs_sa_upgrade_txholds(tx, szp); 3989 zfs_sa_upgrade_txholds(tx, dzp); 3990 error = dmu_tx_assign(tx, TXG_NOWAIT); 3991 if (error) { 3992 zfs_dirent_unlock(dl); 3993 if (error == ERESTART) { 3994 dmu_tx_wait(tx); 3995 dmu_tx_abort(tx); 3996 goto top; 3997 } 3998 dmu_tx_abort(tx); 3999 ZFS_EXIT(zfsvfs); 4000 return (error); 4001 } 4002 4003 error = zfs_link_create(dl, szp, tx, 0); 4004 4005 if (error == 0) { 4006 uint64_t txtype = TX_LINK; 4007 if (flags & FIGNORECASE) 4008 txtype |= TX_CI; 4009 zfs_log_link(zilog, tx, txtype, dzp, szp, name); 4010 } 4011 4012 dmu_tx_commit(tx); 4013 4014 zfs_dirent_unlock(dl); 4015 4016 if (error == 0) { 4017 vnevent_link(svp, ct); 4018 } 4019 4020 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 4021 zil_commit(zilog, 0); 4022 4023 ZFS_EXIT(zfsvfs); 4024 return (error); 4025 } 4026 4027 /* 4028 * zfs_null_putapage() is used when the file system has been force 4029 * unmounted. It just drops the pages. 4030 */ 4031 /* ARGSUSED */ 4032 static int 4033 zfs_null_putapage(vnode_t *vp, page_t *pp, u_offset_t *offp, 4034 size_t *lenp, int flags, cred_t *cr) 4035 { 4036 pvn_write_done(pp, B_INVAL|B_FORCE|B_ERROR); 4037 return (0); 4038 } 4039 4040 /* 4041 * Push a page out to disk, klustering if possible. 4042 * 4043 * IN: vp - file to push page to. 4044 * pp - page to push. 4045 * flags - additional flags. 4046 * cr - credentials of caller. 4047 * 4048 * OUT: offp - start of range pushed. 4049 * lenp - len of range pushed. 4050 * 4051 * RETURN: 0 if success 4052 * error code if failure 4053 * 4054 * NOTE: callers must have locked the page to be pushed. On 4055 * exit, the page (and all other pages in the kluster) must be 4056 * unlocked. 4057 */ 4058 /* ARGSUSED */ 4059 static int 4060 zfs_putapage(vnode_t *vp, page_t *pp, u_offset_t *offp, 4061 size_t *lenp, int flags, cred_t *cr) 4062 { 4063 znode_t *zp = VTOZ(vp); 4064 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4065 dmu_tx_t *tx; 4066 u_offset_t off, koff; 4067 size_t len, klen; 4068 int err; 4069 4070 off = pp->p_offset; 4071 len = PAGESIZE; 4072 /* 4073 * If our blocksize is bigger than the page size, try to kluster 4074 * multiple pages so that we write a full block (thus avoiding 4075 * a read-modify-write). 4076 */ 4077 if (off < zp->z_size && zp->z_blksz > PAGESIZE) { 4078 klen = P2ROUNDUP((ulong_t)zp->z_blksz, PAGESIZE); 4079 koff = ISP2(klen) ? P2ALIGN(off, (u_offset_t)klen) : 0; 4080 ASSERT(koff <= zp->z_size); 4081 if (koff + klen > zp->z_size) 4082 klen = P2ROUNDUP(zp->z_size - koff, (uint64_t)PAGESIZE); 4083 pp = pvn_write_kluster(vp, pp, &off, &len, koff, klen, flags); 4084 } 4085 ASSERT3U(btop(len), ==, btopr(len)); 4086 4087 /* 4088 * Can't push pages past end-of-file. 4089 */ 4090 if (off >= zp->z_size) { 4091 /* ignore all pages */ 4092 err = 0; 4093 goto out; 4094 } else if (off + len > zp->z_size) { 4095 int npages = btopr(zp->z_size - off); 4096 page_t *trunc; 4097 4098 page_list_break(&pp, &trunc, npages); 4099 /* ignore pages past end of file */ 4100 if (trunc) 4101 pvn_write_done(trunc, flags); 4102 len = zp->z_size - off; 4103 } 4104 4105 if (zfs_owner_overquota(zfsvfs, zp, B_FALSE) || 4106 zfs_owner_overquota(zfsvfs, zp, B_TRUE)) { 4107 err = EDQUOT; 4108 goto out; 4109 } 4110 top: 4111 tx = dmu_tx_create(zfsvfs->z_os); 4112 dmu_tx_hold_write(tx, zp->z_id, off, len); 4113 4114 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE); 4115 zfs_sa_upgrade_txholds(tx, zp); 4116 err = dmu_tx_assign(tx, TXG_NOWAIT); 4117 if (err != 0) { 4118 if (err == ERESTART) { 4119 dmu_tx_wait(tx); 4120 dmu_tx_abort(tx); 4121 goto top; 4122 } 4123 dmu_tx_abort(tx); 4124 goto out; 4125 } 4126 4127 if (zp->z_blksz <= PAGESIZE) { 4128 caddr_t va = zfs_map_page(pp, S_READ); 4129 ASSERT3U(len, <=, PAGESIZE); 4130 dmu_write(zfsvfs->z_os, zp->z_id, off, len, va, tx); 4131 zfs_unmap_page(pp, va); 4132 } else { 4133 err = dmu_write_pages(zfsvfs->z_os, zp->z_id, off, len, pp, tx); 4134 } 4135 4136 if (err == 0) { 4137 uint64_t mtime[2], ctime[2]; 4138 sa_bulk_attr_t bulk[3]; 4139 int count = 0; 4140 4141 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, 4142 &mtime, 16); 4143 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, 4144 &ctime, 16); 4145 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL, 4146 &zp->z_pflags, 8); 4147 zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime, 4148 B_TRUE); 4149 zfs_log_write(zfsvfs->z_log, tx, TX_WRITE, zp, off, len, 0); 4150 } 4151 dmu_tx_commit(tx); 4152 4153 out: 4154 pvn_write_done(pp, (err ? B_ERROR : 0) | flags); 4155 if (offp) 4156 *offp = off; 4157 if (lenp) 4158 *lenp = len; 4159 4160 return (err); 4161 } 4162 4163 /* 4164 * Copy the portion of the file indicated from pages into the file. 4165 * The pages are stored in a page list attached to the files vnode. 4166 * 4167 * IN: vp - vnode of file to push page data to. 4168 * off - position in file to put data. 4169 * len - amount of data to write. 4170 * flags - flags to control the operation. 4171 * cr - credentials of caller. 4172 * ct - caller context. 4173 * 4174 * RETURN: 0 if success 4175 * error code if failure 4176 * 4177 * Timestamps: 4178 * vp - ctime|mtime updated 4179 */ 4180 /*ARGSUSED*/ 4181 static int 4182 zfs_putpage(vnode_t *vp, offset_t off, size_t len, int flags, cred_t *cr, 4183 caller_context_t *ct) 4184 { 4185 znode_t *zp = VTOZ(vp); 4186 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4187 page_t *pp; 4188 size_t io_len; 4189 u_offset_t io_off; 4190 uint_t blksz; 4191 rl_t *rl; 4192 int error = 0; 4193 4194 ZFS_ENTER(zfsvfs); 4195 ZFS_VERIFY_ZP(zp); 4196 4197 /* 4198 * There's nothing to do if no data is cached. 4199 */ 4200 if (!vn_has_cached_data(vp)) { 4201 ZFS_EXIT(zfsvfs); 4202 return (0); 4203 } 4204 4205 /* 4206 * Align this request to the file block size in case we kluster. 4207 * XXX - this can result in pretty aggresive locking, which can 4208 * impact simultanious read/write access. One option might be 4209 * to break up long requests (len == 0) into block-by-block 4210 * operations to get narrower locking. 4211 */ 4212 blksz = zp->z_blksz; 4213 if (ISP2(blksz)) 4214 io_off = P2ALIGN_TYPED(off, blksz, u_offset_t); 4215 else 4216 io_off = 0; 4217 if (len > 0 && ISP2(blksz)) 4218 io_len = P2ROUNDUP_TYPED(len + (off - io_off), blksz, size_t); 4219 else 4220 io_len = 0; 4221 4222 if (io_len == 0) { 4223 /* 4224 * Search the entire vp list for pages >= io_off. 4225 */ 4226 rl = zfs_range_lock(zp, io_off, UINT64_MAX, RL_WRITER); 4227 error = pvn_vplist_dirty(vp, io_off, zfs_putapage, flags, cr); 4228 goto out; 4229 } 4230 rl = zfs_range_lock(zp, io_off, io_len, RL_WRITER); 4231 4232 if (off > zp->z_size) { 4233 /* past end of file */ 4234 zfs_range_unlock(rl); 4235 ZFS_EXIT(zfsvfs); 4236 return (0); 4237 } 4238 4239 len = MIN(io_len, P2ROUNDUP(zp->z_size, PAGESIZE) - io_off); 4240 4241 for (off = io_off; io_off < off + len; io_off += io_len) { 4242 if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) { 4243 pp = page_lookup(vp, io_off, 4244 (flags & (B_INVAL | B_FREE)) ? SE_EXCL : SE_SHARED); 4245 } else { 4246 pp = page_lookup_nowait(vp, io_off, 4247 (flags & B_FREE) ? SE_EXCL : SE_SHARED); 4248 } 4249 4250 if (pp != NULL && pvn_getdirty(pp, flags)) { 4251 int err; 4252 4253 /* 4254 * Found a dirty page to push 4255 */ 4256 err = zfs_putapage(vp, pp, &io_off, &io_len, flags, cr); 4257 if (err) 4258 error = err; 4259 } else { 4260 io_len = PAGESIZE; 4261 } 4262 } 4263 out: 4264 zfs_range_unlock(rl); 4265 if ((flags & B_ASYNC) == 0 || zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 4266 zil_commit(zfsvfs->z_log, zp->z_id); 4267 ZFS_EXIT(zfsvfs); 4268 return (error); 4269 } 4270 4271 /*ARGSUSED*/ 4272 void 4273 zfs_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct) 4274 { 4275 znode_t *zp = VTOZ(vp); 4276 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4277 int error; 4278 4279 rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_READER); 4280 if (zp->z_sa_hdl == NULL) { 4281 /* 4282 * The fs has been unmounted, or we did a 4283 * suspend/resume and this file no longer exists. 4284 */ 4285 if (vn_has_cached_data(vp)) { 4286 (void) pvn_vplist_dirty(vp, 0, zfs_null_putapage, 4287 B_INVAL, cr); 4288 } 4289 4290 mutex_enter(&zp->z_lock); 4291 mutex_enter(&vp->v_lock); 4292 ASSERT(vp->v_count == 1); 4293 vp->v_count = 0; 4294 mutex_exit(&vp->v_lock); 4295 mutex_exit(&zp->z_lock); 4296 rw_exit(&zfsvfs->z_teardown_inactive_lock); 4297 zfs_znode_free(zp); 4298 return; 4299 } 4300 4301 /* 4302 * Attempt to push any data in the page cache. If this fails 4303 * we will get kicked out later in zfs_zinactive(). 4304 */ 4305 if (vn_has_cached_data(vp)) { 4306 (void) pvn_vplist_dirty(vp, 0, zfs_putapage, B_INVAL|B_ASYNC, 4307 cr); 4308 } 4309 4310 if (zp->z_atime_dirty && zp->z_unlinked == 0) { 4311 dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os); 4312 4313 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE); 4314 zfs_sa_upgrade_txholds(tx, zp); 4315 error = dmu_tx_assign(tx, TXG_WAIT); 4316 if (error) { 4317 dmu_tx_abort(tx); 4318 } else { 4319 mutex_enter(&zp->z_lock); 4320 (void) sa_update(zp->z_sa_hdl, SA_ZPL_ATIME(zfsvfs), 4321 (void *)&zp->z_atime, sizeof (zp->z_atime), tx); 4322 zp->z_atime_dirty = 0; 4323 mutex_exit(&zp->z_lock); 4324 dmu_tx_commit(tx); 4325 } 4326 } 4327 4328 zfs_zinactive(zp); 4329 rw_exit(&zfsvfs->z_teardown_inactive_lock); 4330 } 4331 4332 /* 4333 * Bounds-check the seek operation. 4334 * 4335 * IN: vp - vnode seeking within 4336 * ooff - old file offset 4337 * noffp - pointer to new file offset 4338 * ct - caller context 4339 * 4340 * RETURN: 0 if success 4341 * EINVAL if new offset invalid 4342 */ 4343 /* ARGSUSED */ 4344 static int 4345 zfs_seek(vnode_t *vp, offset_t ooff, offset_t *noffp, 4346 caller_context_t *ct) 4347 { 4348 if (vp->v_type == VDIR) 4349 return (0); 4350 return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0); 4351 } 4352 4353 /* 4354 * Pre-filter the generic locking function to trap attempts to place 4355 * a mandatory lock on a memory mapped file. 4356 */ 4357 static int 4358 zfs_frlock(vnode_t *vp, int cmd, flock64_t *bfp, int flag, offset_t offset, 4359 flk_callback_t *flk_cbp, cred_t *cr, caller_context_t *ct) 4360 { 4361 znode_t *zp = VTOZ(vp); 4362 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4363 4364 ZFS_ENTER(zfsvfs); 4365 ZFS_VERIFY_ZP(zp); 4366 4367 /* 4368 * We are following the UFS semantics with respect to mapcnt 4369 * here: If we see that the file is mapped already, then we will 4370 * return an error, but we don't worry about races between this 4371 * function and zfs_map(). 4372 */ 4373 if (zp->z_mapcnt > 0 && MANDMODE(zp->z_mode)) { 4374 ZFS_EXIT(zfsvfs); 4375 return (EAGAIN); 4376 } 4377 ZFS_EXIT(zfsvfs); 4378 return (fs_frlock(vp, cmd, bfp, flag, offset, flk_cbp, cr, ct)); 4379 } 4380 4381 /* 4382 * If we can't find a page in the cache, we will create a new page 4383 * and fill it with file data. For efficiency, we may try to fill 4384 * multiple pages at once (klustering) to fill up the supplied page 4385 * list. Note that the pages to be filled are held with an exclusive 4386 * lock to prevent access by other threads while they are being filled. 4387 */ 4388 static int 4389 zfs_fillpage(vnode_t *vp, u_offset_t off, struct seg *seg, 4390 caddr_t addr, page_t *pl[], size_t plsz, enum seg_rw rw) 4391 { 4392 znode_t *zp = VTOZ(vp); 4393 page_t *pp, *cur_pp; 4394 objset_t *os = zp->z_zfsvfs->z_os; 4395 u_offset_t io_off, total; 4396 size_t io_len; 4397 int err; 4398 4399 if (plsz == PAGESIZE || zp->z_blksz <= PAGESIZE) { 4400 /* 4401 * We only have a single page, don't bother klustering 4402 */ 4403 io_off = off; 4404 io_len = PAGESIZE; 4405 pp = page_create_va(vp, io_off, io_len, 4406 PG_EXCL | PG_WAIT, seg, addr); 4407 } else { 4408 /* 4409 * Try to find enough pages to fill the page list 4410 */ 4411 pp = pvn_read_kluster(vp, off, seg, addr, &io_off, 4412 &io_len, off, plsz, 0); 4413 } 4414 if (pp == NULL) { 4415 /* 4416 * The page already exists, nothing to do here. 4417 */ 4418 *pl = NULL; 4419 return (0); 4420 } 4421 4422 /* 4423 * Fill the pages in the kluster. 4424 */ 4425 cur_pp = pp; 4426 for (total = io_off + io_len; io_off < total; io_off += PAGESIZE) { 4427 caddr_t va; 4428 4429 ASSERT3U(io_off, ==, cur_pp->p_offset); 4430 va = zfs_map_page(cur_pp, S_WRITE); 4431 err = dmu_read(os, zp->z_id, io_off, PAGESIZE, va, 4432 DMU_READ_PREFETCH); 4433 zfs_unmap_page(cur_pp, va); 4434 if (err) { 4435 /* On error, toss the entire kluster */ 4436 pvn_read_done(pp, B_ERROR); 4437 /* convert checksum errors into IO errors */ 4438 if (err == ECKSUM) 4439 err = EIO; 4440 return (err); 4441 } 4442 cur_pp = cur_pp->p_next; 4443 } 4444 4445 /* 4446 * Fill in the page list array from the kluster starting 4447 * from the desired offset `off'. 4448 * NOTE: the page list will always be null terminated. 4449 */ 4450 pvn_plist_init(pp, pl, plsz, off, io_len, rw); 4451 ASSERT(pl == NULL || (*pl)->p_offset == off); 4452 4453 return (0); 4454 } 4455 4456 /* 4457 * Return pointers to the pages for the file region [off, off + len] 4458 * in the pl array. If plsz is greater than len, this function may 4459 * also return page pointers from after the specified region 4460 * (i.e. the region [off, off + plsz]). These additional pages are 4461 * only returned if they are already in the cache, or were created as 4462 * part of a klustered read. 4463 * 4464 * IN: vp - vnode of file to get data from. 4465 * off - position in file to get data from. 4466 * len - amount of data to retrieve. 4467 * plsz - length of provided page list. 4468 * seg - segment to obtain pages for. 4469 * addr - virtual address of fault. 4470 * rw - mode of created pages. 4471 * cr - credentials of caller. 4472 * ct - caller context. 4473 * 4474 * OUT: protp - protection mode of created pages. 4475 * pl - list of pages created. 4476 * 4477 * RETURN: 0 if success 4478 * error code if failure 4479 * 4480 * Timestamps: 4481 * vp - atime updated 4482 */ 4483 /* ARGSUSED */ 4484 static int 4485 zfs_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp, 4486 page_t *pl[], size_t plsz, struct seg *seg, caddr_t addr, 4487 enum seg_rw rw, cred_t *cr, caller_context_t *ct) 4488 { 4489 znode_t *zp = VTOZ(vp); 4490 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4491 page_t **pl0 = pl; 4492 int err = 0; 4493 4494 /* we do our own caching, faultahead is unnecessary */ 4495 if (pl == NULL) 4496 return (0); 4497 else if (len > plsz) 4498 len = plsz; 4499 else 4500 len = P2ROUNDUP(len, PAGESIZE); 4501 ASSERT(plsz >= len); 4502 4503 ZFS_ENTER(zfsvfs); 4504 ZFS_VERIFY_ZP(zp); 4505 4506 if (protp) 4507 *protp = PROT_ALL; 4508 4509 /* 4510 * Loop through the requested range [off, off + len) looking 4511 * for pages. If we don't find a page, we will need to create 4512 * a new page and fill it with data from the file. 4513 */ 4514 while (len > 0) { 4515 if (*pl = page_lookup(vp, off, SE_SHARED)) 4516 *(pl+1) = NULL; 4517 else if (err = zfs_fillpage(vp, off, seg, addr, pl, plsz, rw)) 4518 goto out; 4519 while (*pl) { 4520 ASSERT3U((*pl)->p_offset, ==, off); 4521 off += PAGESIZE; 4522 addr += PAGESIZE; 4523 if (len > 0) { 4524 ASSERT3U(len, >=, PAGESIZE); 4525 len -= PAGESIZE; 4526 } 4527 ASSERT3U(plsz, >=, PAGESIZE); 4528 plsz -= PAGESIZE; 4529 pl++; 4530 } 4531 } 4532 4533 /* 4534 * Fill out the page array with any pages already in the cache. 4535 */ 4536 while (plsz > 0 && 4537 (*pl++ = page_lookup_nowait(vp, off, SE_SHARED))) { 4538 off += PAGESIZE; 4539 plsz -= PAGESIZE; 4540 } 4541 out: 4542 if (err) { 4543 /* 4544 * Release any pages we have previously locked. 4545 */ 4546 while (pl > pl0) 4547 page_unlock(*--pl); 4548 } else { 4549 ZFS_ACCESSTIME_STAMP(zfsvfs, zp); 4550 } 4551 4552 *pl = NULL; 4553 4554 ZFS_EXIT(zfsvfs); 4555 return (err); 4556 } 4557 4558 /* 4559 * Request a memory map for a section of a file. This code interacts 4560 * with common code and the VM system as follows: 4561 * 4562 * common code calls mmap(), which ends up in smmap_common() 4563 * 4564 * this calls VOP_MAP(), which takes you into (say) zfs 4565 * 4566 * zfs_map() calls as_map(), passing segvn_create() as the callback 4567 * 4568 * segvn_create() creates the new segment and calls VOP_ADDMAP() 4569 * 4570 * zfs_addmap() updates z_mapcnt 4571 */ 4572 /*ARGSUSED*/ 4573 static int 4574 zfs_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp, 4575 size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr, 4576 caller_context_t *ct) 4577 { 4578 znode_t *zp = VTOZ(vp); 4579 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4580 segvn_crargs_t vn_a; 4581 int error; 4582 4583 ZFS_ENTER(zfsvfs); 4584 ZFS_VERIFY_ZP(zp); 4585 4586 if ((prot & PROT_WRITE) && (zp->z_pflags & 4587 (ZFS_IMMUTABLE | ZFS_READONLY | ZFS_APPENDONLY))) { 4588 ZFS_EXIT(zfsvfs); 4589 return (EPERM); 4590 } 4591 4592 if ((prot & (PROT_READ | PROT_EXEC)) && 4593 (zp->z_pflags & ZFS_AV_QUARANTINED)) { 4594 ZFS_EXIT(zfsvfs); 4595 return (EACCES); 4596 } 4597 4598 if (vp->v_flag & VNOMAP) { 4599 ZFS_EXIT(zfsvfs); 4600 return (ENOSYS); 4601 } 4602 4603 if (off < 0 || len > MAXOFFSET_T - off) { 4604 ZFS_EXIT(zfsvfs); 4605 return (ENXIO); 4606 } 4607 4608 if (vp->v_type != VREG) { 4609 ZFS_EXIT(zfsvfs); 4610 return (ENODEV); 4611 } 4612 4613 /* 4614 * If file is locked, disallow mapping. 4615 */ 4616 if (MANDMODE(zp->z_mode) && vn_has_flocks(vp)) { 4617 ZFS_EXIT(zfsvfs); 4618 return (EAGAIN); 4619 } 4620 4621 as_rangelock(as); 4622 error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags); 4623 if (error != 0) { 4624 as_rangeunlock(as); 4625 ZFS_EXIT(zfsvfs); 4626 return (error); 4627 } 4628 4629 vn_a.vp = vp; 4630 vn_a.offset = (u_offset_t)off; 4631 vn_a.type = flags & MAP_TYPE; 4632 vn_a.prot = prot; 4633 vn_a.maxprot = maxprot; 4634 vn_a.cred = cr; 4635 vn_a.amp = NULL; 4636 vn_a.flags = flags & ~MAP_TYPE; 4637 vn_a.szc = 0; 4638 vn_a.lgrp_mem_policy_flags = 0; 4639 4640 error = as_map(as, *addrp, len, segvn_create, &vn_a); 4641 4642 as_rangeunlock(as); 4643 ZFS_EXIT(zfsvfs); 4644 return (error); 4645 } 4646 4647 /* ARGSUSED */ 4648 static int 4649 zfs_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr, 4650 size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr, 4651 caller_context_t *ct) 4652 { 4653 uint64_t pages = btopr(len); 4654 4655 atomic_add_64(&VTOZ(vp)->z_mapcnt, pages); 4656 return (0); 4657 } 4658 4659 /* 4660 * The reason we push dirty pages as part of zfs_delmap() is so that we get a 4661 * more accurate mtime for the associated file. Since we don't have a way of 4662 * detecting when the data was actually modified, we have to resort to 4663 * heuristics. If an explicit msync() is done, then we mark the mtime when the 4664 * last page is pushed. The problem occurs when the msync() call is omitted, 4665 * which by far the most common case: 4666 * 4667 * open() 4668 * mmap() 4669 * <modify memory> 4670 * munmap() 4671 * close() 4672 * <time lapse> 4673 * putpage() via fsflush 4674 * 4675 * If we wait until fsflush to come along, we can have a modification time that 4676 * is some arbitrary point in the future. In order to prevent this in the 4677 * common case, we flush pages whenever a (MAP_SHARED, PROT_WRITE) mapping is 4678 * torn down. 4679 */ 4680 /* ARGSUSED */ 4681 static int 4682 zfs_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr, 4683 size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr, 4684 caller_context_t *ct) 4685 { 4686 uint64_t pages = btopr(len); 4687 4688 ASSERT3U(VTOZ(vp)->z_mapcnt, >=, pages); 4689 atomic_add_64(&VTOZ(vp)->z_mapcnt, -pages); 4690 4691 if ((flags & MAP_SHARED) && (prot & PROT_WRITE) && 4692 vn_has_cached_data(vp)) 4693 (void) VOP_PUTPAGE(vp, off, len, B_ASYNC, cr, ct); 4694 4695 return (0); 4696 } 4697 4698 /* 4699 * Free or allocate space in a file. Currently, this function only 4700 * supports the `F_FREESP' command. However, this command is somewhat 4701 * misnamed, as its functionality includes the ability to allocate as 4702 * well as free space. 4703 * 4704 * IN: vp - vnode of file to free data in. 4705 * cmd - action to take (only F_FREESP supported). 4706 * bfp - section of file to free/alloc. 4707 * flag - current file open mode flags. 4708 * offset - current file offset. 4709 * cr - credentials of caller [UNUSED]. 4710 * ct - caller context. 4711 * 4712 * RETURN: 0 if success 4713 * error code if failure 4714 * 4715 * Timestamps: 4716 * vp - ctime|mtime updated 4717 */ 4718 /* ARGSUSED */ 4719 static int 4720 zfs_space(vnode_t *vp, int cmd, flock64_t *bfp, int flag, 4721 offset_t offset, cred_t *cr, caller_context_t *ct) 4722 { 4723 znode_t *zp = VTOZ(vp); 4724 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4725 uint64_t off, len; 4726 int error; 4727 4728 ZFS_ENTER(zfsvfs); 4729 ZFS_VERIFY_ZP(zp); 4730 4731 if (cmd != F_FREESP) { 4732 ZFS_EXIT(zfsvfs); 4733 return (EINVAL); 4734 } 4735 4736 if (error = convoff(vp, bfp, 0, offset)) { 4737 ZFS_EXIT(zfsvfs); 4738 return (error); 4739 } 4740 4741 if (bfp->l_len < 0) { 4742 ZFS_EXIT(zfsvfs); 4743 return (EINVAL); 4744 } 4745 4746 off = bfp->l_start; 4747 len = bfp->l_len; /* 0 means from off to end of file */ 4748 4749 error = zfs_freesp(zp, off, len, flag, TRUE); 4750 4751 ZFS_EXIT(zfsvfs); 4752 return (error); 4753 } 4754 4755 /*ARGSUSED*/ 4756 static int 4757 zfs_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct) 4758 { 4759 znode_t *zp = VTOZ(vp); 4760 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4761 uint32_t gen; 4762 uint64_t gen64; 4763 uint64_t object = zp->z_id; 4764 zfid_short_t *zfid; 4765 int size, i, error; 4766 4767 ZFS_ENTER(zfsvfs); 4768 ZFS_VERIFY_ZP(zp); 4769 4770 if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs), 4771 &gen64, sizeof (uint64_t))) != 0) { 4772 ZFS_EXIT(zfsvfs); 4773 return (error); 4774 } 4775 4776 gen = (uint32_t)gen64; 4777 4778 size = (zfsvfs->z_parent != zfsvfs) ? LONG_FID_LEN : SHORT_FID_LEN; 4779 if (fidp->fid_len < size) { 4780 fidp->fid_len = size; 4781 ZFS_EXIT(zfsvfs); 4782 return (ENOSPC); 4783 } 4784 4785 zfid = (zfid_short_t *)fidp; 4786 4787 zfid->zf_len = size; 4788 4789 for (i = 0; i < sizeof (zfid->zf_object); i++) 4790 zfid->zf_object[i] = (uint8_t)(object >> (8 * i)); 4791 4792 /* Must have a non-zero generation number to distinguish from .zfs */ 4793 if (gen == 0) 4794 gen = 1; 4795 for (i = 0; i < sizeof (zfid->zf_gen); i++) 4796 zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i)); 4797 4798 if (size == LONG_FID_LEN) { 4799 uint64_t objsetid = dmu_objset_id(zfsvfs->z_os); 4800 zfid_long_t *zlfid; 4801 4802 zlfid = (zfid_long_t *)fidp; 4803 4804 for (i = 0; i < sizeof (zlfid->zf_setid); i++) 4805 zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i)); 4806 4807 /* XXX - this should be the generation number for the objset */ 4808 for (i = 0; i < sizeof (zlfid->zf_setgen); i++) 4809 zlfid->zf_setgen[i] = 0; 4810 } 4811 4812 ZFS_EXIT(zfsvfs); 4813 return (0); 4814 } 4815 4816 static int 4817 zfs_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr, 4818 caller_context_t *ct) 4819 { 4820 znode_t *zp, *xzp; 4821 zfsvfs_t *zfsvfs; 4822 zfs_dirlock_t *dl; 4823 int error; 4824 4825 switch (cmd) { 4826 case _PC_LINK_MAX: 4827 *valp = ULONG_MAX; 4828 return (0); 4829 4830 case _PC_FILESIZEBITS: 4831 *valp = 64; 4832 return (0); 4833 4834 case _PC_XATTR_EXISTS: 4835 zp = VTOZ(vp); 4836 zfsvfs = zp->z_zfsvfs; 4837 ZFS_ENTER(zfsvfs); 4838 ZFS_VERIFY_ZP(zp); 4839 *valp = 0; 4840 error = zfs_dirent_lock(&dl, zp, "", &xzp, 4841 ZXATTR | ZEXISTS | ZSHARED, NULL, NULL); 4842 if (error == 0) { 4843 zfs_dirent_unlock(dl); 4844 if (!zfs_dirempty(xzp)) 4845 *valp = 1; 4846 VN_RELE(ZTOV(xzp)); 4847 } else if (error == ENOENT) { 4848 /* 4849 * If there aren't extended attributes, it's the 4850 * same as having zero of them. 4851 */ 4852 error = 0; 4853 } 4854 ZFS_EXIT(zfsvfs); 4855 return (error); 4856 4857 case _PC_SATTR_ENABLED: 4858 case _PC_SATTR_EXISTS: 4859 *valp = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) && 4860 (vp->v_type == VREG || vp->v_type == VDIR); 4861 return (0); 4862 4863 case _PC_ACCESS_FILTERING: 4864 *valp = vfs_has_feature(vp->v_vfsp, VFSFT_ACCESS_FILTER) && 4865 vp->v_type == VDIR; 4866 return (0); 4867 4868 case _PC_ACL_ENABLED: 4869 *valp = _ACL_ACE_ENABLED; 4870 return (0); 4871 4872 case _PC_MIN_HOLE_SIZE: 4873 *valp = (ulong_t)SPA_MINBLOCKSIZE; 4874 return (0); 4875 4876 case _PC_TIMESTAMP_RESOLUTION: 4877 /* nanosecond timestamp resolution */ 4878 *valp = 1L; 4879 return (0); 4880 4881 default: 4882 return (fs_pathconf(vp, cmd, valp, cr, ct)); 4883 } 4884 } 4885 4886 /*ARGSUSED*/ 4887 static int 4888 zfs_getsecattr(vnode_t *vp, vsecattr_t *vsecp, int flag, cred_t *cr, 4889 caller_context_t *ct) 4890 { 4891 znode_t *zp = VTOZ(vp); 4892 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4893 int error; 4894 boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE; 4895 4896 ZFS_ENTER(zfsvfs); 4897 ZFS_VERIFY_ZP(zp); 4898 error = zfs_getacl(zp, vsecp, skipaclchk, cr); 4899 ZFS_EXIT(zfsvfs); 4900 4901 return (error); 4902 } 4903 4904 /*ARGSUSED*/ 4905 static int 4906 zfs_setsecattr(vnode_t *vp, vsecattr_t *vsecp, int flag, cred_t *cr, 4907 caller_context_t *ct) 4908 { 4909 znode_t *zp = VTOZ(vp); 4910 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4911 int error; 4912 boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE; 4913 zilog_t *zilog = zfsvfs->z_log; 4914 4915 ZFS_ENTER(zfsvfs); 4916 ZFS_VERIFY_ZP(zp); 4917 4918 error = zfs_setacl(zp, vsecp, skipaclchk, cr); 4919 4920 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 4921 zil_commit(zilog, 0); 4922 4923 ZFS_EXIT(zfsvfs); 4924 return (error); 4925 } 4926 4927 /* 4928 * Tunable, both must be a power of 2. 4929 * 4930 * zcr_blksz_min: the smallest read we may consider to loan out an arcbuf 4931 * zcr_blksz_max: if set to less than the file block size, allow loaning out of 4932 * an arcbuf for a partial block read 4933 */ 4934 int zcr_blksz_min = (1 << 10); /* 1K */ 4935 int zcr_blksz_max = (1 << 17); /* 128K */ 4936 4937 /*ARGSUSED*/ 4938 static int 4939 zfs_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *xuio, cred_t *cr, 4940 caller_context_t *ct) 4941 { 4942 znode_t *zp = VTOZ(vp); 4943 zfsvfs_t *zfsvfs = zp->z_zfsvfs; 4944 int max_blksz = zfsvfs->z_max_blksz; 4945 uio_t *uio = &xuio->xu_uio; 4946 ssize_t size = uio->uio_resid; 4947 offset_t offset = uio->uio_loffset; 4948 int blksz; 4949 int fullblk, i; 4950 arc_buf_t *abuf; 4951 ssize_t maxsize; 4952 int preamble, postamble; 4953 4954 if (xuio->xu_type != UIOTYPE_ZEROCOPY) 4955 return (EINVAL); 4956 4957 ZFS_ENTER(zfsvfs); 4958 ZFS_VERIFY_ZP(zp); 4959 switch (ioflag) { 4960 case UIO_WRITE: 4961 /* 4962 * Loan out an arc_buf for write if write size is bigger than 4963 * max_blksz, and the file's block size is also max_blksz. 4964 */ 4965 blksz = max_blksz; 4966 if (size < blksz || zp->z_blksz != blksz) { 4967 ZFS_EXIT(zfsvfs); 4968 return (EINVAL); 4969 } 4970 /* 4971 * Caller requests buffers for write before knowing where the 4972 * write offset might be (e.g. NFS TCP write). 4973 */ 4974 if (offset == -1) { 4975 preamble = 0; 4976 } else { 4977 preamble = P2PHASE(offset, blksz); 4978 if (preamble) { 4979 preamble = blksz - preamble; 4980 size -= preamble; 4981 } 4982 } 4983 4984 postamble = P2PHASE(size, blksz); 4985 size -= postamble; 4986 4987 fullblk = size / blksz; 4988 (void) dmu_xuio_init(xuio, 4989 (preamble != 0) + fullblk + (postamble != 0)); 4990 DTRACE_PROBE3(zfs_reqzcbuf_align, int, preamble, 4991 int, postamble, int, 4992 (preamble != 0) + fullblk + (postamble != 0)); 4993 4994 /* 4995 * Have to fix iov base/len for partial buffers. They 4996 * currently represent full arc_buf's. 4997 */ 4998 if (preamble) { 4999 /* data begins in the middle of the arc_buf */ 5000 abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl), 5001 blksz); 5002 ASSERT(abuf); 5003 (void) dmu_xuio_add(xuio, abuf, 5004 blksz - preamble, preamble); 5005 } 5006 5007 for (i = 0; i < fullblk; i++) { 5008 abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl), 5009 blksz); 5010 ASSERT(abuf); 5011 (void) dmu_xuio_add(xuio, abuf, 0, blksz); 5012 } 5013 5014 if (postamble) { 5015 /* data ends in the middle of the arc_buf */ 5016 abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl), 5017 blksz); 5018 ASSERT(abuf); 5019 (void) dmu_xuio_add(xuio, abuf, 0, postamble); 5020 } 5021 break; 5022 case UIO_READ: 5023 /* 5024 * Loan out an arc_buf for read if the read size is larger than 5025 * the current file block size. Block alignment is not 5026 * considered. Partial arc_buf will be loaned out for read. 5027 */ 5028 blksz = zp->z_blksz; 5029 if (blksz < zcr_blksz_min) 5030 blksz = zcr_blksz_min; 5031 if (blksz > zcr_blksz_max) 5032 blksz = zcr_blksz_max; 5033 /* avoid potential complexity of dealing with it */ 5034 if (blksz > max_blksz) { 5035 ZFS_EXIT(zfsvfs); 5036 return (EINVAL); 5037 } 5038 5039 maxsize = zp->z_size - uio->uio_loffset; 5040 if (size > maxsize) 5041 size = maxsize; 5042 5043 if (size < blksz || vn_has_cached_data(vp)) { 5044 ZFS_EXIT(zfsvfs); 5045 return (EINVAL); 5046 } 5047 break; 5048 default: 5049 ZFS_EXIT(zfsvfs); 5050 return (EINVAL); 5051 } 5052 5053 uio->uio_extflg = UIO_XUIO; 5054 XUIO_XUZC_RW(xuio) = ioflag; 5055 ZFS_EXIT(zfsvfs); 5056 return (0); 5057 } 5058 5059 /*ARGSUSED*/ 5060 static int 5061 zfs_retzcbuf(vnode_t *vp, xuio_t *xuio, cred_t *cr, caller_context_t *ct) 5062 { 5063 int i; 5064 arc_buf_t *abuf; 5065 int ioflag = XUIO_XUZC_RW(xuio); 5066 5067 ASSERT(xuio->xu_type == UIOTYPE_ZEROCOPY); 5068 5069 i = dmu_xuio_cnt(xuio); 5070 while (i-- > 0) { 5071 abuf = dmu_xuio_arcbuf(xuio, i); 5072 /* 5073 * if abuf == NULL, it must be a write buffer 5074 * that has been returned in zfs_write(). 5075 */ 5076 if (abuf) 5077 dmu_return_arcbuf(abuf); 5078 ASSERT(abuf || ioflag == UIO_WRITE); 5079 } 5080 5081 dmu_xuio_fini(xuio); 5082 return (0); 5083 } 5084 5085 /* 5086 * Predeclare these here so that the compiler assumes that 5087 * this is an "old style" function declaration that does 5088 * not include arguments => we won't get type mismatch errors 5089 * in the initializations that follow. 5090 */ 5091 static int zfs_inval(); 5092 static int zfs_isdir(); 5093 5094 static int 5095 zfs_inval() 5096 { 5097 return (EINVAL); 5098 } 5099 5100 static int 5101 zfs_isdir() 5102 { 5103 return (EISDIR); 5104 } 5105 /* 5106 * Directory vnode operations template 5107 */ 5108 vnodeops_t *zfs_dvnodeops; 5109 const fs_operation_def_t zfs_dvnodeops_template[] = { 5110 VOPNAME_OPEN, { .vop_open = zfs_open }, 5111 VOPNAME_CLOSE, { .vop_close = zfs_close }, 5112 VOPNAME_READ, { .error = zfs_isdir }, 5113 VOPNAME_WRITE, { .error = zfs_isdir }, 5114 VOPNAME_IOCTL, { .vop_ioctl = zfs_ioctl }, 5115 VOPNAME_GETATTR, { .vop_getattr = zfs_getattr }, 5116 VOPNAME_SETATTR, { .vop_setattr = zfs_setattr }, 5117 VOPNAME_ACCESS, { .vop_access = zfs_access }, 5118 VOPNAME_LOOKUP, { .vop_lookup = zfs_lookup }, 5119 VOPNAME_CREATE, { .vop_create = zfs_create }, 5120 VOPNAME_REMOVE, { .vop_remove = zfs_remove }, 5121 VOPNAME_LINK, { .vop_link = zfs_link }, 5122 VOPNAME_RENAME, { .vop_rename = zfs_rename }, 5123 VOPNAME_MKDIR, { .vop_mkdir = zfs_mkdir }, 5124 VOPNAME_RMDIR, { .vop_rmdir = zfs_rmdir }, 5125 VOPNAME_READDIR, { .vop_readdir = zfs_readdir }, 5126 VOPNAME_SYMLINK, { .vop_symlink = zfs_symlink }, 5127 VOPNAME_FSYNC, { .vop_fsync = zfs_fsync }, 5128 VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive }, 5129 VOPNAME_FID, { .vop_fid = zfs_fid }, 5130 VOPNAME_SEEK, { .vop_seek = zfs_seek }, 5131 VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf }, 5132 VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr }, 5133 VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr }, 5134 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 5135 NULL, NULL 5136 }; 5137 5138 /* 5139 * Regular file vnode operations template 5140 */ 5141 vnodeops_t *zfs_fvnodeops; 5142 const fs_operation_def_t zfs_fvnodeops_template[] = { 5143 VOPNAME_OPEN, { .vop_open = zfs_open }, 5144 VOPNAME_CLOSE, { .vop_close = zfs_close }, 5145 VOPNAME_READ, { .vop_read = zfs_read }, 5146 VOPNAME_WRITE, { .vop_write = zfs_write }, 5147 VOPNAME_IOCTL, { .vop_ioctl = zfs_ioctl }, 5148 VOPNAME_GETATTR, { .vop_getattr = zfs_getattr }, 5149 VOPNAME_SETATTR, { .vop_setattr = zfs_setattr }, 5150 VOPNAME_ACCESS, { .vop_access = zfs_access }, 5151 VOPNAME_LOOKUP, { .vop_lookup = zfs_lookup }, 5152 VOPNAME_RENAME, { .vop_rename = zfs_rename }, 5153 VOPNAME_FSYNC, { .vop_fsync = zfs_fsync }, 5154 VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive }, 5155 VOPNAME_FID, { .vop_fid = zfs_fid }, 5156 VOPNAME_SEEK, { .vop_seek = zfs_seek }, 5157 VOPNAME_FRLOCK, { .vop_frlock = zfs_frlock }, 5158 VOPNAME_SPACE, { .vop_space = zfs_space }, 5159 VOPNAME_GETPAGE, { .vop_getpage = zfs_getpage }, 5160 VOPNAME_PUTPAGE, { .vop_putpage = zfs_putpage }, 5161 VOPNAME_MAP, { .vop_map = zfs_map }, 5162 VOPNAME_ADDMAP, { .vop_addmap = zfs_addmap }, 5163 VOPNAME_DELMAP, { .vop_delmap = zfs_delmap }, 5164 VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf }, 5165 VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr }, 5166 VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr }, 5167 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 5168 VOPNAME_REQZCBUF, { .vop_reqzcbuf = zfs_reqzcbuf }, 5169 VOPNAME_RETZCBUF, { .vop_retzcbuf = zfs_retzcbuf }, 5170 NULL, NULL 5171 }; 5172 5173 /* 5174 * Symbolic link vnode operations template 5175 */ 5176 vnodeops_t *zfs_symvnodeops; 5177 const fs_operation_def_t zfs_symvnodeops_template[] = { 5178 VOPNAME_GETATTR, { .vop_getattr = zfs_getattr }, 5179 VOPNAME_SETATTR, { .vop_setattr = zfs_setattr }, 5180 VOPNAME_ACCESS, { .vop_access = zfs_access }, 5181 VOPNAME_RENAME, { .vop_rename = zfs_rename }, 5182 VOPNAME_READLINK, { .vop_readlink = zfs_readlink }, 5183 VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive }, 5184 VOPNAME_FID, { .vop_fid = zfs_fid }, 5185 VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf }, 5186 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 5187 NULL, NULL 5188 }; 5189 5190 /* 5191 * special share hidden files vnode operations template 5192 */ 5193 vnodeops_t *zfs_sharevnodeops; 5194 const fs_operation_def_t zfs_sharevnodeops_template[] = { 5195 VOPNAME_GETATTR, { .vop_getattr = zfs_getattr }, 5196 VOPNAME_ACCESS, { .vop_access = zfs_access }, 5197 VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive }, 5198 VOPNAME_FID, { .vop_fid = zfs_fid }, 5199 VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf }, 5200 VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr }, 5201 VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr }, 5202 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 5203 NULL, NULL 5204 }; 5205 5206 /* 5207 * Extended attribute directory vnode operations template 5208 * This template is identical to the directory vnodes 5209 * operation template except for restricted operations: 5210 * VOP_MKDIR() 5211 * VOP_SYMLINK() 5212 * Note that there are other restrictions embedded in: 5213 * zfs_create() - restrict type to VREG 5214 * zfs_link() - no links into/out of attribute space 5215 * zfs_rename() - no moves into/out of attribute space 5216 */ 5217 vnodeops_t *zfs_xdvnodeops; 5218 const fs_operation_def_t zfs_xdvnodeops_template[] = { 5219 VOPNAME_OPEN, { .vop_open = zfs_open }, 5220 VOPNAME_CLOSE, { .vop_close = zfs_close }, 5221 VOPNAME_IOCTL, { .vop_ioctl = zfs_ioctl }, 5222 VOPNAME_GETATTR, { .vop_getattr = zfs_getattr }, 5223 VOPNAME_SETATTR, { .vop_setattr = zfs_setattr }, 5224 VOPNAME_ACCESS, { .vop_access = zfs_access }, 5225 VOPNAME_LOOKUP, { .vop_lookup = zfs_lookup }, 5226 VOPNAME_CREATE, { .vop_create = zfs_create }, 5227 VOPNAME_REMOVE, { .vop_remove = zfs_remove }, 5228 VOPNAME_LINK, { .vop_link = zfs_link }, 5229 VOPNAME_RENAME, { .vop_rename = zfs_rename }, 5230 VOPNAME_MKDIR, { .error = zfs_inval }, 5231 VOPNAME_RMDIR, { .vop_rmdir = zfs_rmdir }, 5232 VOPNAME_READDIR, { .vop_readdir = zfs_readdir }, 5233 VOPNAME_SYMLINK, { .error = zfs_inval }, 5234 VOPNAME_FSYNC, { .vop_fsync = zfs_fsync }, 5235 VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive }, 5236 VOPNAME_FID, { .vop_fid = zfs_fid }, 5237 VOPNAME_SEEK, { .vop_seek = zfs_seek }, 5238 VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf }, 5239 VOPNAME_GETSECATTR, { .vop_getsecattr = zfs_getsecattr }, 5240 VOPNAME_SETSECATTR, { .vop_setsecattr = zfs_setsecattr }, 5241 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 5242 NULL, NULL 5243 }; 5244 5245 /* 5246 * Error vnode operations template 5247 */ 5248 vnodeops_t *zfs_evnodeops; 5249 const fs_operation_def_t zfs_evnodeops_template[] = { 5250 VOPNAME_INACTIVE, { .vop_inactive = zfs_inactive }, 5251 VOPNAME_PATHCONF, { .vop_pathconf = zfs_pathconf }, 5252 NULL, NULL 5253 }; 5254