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 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright (c) 2015, Joyent, Inc. All rights reserved. 29 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 30 * Copyright 2016 RackTop Systems. 31 * Copyright (c) 2017 by Delphix. All rights reserved. 32 */ 33 34 #include <sys/types.h> 35 #include <sys/param.h> 36 #include <sys/t_lock.h> 37 #include <sys/systm.h> 38 #include <sys/sysmacros.h> 39 #include <sys/user.h> 40 #include <sys/time.h> 41 #include <sys/vfs.h> 42 #include <sys/vfs_opreg.h> 43 #include <sys/vnode.h> 44 #include <sys/file.h> 45 #include <sys/fcntl.h> 46 #include <sys/flock.h> 47 #include <sys/kmem.h> 48 #include <sys/uio.h> 49 #include <sys/errno.h> 50 #include <sys/stat.h> 51 #include <sys/cred.h> 52 #include <sys/dirent.h> 53 #include <sys/pathname.h> 54 #include <sys/vmsystm.h> 55 #include <sys/fs/tmp.h> 56 #include <sys/fs/tmpnode.h> 57 #include <sys/mman.h> 58 #include <vm/hat.h> 59 #include <vm/seg_vn.h> 60 #include <vm/seg_map.h> 61 #include <vm/seg.h> 62 #include <vm/anon.h> 63 #include <vm/as.h> 64 #include <vm/page.h> 65 #include <vm/pvn.h> 66 #include <sys/cmn_err.h> 67 #include <sys/debug.h> 68 #include <sys/swap.h> 69 #include <sys/buf.h> 70 #include <sys/vm.h> 71 #include <sys/vtrace.h> 72 #include <sys/policy.h> 73 #include <fs/fs_subr.h> 74 75 static int tmp_getapage(struct vnode *, u_offset_t, size_t, uint_t *, 76 page_t **, size_t, struct seg *, caddr_t, enum seg_rw, struct cred *); 77 static int tmp_putapage(struct vnode *, page_t *, u_offset_t *, size_t *, 78 int, struct cred *); 79 80 /* ARGSUSED1 */ 81 static int 82 tmp_open(struct vnode **vpp, int flag, struct cred *cred, caller_context_t *ct) 83 { 84 /* 85 * swapon to a tmpfs file is not supported so access 86 * is denied on open if VISSWAP is set. 87 */ 88 if ((*vpp)->v_flag & VISSWAP) 89 return (EINVAL); 90 return (0); 91 } 92 93 /* ARGSUSED1 */ 94 static int 95 tmp_close( 96 struct vnode *vp, 97 int flag, 98 int count, 99 offset_t offset, 100 struct cred *cred, 101 caller_context_t *ct) 102 { 103 cleanlocks(vp, ttoproc(curthread)->p_pid, 0); 104 cleanshares(vp, ttoproc(curthread)->p_pid); 105 return (0); 106 } 107 108 /* 109 * wrtmp does the real work of write requests for tmpfs. 110 */ 111 static int 112 wrtmp( 113 struct tmount *tm, 114 struct tmpnode *tp, 115 struct uio *uio, 116 struct cred *cr, 117 struct caller_context *ct) 118 { 119 pgcnt_t pageoffset; /* offset in pages */ 120 ulong_t segmap_offset; /* pagesize byte offset into segmap */ 121 caddr_t base; /* base of segmap */ 122 ssize_t bytes; /* bytes to uiomove */ 123 pfn_t pagenumber; /* offset in pages into tmp file */ 124 struct vnode *vp; 125 int error = 0; 126 int pagecreate; /* == 1 if we allocated a page */ 127 int newpage; 128 rlim64_t limit = uio->uio_llimit; 129 long oresid = uio->uio_resid; 130 timestruc_t now; 131 132 long tn_size_changed = 0; 133 long old_tn_size; 134 long new_tn_size; 135 136 vp = TNTOV(tp); 137 ASSERT(vp->v_type == VREG); 138 139 TRACE_1(TR_FAC_TMPFS, TR_TMPFS_RWTMP_START, 140 "tmp_wrtmp_start:vp %p", vp); 141 142 ASSERT(RW_WRITE_HELD(&tp->tn_contents)); 143 ASSERT(RW_WRITE_HELD(&tp->tn_rwlock)); 144 145 if (MANDLOCK(vp, tp->tn_mode)) { 146 rw_exit(&tp->tn_contents); 147 /* 148 * tmp_getattr ends up being called by chklock 149 */ 150 error = chklock(vp, FWRITE, uio->uio_loffset, uio->uio_resid, 151 uio->uio_fmode, ct); 152 rw_enter(&tp->tn_contents, RW_WRITER); 153 if (error != 0) { 154 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 155 "tmp_wrtmp_end:vp %p error %d", vp, error); 156 return (error); 157 } 158 } 159 160 if (uio->uio_loffset < 0) 161 return (EINVAL); 162 163 if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T) 164 limit = MAXOFFSET_T; 165 166 if (uio->uio_loffset >= limit) { 167 proc_t *p = ttoproc(curthread); 168 169 mutex_enter(&p->p_lock); 170 (void) rctl_action(rctlproc_legacy[RLIMIT_FSIZE], p->p_rctls, 171 p, RCA_UNSAFE_SIGINFO); 172 mutex_exit(&p->p_lock); 173 return (EFBIG); 174 } 175 176 if (uio->uio_loffset >= MAXOFF_T) { 177 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 178 "tmp_wrtmp_end:vp %p error %d", vp, EINVAL); 179 return (EFBIG); 180 } 181 182 if (uio->uio_resid == 0) { 183 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 184 "tmp_wrtmp_end:vp %p error %d", vp, 0); 185 return (0); 186 } 187 188 if (limit > MAXOFF_T) 189 limit = MAXOFF_T; 190 191 do { 192 long offset; 193 long delta; 194 195 offset = (long)uio->uio_offset; 196 pageoffset = offset & PAGEOFFSET; 197 /* 198 * A maximum of PAGESIZE bytes of data is transferred 199 * each pass through this loop 200 */ 201 bytes = MIN(PAGESIZE - pageoffset, uio->uio_resid); 202 203 if (offset + bytes >= limit) { 204 if (offset >= limit) { 205 error = EFBIG; 206 goto out; 207 } 208 bytes = limit - offset; 209 } 210 pagenumber = btop(offset); 211 212 /* 213 * delta is the amount of anonymous memory 214 * to reserve for the file. 215 * We always reserve in pagesize increments so 216 * unless we're extending the file into a new page, 217 * we don't need to call tmp_resv. 218 */ 219 delta = offset + bytes - 220 P2ROUNDUP_TYPED(tp->tn_size, PAGESIZE, u_offset_t); 221 if (delta > 0) { 222 pagecreate = 1; 223 if (tmp_resv(tm, tp, delta, pagecreate)) { 224 /* 225 * Log file system full in the zone that owns 226 * the tmpfs mount, as well as in the global 227 * zone if necessary. 228 */ 229 zcmn_err(tm->tm_vfsp->vfs_zone->zone_id, 230 CE_WARN, "%s: File system full, " 231 "swap space limit exceeded", 232 tm->tm_mntpath); 233 234 if (tm->tm_vfsp->vfs_zone->zone_id != 235 GLOBAL_ZONEID) { 236 237 vfs_t *vfs = tm->tm_vfsp; 238 239 zcmn_err(GLOBAL_ZONEID, 240 CE_WARN, "%s: File system full, " 241 "swap space limit exceeded", 242 vfs->vfs_vnodecovered->v_path); 243 } 244 error = ENOSPC; 245 break; 246 } 247 tmpnode_growmap(tp, (ulong_t)offset + bytes); 248 } 249 /* grow the file to the new length */ 250 if (offset + bytes > tp->tn_size) { 251 tn_size_changed = 1; 252 old_tn_size = tp->tn_size; 253 /* 254 * Postpone updating tp->tn_size until uiomove() is 255 * done. 256 */ 257 new_tn_size = offset + bytes; 258 } 259 if (bytes == PAGESIZE) { 260 /* 261 * Writing whole page so reading from disk 262 * is a waste 263 */ 264 pagecreate = 1; 265 } else { 266 pagecreate = 0; 267 } 268 /* 269 * If writing past EOF or filling in a hole 270 * we need to allocate an anon slot. 271 */ 272 if (anon_get_ptr(tp->tn_anon, pagenumber) == NULL) { 273 (void) anon_set_ptr(tp->tn_anon, pagenumber, 274 anon_alloc(vp, ptob(pagenumber)), ANON_SLEEP); 275 pagecreate = 1; 276 tp->tn_nblocks++; 277 } 278 279 /* 280 * We have to drop the contents lock to allow the VM 281 * system to reacquire it in tmp_getpage() 282 */ 283 rw_exit(&tp->tn_contents); 284 285 /* 286 * Touch the page and fault it in if it is not in core 287 * before segmap_getmapflt or vpm_data_copy can lock it. 288 * This is to avoid the deadlock if the buffer is mapped 289 * to the same file through mmap which we want to write. 290 */ 291 uio_prefaultpages((long)bytes, uio); 292 293 newpage = 0; 294 if (vpm_enable) { 295 /* 296 * Copy data. If new pages are created, part of 297 * the page that is not written will be initizliazed 298 * with zeros. 299 */ 300 error = vpm_data_copy(vp, offset, bytes, uio, 301 !pagecreate, &newpage, 1, S_WRITE); 302 } else { 303 /* Get offset within the segmap mapping */ 304 segmap_offset = (offset & PAGEMASK) & MAXBOFFSET; 305 base = segmap_getmapflt(segkmap, vp, 306 (offset & MAXBMASK), PAGESIZE, !pagecreate, 307 S_WRITE); 308 } 309 310 311 if (!vpm_enable && pagecreate) { 312 /* 313 * segmap_pagecreate() returns 1 if it calls 314 * page_create_va() to allocate any pages. 315 */ 316 newpage = segmap_pagecreate(segkmap, 317 base + segmap_offset, (size_t)PAGESIZE, 0); 318 /* 319 * Clear from the beginning of the page to the starting 320 * offset of the data. 321 */ 322 if (pageoffset != 0) 323 (void) kzero(base + segmap_offset, 324 (size_t)pageoffset); 325 } 326 327 if (!vpm_enable) { 328 error = uiomove(base + segmap_offset + pageoffset, 329 (long)bytes, UIO_WRITE, uio); 330 } 331 332 if (!vpm_enable && pagecreate && 333 uio->uio_offset < P2ROUNDUP(offset + bytes, PAGESIZE)) { 334 long zoffset; /* zero from offset into page */ 335 /* 336 * We created pages w/o initializing them completely, 337 * thus we need to zero the part that wasn't set up. 338 * This happens on most EOF write cases and if 339 * we had some sort of error during the uiomove. 340 */ 341 long nmoved; 342 343 nmoved = uio->uio_offset - offset; 344 ASSERT((nmoved + pageoffset) <= PAGESIZE); 345 346 /* 347 * Zero from the end of data in the page to the 348 * end of the page. 349 */ 350 if ((zoffset = pageoffset + nmoved) < PAGESIZE) 351 (void) kzero(base + segmap_offset + zoffset, 352 (size_t)PAGESIZE - zoffset); 353 } 354 355 /* 356 * Unlock the pages which have been allocated by 357 * page_create_va() in segmap_pagecreate() 358 */ 359 if (!vpm_enable && newpage) { 360 segmap_pageunlock(segkmap, base + segmap_offset, 361 (size_t)PAGESIZE, S_WRITE); 362 } 363 364 if (error) { 365 /* 366 * If we failed on a write, we must 367 * be sure to invalidate any pages that may have 368 * been allocated. 369 */ 370 if (vpm_enable) { 371 (void) vpm_sync_pages(vp, offset, PAGESIZE, 372 SM_INVAL); 373 } else { 374 (void) segmap_release(segkmap, base, SM_INVAL); 375 } 376 } else { 377 if (vpm_enable) { 378 error = vpm_sync_pages(vp, offset, PAGESIZE, 379 0); 380 } else { 381 error = segmap_release(segkmap, base, 0); 382 } 383 } 384 385 /* 386 * Re-acquire contents lock. 387 */ 388 rw_enter(&tp->tn_contents, RW_WRITER); 389 390 /* 391 * Update tn_size. 392 */ 393 if (tn_size_changed) 394 tp->tn_size = new_tn_size; 395 396 /* 397 * If the uiomove failed, fix up tn_size. 398 */ 399 if (error) { 400 if (tn_size_changed) { 401 /* 402 * The uiomove failed, and we 403 * allocated blocks,so get rid 404 * of them. 405 */ 406 (void) tmpnode_trunc(tm, tp, 407 (ulong_t)old_tn_size); 408 } 409 } else { 410 /* 411 * XXX - Can this be out of the loop? 412 */ 413 if ((tp->tn_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) && 414 (tp->tn_mode & (S_ISUID | S_ISGID)) && 415 secpolicy_vnode_setid_retain(cr, 416 (tp->tn_mode & S_ISUID) != 0 && tp->tn_uid == 0)) { 417 /* 418 * Clear Set-UID & Set-GID bits on 419 * successful write if not privileged 420 * and at least one of the execute bits 421 * is set. If we always clear Set-GID, 422 * mandatory file and record locking is 423 * unuseable. 424 */ 425 tp->tn_mode &= ~(S_ISUID | S_ISGID); 426 } 427 gethrestime(&now); 428 tp->tn_mtime = now; 429 tp->tn_ctime = now; 430 } 431 } while (error == 0 && uio->uio_resid > 0 && bytes != 0); 432 433 out: 434 /* 435 * If we've already done a partial-write, terminate 436 * the write but return no error. 437 */ 438 if (oresid != uio->uio_resid) 439 error = 0; 440 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 441 "tmp_wrtmp_end:vp %p error %d", vp, error); 442 return (error); 443 } 444 445 /* 446 * rdtmp does the real work of read requests for tmpfs. 447 */ 448 static int 449 rdtmp( 450 struct tmount *tm, 451 struct tmpnode *tp, 452 struct uio *uio, 453 struct caller_context *ct) 454 { 455 ulong_t pageoffset; /* offset in tmpfs file (uio_offset) */ 456 ulong_t segmap_offset; /* pagesize byte offset into segmap */ 457 caddr_t base; /* base of segmap */ 458 ssize_t bytes; /* bytes to uiomove */ 459 struct vnode *vp; 460 int error; 461 long oresid = uio->uio_resid; 462 463 #if defined(lint) 464 tm = tm; 465 #endif 466 vp = TNTOV(tp); 467 468 TRACE_1(TR_FAC_TMPFS, TR_TMPFS_RWTMP_START, "tmp_rdtmp_start:vp %p", 469 vp); 470 471 ASSERT(RW_LOCK_HELD(&tp->tn_contents)); 472 473 if (MANDLOCK(vp, tp->tn_mode)) { 474 rw_exit(&tp->tn_contents); 475 /* 476 * tmp_getattr ends up being called by chklock 477 */ 478 error = chklock(vp, FREAD, uio->uio_loffset, uio->uio_resid, 479 uio->uio_fmode, ct); 480 rw_enter(&tp->tn_contents, RW_READER); 481 if (error != 0) { 482 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 483 "tmp_rdtmp_end:vp %p error %d", vp, error); 484 return (error); 485 } 486 } 487 ASSERT(tp->tn_type == VREG); 488 489 if (uio->uio_loffset >= MAXOFF_T) { 490 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 491 "tmp_rdtmp_end:vp %p error %d", vp, EINVAL); 492 return (0); 493 } 494 if (uio->uio_loffset < 0) 495 return (EINVAL); 496 if (uio->uio_resid == 0) { 497 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 498 "tmp_rdtmp_end:vp %p error %d", vp, 0); 499 return (0); 500 } 501 502 vp = TNTOV(tp); 503 504 do { 505 long diff; 506 long offset; 507 508 offset = uio->uio_offset; 509 pageoffset = offset & PAGEOFFSET; 510 bytes = MIN(PAGESIZE - pageoffset, uio->uio_resid); 511 512 diff = tp->tn_size - offset; 513 514 if (diff <= 0) { 515 error = 0; 516 goto out; 517 } 518 if (diff < bytes) 519 bytes = diff; 520 521 /* 522 * We have to drop the contents lock to allow the VM system 523 * to reacquire it in tmp_getpage() should the uiomove cause a 524 * pagefault. 525 */ 526 rw_exit(&tp->tn_contents); 527 528 if (vpm_enable) { 529 /* 530 * Copy data. 531 */ 532 error = vpm_data_copy(vp, offset, bytes, uio, 1, NULL, 533 0, S_READ); 534 } else { 535 segmap_offset = (offset & PAGEMASK) & MAXBOFFSET; 536 base = segmap_getmapflt(segkmap, vp, offset & MAXBMASK, 537 bytes, 1, S_READ); 538 539 error = uiomove(base + segmap_offset + pageoffset, 540 (long)bytes, UIO_READ, uio); 541 } 542 543 if (error) { 544 if (vpm_enable) { 545 (void) vpm_sync_pages(vp, offset, PAGESIZE, 0); 546 } else { 547 (void) segmap_release(segkmap, base, 0); 548 } 549 } else { 550 if (vpm_enable) { 551 error = vpm_sync_pages(vp, offset, PAGESIZE, 552 0); 553 } else { 554 error = segmap_release(segkmap, base, 0); 555 } 556 } 557 558 /* 559 * Re-acquire contents lock. 560 */ 561 rw_enter(&tp->tn_contents, RW_READER); 562 563 } while (error == 0 && uio->uio_resid > 0); 564 565 out: 566 gethrestime(&tp->tn_atime); 567 568 /* 569 * If we've already done a partial read, terminate 570 * the read but return no error. 571 */ 572 if (oresid != uio->uio_resid) 573 error = 0; 574 575 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END, 576 "tmp_rdtmp_end:vp %x error %d", vp, error); 577 return (error); 578 } 579 580 /* ARGSUSED2 */ 581 static int 582 tmp_read(struct vnode *vp, struct uio *uiop, int ioflag, cred_t *cred, 583 struct caller_context *ct) 584 { 585 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 586 struct tmount *tm = (struct tmount *)VTOTM(vp); 587 int error; 588 589 /* 590 * We don't currently support reading non-regular files 591 */ 592 if (vp->v_type == VDIR) 593 return (EISDIR); 594 if (vp->v_type != VREG) 595 return (EINVAL); 596 /* 597 * tmp_rwlock should have already been called from layers above 598 */ 599 ASSERT(RW_READ_HELD(&tp->tn_rwlock)); 600 601 rw_enter(&tp->tn_contents, RW_READER); 602 603 error = rdtmp(tm, tp, uiop, ct); 604 605 rw_exit(&tp->tn_contents); 606 607 return (error); 608 } 609 610 static int 611 tmp_write(struct vnode *vp, struct uio *uiop, int ioflag, struct cred *cred, 612 struct caller_context *ct) 613 { 614 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 615 struct tmount *tm = (struct tmount *)VTOTM(vp); 616 int error; 617 618 /* 619 * We don't currently support writing to non-regular files 620 */ 621 if (vp->v_type != VREG) 622 return (EINVAL); /* XXX EISDIR? */ 623 624 /* 625 * tmp_rwlock should have already been called from layers above 626 */ 627 ASSERT(RW_WRITE_HELD(&tp->tn_rwlock)); 628 629 rw_enter(&tp->tn_contents, RW_WRITER); 630 631 if (ioflag & FAPPEND) { 632 /* 633 * In append mode start at end of file. 634 */ 635 uiop->uio_loffset = tp->tn_size; 636 } 637 638 error = wrtmp(tm, tp, uiop, cred, ct); 639 640 rw_exit(&tp->tn_contents); 641 642 return (error); 643 } 644 645 /* ARGSUSED */ 646 static int 647 tmp_ioctl( 648 struct vnode *vp, 649 int com, 650 intptr_t data, 651 int flag, 652 struct cred *cred, 653 int *rvalp, 654 caller_context_t *ct) 655 { 656 return (ENOTTY); 657 } 658 659 /* ARGSUSED2 */ 660 static int 661 tmp_getattr( 662 struct vnode *vp, 663 struct vattr *vap, 664 int flags, 665 struct cred *cred, 666 caller_context_t *ct) 667 { 668 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 669 struct vnode *mvp; 670 struct vattr va; 671 int attrs = 1; 672 673 /* 674 * A special case to handle the root tnode on a diskless nfs 675 * client who may have had its uid and gid inherited 676 * from an nfs vnode with nobody ownership. Likely the 677 * root filesystem. After nfs is fully functional the uid/gid 678 * may be mapable so ask again. 679 * vfsp can't get unmounted because we hold vp. 680 */ 681 if (vp->v_flag & VROOT && 682 (mvp = vp->v_vfsp->vfs_vnodecovered) != NULL) { 683 mutex_enter(&tp->tn_tlock); 684 if (tp->tn_uid == UID_NOBODY || tp->tn_gid == GID_NOBODY) { 685 mutex_exit(&tp->tn_tlock); 686 bzero(&va, sizeof (struct vattr)); 687 va.va_mask = AT_UID|AT_GID; 688 attrs = VOP_GETATTR(mvp, &va, 0, cred, ct); 689 } else { 690 mutex_exit(&tp->tn_tlock); 691 } 692 } 693 mutex_enter(&tp->tn_tlock); 694 if (attrs == 0) { 695 tp->tn_uid = va.va_uid; 696 tp->tn_gid = va.va_gid; 697 } 698 vap->va_type = vp->v_type; 699 vap->va_mode = tp->tn_mode & MODEMASK; 700 vap->va_uid = tp->tn_uid; 701 vap->va_gid = tp->tn_gid; 702 vap->va_fsid = tp->tn_fsid; 703 vap->va_nodeid = (ino64_t)tp->tn_nodeid; 704 vap->va_nlink = tp->tn_nlink; 705 vap->va_size = (u_offset_t)tp->tn_size; 706 vap->va_atime = tp->tn_atime; 707 vap->va_mtime = tp->tn_mtime; 708 vap->va_ctime = tp->tn_ctime; 709 vap->va_blksize = PAGESIZE; 710 vap->va_rdev = tp->tn_rdev; 711 vap->va_seq = tp->tn_seq; 712 713 /* 714 * XXX Holes are not taken into account. We could take the time to 715 * run through the anon array looking for allocated slots... 716 */ 717 vap->va_nblocks = (fsblkcnt64_t)btodb(ptob(btopr(vap->va_size))); 718 mutex_exit(&tp->tn_tlock); 719 return (0); 720 } 721 722 /*ARGSUSED4*/ 723 static int 724 tmp_setattr( 725 struct vnode *vp, 726 struct vattr *vap, 727 int flags, 728 struct cred *cred, 729 caller_context_t *ct) 730 { 731 struct tmount *tm = (struct tmount *)VTOTM(vp); 732 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 733 int error = 0; 734 struct vattr *get; 735 long mask; 736 737 /* 738 * Cannot set these attributes 739 */ 740 if ((vap->va_mask & AT_NOSET) || (vap->va_mask & AT_XVATTR)) 741 return (EINVAL); 742 743 mutex_enter(&tp->tn_tlock); 744 745 get = &tp->tn_attr; 746 /* 747 * Change file access modes. Must be owner or have sufficient 748 * privileges. 749 */ 750 error = secpolicy_vnode_setattr(cred, vp, vap, get, flags, tmp_taccess, 751 tp); 752 753 if (error) 754 goto out; 755 756 mask = vap->va_mask; 757 758 if (mask & AT_MODE) { 759 get->va_mode &= S_IFMT; 760 get->va_mode |= vap->va_mode & ~S_IFMT; 761 } 762 763 if (mask & AT_UID) 764 get->va_uid = vap->va_uid; 765 if (mask & AT_GID) 766 get->va_gid = vap->va_gid; 767 if (mask & AT_ATIME) 768 get->va_atime = vap->va_atime; 769 if (mask & AT_MTIME) 770 get->va_mtime = vap->va_mtime; 771 772 if (mask & (AT_UID | AT_GID | AT_MODE | AT_MTIME)) 773 gethrestime(&tp->tn_ctime); 774 775 if (mask & AT_SIZE) { 776 ASSERT(vp->v_type != VDIR); 777 778 /* Don't support large files. */ 779 if (vap->va_size > MAXOFF_T) { 780 error = EFBIG; 781 goto out; 782 } 783 mutex_exit(&tp->tn_tlock); 784 785 rw_enter(&tp->tn_rwlock, RW_WRITER); 786 rw_enter(&tp->tn_contents, RW_WRITER); 787 error = tmpnode_trunc(tm, tp, (ulong_t)vap->va_size); 788 rw_exit(&tp->tn_contents); 789 rw_exit(&tp->tn_rwlock); 790 791 if (error == 0 && vap->va_size == 0) 792 vnevent_truncate(vp, ct); 793 794 goto out1; 795 } 796 out: 797 mutex_exit(&tp->tn_tlock); 798 out1: 799 return (error); 800 } 801 802 /* ARGSUSED2 */ 803 static int 804 tmp_access( 805 struct vnode *vp, 806 int mode, 807 int flags, 808 struct cred *cred, 809 caller_context_t *ct) 810 { 811 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 812 int error; 813 814 mutex_enter(&tp->tn_tlock); 815 error = tmp_taccess(tp, mode, cred); 816 mutex_exit(&tp->tn_tlock); 817 return (error); 818 } 819 820 /* ARGSUSED3 */ 821 static int 822 tmp_lookup( 823 struct vnode *dvp, 824 char *nm, 825 struct vnode **vpp, 826 struct pathname *pnp, 827 int flags, 828 struct vnode *rdir, 829 struct cred *cred, 830 caller_context_t *ct, 831 int *direntflags, 832 pathname_t *realpnp) 833 { 834 struct tmpnode *tp = (struct tmpnode *)VTOTN(dvp); 835 struct tmpnode *ntp = NULL; 836 int error; 837 838 839 /* allow cd into @ dir */ 840 if (flags & LOOKUP_XATTR) { 841 struct tmpnode *xdp; 842 struct tmount *tm; 843 844 /* 845 * don't allow attributes if not mounted XATTR support 846 */ 847 if (!(dvp->v_vfsp->vfs_flag & VFS_XATTR)) 848 return (EINVAL); 849 850 if (tp->tn_flags & ISXATTR) 851 /* No attributes on attributes */ 852 return (EINVAL); 853 854 rw_enter(&tp->tn_rwlock, RW_WRITER); 855 if (tp->tn_xattrdp == NULL) { 856 if (!(flags & CREATE_XATTR_DIR)) { 857 rw_exit(&tp->tn_rwlock); 858 return (ENOENT); 859 } 860 861 /* 862 * No attribute directory exists for this 863 * node - create the attr dir as a side effect 864 * of this lookup. 865 */ 866 867 /* 868 * Make sure we have adequate permission... 869 */ 870 871 if ((error = tmp_taccess(tp, VWRITE, cred)) != 0) { 872 rw_exit(&tp->tn_rwlock); 873 return (error); 874 } 875 876 xdp = tmp_memalloc(sizeof (struct tmpnode), 877 TMP_MUSTHAVE); 878 tm = VTOTM(dvp); 879 tmpnode_init(tm, xdp, &tp->tn_attr, NULL); 880 /* 881 * Fix-up fields unique to attribute directories. 882 */ 883 xdp->tn_flags = ISXATTR; 884 xdp->tn_type = VDIR; 885 if (tp->tn_type == VDIR) { 886 xdp->tn_mode = tp->tn_attr.va_mode; 887 } else { 888 xdp->tn_mode = 0700; 889 if (tp->tn_attr.va_mode & 0040) 890 xdp->tn_mode |= 0750; 891 if (tp->tn_attr.va_mode & 0004) 892 xdp->tn_mode |= 0705; 893 } 894 xdp->tn_vnode->v_type = VDIR; 895 xdp->tn_vnode->v_flag |= V_XATTRDIR; 896 tdirinit(tp, xdp); 897 tp->tn_xattrdp = xdp; 898 } else { 899 VN_HOLD(tp->tn_xattrdp->tn_vnode); 900 } 901 *vpp = TNTOV(tp->tn_xattrdp); 902 rw_exit(&tp->tn_rwlock); 903 return (0); 904 } 905 906 /* 907 * Null component name is a synonym for directory being searched. 908 */ 909 if (*nm == '\0') { 910 VN_HOLD(dvp); 911 *vpp = dvp; 912 return (0); 913 } 914 ASSERT(tp); 915 916 error = tdirlookup(tp, nm, &ntp, cred); 917 918 if (error == 0) { 919 ASSERT(ntp); 920 *vpp = TNTOV(ntp); 921 /* 922 * If vnode is a device return special vnode instead 923 */ 924 if (IS_DEVVP(*vpp)) { 925 struct vnode *newvp; 926 927 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, 928 cred); 929 VN_RELE(*vpp); 930 *vpp = newvp; 931 } 932 } 933 TRACE_4(TR_FAC_TMPFS, TR_TMPFS_LOOKUP, 934 "tmpfs lookup:vp %p name %s vpp %p error %d", 935 dvp, nm, vpp, error); 936 return (error); 937 } 938 939 /*ARGSUSED7*/ 940 static int 941 tmp_create( 942 struct vnode *dvp, 943 char *nm, 944 struct vattr *vap, 945 enum vcexcl exclusive, 946 int mode, 947 struct vnode **vpp, 948 struct cred *cred, 949 int flag, 950 caller_context_t *ct, 951 vsecattr_t *vsecp) 952 { 953 struct tmpnode *parent; 954 struct tmount *tm; 955 struct tmpnode *self; 956 int error; 957 struct tmpnode *oldtp; 958 959 again: 960 parent = (struct tmpnode *)VTOTN(dvp); 961 tm = (struct tmount *)VTOTM(dvp); 962 self = NULL; 963 error = 0; 964 oldtp = NULL; 965 966 /* device files not allowed in ext. attr dirs */ 967 if ((parent->tn_flags & ISXATTR) && 968 (vap->va_type == VBLK || vap->va_type == VCHR || 969 vap->va_type == VFIFO || vap->va_type == VDOOR || 970 vap->va_type == VSOCK || vap->va_type == VPORT)) 971 return (EINVAL); 972 973 if (vap->va_type == VREG && (vap->va_mode & VSVTX)) { 974 /* Must be privileged to set sticky bit */ 975 if (secpolicy_vnode_stky_modify(cred)) 976 vap->va_mode &= ~VSVTX; 977 } else if (vap->va_type == VNON) { 978 return (EINVAL); 979 } 980 981 /* 982 * Null component name is a synonym for directory being searched. 983 */ 984 if (*nm == '\0') { 985 VN_HOLD(dvp); 986 oldtp = parent; 987 } else { 988 error = tdirlookup(parent, nm, &oldtp, cred); 989 } 990 991 if (error == 0) { /* name found */ 992 boolean_t trunc = B_FALSE; 993 994 ASSERT(oldtp); 995 996 rw_enter(&oldtp->tn_rwlock, RW_WRITER); 997 998 /* 999 * if create/read-only an existing 1000 * directory, allow it 1001 */ 1002 if (exclusive == EXCL) 1003 error = EEXIST; 1004 else if ((oldtp->tn_type == VDIR) && (mode & VWRITE)) 1005 error = EISDIR; 1006 else { 1007 error = tmp_taccess(oldtp, mode, cred); 1008 } 1009 1010 if (error) { 1011 rw_exit(&oldtp->tn_rwlock); 1012 tmpnode_rele(oldtp); 1013 return (error); 1014 } 1015 *vpp = TNTOV(oldtp); 1016 if ((*vpp)->v_type == VREG && (vap->va_mask & AT_SIZE) && 1017 vap->va_size == 0) { 1018 rw_enter(&oldtp->tn_contents, RW_WRITER); 1019 (void) tmpnode_trunc(tm, oldtp, 0); 1020 rw_exit(&oldtp->tn_contents); 1021 trunc = B_TRUE; 1022 } 1023 rw_exit(&oldtp->tn_rwlock); 1024 if (IS_DEVVP(*vpp)) { 1025 struct vnode *newvp; 1026 1027 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, 1028 cred); 1029 VN_RELE(*vpp); 1030 if (newvp == NULL) { 1031 return (ENOSYS); 1032 } 1033 *vpp = newvp; 1034 } 1035 1036 if (trunc) 1037 vnevent_create(*vpp, ct); 1038 1039 return (0); 1040 } 1041 1042 if (error != ENOENT) 1043 return (error); 1044 1045 rw_enter(&parent->tn_rwlock, RW_WRITER); 1046 error = tdirenter(tm, parent, nm, DE_CREATE, 1047 (struct tmpnode *)NULL, (struct tmpnode *)NULL, 1048 vap, &self, cred, ct); 1049 rw_exit(&parent->tn_rwlock); 1050 1051 if (error) { 1052 if (self) 1053 tmpnode_rele(self); 1054 1055 if (error == EEXIST) { 1056 /* 1057 * This means that the file was created sometime 1058 * after we checked and did not find it and when 1059 * we went to create it. 1060 * Since creat() is supposed to truncate a file 1061 * that already exits go back to the begining 1062 * of the function. This time we will find it 1063 * and go down the tmp_trunc() path 1064 */ 1065 goto again; 1066 } 1067 return (error); 1068 } 1069 1070 *vpp = TNTOV(self); 1071 1072 if (!error && IS_DEVVP(*vpp)) { 1073 struct vnode *newvp; 1074 1075 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cred); 1076 VN_RELE(*vpp); 1077 if (newvp == NULL) 1078 return (ENOSYS); 1079 *vpp = newvp; 1080 } 1081 TRACE_3(TR_FAC_TMPFS, TR_TMPFS_CREATE, 1082 "tmpfs create:dvp %p nm %s vpp %p", dvp, nm, vpp); 1083 return (0); 1084 } 1085 1086 /* ARGSUSED3 */ 1087 static int 1088 tmp_remove( 1089 struct vnode *dvp, 1090 char *nm, 1091 struct cred *cred, 1092 caller_context_t *ct, 1093 int flags) 1094 { 1095 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp); 1096 int error; 1097 struct tmpnode *tp = NULL; 1098 1099 error = tdirlookup(parent, nm, &tp, cred); 1100 if (error) 1101 return (error); 1102 1103 ASSERT(tp); 1104 rw_enter(&parent->tn_rwlock, RW_WRITER); 1105 rw_enter(&tp->tn_rwlock, RW_WRITER); 1106 1107 error = (tp->tn_type == VDIR) ? EPERM : 1108 tdirdelete(parent, tp, nm, DR_REMOVE, cred); 1109 1110 rw_exit(&tp->tn_rwlock); 1111 rw_exit(&parent->tn_rwlock); 1112 vnevent_remove(TNTOV(tp), dvp, nm, ct); 1113 tmpnode_rele(tp); 1114 1115 TRACE_3(TR_FAC_TMPFS, TR_TMPFS_REMOVE, 1116 "tmpfs remove:dvp %p nm %s error %d", dvp, nm, error); 1117 return (error); 1118 } 1119 1120 /* ARGSUSED4 */ 1121 static int 1122 tmp_link( 1123 struct vnode *dvp, 1124 struct vnode *srcvp, 1125 char *tnm, 1126 struct cred *cred, 1127 caller_context_t *ct, 1128 int flags) 1129 { 1130 struct tmpnode *parent; 1131 struct tmpnode *from; 1132 struct tmount *tm = (struct tmount *)VTOTM(dvp); 1133 int error; 1134 struct tmpnode *found = NULL; 1135 struct vnode *realvp; 1136 1137 if (VOP_REALVP(srcvp, &realvp, ct) == 0) 1138 srcvp = realvp; 1139 1140 parent = (struct tmpnode *)VTOTN(dvp); 1141 from = (struct tmpnode *)VTOTN(srcvp); 1142 1143 if (srcvp->v_type == VDIR || 1144 (from->tn_uid != crgetuid(cred) && secpolicy_basic_link(cred))) 1145 return (EPERM); 1146 1147 /* 1148 * Make sure link for extended attributes is valid 1149 * We only support hard linking of xattr's in xattrdir to an xattrdir 1150 */ 1151 if ((from->tn_flags & ISXATTR) != (parent->tn_flags & ISXATTR)) 1152 return (EINVAL); 1153 1154 error = tdirlookup(parent, tnm, &found, cred); 1155 if (error == 0) { 1156 ASSERT(found); 1157 tmpnode_rele(found); 1158 return (EEXIST); 1159 } 1160 1161 if (error != ENOENT) 1162 return (error); 1163 1164 rw_enter(&parent->tn_rwlock, RW_WRITER); 1165 error = tdirenter(tm, parent, tnm, DE_LINK, (struct tmpnode *)NULL, 1166 from, NULL, (struct tmpnode **)NULL, cred, ct); 1167 rw_exit(&parent->tn_rwlock); 1168 if (error == 0) { 1169 vnevent_link(srcvp, ct); 1170 } 1171 return (error); 1172 } 1173 1174 /* ARGSUSED5 */ 1175 static int 1176 tmp_rename( 1177 struct vnode *odvp, /* source parent vnode */ 1178 char *onm, /* source name */ 1179 struct vnode *ndvp, /* destination parent vnode */ 1180 char *nnm, /* destination name */ 1181 struct cred *cred, 1182 caller_context_t *ct, 1183 int flags) 1184 { 1185 struct tmpnode *fromparent; 1186 struct tmpnode *toparent; 1187 struct tmpnode *fromtp = NULL; /* source tmpnode */ 1188 struct tmpnode *totp; /* target tmpnode */ 1189 struct tmount *tm = (struct tmount *)VTOTM(odvp); 1190 int error; 1191 int samedir = 0; /* set if odvp == ndvp */ 1192 struct vnode *realvp; 1193 1194 if (VOP_REALVP(ndvp, &realvp, ct) == 0) 1195 ndvp = realvp; 1196 1197 fromparent = (struct tmpnode *)VTOTN(odvp); 1198 toparent = (struct tmpnode *)VTOTN(ndvp); 1199 1200 if ((fromparent->tn_flags & ISXATTR) != (toparent->tn_flags & ISXATTR)) 1201 return (EINVAL); 1202 1203 mutex_enter(&tm->tm_renamelck); 1204 1205 /* 1206 * Look up tmpnode of file we're supposed to rename. 1207 */ 1208 error = tdirlookup(fromparent, onm, &fromtp, cred); 1209 if (error) { 1210 mutex_exit(&tm->tm_renamelck); 1211 return (error); 1212 } 1213 1214 /* 1215 * Make sure we can delete the old (source) entry. This 1216 * requires write permission on the containing directory. If 1217 * that directory is "sticky" it requires further checks. 1218 */ 1219 if (((error = tmp_taccess(fromparent, VWRITE, cred)) != 0) || 1220 (error = tmp_sticky_remove_access(fromparent, fromtp, cred)) != 0) 1221 goto done; 1222 1223 /* 1224 * Check for renaming to or from '.' or '..' or that 1225 * fromtp == fromparent 1226 */ 1227 if ((onm[0] == '.' && 1228 (onm[1] == '\0' || (onm[1] == '.' && onm[2] == '\0'))) || 1229 (nnm[0] == '.' && 1230 (nnm[1] == '\0' || (nnm[1] == '.' && nnm[2] == '\0'))) || 1231 (fromparent == fromtp)) { 1232 error = EINVAL; 1233 goto done; 1234 } 1235 1236 samedir = (fromparent == toparent); 1237 /* 1238 * Make sure we can search and rename into the new 1239 * (destination) directory. 1240 */ 1241 if (!samedir) { 1242 error = tmp_taccess(toparent, VEXEC|VWRITE, cred); 1243 if (error) 1244 goto done; 1245 } 1246 1247 if (tdirlookup(toparent, nnm, &totp, cred) == 0) { 1248 vnevent_pre_rename_dest(TNTOV(totp), ndvp, nnm, ct); 1249 tmpnode_rele(totp); 1250 } 1251 1252 /* Notify the target dir. if not the same as the source dir. */ 1253 if (ndvp != odvp) { 1254 vnevent_pre_rename_dest_dir(ndvp, TNTOV(fromtp), nnm, ct); 1255 } 1256 1257 vnevent_pre_rename_src(TNTOV(fromtp), odvp, onm, ct); 1258 1259 /* 1260 * Link source to new target 1261 */ 1262 rw_enter(&toparent->tn_rwlock, RW_WRITER); 1263 error = tdirenter(tm, toparent, nnm, DE_RENAME, 1264 fromparent, fromtp, (struct vattr *)NULL, 1265 (struct tmpnode **)NULL, cred, ct); 1266 rw_exit(&toparent->tn_rwlock); 1267 1268 if (error) { 1269 /* 1270 * ESAME isn't really an error; it indicates that the 1271 * operation should not be done because the source and target 1272 * are the same file, but that no error should be reported. 1273 */ 1274 if (error == ESAME) 1275 error = 0; 1276 goto done; 1277 } 1278 1279 /* 1280 * Unlink from source. 1281 */ 1282 rw_enter(&fromparent->tn_rwlock, RW_WRITER); 1283 rw_enter(&fromtp->tn_rwlock, RW_WRITER); 1284 1285 error = tdirdelete(fromparent, fromtp, onm, DR_RENAME, cred); 1286 1287 /* 1288 * The following handles the case where our source tmpnode was 1289 * removed before we got to it. 1290 * 1291 * XXX We should also cleanup properly in the case where tdirdelete 1292 * fails for some other reason. Currently this case shouldn't happen. 1293 * (see 1184991). 1294 */ 1295 if (error == ENOENT) 1296 error = 0; 1297 1298 rw_exit(&fromtp->tn_rwlock); 1299 rw_exit(&fromparent->tn_rwlock); 1300 1301 if (error == 0) { 1302 vnevent_rename_src(TNTOV(fromtp), odvp, onm, ct); 1303 /* 1304 * vnevent_rename_dest is called in tdirenter(). 1305 * Notify the target dir if not same as source dir. 1306 */ 1307 if (ndvp != odvp) 1308 vnevent_rename_dest_dir(ndvp, ct); 1309 } 1310 1311 done: 1312 tmpnode_rele(fromtp); 1313 mutex_exit(&tm->tm_renamelck); 1314 1315 TRACE_5(TR_FAC_TMPFS, TR_TMPFS_RENAME, 1316 "tmpfs rename:ovp %p onm %s nvp %p nnm %s error %d", odvp, onm, 1317 ndvp, nnm, error); 1318 return (error); 1319 } 1320 1321 /* ARGSUSED5 */ 1322 static int 1323 tmp_mkdir( 1324 struct vnode *dvp, 1325 char *nm, 1326 struct vattr *va, 1327 struct vnode **vpp, 1328 struct cred *cred, 1329 caller_context_t *ct, 1330 int flags, 1331 vsecattr_t *vsecp) 1332 { 1333 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp); 1334 struct tmpnode *self = NULL; 1335 struct tmount *tm = (struct tmount *)VTOTM(dvp); 1336 int error; 1337 1338 /* no new dirs allowed in xattr dirs */ 1339 if (parent->tn_flags & ISXATTR) 1340 return (EINVAL); 1341 1342 /* 1343 * Might be dangling directory. Catch it here, 1344 * because a ENOENT return from tdirlookup() is 1345 * an "o.k. return". 1346 */ 1347 if (parent->tn_nlink == 0) 1348 return (ENOENT); 1349 1350 error = tdirlookup(parent, nm, &self, cred); 1351 if (error == 0) { 1352 ASSERT(self); 1353 tmpnode_rele(self); 1354 return (EEXIST); 1355 } 1356 if (error != ENOENT) 1357 return (error); 1358 1359 rw_enter(&parent->tn_rwlock, RW_WRITER); 1360 error = tdirenter(tm, parent, nm, DE_MKDIR, (struct tmpnode *)NULL, 1361 (struct tmpnode *)NULL, va, &self, cred, ct); 1362 if (error) { 1363 rw_exit(&parent->tn_rwlock); 1364 if (self) 1365 tmpnode_rele(self); 1366 return (error); 1367 } 1368 rw_exit(&parent->tn_rwlock); 1369 *vpp = TNTOV(self); 1370 return (0); 1371 } 1372 1373 /* ARGSUSED4 */ 1374 static int 1375 tmp_rmdir( 1376 struct vnode *dvp, 1377 char *nm, 1378 struct vnode *cdir, 1379 struct cred *cred, 1380 caller_context_t *ct, 1381 int flags) 1382 { 1383 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp); 1384 struct tmpnode *self = NULL; 1385 struct vnode *vp; 1386 int error = 0; 1387 1388 /* 1389 * Return error when removing . and .. 1390 */ 1391 if (strcmp(nm, ".") == 0) 1392 return (EINVAL); 1393 if (strcmp(nm, "..") == 0) 1394 return (EEXIST); /* Should be ENOTEMPTY */ 1395 error = tdirlookup(parent, nm, &self, cred); 1396 if (error) 1397 return (error); 1398 1399 rw_enter(&parent->tn_rwlock, RW_WRITER); 1400 rw_enter(&self->tn_rwlock, RW_WRITER); 1401 1402 vp = TNTOV(self); 1403 if (vp == dvp || vp == cdir) { 1404 error = EINVAL; 1405 goto done1; 1406 } 1407 if (self->tn_type != VDIR) { 1408 error = ENOTDIR; 1409 goto done1; 1410 } 1411 1412 mutex_enter(&self->tn_tlock); 1413 if (self->tn_nlink > 2) { 1414 mutex_exit(&self->tn_tlock); 1415 error = EEXIST; 1416 goto done1; 1417 } 1418 mutex_exit(&self->tn_tlock); 1419 1420 if (vn_vfswlock(vp)) { 1421 error = EBUSY; 1422 goto done1; 1423 } 1424 if (vn_mountedvfs(vp) != NULL) { 1425 error = EBUSY; 1426 goto done; 1427 } 1428 1429 /* 1430 * Check for an empty directory 1431 * i.e. only includes entries for "." and ".." 1432 */ 1433 if (self->tn_dirents > 2) { 1434 error = EEXIST; /* SIGH should be ENOTEMPTY */ 1435 /* 1436 * Update atime because checking tn_dirents is logically 1437 * equivalent to reading the directory 1438 */ 1439 gethrestime(&self->tn_atime); 1440 goto done; 1441 } 1442 1443 error = tdirdelete(parent, self, nm, DR_RMDIR, cred); 1444 done: 1445 vn_vfsunlock(vp); 1446 done1: 1447 rw_exit(&self->tn_rwlock); 1448 rw_exit(&parent->tn_rwlock); 1449 vnevent_rmdir(TNTOV(self), dvp, nm, ct); 1450 tmpnode_rele(self); 1451 1452 return (error); 1453 } 1454 1455 /* ARGSUSED2 */ 1456 static int 1457 tmp_readdir( 1458 struct vnode *vp, 1459 struct uio *uiop, 1460 struct cred *cred, 1461 int *eofp, 1462 caller_context_t *ct, 1463 int flags) 1464 { 1465 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 1466 struct tdirent *tdp; 1467 int error = 0; 1468 size_t namelen; 1469 struct dirent64 *dp; 1470 ulong_t offset; 1471 ulong_t total_bytes_wanted; 1472 long outcount = 0; 1473 long bufsize; 1474 int reclen; 1475 caddr_t outbuf; 1476 1477 if (uiop->uio_loffset >= MAXOFF_T) { 1478 if (eofp) 1479 *eofp = 1; 1480 return (0); 1481 } 1482 /* 1483 * assuming system call has already called tmp_rwlock 1484 */ 1485 ASSERT(RW_READ_HELD(&tp->tn_rwlock)); 1486 1487 if (uiop->uio_iovcnt != 1) 1488 return (EINVAL); 1489 1490 if (vp->v_type != VDIR) 1491 return (ENOTDIR); 1492 1493 /* 1494 * There's a window here where someone could have removed 1495 * all the entries in the directory after we put a hold on the 1496 * vnode but before we grabbed the rwlock. Just return. 1497 */ 1498 if (tp->tn_dir == NULL) { 1499 if (tp->tn_nlink) { 1500 panic("empty directory 0x%p", (void *)tp); 1501 /*NOTREACHED*/ 1502 } 1503 return (0); 1504 } 1505 1506 /* 1507 * Get space for multiple directory entries 1508 */ 1509 total_bytes_wanted = uiop->uio_iov->iov_len; 1510 bufsize = total_bytes_wanted + sizeof (struct dirent64); 1511 outbuf = kmem_alloc(bufsize, KM_SLEEP); 1512 1513 dp = (struct dirent64 *)outbuf; 1514 1515 1516 offset = 0; 1517 tdp = tp->tn_dir; 1518 while (tdp) { 1519 namelen = strlen(tdp->td_name); /* no +1 needed */ 1520 offset = tdp->td_offset; 1521 if (offset >= uiop->uio_offset) { 1522 reclen = (int)DIRENT64_RECLEN(namelen); 1523 if (outcount + reclen > total_bytes_wanted) { 1524 if (!outcount) 1525 /* 1526 * Buffer too small for any entries. 1527 */ 1528 error = EINVAL; 1529 break; 1530 } 1531 ASSERT(tdp->td_tmpnode != NULL); 1532 1533 /* use strncpy(9f) to zero out uninitialized bytes */ 1534 1535 (void) strncpy(dp->d_name, tdp->td_name, 1536 DIRENT64_NAMELEN(reclen)); 1537 dp->d_reclen = (ushort_t)reclen; 1538 dp->d_ino = (ino64_t)tdp->td_tmpnode->tn_nodeid; 1539 dp->d_off = (offset_t)tdp->td_offset + 1; 1540 dp = (struct dirent64 *) 1541 ((uintptr_t)dp + dp->d_reclen); 1542 outcount += reclen; 1543 ASSERT(outcount <= bufsize); 1544 } 1545 tdp = tdp->td_next; 1546 } 1547 1548 if (!error) 1549 error = uiomove(outbuf, outcount, UIO_READ, uiop); 1550 1551 if (!error) { 1552 /* If we reached the end of the list our offset */ 1553 /* should now be just past the end. */ 1554 if (!tdp) { 1555 offset += 1; 1556 if (eofp) 1557 *eofp = 1; 1558 } else if (eofp) 1559 *eofp = 0; 1560 uiop->uio_offset = offset; 1561 } 1562 gethrestime(&tp->tn_atime); 1563 kmem_free(outbuf, bufsize); 1564 return (error); 1565 } 1566 1567 /* ARGSUSED5 */ 1568 static int 1569 tmp_symlink( 1570 struct vnode *dvp, 1571 char *lnm, 1572 struct vattr *tva, 1573 char *tnm, 1574 struct cred *cred, 1575 caller_context_t *ct, 1576 int flags) 1577 { 1578 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp); 1579 struct tmpnode *self = (struct tmpnode *)NULL; 1580 struct tmount *tm = (struct tmount *)VTOTM(dvp); 1581 char *cp = NULL; 1582 int error; 1583 size_t len; 1584 1585 /* no symlinks allowed to files in xattr dirs */ 1586 if (parent->tn_flags & ISXATTR) 1587 return (EINVAL); 1588 1589 error = tdirlookup(parent, lnm, &self, cred); 1590 if (error == 0) { 1591 /* 1592 * The entry already exists 1593 */ 1594 tmpnode_rele(self); 1595 return (EEXIST); /* was 0 */ 1596 } 1597 1598 if (error != ENOENT) { 1599 if (self != NULL) 1600 tmpnode_rele(self); 1601 return (error); 1602 } 1603 1604 rw_enter(&parent->tn_rwlock, RW_WRITER); 1605 error = tdirenter(tm, parent, lnm, DE_CREATE, (struct tmpnode *)NULL, 1606 (struct tmpnode *)NULL, tva, &self, cred, ct); 1607 rw_exit(&parent->tn_rwlock); 1608 1609 if (error) { 1610 if (self) 1611 tmpnode_rele(self); 1612 return (error); 1613 } 1614 len = strlen(tnm) + 1; 1615 cp = tmp_memalloc(len, 0); 1616 if (cp == NULL) { 1617 tmpnode_rele(self); 1618 return (ENOSPC); 1619 } 1620 (void) strcpy(cp, tnm); 1621 1622 self->tn_symlink = cp; 1623 self->tn_size = len - 1; 1624 tmpnode_rele(self); 1625 return (error); 1626 } 1627 1628 /* ARGSUSED2 */ 1629 static int 1630 tmp_readlink( 1631 struct vnode *vp, 1632 struct uio *uiop, 1633 struct cred *cred, 1634 caller_context_t *ct) 1635 { 1636 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 1637 int error = 0; 1638 1639 if (vp->v_type != VLNK) 1640 return (EINVAL); 1641 1642 rw_enter(&tp->tn_rwlock, RW_READER); 1643 rw_enter(&tp->tn_contents, RW_READER); 1644 error = uiomove(tp->tn_symlink, tp->tn_size, UIO_READ, uiop); 1645 gethrestime(&tp->tn_atime); 1646 rw_exit(&tp->tn_contents); 1647 rw_exit(&tp->tn_rwlock); 1648 return (error); 1649 } 1650 1651 /* ARGSUSED */ 1652 static int 1653 tmp_fsync( 1654 struct vnode *vp, 1655 int syncflag, 1656 struct cred *cred, 1657 caller_context_t *ct) 1658 { 1659 return (0); 1660 } 1661 1662 /* ARGSUSED */ 1663 static void 1664 tmp_inactive(struct vnode *vp, struct cred *cred, caller_context_t *ct) 1665 { 1666 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 1667 struct tmount *tm = (struct tmount *)VFSTOTM(vp->v_vfsp); 1668 1669 rw_enter(&tp->tn_rwlock, RW_WRITER); 1670 top: 1671 mutex_enter(&tp->tn_tlock); 1672 mutex_enter(&vp->v_lock); 1673 ASSERT(vp->v_count >= 1); 1674 1675 /* 1676 * If we don't have the last hold or the link count is non-zero, 1677 * there's little to do -- just drop our hold. 1678 */ 1679 if (vp->v_count > 1 || tp->tn_nlink != 0) { 1680 VN_RELE_LOCKED(vp); 1681 mutex_exit(&vp->v_lock); 1682 mutex_exit(&tp->tn_tlock); 1683 rw_exit(&tp->tn_rwlock); 1684 return; 1685 } 1686 1687 /* 1688 * We have the last hold *and* the link count is zero, so this 1689 * tmpnode is dead from the filesystem's viewpoint. However, 1690 * if the tmpnode has any pages associated with it (i.e. if it's 1691 * a normal file with non-zero size), the tmpnode can still be 1692 * discovered by pageout or fsflush via the page vnode pointers. 1693 * In this case we must drop all our locks, truncate the tmpnode, 1694 * and try the whole dance again. 1695 */ 1696 if (tp->tn_size != 0) { 1697 if (tp->tn_type == VREG) { 1698 mutex_exit(&vp->v_lock); 1699 mutex_exit(&tp->tn_tlock); 1700 rw_enter(&tp->tn_contents, RW_WRITER); 1701 (void) tmpnode_trunc(tm, tp, 0); 1702 rw_exit(&tp->tn_contents); 1703 ASSERT(tp->tn_size == 0); 1704 ASSERT(tp->tn_nblocks == 0); 1705 goto top; 1706 } 1707 if (tp->tn_type == VLNK) 1708 tmp_memfree(tp->tn_symlink, tp->tn_size + 1); 1709 } 1710 1711 /* 1712 * Remove normal file/dir's xattr dir and xattrs. 1713 */ 1714 if (tp->tn_xattrdp) { 1715 struct tmpnode *xtp = tp->tn_xattrdp; 1716 1717 ASSERT(xtp->tn_flags & ISXATTR); 1718 tmpnode_hold(xtp); 1719 rw_enter(&xtp->tn_rwlock, RW_WRITER); 1720 tdirtrunc(xtp); 1721 DECR_COUNT(&xtp->tn_nlink, &xtp->tn_tlock); 1722 tp->tn_xattrdp = NULL; 1723 rw_exit(&xtp->tn_rwlock); 1724 tmpnode_rele(xtp); 1725 } 1726 1727 mutex_exit(&vp->v_lock); 1728 mutex_exit(&tp->tn_tlock); 1729 /* Here's our chance to send invalid event while we're between locks */ 1730 vn_invalid(TNTOV(tp)); 1731 mutex_enter(&tm->tm_contents); 1732 if (tp->tn_forw == NULL) 1733 tm->tm_rootnode->tn_back = tp->tn_back; 1734 else 1735 tp->tn_forw->tn_back = tp->tn_back; 1736 tp->tn_back->tn_forw = tp->tn_forw; 1737 mutex_exit(&tm->tm_contents); 1738 rw_exit(&tp->tn_rwlock); 1739 rw_destroy(&tp->tn_rwlock); 1740 mutex_destroy(&tp->tn_tlock); 1741 vn_free(TNTOV(tp)); 1742 tmp_memfree(tp, sizeof (struct tmpnode)); 1743 } 1744 1745 /* ARGSUSED2 */ 1746 static int 1747 tmp_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ct) 1748 { 1749 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 1750 struct tfid *tfid; 1751 1752 if (fidp->fid_len < (sizeof (struct tfid) - sizeof (ushort_t))) { 1753 fidp->fid_len = sizeof (struct tfid) - sizeof (ushort_t); 1754 return (ENOSPC); 1755 } 1756 1757 tfid = (struct tfid *)fidp; 1758 bzero(tfid, sizeof (struct tfid)); 1759 tfid->tfid_len = (int)sizeof (struct tfid) - sizeof (ushort_t); 1760 1761 tfid->tfid_ino = tp->tn_nodeid; 1762 tfid->tfid_gen = tp->tn_gen; 1763 1764 return (0); 1765 } 1766 1767 1768 /* 1769 * Return all the pages from [off..off+len] in given file 1770 */ 1771 /* ARGSUSED */ 1772 static int 1773 tmp_getpage( 1774 struct vnode *vp, 1775 offset_t off, 1776 size_t len, 1777 uint_t *protp, 1778 page_t *pl[], 1779 size_t plsz, 1780 struct seg *seg, 1781 caddr_t addr, 1782 enum seg_rw rw, 1783 struct cred *cr, 1784 caller_context_t *ct) 1785 { 1786 int err = 0; 1787 struct tmpnode *tp = VTOTN(vp); 1788 anoff_t toff = (anoff_t)off; 1789 size_t tlen = len; 1790 u_offset_t tmpoff; 1791 timestruc_t now; 1792 1793 rw_enter(&tp->tn_contents, RW_READER); 1794 1795 if (off + len > tp->tn_size + PAGEOFFSET) { 1796 err = EFAULT; 1797 goto out; 1798 } 1799 /* 1800 * Look for holes (no anon slot) in faulting range. If there are 1801 * holes we have to switch to a write lock and fill them in. Swap 1802 * space for holes was already reserved when the file was grown. 1803 */ 1804 tmpoff = toff; 1805 if (non_anon(tp->tn_anon, btop(off), &tmpoff, &tlen)) { 1806 if (!rw_tryupgrade(&tp->tn_contents)) { 1807 rw_exit(&tp->tn_contents); 1808 rw_enter(&tp->tn_contents, RW_WRITER); 1809 /* Size may have changed when lock was dropped */ 1810 if (off + len > tp->tn_size + PAGEOFFSET) { 1811 err = EFAULT; 1812 goto out; 1813 } 1814 } 1815 for (toff = (anoff_t)off; toff < (anoff_t)off + len; 1816 toff += PAGESIZE) { 1817 if (anon_get_ptr(tp->tn_anon, btop(toff)) == NULL) { 1818 /* XXX - may allocate mem w. write lock held */ 1819 (void) anon_set_ptr(tp->tn_anon, btop(toff), 1820 anon_alloc(vp, toff), ANON_SLEEP); 1821 tp->tn_nblocks++; 1822 } 1823 } 1824 rw_downgrade(&tp->tn_contents); 1825 } 1826 1827 1828 err = pvn_getpages(tmp_getapage, vp, (u_offset_t)off, len, protp, 1829 pl, plsz, seg, addr, rw, cr); 1830 1831 gethrestime(&now); 1832 tp->tn_atime = now; 1833 if (rw == S_WRITE) 1834 tp->tn_mtime = now; 1835 1836 out: 1837 rw_exit(&tp->tn_contents); 1838 return (err); 1839 } 1840 1841 /* 1842 * Called from pvn_getpages to get a particular page. 1843 */ 1844 /*ARGSUSED*/ 1845 static int 1846 tmp_getapage( 1847 struct vnode *vp, 1848 u_offset_t off, 1849 size_t len, 1850 uint_t *protp, 1851 page_t *pl[], 1852 size_t plsz, 1853 struct seg *seg, 1854 caddr_t addr, 1855 enum seg_rw rw, 1856 struct cred *cr) 1857 { 1858 struct page *pp; 1859 int flags; 1860 int err = 0; 1861 struct vnode *pvp; 1862 u_offset_t poff; 1863 1864 if (protp != NULL) 1865 *protp = PROT_ALL; 1866 again: 1867 if (pp = page_lookup(vp, off, rw == S_CREATE ? SE_EXCL : SE_SHARED)) { 1868 if (pl) { 1869 pl[0] = pp; 1870 pl[1] = NULL; 1871 } else { 1872 page_unlock(pp); 1873 } 1874 } else { 1875 pp = page_create_va(vp, off, PAGESIZE, 1876 PG_WAIT | PG_EXCL, seg, addr); 1877 /* 1878 * Someone raced in and created the page after we did the 1879 * lookup but before we did the create, so go back and 1880 * try to look it up again. 1881 */ 1882 if (pp == NULL) 1883 goto again; 1884 /* 1885 * Fill page from backing store, if any. If none, then 1886 * either this is a newly filled hole or page must have 1887 * been unmodified and freed so just zero it out. 1888 */ 1889 err = swap_getphysname(vp, off, &pvp, &poff); 1890 if (err) { 1891 panic("tmp_getapage: no anon slot vp %p " 1892 "off %llx pp %p\n", (void *)vp, off, (void *)pp); 1893 } 1894 if (pvp) { 1895 flags = (pl == NULL ? B_ASYNC|B_READ : B_READ); 1896 err = VOP_PAGEIO(pvp, pp, (u_offset_t)poff, PAGESIZE, 1897 flags, cr, NULL); 1898 if (flags & B_ASYNC) 1899 pp = NULL; 1900 } else if (rw != S_CREATE) { 1901 pagezero(pp, 0, PAGESIZE); 1902 } 1903 if (err && pp) 1904 pvn_read_done(pp, B_ERROR); 1905 if (err == 0) { 1906 if (pl) 1907 pvn_plist_init(pp, pl, plsz, off, PAGESIZE, rw); 1908 else 1909 pvn_io_done(pp); 1910 } 1911 } 1912 return (err); 1913 } 1914 1915 1916 /* 1917 * Flags are composed of {B_INVAL, B_DIRTY B_FREE, B_DONTNEED}. 1918 * If len == 0, do from off to EOF. 1919 */ 1920 static int tmp_nopage = 0; /* Don't do tmp_putpage's if set */ 1921 1922 /* ARGSUSED */ 1923 int 1924 tmp_putpage( 1925 register struct vnode *vp, 1926 offset_t off, 1927 size_t len, 1928 int flags, 1929 struct cred *cr, 1930 caller_context_t *ct) 1931 { 1932 register page_t *pp; 1933 u_offset_t io_off; 1934 size_t io_len = 0; 1935 int err = 0; 1936 struct tmpnode *tp = VTOTN(vp); 1937 int dolock; 1938 1939 if (tmp_nopage) 1940 return (0); 1941 1942 ASSERT(vp->v_count != 0); 1943 1944 if (vp->v_flag & VNOMAP) 1945 return (ENOSYS); 1946 1947 /* 1948 * This being tmpfs, we don't ever do i/o unless we really 1949 * have to (when we're low on memory and pageout calls us 1950 * with B_ASYNC | B_FREE or the user explicitly asks for it with 1951 * B_DONTNEED). 1952 * XXX to approximately track the mod time like ufs we should 1953 * update the times here. The problem is, once someone does a 1954 * store we never clear the mod bit and do i/o, thus fsflush 1955 * will keep calling us every 30 seconds to do the i/o and we'll 1956 * continually update the mod time. At least we update the mod 1957 * time on the first store because this results in a call to getpage. 1958 */ 1959 if (flags != (B_ASYNC | B_FREE) && (flags & B_INVAL) == 0 && 1960 (flags & B_DONTNEED) == 0) 1961 return (0); 1962 /* 1963 * If this thread owns the lock, i.e., this thread grabbed it 1964 * as writer somewhere above, then we don't need to grab the 1965 * lock as reader in this routine. 1966 */ 1967 dolock = (rw_owner(&tp->tn_contents) != curthread); 1968 1969 /* 1970 * If this is pageout don't block on the lock as you could deadlock 1971 * when freemem == 0 (another thread has the read lock and is blocked 1972 * creating a page, and a third thread is waiting to get the writers 1973 * lock - waiting writers priority blocks us from getting the read 1974 * lock). Of course, if the only freeable pages are on this tmpnode 1975 * we're hosed anyways. A better solution might be a new lock type. 1976 * Note: ufs has the same problem. 1977 */ 1978 if (curproc == proc_pageout) { 1979 if (!rw_tryenter(&tp->tn_contents, RW_READER)) 1980 return (ENOMEM); 1981 } else if (dolock) 1982 rw_enter(&tp->tn_contents, RW_READER); 1983 1984 if (!vn_has_cached_data(vp)) 1985 goto out; 1986 1987 if (len == 0) { 1988 if (curproc == proc_pageout) { 1989 panic("tmp: pageout can't block"); 1990 /*NOTREACHED*/ 1991 } 1992 1993 /* Search the entire vp list for pages >= off. */ 1994 err = pvn_vplist_dirty(vp, (u_offset_t)off, tmp_putapage, 1995 flags, cr); 1996 } else { 1997 u_offset_t eoff; 1998 1999 /* 2000 * Loop over all offsets in the range [off...off + len] 2001 * looking for pages to deal with. 2002 */ 2003 eoff = MIN(off + len, tp->tn_size); 2004 for (io_off = off; io_off < eoff; io_off += io_len) { 2005 /* 2006 * If we are not invalidating, synchronously 2007 * freeing or writing pages use the routine 2008 * page_lookup_nowait() to prevent reclaiming 2009 * them from the free list. 2010 */ 2011 if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) { 2012 pp = page_lookup(vp, io_off, 2013 (flags & (B_INVAL | B_FREE)) ? 2014 SE_EXCL : SE_SHARED); 2015 } else { 2016 pp = page_lookup_nowait(vp, io_off, 2017 (flags & B_FREE) ? SE_EXCL : SE_SHARED); 2018 } 2019 2020 if (pp == NULL || pvn_getdirty(pp, flags) == 0) 2021 io_len = PAGESIZE; 2022 else { 2023 err = tmp_putapage(vp, pp, &io_off, &io_len, 2024 flags, cr); 2025 if (err != 0) 2026 break; 2027 } 2028 } 2029 } 2030 /* If invalidating, verify all pages on vnode list are gone. */ 2031 if (err == 0 && off == 0 && len == 0 && 2032 (flags & B_INVAL) && vn_has_cached_data(vp)) { 2033 panic("tmp_putpage: B_INVAL, pages not gone"); 2034 /*NOTREACHED*/ 2035 } 2036 out: 2037 if ((curproc == proc_pageout) || dolock) 2038 rw_exit(&tp->tn_contents); 2039 /* 2040 * Only reason putapage is going to give us SE_NOSWAP as error 2041 * is when we ask a page to be written to physical backing store 2042 * and there is none. Ignore this because we might be dealing 2043 * with a swap page which does not have any backing store 2044 * on disk. In any other case we won't get this error over here. 2045 */ 2046 if (err == SE_NOSWAP) 2047 err = 0; 2048 return (err); 2049 } 2050 2051 long tmp_putpagecnt, tmp_pagespushed; 2052 2053 /* 2054 * Write out a single page. 2055 * For tmpfs this means choose a physical swap slot and write the page 2056 * out using VOP_PAGEIO. For performance, we attempt to kluster; i.e., 2057 * we try to find a bunch of other dirty pages adjacent in the file 2058 * and a bunch of contiguous swap slots, and then write all the pages 2059 * out in a single i/o. 2060 */ 2061 /*ARGSUSED*/ 2062 static int 2063 tmp_putapage( 2064 struct vnode *vp, 2065 page_t *pp, 2066 u_offset_t *offp, 2067 size_t *lenp, 2068 int flags, 2069 struct cred *cr) 2070 { 2071 int err; 2072 ulong_t klstart, kllen; 2073 page_t *pplist, *npplist; 2074 extern int klustsize; 2075 long tmp_klustsize; 2076 struct tmpnode *tp; 2077 size_t pp_off, pp_len; 2078 u_offset_t io_off; 2079 size_t io_len; 2080 struct vnode *pvp; 2081 u_offset_t pstart; 2082 u_offset_t offset; 2083 u_offset_t tmpoff; 2084 2085 ASSERT(PAGE_LOCKED(pp)); 2086 2087 /* Kluster in tmp_klustsize chunks */ 2088 tp = VTOTN(vp); 2089 tmp_klustsize = klustsize; 2090 offset = pp->p_offset; 2091 klstart = (offset / tmp_klustsize) * tmp_klustsize; 2092 kllen = MIN(tmp_klustsize, tp->tn_size - klstart); 2093 2094 /* Get a kluster of pages */ 2095 pplist = 2096 pvn_write_kluster(vp, pp, &tmpoff, &pp_len, klstart, kllen, flags); 2097 2098 pp_off = (size_t)tmpoff; 2099 2100 /* 2101 * Get a cluster of physical offsets for the pages; the amount we 2102 * get may be some subrange of what we ask for (io_off, io_len). 2103 */ 2104 io_off = pp_off; 2105 io_len = pp_len; 2106 err = swap_newphysname(vp, offset, &io_off, &io_len, &pvp, &pstart); 2107 ASSERT(err != SE_NOANON); /* anon slot must have been filled */ 2108 if (err) { 2109 pvn_write_done(pplist, B_ERROR | B_WRITE | flags); 2110 /* 2111 * If this routine is called as a result of segvn_sync 2112 * operation and we have no physical swap then we can get an 2113 * error here. In such case we would return SE_NOSWAP as error. 2114 * At this point, we expect only SE_NOSWAP. 2115 */ 2116 ASSERT(err == SE_NOSWAP); 2117 if (flags & B_INVAL) 2118 err = ENOMEM; 2119 goto out; 2120 } 2121 ASSERT(pp_off <= io_off && io_off + io_len <= pp_off + pp_len); 2122 ASSERT(io_off <= offset && offset < io_off + io_len); 2123 2124 /* Toss pages at front/rear that we couldn't get physical backing for */ 2125 if (io_off != pp_off) { 2126 npplist = NULL; 2127 page_list_break(&pplist, &npplist, btop(io_off - pp_off)); 2128 ASSERT(pplist->p_offset == pp_off); 2129 ASSERT(pplist->p_prev->p_offset == io_off - PAGESIZE); 2130 pvn_write_done(pplist, B_ERROR | B_WRITE | flags); 2131 pplist = npplist; 2132 } 2133 if (io_off + io_len < pp_off + pp_len) { 2134 npplist = NULL; 2135 page_list_break(&pplist, &npplist, btop(io_len)); 2136 ASSERT(npplist->p_offset == io_off + io_len); 2137 ASSERT(npplist->p_prev->p_offset == pp_off + pp_len - PAGESIZE); 2138 pvn_write_done(npplist, B_ERROR | B_WRITE | flags); 2139 } 2140 2141 ASSERT(pplist->p_offset == io_off); 2142 ASSERT(pplist->p_prev->p_offset == io_off + io_len - PAGESIZE); 2143 ASSERT(btopr(io_len) <= btopr(kllen)); 2144 2145 /* Do i/o on the remaining kluster */ 2146 err = VOP_PAGEIO(pvp, pplist, (u_offset_t)pstart, io_len, 2147 B_WRITE | flags, cr, NULL); 2148 2149 if ((flags & B_ASYNC) == 0) { 2150 pvn_write_done(pplist, ((err) ? B_ERROR : 0) | B_WRITE | flags); 2151 } 2152 out: 2153 if (!err) { 2154 if (offp) 2155 *offp = io_off; 2156 if (lenp) 2157 *lenp = io_len; 2158 tmp_putpagecnt++; 2159 tmp_pagespushed += btop(io_len); 2160 } 2161 if (err && err != ENOMEM && err != SE_NOSWAP) 2162 cmn_err(CE_WARN, "tmp_putapage: err %d\n", err); 2163 return (err); 2164 } 2165 2166 /* ARGSUSED */ 2167 static int 2168 tmp_map( 2169 struct vnode *vp, 2170 offset_t off, 2171 struct as *as, 2172 caddr_t *addrp, 2173 size_t len, 2174 uchar_t prot, 2175 uchar_t maxprot, 2176 uint_t flags, 2177 struct cred *cred, 2178 caller_context_t *ct) 2179 { 2180 struct segvn_crargs vn_a; 2181 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp); 2182 int error; 2183 2184 #ifdef _ILP32 2185 if (len > MAXOFF_T) 2186 return (ENOMEM); 2187 #endif 2188 2189 if (vp->v_flag & VNOMAP) 2190 return (ENOSYS); 2191 2192 if (off < 0 || (offset_t)(off + len) < 0 || 2193 off > MAXOFF_T || (off + len) > MAXOFF_T) 2194 return (ENXIO); 2195 2196 if (vp->v_type != VREG) 2197 return (ENODEV); 2198 2199 /* 2200 * Don't allow mapping to locked file 2201 */ 2202 if (vn_has_mandatory_locks(vp, tp->tn_mode)) { 2203 return (EAGAIN); 2204 } 2205 2206 as_rangelock(as); 2207 error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags); 2208 if (error != 0) { 2209 as_rangeunlock(as); 2210 return (error); 2211 } 2212 2213 vn_a.vp = vp; 2214 vn_a.offset = (u_offset_t)off; 2215 vn_a.type = flags & MAP_TYPE; 2216 vn_a.prot = prot; 2217 vn_a.maxprot = maxprot; 2218 vn_a.flags = flags & ~MAP_TYPE; 2219 vn_a.cred = cred; 2220 vn_a.amp = NULL; 2221 vn_a.szc = 0; 2222 vn_a.lgrp_mem_policy_flags = 0; 2223 2224 error = as_map(as, *addrp, len, segvn_create, &vn_a); 2225 as_rangeunlock(as); 2226 return (error); 2227 } 2228 2229 /* 2230 * tmp_addmap and tmp_delmap can't be called since the vp 2231 * maintained in the segvn mapping is NULL. 2232 */ 2233 /* ARGSUSED */ 2234 static int 2235 tmp_addmap( 2236 struct vnode *vp, 2237 offset_t off, 2238 struct as *as, 2239 caddr_t addr, 2240 size_t len, 2241 uchar_t prot, 2242 uchar_t maxprot, 2243 uint_t flags, 2244 struct cred *cred, 2245 caller_context_t *ct) 2246 { 2247 return (0); 2248 } 2249 2250 /* ARGSUSED */ 2251 static int 2252 tmp_delmap( 2253 struct vnode *vp, 2254 offset_t off, 2255 struct as *as, 2256 caddr_t addr, 2257 size_t len, 2258 uint_t prot, 2259 uint_t maxprot, 2260 uint_t flags, 2261 struct cred *cred, 2262 caller_context_t *ct) 2263 { 2264 return (0); 2265 } 2266 2267 static int 2268 tmp_freesp(struct vnode *vp, struct flock64 *lp, int flag) 2269 { 2270 register int i; 2271 register struct tmpnode *tp = VTOTN(vp); 2272 int error; 2273 2274 ASSERT(vp->v_type == VREG); 2275 ASSERT(lp->l_start >= 0); 2276 2277 if (lp->l_len != 0) 2278 return (EINVAL); 2279 2280 rw_enter(&tp->tn_rwlock, RW_WRITER); 2281 if (tp->tn_size == lp->l_start) { 2282 rw_exit(&tp->tn_rwlock); 2283 return (0); 2284 } 2285 2286 /* 2287 * Check for any mandatory locks on the range 2288 */ 2289 if (MANDLOCK(vp, tp->tn_mode)) { 2290 long save_start; 2291 2292 save_start = lp->l_start; 2293 2294 if (tp->tn_size < lp->l_start) { 2295 /* 2296 * "Truncate up" case: need to make sure there 2297 * is no lock beyond current end-of-file. To 2298 * do so, we need to set l_start to the size 2299 * of the file temporarily. 2300 */ 2301 lp->l_start = tp->tn_size; 2302 } 2303 lp->l_type = F_WRLCK; 2304 lp->l_sysid = 0; 2305 lp->l_pid = ttoproc(curthread)->p_pid; 2306 i = (flag & (FNDELAY|FNONBLOCK)) ? 0 : SLPFLCK; 2307 if ((i = reclock(vp, lp, i, 0, lp->l_start, NULL)) != 0 || 2308 lp->l_type != F_UNLCK) { 2309 rw_exit(&tp->tn_rwlock); 2310 return (i ? i : EAGAIN); 2311 } 2312 2313 lp->l_start = save_start; 2314 } 2315 VFSTOTM(vp->v_vfsp); 2316 2317 rw_enter(&tp->tn_contents, RW_WRITER); 2318 error = tmpnode_trunc((struct tmount *)VFSTOTM(vp->v_vfsp), 2319 tp, (ulong_t)lp->l_start); 2320 rw_exit(&tp->tn_contents); 2321 rw_exit(&tp->tn_rwlock); 2322 return (error); 2323 } 2324 2325 /* ARGSUSED */ 2326 static int 2327 tmp_space( 2328 struct vnode *vp, 2329 int cmd, 2330 struct flock64 *bfp, 2331 int flag, 2332 offset_t offset, 2333 cred_t *cred, 2334 caller_context_t *ct) 2335 { 2336 int error; 2337 2338 if (cmd != F_FREESP) 2339 return (EINVAL); 2340 if ((error = convoff(vp, bfp, 0, (offset_t)offset)) == 0) { 2341 if ((bfp->l_start > MAXOFF_T) || (bfp->l_len > MAXOFF_T)) 2342 return (EFBIG); 2343 error = tmp_freesp(vp, bfp, flag); 2344 2345 if (error == 0 && bfp->l_start == 0) 2346 vnevent_truncate(vp, ct); 2347 } 2348 return (error); 2349 } 2350 2351 /* ARGSUSED */ 2352 static int 2353 tmp_seek( 2354 struct vnode *vp, 2355 offset_t ooff, 2356 offset_t *noffp, 2357 caller_context_t *ct) 2358 { 2359 return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0); 2360 } 2361 2362 /* ARGSUSED2 */ 2363 static int 2364 tmp_rwlock(struct vnode *vp, int write_lock, caller_context_t *ctp) 2365 { 2366 struct tmpnode *tp = VTOTN(vp); 2367 2368 if (write_lock) { 2369 rw_enter(&tp->tn_rwlock, RW_WRITER); 2370 } else { 2371 rw_enter(&tp->tn_rwlock, RW_READER); 2372 } 2373 return (write_lock); 2374 } 2375 2376 /* ARGSUSED1 */ 2377 static void 2378 tmp_rwunlock(struct vnode *vp, int write_lock, caller_context_t *ctp) 2379 { 2380 struct tmpnode *tp = VTOTN(vp); 2381 2382 rw_exit(&tp->tn_rwlock); 2383 } 2384 2385 static int 2386 tmp_pathconf( 2387 struct vnode *vp, 2388 int cmd, 2389 ulong_t *valp, 2390 cred_t *cr, 2391 caller_context_t *ct) 2392 { 2393 struct tmpnode *tp = NULL; 2394 int error; 2395 2396 switch (cmd) { 2397 case _PC_XATTR_EXISTS: 2398 if (vp->v_vfsp->vfs_flag & VFS_XATTR) { 2399 *valp = 0; /* assume no attributes */ 2400 error = 0; /* okay to ask */ 2401 tp = VTOTN(vp); 2402 rw_enter(&tp->tn_rwlock, RW_READER); 2403 if (tp->tn_xattrdp) { 2404 rw_enter(&tp->tn_xattrdp->tn_rwlock, RW_READER); 2405 /* do not count "." and ".." */ 2406 if (tp->tn_xattrdp->tn_dirents > 2) 2407 *valp = 1; 2408 rw_exit(&tp->tn_xattrdp->tn_rwlock); 2409 } 2410 rw_exit(&tp->tn_rwlock); 2411 } else { 2412 error = EINVAL; 2413 } 2414 break; 2415 case _PC_SATTR_ENABLED: 2416 case _PC_SATTR_EXISTS: 2417 *valp = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) && 2418 (vp->v_type == VREG || vp->v_type == VDIR); 2419 error = 0; 2420 break; 2421 case _PC_TIMESTAMP_RESOLUTION: 2422 /* nanosecond timestamp resolution */ 2423 *valp = 1L; 2424 error = 0; 2425 break; 2426 default: 2427 error = fs_pathconf(vp, cmd, valp, cr, ct); 2428 } 2429 return (error); 2430 } 2431 2432 2433 struct vnodeops *tmp_vnodeops; 2434 2435 const fs_operation_def_t tmp_vnodeops_template[] = { 2436 VOPNAME_OPEN, { .vop_open = tmp_open }, 2437 VOPNAME_CLOSE, { .vop_close = tmp_close }, 2438 VOPNAME_READ, { .vop_read = tmp_read }, 2439 VOPNAME_WRITE, { .vop_write = tmp_write }, 2440 VOPNAME_IOCTL, { .vop_ioctl = tmp_ioctl }, 2441 VOPNAME_GETATTR, { .vop_getattr = tmp_getattr }, 2442 VOPNAME_SETATTR, { .vop_setattr = tmp_setattr }, 2443 VOPNAME_ACCESS, { .vop_access = tmp_access }, 2444 VOPNAME_LOOKUP, { .vop_lookup = tmp_lookup }, 2445 VOPNAME_CREATE, { .vop_create = tmp_create }, 2446 VOPNAME_REMOVE, { .vop_remove = tmp_remove }, 2447 VOPNAME_LINK, { .vop_link = tmp_link }, 2448 VOPNAME_RENAME, { .vop_rename = tmp_rename }, 2449 VOPNAME_MKDIR, { .vop_mkdir = tmp_mkdir }, 2450 VOPNAME_RMDIR, { .vop_rmdir = tmp_rmdir }, 2451 VOPNAME_READDIR, { .vop_readdir = tmp_readdir }, 2452 VOPNAME_SYMLINK, { .vop_symlink = tmp_symlink }, 2453 VOPNAME_READLINK, { .vop_readlink = tmp_readlink }, 2454 VOPNAME_FSYNC, { .vop_fsync = tmp_fsync }, 2455 VOPNAME_INACTIVE, { .vop_inactive = tmp_inactive }, 2456 VOPNAME_FID, { .vop_fid = tmp_fid }, 2457 VOPNAME_RWLOCK, { .vop_rwlock = tmp_rwlock }, 2458 VOPNAME_RWUNLOCK, { .vop_rwunlock = tmp_rwunlock }, 2459 VOPNAME_SEEK, { .vop_seek = tmp_seek }, 2460 VOPNAME_SPACE, { .vop_space = tmp_space }, 2461 VOPNAME_GETPAGE, { .vop_getpage = tmp_getpage }, 2462 VOPNAME_PUTPAGE, { .vop_putpage = tmp_putpage }, 2463 VOPNAME_MAP, { .vop_map = tmp_map }, 2464 VOPNAME_ADDMAP, { .vop_addmap = tmp_addmap }, 2465 VOPNAME_DELMAP, { .vop_delmap = tmp_delmap }, 2466 VOPNAME_PATHCONF, { .vop_pathconf = tmp_pathconf }, 2467 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support }, 2468 NULL, NULL 2469 }; 2470