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