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 https://opensource.org/licenses/CDDL-1.0. 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 /* 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2012, 2018 by Delphix. All rights reserved. 25 * Copyright (c) 2015 by Chunwei Chen. All rights reserved. 26 * Copyright 2017 Nexenta Systems, Inc. 27 */ 28 29 /* Portions Copyright 2007 Jeremy Teo */ 30 /* Portions Copyright 2010 Robert Milkowski */ 31 32 #include <sys/types.h> 33 #include <sys/param.h> 34 #include <sys/time.h> 35 #include <sys/sysmacros.h> 36 #include <sys/vfs.h> 37 #include <sys/uio_impl.h> 38 #include <sys/file.h> 39 #include <sys/stat.h> 40 #include <sys/kmem.h> 41 #include <sys/cmn_err.h> 42 #include <sys/errno.h> 43 #include <sys/zfs_dir.h> 44 #include <sys/zfs_acl.h> 45 #include <sys/zfs_ioctl.h> 46 #include <sys/fs/zfs.h> 47 #include <sys/dmu.h> 48 #include <sys/dmu_objset.h> 49 #include <sys/spa.h> 50 #include <sys/txg.h> 51 #include <sys/dbuf.h> 52 #include <sys/policy.h> 53 #include <sys/zfs_vnops.h> 54 #include <sys/zfs_quota.h> 55 #include <sys/zfs_vfsops.h> 56 #include <sys/zfs_znode.h> 57 58 59 static ulong_t zfs_fsync_sync_cnt = 4; 60 61 int 62 zfs_fsync(znode_t *zp, int syncflag, cred_t *cr) 63 { 64 int error = 0; 65 zfsvfs_t *zfsvfs = ZTOZSB(zp); 66 67 (void) tsd_set(zfs_fsyncer_key, (void *)(uintptr_t)zfs_fsync_sync_cnt); 68 69 if (zfsvfs->z_os->os_sync != ZFS_SYNC_DISABLED) { 70 if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0) 71 goto out; 72 atomic_inc_32(&zp->z_sync_writes_cnt); 73 zil_commit(zfsvfs->z_log, zp->z_id); 74 atomic_dec_32(&zp->z_sync_writes_cnt); 75 zfs_exit(zfsvfs, FTAG); 76 } 77 out: 78 tsd_set(zfs_fsyncer_key, NULL); 79 80 return (error); 81 } 82 83 84 #if defined(SEEK_HOLE) && defined(SEEK_DATA) 85 /* 86 * Lseek support for finding holes (cmd == SEEK_HOLE) and 87 * data (cmd == SEEK_DATA). "off" is an in/out parameter. 88 */ 89 static int 90 zfs_holey_common(znode_t *zp, ulong_t cmd, loff_t *off) 91 { 92 zfs_locked_range_t *lr; 93 uint64_t noff = (uint64_t)*off; /* new offset */ 94 uint64_t file_sz; 95 int error; 96 boolean_t hole; 97 98 file_sz = zp->z_size; 99 if (noff >= file_sz) { 100 return (SET_ERROR(ENXIO)); 101 } 102 103 if (cmd == F_SEEK_HOLE) 104 hole = B_TRUE; 105 else 106 hole = B_FALSE; 107 108 /* Flush any mmap()'d data to disk */ 109 if (zn_has_cached_data(zp)) 110 zn_flush_cached_data(zp, B_FALSE); 111 112 lr = zfs_rangelock_enter(&zp->z_rangelock, 0, file_sz, RL_READER); 113 error = dmu_offset_next(ZTOZSB(zp)->z_os, zp->z_id, hole, &noff); 114 zfs_rangelock_exit(lr); 115 116 if (error == ESRCH) 117 return (SET_ERROR(ENXIO)); 118 119 /* File was dirty, so fall back to using generic logic */ 120 if (error == EBUSY) { 121 if (hole) 122 *off = file_sz; 123 124 return (0); 125 } 126 127 /* 128 * We could find a hole that begins after the logical end-of-file, 129 * because dmu_offset_next() only works on whole blocks. If the 130 * EOF falls mid-block, then indicate that the "virtual hole" 131 * at the end of the file begins at the logical EOF, rather than 132 * at the end of the last block. 133 */ 134 if (noff > file_sz) { 135 ASSERT(hole); 136 noff = file_sz; 137 } 138 139 if (noff < *off) 140 return (error); 141 *off = noff; 142 return (error); 143 } 144 145 int 146 zfs_holey(znode_t *zp, ulong_t cmd, loff_t *off) 147 { 148 zfsvfs_t *zfsvfs = ZTOZSB(zp); 149 int error; 150 151 if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0) 152 return (error); 153 154 error = zfs_holey_common(zp, cmd, off); 155 156 zfs_exit(zfsvfs, FTAG); 157 return (error); 158 } 159 #endif /* SEEK_HOLE && SEEK_DATA */ 160 161 int 162 zfs_access(znode_t *zp, int mode, int flag, cred_t *cr) 163 { 164 zfsvfs_t *zfsvfs = ZTOZSB(zp); 165 int error; 166 167 if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0) 168 return (error); 169 170 if (flag & V_ACE_MASK) 171 #if defined(__linux__) 172 error = zfs_zaccess(zp, mode, flag, B_FALSE, cr, 173 kcred->user_ns); 174 #else 175 error = zfs_zaccess(zp, mode, flag, B_FALSE, cr, 176 NULL); 177 #endif 178 else 179 #if defined(__linux__) 180 error = zfs_zaccess_rwx(zp, mode, flag, cr, kcred->user_ns); 181 #else 182 error = zfs_zaccess_rwx(zp, mode, flag, cr, NULL); 183 #endif 184 185 zfs_exit(zfsvfs, FTAG); 186 return (error); 187 } 188 189 static uint64_t zfs_vnops_read_chunk_size = 1024 * 1024; /* Tunable */ 190 191 /* 192 * Read bytes from specified file into supplied buffer. 193 * 194 * IN: zp - inode of file to be read from. 195 * uio - structure supplying read location, range info, 196 * and return buffer. 197 * ioflag - O_SYNC flags; used to provide FRSYNC semantics. 198 * O_DIRECT flag; used to bypass page cache. 199 * cr - credentials of caller. 200 * 201 * OUT: uio - updated offset and range, buffer filled. 202 * 203 * RETURN: 0 on success, error code on failure. 204 * 205 * Side Effects: 206 * inode - atime updated if byte count > 0 207 */ 208 int 209 zfs_read(struct znode *zp, zfs_uio_t *uio, int ioflag, cred_t *cr) 210 { 211 (void) cr; 212 int error = 0; 213 boolean_t frsync = B_FALSE; 214 215 zfsvfs_t *zfsvfs = ZTOZSB(zp); 216 if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0) 217 return (error); 218 219 if (zp->z_pflags & ZFS_AV_QUARANTINED) { 220 zfs_exit(zfsvfs, FTAG); 221 return (SET_ERROR(EACCES)); 222 } 223 224 /* We don't copy out anything useful for directories. */ 225 if (Z_ISDIR(ZTOTYPE(zp))) { 226 zfs_exit(zfsvfs, FTAG); 227 return (SET_ERROR(EISDIR)); 228 } 229 230 /* 231 * Validate file offset 232 */ 233 if (zfs_uio_offset(uio) < (offset_t)0) { 234 zfs_exit(zfsvfs, FTAG); 235 return (SET_ERROR(EINVAL)); 236 } 237 238 /* 239 * Fasttrack empty reads 240 */ 241 if (zfs_uio_resid(uio) == 0) { 242 zfs_exit(zfsvfs, FTAG); 243 return (0); 244 } 245 246 #ifdef FRSYNC 247 /* 248 * If we're in FRSYNC mode, sync out this znode before reading it. 249 * Only do this for non-snapshots. 250 * 251 * Some platforms do not support FRSYNC and instead map it 252 * to O_SYNC, which results in unnecessary calls to zil_commit. We 253 * only honor FRSYNC requests on platforms which support it. 254 */ 255 frsync = !!(ioflag & FRSYNC); 256 #endif 257 if (zfsvfs->z_log && 258 (frsync || zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)) 259 zil_commit(zfsvfs->z_log, zp->z_id); 260 261 /* 262 * Lock the range against changes. 263 */ 264 zfs_locked_range_t *lr = zfs_rangelock_enter(&zp->z_rangelock, 265 zfs_uio_offset(uio), zfs_uio_resid(uio), RL_READER); 266 267 /* 268 * If we are reading past end-of-file we can skip 269 * to the end; but we might still need to set atime. 270 */ 271 if (zfs_uio_offset(uio) >= zp->z_size) { 272 error = 0; 273 goto out; 274 } 275 276 ASSERT(zfs_uio_offset(uio) < zp->z_size); 277 #if defined(__linux__) 278 ssize_t start_offset = zfs_uio_offset(uio); 279 #endif 280 ssize_t n = MIN(zfs_uio_resid(uio), zp->z_size - zfs_uio_offset(uio)); 281 ssize_t start_resid = n; 282 283 while (n > 0) { 284 ssize_t nbytes = MIN(n, zfs_vnops_read_chunk_size - 285 P2PHASE(zfs_uio_offset(uio), zfs_vnops_read_chunk_size)); 286 #ifdef UIO_NOCOPY 287 if (zfs_uio_segflg(uio) == UIO_NOCOPY) 288 error = mappedread_sf(zp, nbytes, uio); 289 else 290 #endif 291 if (zn_has_cached_data(zp) && !(ioflag & O_DIRECT)) { 292 error = mappedread(zp, nbytes, uio); 293 } else { 294 error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl), 295 uio, nbytes); 296 } 297 298 if (error) { 299 /* convert checksum errors into IO errors */ 300 if (error == ECKSUM) 301 error = SET_ERROR(EIO); 302 303 #if defined(__linux__) 304 /* 305 * if we actually read some bytes, bubbling EFAULT 306 * up to become EAGAIN isn't what we want here... 307 * 308 * ...on Linux, at least. On FBSD, doing this breaks. 309 */ 310 if (error == EFAULT && 311 (zfs_uio_offset(uio) - start_offset) != 0) 312 error = 0; 313 #endif 314 break; 315 } 316 317 n -= nbytes; 318 } 319 320 int64_t nread = start_resid - n; 321 dataset_kstats_update_read_kstats(&zfsvfs->z_kstat, nread); 322 task_io_account_read(nread); 323 out: 324 zfs_rangelock_exit(lr); 325 326 ZFS_ACCESSTIME_STAMP(zfsvfs, zp); 327 zfs_exit(zfsvfs, FTAG); 328 return (error); 329 } 330 331 static void 332 zfs_clear_setid_bits_if_necessary(zfsvfs_t *zfsvfs, znode_t *zp, cred_t *cr, 333 uint64_t *clear_setid_bits_txgp, dmu_tx_t *tx) 334 { 335 zilog_t *zilog = zfsvfs->z_log; 336 const uint64_t uid = KUID_TO_SUID(ZTOUID(zp)); 337 338 ASSERT(clear_setid_bits_txgp != NULL); 339 ASSERT(tx != NULL); 340 341 /* 342 * Clear Set-UID/Set-GID bits on successful write if not 343 * privileged and at least one of the execute bits is set. 344 * 345 * It would be nice to do this after all writes have 346 * been done, but that would still expose the ISUID/ISGID 347 * to another app after the partial write is committed. 348 * 349 * Note: we don't call zfs_fuid_map_id() here because 350 * user 0 is not an ephemeral uid. 351 */ 352 mutex_enter(&zp->z_acl_lock); 353 if ((zp->z_mode & (S_IXUSR | (S_IXUSR >> 3) | (S_IXUSR >> 6))) != 0 && 354 (zp->z_mode & (S_ISUID | S_ISGID)) != 0 && 355 secpolicy_vnode_setid_retain(zp, cr, 356 ((zp->z_mode & S_ISUID) != 0 && uid == 0)) != 0) { 357 uint64_t newmode; 358 359 zp->z_mode &= ~(S_ISUID | S_ISGID); 360 newmode = zp->z_mode; 361 (void) sa_update(zp->z_sa_hdl, SA_ZPL_MODE(zfsvfs), 362 (void *)&newmode, sizeof (uint64_t), tx); 363 364 mutex_exit(&zp->z_acl_lock); 365 366 /* 367 * Make sure SUID/SGID bits will be removed when we replay the 368 * log. If the setid bits are keep coming back, don't log more 369 * than one TX_SETATTR per transaction group. 370 */ 371 if (*clear_setid_bits_txgp != dmu_tx_get_txg(tx)) { 372 vattr_t va = {0}; 373 374 va.va_mask = ATTR_MODE; 375 va.va_nodeid = zp->z_id; 376 va.va_mode = newmode; 377 zfs_log_setattr(zilog, tx, TX_SETATTR, zp, &va, 378 ATTR_MODE, NULL); 379 *clear_setid_bits_txgp = dmu_tx_get_txg(tx); 380 } 381 } else { 382 mutex_exit(&zp->z_acl_lock); 383 } 384 } 385 386 /* 387 * Write the bytes to a file. 388 * 389 * IN: zp - znode of file to be written to. 390 * uio - structure supplying write location, range info, 391 * and data buffer. 392 * ioflag - O_APPEND flag set if in append mode. 393 * O_DIRECT flag; used to bypass page cache. 394 * cr - credentials of caller. 395 * 396 * OUT: uio - updated offset and range. 397 * 398 * RETURN: 0 if success 399 * error code if failure 400 * 401 * Timestamps: 402 * ip - ctime|mtime updated if byte count > 0 403 */ 404 int 405 zfs_write(znode_t *zp, zfs_uio_t *uio, int ioflag, cred_t *cr) 406 { 407 int error = 0, error1; 408 ssize_t start_resid = zfs_uio_resid(uio); 409 uint64_t clear_setid_bits_txg = 0; 410 411 /* 412 * Fasttrack empty write 413 */ 414 ssize_t n = start_resid; 415 if (n == 0) 416 return (0); 417 418 zfsvfs_t *zfsvfs = ZTOZSB(zp); 419 if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0) 420 return (error); 421 422 sa_bulk_attr_t bulk[4]; 423 int count = 0; 424 uint64_t mtime[2], ctime[2]; 425 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16); 426 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16); 427 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL, 428 &zp->z_size, 8); 429 SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL, 430 &zp->z_pflags, 8); 431 432 /* 433 * Callers might not be able to detect properly that we are read-only, 434 * so check it explicitly here. 435 */ 436 if (zfs_is_readonly(zfsvfs)) { 437 zfs_exit(zfsvfs, FTAG); 438 return (SET_ERROR(EROFS)); 439 } 440 441 /* 442 * If immutable or not appending then return EPERM. 443 * Intentionally allow ZFS_READONLY through here. 444 * See zfs_zaccess_common() 445 */ 446 if ((zp->z_pflags & ZFS_IMMUTABLE) || 447 ((zp->z_pflags & ZFS_APPENDONLY) && !(ioflag & O_APPEND) && 448 (zfs_uio_offset(uio) < zp->z_size))) { 449 zfs_exit(zfsvfs, FTAG); 450 return (SET_ERROR(EPERM)); 451 } 452 453 /* 454 * Validate file offset 455 */ 456 offset_t woff = ioflag & O_APPEND ? zp->z_size : zfs_uio_offset(uio); 457 if (woff < 0) { 458 zfs_exit(zfsvfs, FTAG); 459 return (SET_ERROR(EINVAL)); 460 } 461 462 const uint64_t max_blksz = zfsvfs->z_max_blksz; 463 464 /* 465 * Pre-fault the pages to ensure slow (eg NFS) pages 466 * don't hold up txg. 467 * Skip this if uio contains loaned arc_buf. 468 */ 469 if (zfs_uio_prefaultpages(MIN(n, max_blksz), uio)) { 470 zfs_exit(zfsvfs, FTAG); 471 return (SET_ERROR(EFAULT)); 472 } 473 474 /* 475 * If in append mode, set the io offset pointer to eof. 476 */ 477 zfs_locked_range_t *lr; 478 if (ioflag & O_APPEND) { 479 /* 480 * Obtain an appending range lock to guarantee file append 481 * semantics. We reset the write offset once we have the lock. 482 */ 483 lr = zfs_rangelock_enter(&zp->z_rangelock, 0, n, RL_APPEND); 484 woff = lr->lr_offset; 485 if (lr->lr_length == UINT64_MAX) { 486 /* 487 * We overlocked the file because this write will cause 488 * the file block size to increase. 489 * Note that zp_size cannot change with this lock held. 490 */ 491 woff = zp->z_size; 492 } 493 zfs_uio_setoffset(uio, woff); 494 } else { 495 /* 496 * Note that if the file block size will change as a result of 497 * this write, then this range lock will lock the entire file 498 * so that we can re-write the block safely. 499 */ 500 lr = zfs_rangelock_enter(&zp->z_rangelock, woff, n, RL_WRITER); 501 } 502 503 if (zn_rlimit_fsize(zp, uio)) { 504 zfs_rangelock_exit(lr); 505 zfs_exit(zfsvfs, FTAG); 506 return (SET_ERROR(EFBIG)); 507 } 508 509 const rlim64_t limit = MAXOFFSET_T; 510 511 if (woff >= limit) { 512 zfs_rangelock_exit(lr); 513 zfs_exit(zfsvfs, FTAG); 514 return (SET_ERROR(EFBIG)); 515 } 516 517 if (n > limit - woff) 518 n = limit - woff; 519 520 uint64_t end_size = MAX(zp->z_size, woff + n); 521 zilog_t *zilog = zfsvfs->z_log; 522 523 const uint64_t uid = KUID_TO_SUID(ZTOUID(zp)); 524 const uint64_t gid = KGID_TO_SGID(ZTOGID(zp)); 525 const uint64_t projid = zp->z_projid; 526 527 /* 528 * Write the file in reasonable size chunks. Each chunk is written 529 * in a separate transaction; this keeps the intent log records small 530 * and allows us to do more fine-grained space accounting. 531 */ 532 while (n > 0) { 533 woff = zfs_uio_offset(uio); 534 535 if (zfs_id_overblockquota(zfsvfs, DMU_USERUSED_OBJECT, uid) || 536 zfs_id_overblockquota(zfsvfs, DMU_GROUPUSED_OBJECT, gid) || 537 (projid != ZFS_DEFAULT_PROJID && 538 zfs_id_overblockquota(zfsvfs, DMU_PROJECTUSED_OBJECT, 539 projid))) { 540 error = SET_ERROR(EDQUOT); 541 break; 542 } 543 544 arc_buf_t *abuf = NULL; 545 if (n >= max_blksz && woff >= zp->z_size && 546 P2PHASE(woff, max_blksz) == 0 && 547 zp->z_blksz == max_blksz) { 548 /* 549 * This write covers a full block. "Borrow" a buffer 550 * from the dmu so that we can fill it before we enter 551 * a transaction. This avoids the possibility of 552 * holding up the transaction if the data copy hangs 553 * up on a pagefault (e.g., from an NFS server mapping). 554 */ 555 size_t cbytes; 556 557 abuf = dmu_request_arcbuf(sa_get_db(zp->z_sa_hdl), 558 max_blksz); 559 ASSERT(abuf != NULL); 560 ASSERT(arc_buf_size(abuf) == max_blksz); 561 if ((error = zfs_uiocopy(abuf->b_data, max_blksz, 562 UIO_WRITE, uio, &cbytes))) { 563 dmu_return_arcbuf(abuf); 564 break; 565 } 566 ASSERT3S(cbytes, ==, max_blksz); 567 } 568 569 /* 570 * Start a transaction. 571 */ 572 dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os); 573 dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE); 574 dmu_buf_impl_t *db = (dmu_buf_impl_t *)sa_get_db(zp->z_sa_hdl); 575 DB_DNODE_ENTER(db); 576 dmu_tx_hold_write_by_dnode(tx, DB_DNODE(db), woff, 577 MIN(n, max_blksz)); 578 DB_DNODE_EXIT(db); 579 zfs_sa_upgrade_txholds(tx, zp); 580 error = dmu_tx_assign(tx, TXG_WAIT); 581 if (error) { 582 dmu_tx_abort(tx); 583 if (abuf != NULL) 584 dmu_return_arcbuf(abuf); 585 break; 586 } 587 588 /* 589 * NB: We must call zfs_clear_setid_bits_if_necessary before 590 * committing the transaction! 591 */ 592 593 /* 594 * If rangelock_enter() over-locked we grow the blocksize 595 * and then reduce the lock range. This will only happen 596 * on the first iteration since rangelock_reduce() will 597 * shrink down lr_length to the appropriate size. 598 */ 599 if (lr->lr_length == UINT64_MAX) { 600 uint64_t new_blksz; 601 602 if (zp->z_blksz > max_blksz) { 603 /* 604 * File's blocksize is already larger than the 605 * "recordsize" property. Only let it grow to 606 * the next power of 2. 607 */ 608 ASSERT(!ISP2(zp->z_blksz)); 609 new_blksz = MIN(end_size, 610 1 << highbit64(zp->z_blksz)); 611 } else { 612 new_blksz = MIN(end_size, max_blksz); 613 } 614 zfs_grow_blocksize(zp, new_blksz, tx); 615 zfs_rangelock_reduce(lr, woff, n); 616 } 617 618 /* 619 * XXX - should we really limit each write to z_max_blksz? 620 * Perhaps we should use SPA_MAXBLOCKSIZE chunks? 621 */ 622 const ssize_t nbytes = 623 MIN(n, max_blksz - P2PHASE(woff, max_blksz)); 624 625 ssize_t tx_bytes; 626 if (abuf == NULL) { 627 tx_bytes = zfs_uio_resid(uio); 628 zfs_uio_fault_disable(uio, B_TRUE); 629 error = dmu_write_uio_dbuf(sa_get_db(zp->z_sa_hdl), 630 uio, nbytes, tx); 631 zfs_uio_fault_disable(uio, B_FALSE); 632 #ifdef __linux__ 633 if (error == EFAULT) { 634 zfs_clear_setid_bits_if_necessary(zfsvfs, zp, 635 cr, &clear_setid_bits_txg, tx); 636 dmu_tx_commit(tx); 637 /* 638 * Account for partial writes before 639 * continuing the loop. 640 * Update needs to occur before the next 641 * zfs_uio_prefaultpages, or prefaultpages may 642 * error, and we may break the loop early. 643 */ 644 if (tx_bytes != zfs_uio_resid(uio)) 645 n -= tx_bytes - zfs_uio_resid(uio); 646 if (zfs_uio_prefaultpages(MIN(n, max_blksz), 647 uio)) { 648 break; 649 } 650 continue; 651 } 652 #endif 653 /* 654 * On FreeBSD, EFAULT should be propagated back to the 655 * VFS, which will handle faulting and will retry. 656 */ 657 if (error != 0 && error != EFAULT) { 658 zfs_clear_setid_bits_if_necessary(zfsvfs, zp, 659 cr, &clear_setid_bits_txg, tx); 660 dmu_tx_commit(tx); 661 break; 662 } 663 tx_bytes -= zfs_uio_resid(uio); 664 } else { 665 /* Implied by abuf != NULL: */ 666 ASSERT3S(n, >=, max_blksz); 667 ASSERT0(P2PHASE(woff, max_blksz)); 668 /* 669 * We can simplify nbytes to MIN(n, max_blksz) since 670 * P2PHASE(woff, max_blksz) is 0, and knowing 671 * n >= max_blksz lets us simplify further: 672 */ 673 ASSERT3S(nbytes, ==, max_blksz); 674 /* 675 * Thus, we're writing a full block at a block-aligned 676 * offset and extending the file past EOF. 677 * 678 * dmu_assign_arcbuf_by_dbuf() will directly assign the 679 * arc buffer to a dbuf. 680 */ 681 error = dmu_assign_arcbuf_by_dbuf( 682 sa_get_db(zp->z_sa_hdl), woff, abuf, tx); 683 if (error != 0) { 684 /* 685 * XXX This might not be necessary if 686 * dmu_assign_arcbuf_by_dbuf is guaranteed 687 * to be atomic. 688 */ 689 zfs_clear_setid_bits_if_necessary(zfsvfs, zp, 690 cr, &clear_setid_bits_txg, tx); 691 dmu_return_arcbuf(abuf); 692 dmu_tx_commit(tx); 693 break; 694 } 695 ASSERT3S(nbytes, <=, zfs_uio_resid(uio)); 696 zfs_uioskip(uio, nbytes); 697 tx_bytes = nbytes; 698 } 699 if (tx_bytes && zn_has_cached_data(zp) && 700 !(ioflag & O_DIRECT)) { 701 update_pages(zp, woff, tx_bytes, zfsvfs->z_os); 702 } 703 704 /* 705 * If we made no progress, we're done. If we made even 706 * partial progress, update the znode and ZIL accordingly. 707 */ 708 if (tx_bytes == 0) { 709 (void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs), 710 (void *)&zp->z_size, sizeof (uint64_t), tx); 711 dmu_tx_commit(tx); 712 ASSERT(error != 0); 713 break; 714 } 715 716 zfs_clear_setid_bits_if_necessary(zfsvfs, zp, cr, 717 &clear_setid_bits_txg, tx); 718 719 zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime); 720 721 /* 722 * Update the file size (zp_size) if it has changed; 723 * account for possible concurrent updates. 724 */ 725 while ((end_size = zp->z_size) < zfs_uio_offset(uio)) { 726 (void) atomic_cas_64(&zp->z_size, end_size, 727 zfs_uio_offset(uio)); 728 ASSERT(error == 0 || error == EFAULT); 729 } 730 /* 731 * If we are replaying and eof is non zero then force 732 * the file size to the specified eof. Note, there's no 733 * concurrency during replay. 734 */ 735 if (zfsvfs->z_replay && zfsvfs->z_replay_eof != 0) 736 zp->z_size = zfsvfs->z_replay_eof; 737 738 error1 = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx); 739 if (error1 != 0) 740 /* Avoid clobbering EFAULT. */ 741 error = error1; 742 743 /* 744 * NB: During replay, the TX_SETATTR record logged by 745 * zfs_clear_setid_bits_if_necessary must precede any of 746 * the TX_WRITE records logged here. 747 */ 748 zfs_log_write(zilog, tx, TX_WRITE, zp, woff, tx_bytes, ioflag, 749 NULL, NULL); 750 751 dmu_tx_commit(tx); 752 753 if (error != 0) 754 break; 755 ASSERT3S(tx_bytes, ==, nbytes); 756 n -= nbytes; 757 758 if (n > 0) { 759 if (zfs_uio_prefaultpages(MIN(n, max_blksz), uio)) { 760 error = SET_ERROR(EFAULT); 761 break; 762 } 763 } 764 } 765 766 zfs_znode_update_vfs(zp); 767 zfs_rangelock_exit(lr); 768 769 /* 770 * If we're in replay mode, or we made no progress, or the 771 * uio data is inaccessible return an error. Otherwise, it's 772 * at least a partial write, so it's successful. 773 */ 774 if (zfsvfs->z_replay || zfs_uio_resid(uio) == start_resid || 775 error == EFAULT) { 776 zfs_exit(zfsvfs, FTAG); 777 return (error); 778 } 779 780 if (ioflag & (O_SYNC | O_DSYNC) || 781 zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 782 zil_commit(zilog, zp->z_id); 783 784 const int64_t nwritten = start_resid - zfs_uio_resid(uio); 785 dataset_kstats_update_write_kstats(&zfsvfs->z_kstat, nwritten); 786 task_io_account_write(nwritten); 787 788 zfs_exit(zfsvfs, FTAG); 789 return (0); 790 } 791 792 int 793 zfs_getsecattr(znode_t *zp, vsecattr_t *vsecp, int flag, cred_t *cr) 794 { 795 zfsvfs_t *zfsvfs = ZTOZSB(zp); 796 int error; 797 boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE; 798 799 if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0) 800 return (error); 801 error = zfs_getacl(zp, vsecp, skipaclchk, cr); 802 zfs_exit(zfsvfs, FTAG); 803 804 return (error); 805 } 806 807 int 808 zfs_setsecattr(znode_t *zp, vsecattr_t *vsecp, int flag, cred_t *cr) 809 { 810 zfsvfs_t *zfsvfs = ZTOZSB(zp); 811 int error; 812 boolean_t skipaclchk = (flag & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE; 813 zilog_t *zilog = zfsvfs->z_log; 814 815 if ((error = zfs_enter_verify_zp(zfsvfs, zp, FTAG)) != 0) 816 return (error); 817 818 error = zfs_setacl(zp, vsecp, skipaclchk, cr); 819 820 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS) 821 zil_commit(zilog, 0); 822 823 zfs_exit(zfsvfs, FTAG); 824 return (error); 825 } 826 827 #ifdef ZFS_DEBUG 828 static int zil_fault_io = 0; 829 #endif 830 831 static void zfs_get_done(zgd_t *zgd, int error); 832 833 /* 834 * Get data to generate a TX_WRITE intent log record. 835 */ 836 int 837 zfs_get_data(void *arg, uint64_t gen, lr_write_t *lr, char *buf, 838 struct lwb *lwb, zio_t *zio) 839 { 840 zfsvfs_t *zfsvfs = arg; 841 objset_t *os = zfsvfs->z_os; 842 znode_t *zp; 843 uint64_t object = lr->lr_foid; 844 uint64_t offset = lr->lr_offset; 845 uint64_t size = lr->lr_length; 846 dmu_buf_t *db; 847 zgd_t *zgd; 848 int error = 0; 849 uint64_t zp_gen; 850 851 ASSERT3P(lwb, !=, NULL); 852 ASSERT3P(zio, !=, NULL); 853 ASSERT3U(size, !=, 0); 854 855 /* 856 * Nothing to do if the file has been removed 857 */ 858 if (zfs_zget(zfsvfs, object, &zp) != 0) 859 return (SET_ERROR(ENOENT)); 860 if (zp->z_unlinked) { 861 /* 862 * Release the vnode asynchronously as we currently have the 863 * txg stopped from syncing. 864 */ 865 zfs_zrele_async(zp); 866 return (SET_ERROR(ENOENT)); 867 } 868 /* check if generation number matches */ 869 if (sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs), &zp_gen, 870 sizeof (zp_gen)) != 0) { 871 zfs_zrele_async(zp); 872 return (SET_ERROR(EIO)); 873 } 874 if (zp_gen != gen) { 875 zfs_zrele_async(zp); 876 return (SET_ERROR(ENOENT)); 877 } 878 879 zgd = kmem_zalloc(sizeof (zgd_t), KM_SLEEP); 880 zgd->zgd_lwb = lwb; 881 zgd->zgd_private = zp; 882 883 /* 884 * Write records come in two flavors: immediate and indirect. 885 * For small writes it's cheaper to store the data with the 886 * log record (immediate); for large writes it's cheaper to 887 * sync the data and get a pointer to it (indirect) so that 888 * we don't have to write the data twice. 889 */ 890 if (buf != NULL) { /* immediate write */ 891 zgd->zgd_lr = zfs_rangelock_enter(&zp->z_rangelock, 892 offset, size, RL_READER); 893 /* test for truncation needs to be done while range locked */ 894 if (offset >= zp->z_size) { 895 error = SET_ERROR(ENOENT); 896 } else { 897 error = dmu_read(os, object, offset, size, buf, 898 DMU_READ_NO_PREFETCH); 899 } 900 ASSERT(error == 0 || error == ENOENT); 901 } else { /* indirect write */ 902 /* 903 * Have to lock the whole block to ensure when it's 904 * written out and its checksum is being calculated 905 * that no one can change the data. We need to re-check 906 * blocksize after we get the lock in case it's changed! 907 */ 908 for (;;) { 909 uint64_t blkoff; 910 size = zp->z_blksz; 911 blkoff = ISP2(size) ? P2PHASE(offset, size) : offset; 912 offset -= blkoff; 913 zgd->zgd_lr = zfs_rangelock_enter(&zp->z_rangelock, 914 offset, size, RL_READER); 915 if (zp->z_blksz == size) 916 break; 917 offset += blkoff; 918 zfs_rangelock_exit(zgd->zgd_lr); 919 } 920 /* test for truncation needs to be done while range locked */ 921 if (lr->lr_offset >= zp->z_size) 922 error = SET_ERROR(ENOENT); 923 #ifdef ZFS_DEBUG 924 if (zil_fault_io) { 925 error = SET_ERROR(EIO); 926 zil_fault_io = 0; 927 } 928 #endif 929 if (error == 0) 930 error = dmu_buf_hold(os, object, offset, zgd, &db, 931 DMU_READ_NO_PREFETCH); 932 933 if (error == 0) { 934 blkptr_t *bp = &lr->lr_blkptr; 935 936 zgd->zgd_db = db; 937 zgd->zgd_bp = bp; 938 939 ASSERT(db->db_offset == offset); 940 ASSERT(db->db_size == size); 941 942 error = dmu_sync(zio, lr->lr_common.lrc_txg, 943 zfs_get_done, zgd); 944 ASSERT(error || lr->lr_length <= size); 945 946 /* 947 * On success, we need to wait for the write I/O 948 * initiated by dmu_sync() to complete before we can 949 * release this dbuf. We will finish everything up 950 * in the zfs_get_done() callback. 951 */ 952 if (error == 0) 953 return (0); 954 955 if (error == EALREADY) { 956 lr->lr_common.lrc_txtype = TX_WRITE2; 957 /* 958 * TX_WRITE2 relies on the data previously 959 * written by the TX_WRITE that caused 960 * EALREADY. We zero out the BP because 961 * it is the old, currently-on-disk BP. 962 */ 963 zgd->zgd_bp = NULL; 964 BP_ZERO(bp); 965 error = 0; 966 } 967 } 968 } 969 970 zfs_get_done(zgd, error); 971 972 return (error); 973 } 974 975 976 static void 977 zfs_get_done(zgd_t *zgd, int error) 978 { 979 (void) error; 980 znode_t *zp = zgd->zgd_private; 981 982 if (zgd->zgd_db) 983 dmu_buf_rele(zgd->zgd_db, zgd); 984 985 zfs_rangelock_exit(zgd->zgd_lr); 986 987 /* 988 * Release the vnode asynchronously as we currently have the 989 * txg stopped from syncing. 990 */ 991 zfs_zrele_async(zp); 992 993 kmem_free(zgd, sizeof (zgd_t)); 994 } 995 996 EXPORT_SYMBOL(zfs_access); 997 EXPORT_SYMBOL(zfs_fsync); 998 EXPORT_SYMBOL(zfs_holey); 999 EXPORT_SYMBOL(zfs_read); 1000 EXPORT_SYMBOL(zfs_write); 1001 EXPORT_SYMBOL(zfs_getsecattr); 1002 EXPORT_SYMBOL(zfs_setsecattr); 1003 1004 ZFS_MODULE_PARAM(zfs_vnops, zfs_vnops_, read_chunk_size, U64, ZMOD_RW, 1005 "Bytes to read per chunk"); 1006