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