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 2016, Joyent, Inc.
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) {
791 if (vap->va_size == 0) {
792 vnevent_truncate(vp, ct);
793 } else {
794 vnevent_resize(vp, ct);
795 }
796 }
797
798 goto out1;
799 }
800 out:
801 mutex_exit(&tp->tn_tlock);
802 out1:
803 return (error);
804 }
805
806 /* ARGSUSED2 */
807 static int
808 tmp_access(
809 struct vnode *vp,
810 int mode,
811 int flags,
812 struct cred *cred,
813 caller_context_t *ct)
814 {
815 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
816 int error;
817
818 mutex_enter(&tp->tn_tlock);
819 error = tmp_taccess(tp, mode, cred);
820 mutex_exit(&tp->tn_tlock);
821 return (error);
822 }
823
824 /* ARGSUSED3 */
825 static int
826 tmp_lookup(
827 struct vnode *dvp,
828 char *nm,
829 struct vnode **vpp,
830 struct pathname *pnp,
831 int flags,
832 struct vnode *rdir,
833 struct cred *cred,
834 caller_context_t *ct,
835 int *direntflags,
836 pathname_t *realpnp)
837 {
838 struct tmpnode *tp = (struct tmpnode *)VTOTN(dvp);
839 struct tmpnode *ntp = NULL;
840 int error;
841
842
843 /* allow cd into @ dir */
844 if (flags & LOOKUP_XATTR) {
845 struct tmpnode *xdp;
846 struct tmount *tm;
847
848 /*
849 * don't allow attributes if not mounted XATTR support
850 */
851 if (!(dvp->v_vfsp->vfs_flag & VFS_XATTR))
852 return (EINVAL);
853
854 if (tp->tn_flags & ISXATTR)
855 /* No attributes on attributes */
856 return (EINVAL);
857
858 rw_enter(&tp->tn_rwlock, RW_WRITER);
859 if (tp->tn_xattrdp == NULL) {
860 if (!(flags & CREATE_XATTR_DIR)) {
861 rw_exit(&tp->tn_rwlock);
862 return (ENOENT);
863 }
864
865 /*
866 * No attribute directory exists for this
867 * node - create the attr dir as a side effect
868 * of this lookup.
869 */
870
871 /*
872 * Make sure we have adequate permission...
873 */
874
875 if ((error = tmp_taccess(tp, VWRITE, cred)) != 0) {
876 rw_exit(&tp->tn_rwlock);
877 return (error);
878 }
879
880 xdp = tmp_memalloc(sizeof (struct tmpnode),
881 TMP_MUSTHAVE);
882 tm = VTOTM(dvp);
883 tmpnode_init(tm, xdp, &tp->tn_attr, NULL);
884 /*
885 * Fix-up fields unique to attribute directories.
886 */
887 xdp->tn_flags = ISXATTR;
888 xdp->tn_type = VDIR;
889 if (tp->tn_type == VDIR) {
890 xdp->tn_mode = tp->tn_attr.va_mode;
891 } else {
892 xdp->tn_mode = 0700;
893 if (tp->tn_attr.va_mode & 0040)
894 xdp->tn_mode |= 0750;
895 if (tp->tn_attr.va_mode & 0004)
896 xdp->tn_mode |= 0705;
897 }
898 xdp->tn_vnode->v_type = VDIR;
899 xdp->tn_vnode->v_flag |= V_XATTRDIR;
900 tdirinit(tp, xdp);
901 tp->tn_xattrdp = xdp;
902 } else {
903 VN_HOLD(tp->tn_xattrdp->tn_vnode);
904 }
905 *vpp = TNTOV(tp->tn_xattrdp);
906 rw_exit(&tp->tn_rwlock);
907 return (0);
908 }
909
910 /*
911 * Null component name is a synonym for directory being searched.
912 */
913 if (*nm == '\0') {
914 VN_HOLD(dvp);
915 *vpp = dvp;
916 return (0);
917 }
918 ASSERT(tp);
919
920 error = tdirlookup(tp, nm, &ntp, cred);
921
922 if (error == 0) {
923 ASSERT(ntp);
924 *vpp = TNTOV(ntp);
925 /*
926 * If vnode is a device return special vnode instead
927 */
928 if (IS_DEVVP(*vpp)) {
929 struct vnode *newvp;
930
931 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type,
932 cred);
933 VN_RELE(*vpp);
934 *vpp = newvp;
935 }
936 }
937 TRACE_4(TR_FAC_TMPFS, TR_TMPFS_LOOKUP,
938 "tmpfs lookup:vp %p name %s vpp %p error %d",
939 dvp, nm, vpp, error);
940 return (error);
941 }
942
943 /*ARGSUSED7*/
944 static int
945 tmp_create(
946 struct vnode *dvp,
947 char *nm,
948 struct vattr *vap,
949 enum vcexcl exclusive,
950 int mode,
951 struct vnode **vpp,
952 struct cred *cred,
953 int flag,
954 caller_context_t *ct,
955 vsecattr_t *vsecp)
956 {
957 struct tmpnode *parent;
958 struct tmount *tm;
959 struct tmpnode *self;
960 int error;
961 struct tmpnode *oldtp;
962
963 again:
964 parent = (struct tmpnode *)VTOTN(dvp);
965 tm = (struct tmount *)VTOTM(dvp);
966 self = NULL;
967 error = 0;
968 oldtp = NULL;
969
970 /* device files not allowed in ext. attr dirs */
971 if ((parent->tn_flags & ISXATTR) &&
972 (vap->va_type == VBLK || vap->va_type == VCHR ||
973 vap->va_type == VFIFO || vap->va_type == VDOOR ||
974 vap->va_type == VSOCK || vap->va_type == VPORT))
975 return (EINVAL);
976
977 if (vap->va_type == VREG && (vap->va_mode & VSVTX)) {
978 /* Must be privileged to set sticky bit */
979 if (secpolicy_vnode_stky_modify(cred))
980 vap->va_mode &= ~VSVTX;
981 } else if (vap->va_type == VNON) {
982 return (EINVAL);
983 }
984
985 /*
986 * Null component name is a synonym for directory being searched.
987 */
988 if (*nm == '\0') {
989 VN_HOLD(dvp);
990 oldtp = parent;
991 } else {
992 error = tdirlookup(parent, nm, &oldtp, cred);
993 }
994
995 if (error == 0) { /* name found */
996 boolean_t trunc = B_FALSE;
997
998 ASSERT(oldtp);
999
1000 rw_enter(&oldtp->tn_rwlock, RW_WRITER);
1001
1002 /*
1003 * if create/read-only an existing
1004 * directory, allow it
1005 */
1006 if (exclusive == EXCL)
1007 error = EEXIST;
1008 else if ((oldtp->tn_type == VDIR) && (mode & VWRITE))
1009 error = EISDIR;
1010 else {
1011 error = tmp_taccess(oldtp, mode, cred);
1012 }
1013
1014 if (error) {
1015 rw_exit(&oldtp->tn_rwlock);
1016 tmpnode_rele(oldtp);
1017 return (error);
1018 }
1019 *vpp = TNTOV(oldtp);
1020 if ((*vpp)->v_type == VREG && (vap->va_mask & AT_SIZE) &&
1021 vap->va_size == 0) {
1022 rw_enter(&oldtp->tn_contents, RW_WRITER);
1023 (void) tmpnode_trunc(tm, oldtp, 0);
1024 rw_exit(&oldtp->tn_contents);
1025 trunc = B_TRUE;
1026 }
1027 rw_exit(&oldtp->tn_rwlock);
1028 if (IS_DEVVP(*vpp)) {
1029 struct vnode *newvp;
1030
1031 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type,
1032 cred);
1033 VN_RELE(*vpp);
1034 if (newvp == NULL) {
1035 return (ENOSYS);
1036 }
1037 *vpp = newvp;
1038 }
1039
1040 if (trunc)
1041 vnevent_create(*vpp, ct);
1042
1043 return (0);
1044 }
1045
1046 if (error != ENOENT)
1047 return (error);
1048
1049 rw_enter(&parent->tn_rwlock, RW_WRITER);
1050 error = tdirenter(tm, parent, nm, DE_CREATE,
1051 (struct tmpnode *)NULL, (struct tmpnode *)NULL,
1052 vap, &self, cred, ct);
1053 rw_exit(&parent->tn_rwlock);
1054
1055 if (error) {
1056 if (self)
1057 tmpnode_rele(self);
1058
1059 if (error == EEXIST) {
1060 /*
1061 * This means that the file was created sometime
1062 * after we checked and did not find it and when
1063 * we went to create it.
1064 * Since creat() is supposed to truncate a file
1065 * that already exits go back to the begining
1066 * of the function. This time we will find it
1067 * and go down the tmp_trunc() path
1068 */
1069 goto again;
1070 }
1071 return (error);
1072 }
1073
1074 *vpp = TNTOV(self);
1075
1076 if (!error && IS_DEVVP(*vpp)) {
1077 struct vnode *newvp;
1078
1079 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cred);
1080 VN_RELE(*vpp);
1081 if (newvp == NULL)
1082 return (ENOSYS);
1083 *vpp = newvp;
1084 }
1085 TRACE_3(TR_FAC_TMPFS, TR_TMPFS_CREATE,
1086 "tmpfs create:dvp %p nm %s vpp %p", dvp, nm, vpp);
1087 return (0);
1088 }
1089
1090 /* ARGSUSED3 */
1091 static int
1092 tmp_remove(
1093 struct vnode *dvp,
1094 char *nm,
1095 struct cred *cred,
1096 caller_context_t *ct,
1097 int flags)
1098 {
1099 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1100 int error;
1101 struct tmpnode *tp = NULL;
1102
1103 error = tdirlookup(parent, nm, &tp, cred);
1104 if (error)
1105 return (error);
1106
1107 ASSERT(tp);
1108 rw_enter(&parent->tn_rwlock, RW_WRITER);
1109 rw_enter(&tp->tn_rwlock, RW_WRITER);
1110
1111 if (tp->tn_type != VDIR ||
1112 (error = secpolicy_fs_linkdir(cred, dvp->v_vfsp)) == 0)
1113 error = tdirdelete(parent, tp, nm, tp->tn_type == VDIR ?
1114 DR_RMDIR : DR_REMOVE, cred);
1115
1116 rw_exit(&tp->tn_rwlock);
1117 rw_exit(&parent->tn_rwlock);
1118 vnevent_remove(TNTOV(tp), dvp, nm, ct);
1119 tmpnode_rele(tp);
1120
1121 TRACE_3(TR_FAC_TMPFS, TR_TMPFS_REMOVE,
1122 "tmpfs remove:dvp %p nm %s error %d", dvp, nm, error);
1123 return (error);
1124 }
1125
1126 /* ARGSUSED4 */
1127 static int
1128 tmp_link(
1129 struct vnode *dvp,
1130 struct vnode *srcvp,
1131 char *tnm,
1132 struct cred *cred,
1133 caller_context_t *ct,
1134 int flags)
1135 {
1136 struct tmpnode *parent;
1137 struct tmpnode *from;
1138 struct tmount *tm = (struct tmount *)VTOTM(dvp);
1139 int error;
1140 struct tmpnode *found = NULL;
1141 struct vnode *realvp;
1142
1143 if (VOP_REALVP(srcvp, &realvp, ct) == 0)
1144 srcvp = realvp;
1145
1146 parent = (struct tmpnode *)VTOTN(dvp);
1147 from = (struct tmpnode *)VTOTN(srcvp);
1148
1149 if ((srcvp->v_type == VDIR &&
1150 secpolicy_fs_linkdir(cred, dvp->v_vfsp)) ||
1151 (from->tn_uid != crgetuid(cred) && secpolicy_basic_link(cred)))
1152 return (EPERM);
1153
1154 /*
1155 * Make sure link for extended attributes is valid
1156 * We only support hard linking of xattr's in xattrdir to an xattrdir
1157 */
1158 if ((from->tn_flags & ISXATTR) != (parent->tn_flags & ISXATTR))
1159 return (EINVAL);
1160
1161 error = tdirlookup(parent, tnm, &found, cred);
1162 if (error == 0) {
1163 ASSERT(found);
1164 tmpnode_rele(found);
1165 return (EEXIST);
1166 }
1167
1168 if (error != ENOENT)
1169 return (error);
1170
1171 rw_enter(&parent->tn_rwlock, RW_WRITER);
1172 error = tdirenter(tm, parent, tnm, DE_LINK, (struct tmpnode *)NULL,
1173 from, NULL, (struct tmpnode **)NULL, cred, ct);
1174 rw_exit(&parent->tn_rwlock);
1175 if (error == 0) {
1176 vnevent_link(srcvp, ct);
1177 }
1178 return (error);
1179 }
1180
1181 /* ARGSUSED5 */
1182 static int
1183 tmp_rename(
1184 struct vnode *odvp, /* source parent vnode */
1185 char *onm, /* source name */
1186 struct vnode *ndvp, /* destination parent vnode */
1187 char *nnm, /* destination name */
1188 struct cred *cred,
1189 caller_context_t *ct,
1190 int flags)
1191 {
1192 struct tmpnode *fromparent;
1193 struct tmpnode *toparent;
1194 struct tmpnode *fromtp = NULL; /* source tmpnode */
1195 struct tmpnode *totp; /* target tmpnode */
1196 struct tmount *tm = (struct tmount *)VTOTM(odvp);
1197 int error;
1198 int samedir = 0; /* set if odvp == ndvp */
1199 struct vnode *realvp;
1200
1201 if (VOP_REALVP(ndvp, &realvp, ct) == 0)
1202 ndvp = realvp;
1203
1204 fromparent = (struct tmpnode *)VTOTN(odvp);
1205 toparent = (struct tmpnode *)VTOTN(ndvp);
1206
1207 if ((fromparent->tn_flags & ISXATTR) != (toparent->tn_flags & ISXATTR))
1208 return (EINVAL);
1209
1210 mutex_enter(&tm->tm_renamelck);
1211
1212 /*
1213 * Look up tmpnode of file we're supposed to rename.
1214 */
1215 error = tdirlookup(fromparent, onm, &fromtp, cred);
1216 if (error) {
1217 mutex_exit(&tm->tm_renamelck);
1218 return (error);
1219 }
1220
1221 /*
1222 * Make sure we can delete the old (source) entry. This
1223 * requires write permission on the containing directory. If
1224 * that directory is "sticky" it requires further checks.
1225 */
1226 if (((error = tmp_taccess(fromparent, VWRITE, cred)) != 0) ||
1227 (error = tmp_sticky_remove_access(fromparent, fromtp, cred)) != 0)
1228 goto done;
1229
1230 /*
1231 * Check for renaming to or from '.' or '..' or that
1232 * fromtp == fromparent
1233 */
1234 if ((onm[0] == '.' &&
1235 (onm[1] == '\0' || (onm[1] == '.' && onm[2] == '\0'))) ||
1236 (nnm[0] == '.' &&
1237 (nnm[1] == '\0' || (nnm[1] == '.' && nnm[2] == '\0'))) ||
1238 (fromparent == fromtp)) {
1239 error = EINVAL;
1240 goto done;
1241 }
1242
1243 samedir = (fromparent == toparent);
1244 /*
1245 * Make sure we can search and rename into the new
1246 * (destination) directory.
1247 */
1248 if (!samedir) {
1249 error = tmp_taccess(toparent, VEXEC|VWRITE, cred);
1250 if (error)
1251 goto done;
1252 }
1253
1254 if (tdirlookup(toparent, nnm, &totp, cred) == 0) {
1255 vnevent_pre_rename_dest(TNTOV(totp), ndvp, nnm, ct);
1256 tmpnode_rele(totp);
1257 }
1258
1259 /* Notify the target dir. if not the same as the source dir. */
1260 if (ndvp != odvp) {
1261 vnevent_pre_rename_dest_dir(ndvp, TNTOV(fromtp), nnm, ct);
1262 }
1263
1264 vnevent_pre_rename_src(TNTOV(fromtp), odvp, onm, ct);
1265
1266 /*
1267 * Link source to new target
1268 */
1269 rw_enter(&toparent->tn_rwlock, RW_WRITER);
1270 error = tdirenter(tm, toparent, nnm, DE_RENAME,
1271 fromparent, fromtp, (struct vattr *)NULL,
1272 (struct tmpnode **)NULL, cred, ct);
1273 rw_exit(&toparent->tn_rwlock);
1274
1275 if (error) {
1276 /*
1277 * ESAME isn't really an error; it indicates that the
1278 * operation should not be done because the source and target
1279 * are the same file, but that no error should be reported.
1280 */
1281 if (error == ESAME)
1282 error = 0;
1283 goto done;
1284 }
1285
1286 /*
1287 * Unlink from source.
1288 */
1289 rw_enter(&fromparent->tn_rwlock, RW_WRITER);
1290 rw_enter(&fromtp->tn_rwlock, RW_WRITER);
1291
1292 error = tdirdelete(fromparent, fromtp, onm, DR_RENAME, cred);
1293
1294 /*
1295 * The following handles the case where our source tmpnode was
1296 * removed before we got to it.
1297 *
1298 * XXX We should also cleanup properly in the case where tdirdelete
1299 * fails for some other reason. Currently this case shouldn't happen.
1300 * (see 1184991).
1301 */
1302 if (error == ENOENT)
1303 error = 0;
1304
1305 rw_exit(&fromtp->tn_rwlock);
1306 rw_exit(&fromparent->tn_rwlock);
1307
1308 if (error == 0) {
1309 vnevent_rename_src(TNTOV(fromtp), odvp, onm, ct);
1310 /*
1311 * vnevent_rename_dest is called in tdirenter().
1312 */
1313 vnevent_rename_dest_dir(ndvp, TNTOV(fromtp), nnm, ct);
1314 }
1315
1316 done:
1317 tmpnode_rele(fromtp);
1318 mutex_exit(&tm->tm_renamelck);
1319
1320 TRACE_5(TR_FAC_TMPFS, TR_TMPFS_RENAME,
1321 "tmpfs rename:ovp %p onm %s nvp %p nnm %s error %d", odvp, onm,
1322 ndvp, nnm, error);
1323 return (error);
1324 }
1325
1326 /* ARGSUSED5 */
1327 static int
1328 tmp_mkdir(
1329 struct vnode *dvp,
1330 char *nm,
1331 struct vattr *va,
1332 struct vnode **vpp,
1333 struct cred *cred,
1334 caller_context_t *ct,
1335 int flags,
1336 vsecattr_t *vsecp)
1337 {
1338 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1339 struct tmpnode *self = NULL;
1340 struct tmount *tm = (struct tmount *)VTOTM(dvp);
1341 int error;
1342
1343 /* no new dirs allowed in xattr dirs */
1344 if (parent->tn_flags & ISXATTR)
1345 return (EINVAL);
1346
1347 /*
1348 * Might be dangling directory. Catch it here,
1349 * because a ENOENT return from tdirlookup() is
1350 * an "o.k. return".
1351 */
1352 if (parent->tn_nlink == 0)
1353 return (ENOENT);
1354
1355 error = tdirlookup(parent, nm, &self, cred);
1356 if (error == 0) {
1357 ASSERT(self);
1358 tmpnode_rele(self);
1359 return (EEXIST);
1360 }
1361 if (error != ENOENT)
1362 return (error);
1363
1364 rw_enter(&parent->tn_rwlock, RW_WRITER);
1365 error = tdirenter(tm, parent, nm, DE_MKDIR, (struct tmpnode *)NULL,
1366 (struct tmpnode *)NULL, va, &self, cred, ct);
1367 if (error) {
1368 rw_exit(&parent->tn_rwlock);
1369 if (self)
1370 tmpnode_rele(self);
1371 return (error);
1372 }
1373 rw_exit(&parent->tn_rwlock);
1374 *vpp = TNTOV(self);
1375 return (0);
1376 }
1377
1378 /* ARGSUSED4 */
1379 static int
1380 tmp_rmdir(
1381 struct vnode *dvp,
1382 char *nm,
1383 struct vnode *cdir,
1384 struct cred *cred,
1385 caller_context_t *ct,
1386 int flags)
1387 {
1388 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1389 struct tmpnode *self = NULL;
1390 struct vnode *vp;
1391 int error = 0;
1392
1393 /*
1394 * Return error when removing . and ..
1395 */
1396 if (strcmp(nm, ".") == 0)
1397 return (EINVAL);
1398 if (strcmp(nm, "..") == 0)
1399 return (EEXIST); /* Should be ENOTEMPTY */
1400 error = tdirlookup(parent, nm, &self, cred);
1401 if (error)
1402 return (error);
1403
1404 rw_enter(&parent->tn_rwlock, RW_WRITER);
1405 rw_enter(&self->tn_rwlock, RW_WRITER);
1406
1407 vp = TNTOV(self);
1408 if (vp == dvp || vp == cdir) {
1409 error = EINVAL;
1410 goto done1;
1411 }
1412 if (self->tn_type != VDIR) {
1413 error = ENOTDIR;
1414 goto done1;
1415 }
1416
1417 mutex_enter(&self->tn_tlock);
1418 if (self->tn_nlink > 2) {
1419 mutex_exit(&self->tn_tlock);
1420 error = EEXIST;
1421 goto done1;
1422 }
1423 mutex_exit(&self->tn_tlock);
1424
1425 if (vn_vfswlock(vp)) {
1426 error = EBUSY;
1427 goto done1;
1428 }
1429 if (vn_mountedvfs(vp) != NULL) {
1430 error = EBUSY;
1431 goto done;
1432 }
1433
1434 /*
1435 * Check for an empty directory
1436 * i.e. only includes entries for "." and ".."
1437 */
1438 if (self->tn_dirents > 2) {
1439 error = EEXIST; /* SIGH should be ENOTEMPTY */
1440 /*
1441 * Update atime because checking tn_dirents is logically
1442 * equivalent to reading the directory
1443 */
1444 gethrestime(&self->tn_atime);
1445 goto done;
1446 }
1447
1448 error = tdirdelete(parent, self, nm, DR_RMDIR, cred);
1449 done:
1450 vn_vfsunlock(vp);
1451 done1:
1452 rw_exit(&self->tn_rwlock);
1453 rw_exit(&parent->tn_rwlock);
1454 vnevent_rmdir(TNTOV(self), dvp, nm, ct);
1455 tmpnode_rele(self);
1456
1457 return (error);
1458 }
1459
1460 /* ARGSUSED2 */
1461 static int
1462 tmp_readdir(
1463 struct vnode *vp,
1464 struct uio *uiop,
1465 struct cred *cred,
1466 int *eofp,
1467 caller_context_t *ct,
1468 int flags)
1469 {
1470 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1471 struct tdirent *tdp;
1472 int error = 0;
1473 size_t namelen;
1474 struct dirent64 *dp;
1475 ulong_t offset;
1476 ulong_t total_bytes_wanted;
1477 long outcount = 0;
1478 long bufsize;
1479 int reclen;
1480 caddr_t outbuf;
1481
1482 if (uiop->uio_loffset >= MAXOFF_T) {
1483 if (eofp)
1484 *eofp = 1;
1485 return (0);
1486 }
1487 /*
1488 * assuming system call has already called tmp_rwlock
1489 */
1490 ASSERT(RW_READ_HELD(&tp->tn_rwlock));
1491
1492 if (uiop->uio_iovcnt != 1)
1493 return (EINVAL);
1494
1495 if (vp->v_type != VDIR)
1496 return (ENOTDIR);
1497
1498 /*
1499 * There's a window here where someone could have removed
1500 * all the entries in the directory after we put a hold on the
1501 * vnode but before we grabbed the rwlock. Just return.
1502 */
1503 if (tp->tn_dir == NULL) {
1504 if (tp->tn_nlink) {
1505 panic("empty directory 0x%p", (void *)tp);
1506 /*NOTREACHED*/
1507 }
1508 return (0);
1509 }
1510
1511 /*
1512 * Get space for multiple directory entries
1513 */
1514 total_bytes_wanted = uiop->uio_iov->iov_len;
1515 bufsize = total_bytes_wanted + sizeof (struct dirent64);
1516 outbuf = kmem_alloc(bufsize, KM_SLEEP);
1517
1518 dp = (struct dirent64 *)outbuf;
1519
1520
1521 offset = 0;
1522 tdp = tp->tn_dir;
1523 while (tdp) {
1524 namelen = strlen(tdp->td_name); /* no +1 needed */
1525 offset = tdp->td_offset;
1526 if (offset >= uiop->uio_offset) {
1527 reclen = (int)DIRENT64_RECLEN(namelen);
1528 if (outcount + reclen > total_bytes_wanted) {
1529 if (!outcount)
1530 /*
1531 * Buffer too small for any entries.
1532 */
1533 error = EINVAL;
1534 break;
1535 }
1536 ASSERT(tdp->td_tmpnode != NULL);
1537
1538 /* use strncpy(9f) to zero out uninitialized bytes */
1539
1540 (void) strncpy(dp->d_name, tdp->td_name,
1541 DIRENT64_NAMELEN(reclen));
1542 dp->d_reclen = (ushort_t)reclen;
1543 dp->d_ino = (ino64_t)tdp->td_tmpnode->tn_nodeid;
1544 dp->d_off = (offset_t)tdp->td_offset + 1;
1545 dp = (struct dirent64 *)
1546 ((uintptr_t)dp + dp->d_reclen);
1547 outcount += reclen;
1548 ASSERT(outcount <= bufsize);
1549 }
1550 tdp = tdp->td_next;
1551 }
1552
1553 if (!error)
1554 error = uiomove(outbuf, outcount, UIO_READ, uiop);
1555
1556 if (!error) {
1557 /* If we reached the end of the list our offset */
1558 /* should now be just past the end. */
1559 if (!tdp) {
1560 offset += 1;
1561 if (eofp)
1562 *eofp = 1;
1563 } else if (eofp)
1564 *eofp = 0;
1565 uiop->uio_offset = offset;
1566 }
1567 gethrestime(&tp->tn_atime);
1568 kmem_free(outbuf, bufsize);
1569 return (error);
1570 }
1571
1572 /* ARGSUSED5 */
1573 static int
1574 tmp_symlink(
1575 struct vnode *dvp,
1576 char *lnm,
1577 struct vattr *tva,
1578 char *tnm,
1579 struct cred *cred,
1580 caller_context_t *ct,
1581 int flags)
1582 {
1583 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1584 struct tmpnode *self = (struct tmpnode *)NULL;
1585 struct tmount *tm = (struct tmount *)VTOTM(dvp);
1586 char *cp = NULL;
1587 int error;
1588 size_t len;
1589
1590 /* no symlinks allowed to files in xattr dirs */
1591 if (parent->tn_flags & ISXATTR)
1592 return (EINVAL);
1593
1594 error = tdirlookup(parent, lnm, &self, cred);
1595 if (error == 0) {
1596 /*
1597 * The entry already exists
1598 */
1599 tmpnode_rele(self);
1600 return (EEXIST); /* was 0 */
1601 }
1602
1603 if (error != ENOENT) {
1604 if (self != NULL)
1605 tmpnode_rele(self);
1606 return (error);
1607 }
1608
1609 rw_enter(&parent->tn_rwlock, RW_WRITER);
1610 error = tdirenter(tm, parent, lnm, DE_CREATE, (struct tmpnode *)NULL,
1611 (struct tmpnode *)NULL, tva, &self, cred, ct);
1612 rw_exit(&parent->tn_rwlock);
1613
1614 if (error) {
1615 if (self)
1616 tmpnode_rele(self);
1617 return (error);
1618 }
1619 len = strlen(tnm) + 1;
1620 cp = tmp_memalloc(len, 0);
1621 if (cp == NULL) {
1622 tmpnode_rele(self);
1623 return (ENOSPC);
1624 }
1625 (void) strcpy(cp, tnm);
1626
1627 self->tn_symlink = cp;
1628 self->tn_size = len - 1;
1629 tmpnode_rele(self);
1630 return (error);
1631 }
1632
1633 /* ARGSUSED2 */
1634 static int
1635 tmp_readlink(
1636 struct vnode *vp,
1637 struct uio *uiop,
1638 struct cred *cred,
1639 caller_context_t *ct)
1640 {
1641 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1642 int error = 0;
1643
1644 if (vp->v_type != VLNK)
1645 return (EINVAL);
1646
1647 rw_enter(&tp->tn_rwlock, RW_READER);
1648 rw_enter(&tp->tn_contents, RW_READER);
1649 error = uiomove(tp->tn_symlink, tp->tn_size, UIO_READ, uiop);
1650 gethrestime(&tp->tn_atime);
1651 rw_exit(&tp->tn_contents);
1652 rw_exit(&tp->tn_rwlock);
1653 return (error);
1654 }
1655
1656 /* ARGSUSED */
1657 static int
1658 tmp_fsync(
1659 struct vnode *vp,
1660 int syncflag,
1661 struct cred *cred,
1662 caller_context_t *ct)
1663 {
1664 return (0);
1665 }
1666
1667 /* ARGSUSED */
1668 static void
1669 tmp_inactive(struct vnode *vp, struct cred *cred, caller_context_t *ct)
1670 {
1671 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1672 struct tmount *tm = (struct tmount *)VFSTOTM(vp->v_vfsp);
1673
1674 rw_enter(&tp->tn_rwlock, RW_WRITER);
1675 top:
1676 mutex_enter(&tp->tn_tlock);
1677 mutex_enter(&vp->v_lock);
1678 ASSERT(vp->v_count >= 1);
1679
1680 /*
1681 * If we don't have the last hold or the link count is non-zero,
1682 * there's little to do -- just drop our hold.
1683 */
1684 if (vp->v_count > 1 || tp->tn_nlink != 0) {
1685 vp->v_count--;
1686 mutex_exit(&vp->v_lock);
1687 mutex_exit(&tp->tn_tlock);
1688 rw_exit(&tp->tn_rwlock);
1689 return;
1690 }
1691
1692 /*
1693 * We have the last hold *and* the link count is zero, so this
1694 * tmpnode is dead from the filesystem's viewpoint. However,
1695 * if the tmpnode has any pages associated with it (i.e. if it's
1696 * a normal file with non-zero size), the tmpnode can still be
1697 * discovered by pageout or fsflush via the page vnode pointers.
1698 * In this case we must drop all our locks, truncate the tmpnode,
1699 * and try the whole dance again.
1700 */
1701 if (tp->tn_size != 0) {
1702 if (tp->tn_type == VREG) {
1703 mutex_exit(&vp->v_lock);
1704 mutex_exit(&tp->tn_tlock);
1705 rw_enter(&tp->tn_contents, RW_WRITER);
1706 (void) tmpnode_trunc(tm, tp, 0);
1707 rw_exit(&tp->tn_contents);
1708 ASSERT(tp->tn_size == 0);
1709 ASSERT(tp->tn_nblocks == 0);
1710 goto top;
1711 }
1712 if (tp->tn_type == VLNK)
1713 tmp_memfree(tp->tn_symlink, tp->tn_size + 1);
1714 }
1715
1716 /*
1717 * Remove normal file/dir's xattr dir and xattrs.
1718 */
1719 if (tp->tn_xattrdp) {
1720 struct tmpnode *xtp = tp->tn_xattrdp;
1721
1722 ASSERT(xtp->tn_flags & ISXATTR);
1723 tmpnode_hold(xtp);
1724 rw_enter(&xtp->tn_rwlock, RW_WRITER);
1725 tdirtrunc(xtp);
1726 DECR_COUNT(&xtp->tn_nlink, &xtp->tn_tlock);
1727 tp->tn_xattrdp = NULL;
1728 rw_exit(&xtp->tn_rwlock);
1729 tmpnode_rele(xtp);
1730 }
1731
1732 mutex_exit(&vp->v_lock);
1733 mutex_exit(&tp->tn_tlock);
1734 /* Here's our chance to send invalid event while we're between locks */
1735 vn_invalid(TNTOV(tp));
1736 mutex_enter(&tm->tm_contents);
1737 if (tp->tn_forw == NULL)
1738 tm->tm_rootnode->tn_back = tp->tn_back;
1739 else
1740 tp->tn_forw->tn_back = tp->tn_back;
1741 tp->tn_back->tn_forw = tp->tn_forw;
1742 mutex_exit(&tm->tm_contents);
1743 rw_exit(&tp->tn_rwlock);
1744 rw_destroy(&tp->tn_rwlock);
1745 mutex_destroy(&tp->tn_tlock);
1746 vn_free(TNTOV(tp));
1747 tmp_memfree(tp, sizeof (struct tmpnode));
1748 }
1749
1750 /* ARGSUSED2 */
1751 static int
1752 tmp_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ct)
1753 {
1754 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1755 struct tfid *tfid;
1756
1757 if (fidp->fid_len < (sizeof (struct tfid) - sizeof (ushort_t))) {
1758 fidp->fid_len = sizeof (struct tfid) - sizeof (ushort_t);
1759 return (ENOSPC);
1760 }
1761
1762 tfid = (struct tfid *)fidp;
1763 bzero(tfid, sizeof (struct tfid));
1764 tfid->tfid_len = (int)sizeof (struct tfid) - sizeof (ushort_t);
1765
1766 tfid->tfid_ino = tp->tn_nodeid;
1767 tfid->tfid_gen = tp->tn_gen;
1768
1769 return (0);
1770 }
1771
1772
1773 /*
1774 * Return all the pages from [off..off+len] in given file
1775 */
1776 /* ARGSUSED */
1777 static int
1778 tmp_getpage(
1779 struct vnode *vp,
1780 offset_t off,
1781 size_t len,
1782 uint_t *protp,
1783 page_t *pl[],
1784 size_t plsz,
1785 struct seg *seg,
1786 caddr_t addr,
1787 enum seg_rw rw,
1788 struct cred *cr,
1789 caller_context_t *ct)
1790 {
1791 int err = 0;
1792 struct tmpnode *tp = VTOTN(vp);
1793 anoff_t toff = (anoff_t)off;
1794 size_t tlen = len;
1795 u_offset_t tmpoff;
1796 timestruc_t now;
1797
1798 rw_enter(&tp->tn_contents, RW_READER);
1799
1800 if (off + len > tp->tn_size + PAGEOFFSET) {
1801 err = EFAULT;
1802 goto out;
1803 }
1804 /*
1805 * Look for holes (no anon slot) in faulting range. If there are
1806 * holes we have to switch to a write lock and fill them in. Swap
1807 * space for holes was already reserved when the file was grown.
1808 */
1809 tmpoff = toff;
1810 if (non_anon(tp->tn_anon, btop(off), &tmpoff, &tlen)) {
1811 if (!rw_tryupgrade(&tp->tn_contents)) {
1812 rw_exit(&tp->tn_contents);
1813 rw_enter(&tp->tn_contents, RW_WRITER);
1814 /* Size may have changed when lock was dropped */
1815 if (off + len > tp->tn_size + PAGEOFFSET) {
1816 err = EFAULT;
1817 goto out;
1818 }
1819 }
1820 for (toff = (anoff_t)off; toff < (anoff_t)off + len;
1821 toff += PAGESIZE) {
1822 if (anon_get_ptr(tp->tn_anon, btop(toff)) == NULL) {
1823 /* XXX - may allocate mem w. write lock held */
1824 (void) anon_set_ptr(tp->tn_anon, btop(toff),
1825 anon_alloc(vp, toff), ANON_SLEEP);
1826 tp->tn_nblocks++;
1827 }
1828 }
1829 rw_downgrade(&tp->tn_contents);
1830 }
1831
1832
1833 err = pvn_getpages(tmp_getapage, vp, (u_offset_t)off, len, protp,
1834 pl, plsz, seg, addr, rw, cr);
1835
1836 gethrestime(&now);
1837 tp->tn_atime = now;
1838 if (rw == S_WRITE)
1839 tp->tn_mtime = now;
1840
1841 out:
1842 rw_exit(&tp->tn_contents);
1843 return (err);
1844 }
1845
1846 /*
1847 * Called from pvn_getpages to get a particular page.
1848 */
1849 /*ARGSUSED*/
1850 static int
1851 tmp_getapage(
1852 struct vnode *vp,
1853 u_offset_t off,
1854 size_t len,
1855 uint_t *protp,
1856 page_t *pl[],
1857 size_t plsz,
1858 struct seg *seg,
1859 caddr_t addr,
1860 enum seg_rw rw,
1861 struct cred *cr)
1862 {
1863 struct page *pp;
1864 int flags;
1865 int err = 0;
1866 struct vnode *pvp;
1867 u_offset_t poff;
1868
1869 if (protp != NULL)
1870 *protp = PROT_ALL;
1871 again:
1872 if (pp = page_lookup(vp, off, rw == S_CREATE ? SE_EXCL : SE_SHARED)) {
1873 if (pl) {
1874 pl[0] = pp;
1875 pl[1] = NULL;
1876 } else {
1877 page_unlock(pp);
1878 }
1879 } else {
1880 pp = page_create_va(vp, off, PAGESIZE,
1881 PG_WAIT | PG_EXCL, seg, addr);
1882 /*
1883 * Someone raced in and created the page after we did the
1884 * lookup but before we did the create, so go back and
1885 * try to look it up again.
1886 */
1887 if (pp == NULL)
1888 goto again;
1889 /*
1890 * Fill page from backing store, if any. If none, then
1891 * either this is a newly filled hole or page must have
1892 * been unmodified and freed so just zero it out.
1893 */
1894 err = swap_getphysname(vp, off, &pvp, &poff);
1895 if (err) {
1896 panic("tmp_getapage: no anon slot vp %p "
1897 "off %llx pp %p\n", (void *)vp, off, (void *)pp);
1898 }
1899 if (pvp) {
1900 flags = (pl == NULL ? B_ASYNC|B_READ : B_READ);
1901 err = VOP_PAGEIO(pvp, pp, (u_offset_t)poff, PAGESIZE,
1902 flags, cr, NULL);
1903 if (flags & B_ASYNC)
1904 pp = NULL;
1905 } else if (rw != S_CREATE) {
1906 pagezero(pp, 0, PAGESIZE);
1907 }
1908 if (err && pp)
1909 pvn_read_done(pp, B_ERROR);
1910 if (err == 0) {
1911 if (pl)
1912 pvn_plist_init(pp, pl, plsz, off, PAGESIZE, rw);
1913 else
1914 pvn_io_done(pp);
1915 }
1916 }
1917 return (err);
1918 }
1919
1920
1921 /*
1922 * Flags are composed of {B_INVAL, B_DIRTY B_FREE, B_DONTNEED}.
1923 * If len == 0, do from off to EOF.
1924 */
1925 static int tmp_nopage = 0; /* Don't do tmp_putpage's if set */
1926
1927 /* ARGSUSED */
1928 int
1929 tmp_putpage(
1930 register struct vnode *vp,
1931 offset_t off,
1932 size_t len,
1933 int flags,
1934 struct cred *cr,
1935 caller_context_t *ct)
1936 {
1937 register page_t *pp;
1938 u_offset_t io_off;
1939 size_t io_len = 0;
1940 int err = 0;
1941 struct tmpnode *tp = VTOTN(vp);
1942 int dolock;
1943
1944 if (tmp_nopage)
1945 return (0);
1946
1947 ASSERT(vp->v_count != 0);
1948
1949 if (vp->v_flag & VNOMAP)
1950 return (ENOSYS);
1951
1952 /*
1953 * This being tmpfs, we don't ever do i/o unless we really
1954 * have to (when we're low on memory and pageout calls us
1955 * with B_ASYNC | B_FREE or the user explicitly asks for it with
1956 * B_DONTNEED).
1957 * XXX to approximately track the mod time like ufs we should
1958 * update the times here. The problem is, once someone does a
1959 * store we never clear the mod bit and do i/o, thus fsflush
1960 * will keep calling us every 30 seconds to do the i/o and we'll
1961 * continually update the mod time. At least we update the mod
1962 * time on the first store because this results in a call to getpage.
1963 */
1964 if (flags != (B_ASYNC | B_FREE) && (flags & B_INVAL) == 0 &&
1965 (flags & B_DONTNEED) == 0)
1966 return (0);
1967 /*
1968 * If this thread owns the lock, i.e., this thread grabbed it
1969 * as writer somewhere above, then we don't need to grab the
1970 * lock as reader in this routine.
1971 */
1972 dolock = (rw_owner(&tp->tn_contents) != curthread);
1973
1974 /*
1975 * If this is pageout don't block on the lock as you could deadlock
1976 * when freemem == 0 (another thread has the read lock and is blocked
1977 * creating a page, and a third thread is waiting to get the writers
1978 * lock - waiting writers priority blocks us from getting the read
1979 * lock). Of course, if the only freeable pages are on this tmpnode
1980 * we're hosed anyways. A better solution might be a new lock type.
1981 * Note: ufs has the same problem.
1982 */
1983 if (curproc == proc_pageout) {
1984 if (!rw_tryenter(&tp->tn_contents, RW_READER))
1985 return (ENOMEM);
1986 } else if (dolock)
1987 rw_enter(&tp->tn_contents, RW_READER);
1988
1989 if (!vn_has_cached_data(vp))
1990 goto out;
1991
1992 if (len == 0) {
1993 if (curproc == proc_pageout) {
1994 panic("tmp: pageout can't block");
1995 /*NOTREACHED*/
1996 }
1997
1998 /* Search the entire vp list for pages >= off. */
1999 err = pvn_vplist_dirty(vp, (u_offset_t)off, tmp_putapage,
2000 flags, cr);
2001 } else {
2002 u_offset_t eoff;
2003
2004 /*
2005 * Loop over all offsets in the range [off...off + len]
2006 * looking for pages to deal with.
2007 */
2008 eoff = MIN(off + len, tp->tn_size);
2009 for (io_off = off; io_off < eoff; io_off += io_len) {
2010 /*
2011 * If we are not invalidating, synchronously
2012 * freeing or writing pages use the routine
2013 * page_lookup_nowait() to prevent reclaiming
2014 * them from the free list.
2015 */
2016 if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) {
2017 pp = page_lookup(vp, io_off,
2018 (flags & (B_INVAL | B_FREE)) ?
2019 SE_EXCL : SE_SHARED);
2020 } else {
2021 pp = page_lookup_nowait(vp, io_off,
2022 (flags & B_FREE) ? SE_EXCL : SE_SHARED);
2023 }
2024
2025 if (pp == NULL || pvn_getdirty(pp, flags) == 0)
2026 io_len = PAGESIZE;
2027 else {
2028 err = tmp_putapage(vp, pp, &io_off, &io_len,
2029 flags, cr);
2030 if (err != 0)
2031 break;
2032 }
2033 }
2034 }
2035 /* If invalidating, verify all pages on vnode list are gone. */
2036 if (err == 0 && off == 0 && len == 0 &&
2037 (flags & B_INVAL) && vn_has_cached_data(vp)) {
2038 panic("tmp_putpage: B_INVAL, pages not gone");
2039 /*NOTREACHED*/
2040 }
2041 out:
2042 if ((curproc == proc_pageout) || dolock)
2043 rw_exit(&tp->tn_contents);
2044 /*
2045 * Only reason putapage is going to give us SE_NOSWAP as error
2046 * is when we ask a page to be written to physical backing store
2047 * and there is none. Ignore this because we might be dealing
2048 * with a swap page which does not have any backing store
2049 * on disk. In any other case we won't get this error over here.
2050 */
2051 if (err == SE_NOSWAP)
2052 err = 0;
2053 return (err);
2054 }
2055
2056 long tmp_putpagecnt, tmp_pagespushed;
2057
2058 /*
2059 * Write out a single page.
2060 * For tmpfs this means choose a physical swap slot and write the page
2061 * out using VOP_PAGEIO. For performance, we attempt to kluster; i.e.,
2062 * we try to find a bunch of other dirty pages adjacent in the file
2063 * and a bunch of contiguous swap slots, and then write all the pages
2064 * out in a single i/o.
2065 */
2066 /*ARGSUSED*/
2067 static int
2068 tmp_putapage(
2069 struct vnode *vp,
2070 page_t *pp,
2071 u_offset_t *offp,
2072 size_t *lenp,
2073 int flags,
2074 struct cred *cr)
2075 {
2076 int err;
2077 ulong_t klstart, kllen;
2078 page_t *pplist, *npplist;
2079 extern int klustsize;
2080 long tmp_klustsize;
2081 struct tmpnode *tp;
2082 size_t pp_off, pp_len;
2083 u_offset_t io_off;
2084 size_t io_len;
2085 struct vnode *pvp;
2086 u_offset_t pstart;
2087 u_offset_t offset;
2088 u_offset_t tmpoff;
2089
2090 ASSERT(PAGE_LOCKED(pp));
2091
2092 /* Kluster in tmp_klustsize chunks */
2093 tp = VTOTN(vp);
2094 tmp_klustsize = klustsize;
2095 offset = pp->p_offset;
2096 klstart = (offset / tmp_klustsize) * tmp_klustsize;
2097 kllen = MIN(tmp_klustsize, tp->tn_size - klstart);
2098
2099 /* Get a kluster of pages */
2100 pplist =
2101 pvn_write_kluster(vp, pp, &tmpoff, &pp_len, klstart, kllen, flags);
2102
2103 pp_off = (size_t)tmpoff;
2104
2105 /*
2106 * Get a cluster of physical offsets for the pages; the amount we
2107 * get may be some subrange of what we ask for (io_off, io_len).
2108 */
2109 io_off = pp_off;
2110 io_len = pp_len;
2111 err = swap_newphysname(vp, offset, &io_off, &io_len, &pvp, &pstart);
2112 ASSERT(err != SE_NOANON); /* anon slot must have been filled */
2113 if (err) {
2114 pvn_write_done(pplist, B_ERROR | B_WRITE | flags);
2115 /*
2116 * If this routine is called as a result of segvn_sync
2117 * operation and we have no physical swap then we can get an
2118 * error here. In such case we would return SE_NOSWAP as error.
2119 * At this point, we expect only SE_NOSWAP.
2120 */
2121 ASSERT(err == SE_NOSWAP);
2122 if (flags & B_INVAL)
2123 err = ENOMEM;
2124 goto out;
2125 }
2126 ASSERT(pp_off <= io_off && io_off + io_len <= pp_off + pp_len);
2127 ASSERT(io_off <= offset && offset < io_off + io_len);
2128
2129 /* Toss pages at front/rear that we couldn't get physical backing for */
2130 if (io_off != pp_off) {
2131 npplist = NULL;
2132 page_list_break(&pplist, &npplist, btop(io_off - pp_off));
2133 ASSERT(pplist->p_offset == pp_off);
2134 ASSERT(pplist->p_prev->p_offset == io_off - PAGESIZE);
2135 pvn_write_done(pplist, B_ERROR | B_WRITE | flags);
2136 pplist = npplist;
2137 }
2138 if (io_off + io_len < pp_off + pp_len) {
2139 npplist = NULL;
2140 page_list_break(&pplist, &npplist, btop(io_len));
2141 ASSERT(npplist->p_offset == io_off + io_len);
2142 ASSERT(npplist->p_prev->p_offset == pp_off + pp_len - PAGESIZE);
2143 pvn_write_done(npplist, B_ERROR | B_WRITE | flags);
2144 }
2145
2146 ASSERT(pplist->p_offset == io_off);
2147 ASSERT(pplist->p_prev->p_offset == io_off + io_len - PAGESIZE);
2148 ASSERT(btopr(io_len) <= btopr(kllen));
2149
2150 /* Do i/o on the remaining kluster */
2151 err = VOP_PAGEIO(pvp, pplist, (u_offset_t)pstart, io_len,
2152 B_WRITE | flags, cr, NULL);
2153
2154 if ((flags & B_ASYNC) == 0) {
2155 pvn_write_done(pplist, ((err) ? B_ERROR : 0) | B_WRITE | flags);
2156 }
2157 out:
2158 if (!err) {
2159 if (offp)
2160 *offp = io_off;
2161 if (lenp)
2162 *lenp = io_len;
2163 tmp_putpagecnt++;
2164 tmp_pagespushed += btop(io_len);
2165 }
2166 if (err && err != ENOMEM && err != SE_NOSWAP)
2167 cmn_err(CE_WARN, "tmp_putapage: err %d\n", err);
2168 return (err);
2169 }
2170
2171 /* ARGSUSED */
2172 static int
2173 tmp_map(
2174 struct vnode *vp,
2175 offset_t off,
2176 struct as *as,
2177 caddr_t *addrp,
2178 size_t len,
2179 uchar_t prot,
2180 uchar_t maxprot,
2181 uint_t flags,
2182 struct cred *cred,
2183 caller_context_t *ct)
2184 {
2185 struct segvn_crargs vn_a;
2186 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
2187 int error;
2188
2189 #ifdef _ILP32
2190 if (len > MAXOFF_T)
2191 return (ENOMEM);
2192 #endif
2193
2194 if (vp->v_flag & VNOMAP)
2195 return (ENOSYS);
2196
2197 if (off < 0 || (offset_t)(off + len) < 0 ||
2198 off > MAXOFF_T || (off + len) > MAXOFF_T)
2199 return (ENXIO);
2200
2201 if (vp->v_type != VREG)
2202 return (ENODEV);
2203
2204 /*
2205 * Don't allow mapping to locked file
2206 */
2207 if (vn_has_mandatory_locks(vp, tp->tn_mode)) {
2208 return (EAGAIN);
2209 }
2210
2211 as_rangelock(as);
2212 error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
2213 if (error != 0) {
2214 as_rangeunlock(as);
2215 return (error);
2216 }
2217
2218 vn_a.vp = vp;
2219 vn_a.offset = (u_offset_t)off;
2220 vn_a.type = flags & MAP_TYPE;
2221 vn_a.prot = prot;
2222 vn_a.maxprot = maxprot;
2223 vn_a.flags = flags & ~MAP_TYPE;
2224 vn_a.cred = cred;
2225 vn_a.amp = NULL;
2226 vn_a.szc = 0;
2227 vn_a.lgrp_mem_policy_flags = 0;
2228
2229 error = as_map(as, *addrp, len, segvn_create, &vn_a);
2230 as_rangeunlock(as);
2231 return (error);
2232 }
2233
2234 /*
2235 * tmp_addmap and tmp_delmap can't be called since the vp
2236 * maintained in the segvn mapping is NULL.
2237 */
2238 /* ARGSUSED */
2239 static int
2240 tmp_addmap(
2241 struct vnode *vp,
2242 offset_t off,
2243 struct as *as,
2244 caddr_t addr,
2245 size_t len,
2246 uchar_t prot,
2247 uchar_t maxprot,
2248 uint_t flags,
2249 struct cred *cred,
2250 caller_context_t *ct)
2251 {
2252 return (0);
2253 }
2254
2255 /* ARGSUSED */
2256 static int
2257 tmp_delmap(
2258 struct vnode *vp,
2259 offset_t off,
2260 struct as *as,
2261 caddr_t addr,
2262 size_t len,
2263 uint_t prot,
2264 uint_t maxprot,
2265 uint_t flags,
2266 struct cred *cred,
2267 caller_context_t *ct)
2268 {
2269 return (0);
2270 }
2271
2272 static int
2273 tmp_freesp(struct vnode *vp, struct flock64 *lp, int flag)
2274 {
2275 register int i;
2276 register struct tmpnode *tp = VTOTN(vp);
2277 int error;
2278
2279 ASSERT(vp->v_type == VREG);
2280 ASSERT(lp->l_start >= 0);
2281
2282 if (lp->l_len != 0)
2283 return (EINVAL);
2284
2285 rw_enter(&tp->tn_rwlock, RW_WRITER);
2286 if (tp->tn_size == lp->l_start) {
2287 rw_exit(&tp->tn_rwlock);
2288 return (0);
2289 }
2290
2291 /*
2292 * Check for any mandatory locks on the range
2293 */
2294 if (MANDLOCK(vp, tp->tn_mode)) {
2295 long save_start;
2296
2297 save_start = lp->l_start;
2298
2299 if (tp->tn_size < lp->l_start) {
2300 /*
2301 * "Truncate up" case: need to make sure there
2302 * is no lock beyond current end-of-file. To
2303 * do so, we need to set l_start to the size
2304 * of the file temporarily.
2305 */
2306 lp->l_start = tp->tn_size;
2307 }
2308 lp->l_type = F_WRLCK;
2309 lp->l_sysid = 0;
2310 lp->l_pid = ttoproc(curthread)->p_pid;
2311 i = (flag & (FNDELAY|FNONBLOCK)) ? 0 : SLPFLCK;
2312 if ((i = reclock(vp, lp, i, 0, lp->l_start, NULL)) != 0 ||
2313 lp->l_type != F_UNLCK) {
2314 rw_exit(&tp->tn_rwlock);
2315 return (i ? i : EAGAIN);
2316 }
2317
2318 lp->l_start = save_start;
2319 }
2320 VFSTOTM(vp->v_vfsp);
2321
2322 rw_enter(&tp->tn_contents, RW_WRITER);
2323 error = tmpnode_trunc((struct tmount *)VFSTOTM(vp->v_vfsp),
2324 tp, (ulong_t)lp->l_start);
2325 rw_exit(&tp->tn_contents);
2326 rw_exit(&tp->tn_rwlock);
2327 return (error);
2328 }
2329
2330 /* ARGSUSED */
2331 static int
2332 tmp_space(
2333 struct vnode *vp,
2334 int cmd,
2335 struct flock64 *bfp,
2336 int flag,
2337 offset_t offset,
2338 cred_t *cred,
2339 caller_context_t *ct)
2340 {
2341 int error;
2342
2343 if (cmd != F_FREESP)
2344 return (EINVAL);
2345 if ((error = convoff(vp, bfp, 0, (offset_t)offset)) == 0) {
2346 if ((bfp->l_start > MAXOFF_T) || (bfp->l_len > MAXOFF_T))
2347 return (EFBIG);
2348 error = tmp_freesp(vp, bfp, flag);
2349
2350 if (error == 0) {
2351 if (bfp->l_start == 0) {
2352 vnevent_truncate(vp, ct);
2353 } else {
2354 vnevent_resize(vp, ct);
2355 }
2356 }
2357 }
2358 return (error);
2359 }
2360
2361 /* ARGSUSED */
2362 static int
2363 tmp_seek(
2364 struct vnode *vp,
2365 offset_t ooff,
2366 offset_t *noffp,
2367 caller_context_t *ct)
2368 {
2369 return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0);
2370 }
2371
2372 /* ARGSUSED2 */
2373 static int
2374 tmp_rwlock(struct vnode *vp, int write_lock, caller_context_t *ctp)
2375 {
2376 struct tmpnode *tp = VTOTN(vp);
2377
2378 if (write_lock) {
2379 rw_enter(&tp->tn_rwlock, RW_WRITER);
2380 } else {
2381 rw_enter(&tp->tn_rwlock, RW_READER);
2382 }
2383 return (write_lock);
2384 }
2385
2386 /* ARGSUSED1 */
2387 static void
2388 tmp_rwunlock(struct vnode *vp, int write_lock, caller_context_t *ctp)
2389 {
2390 struct tmpnode *tp = VTOTN(vp);
2391
2392 rw_exit(&tp->tn_rwlock);
2393 }
2394
2395 static int
2396 tmp_pathconf(
2397 struct vnode *vp,
2398 int cmd,
2399 ulong_t *valp,
2400 cred_t *cr,
2401 caller_context_t *ct)
2402 {
2403 struct tmpnode *tp = NULL;
2404 int error;
2405
2406 switch (cmd) {
2407 case _PC_XATTR_EXISTS:
2408 if (vp->v_vfsp->vfs_flag & VFS_XATTR) {
2409 *valp = 0; /* assume no attributes */
2410 error = 0; /* okay to ask */
2411 tp = VTOTN(vp);
2412 rw_enter(&tp->tn_rwlock, RW_READER);
2413 if (tp->tn_xattrdp) {
2414 rw_enter(&tp->tn_xattrdp->tn_rwlock, RW_READER);
2415 /* do not count "." and ".." */
2416 if (tp->tn_xattrdp->tn_dirents > 2)
2417 *valp = 1;
2418 rw_exit(&tp->tn_xattrdp->tn_rwlock);
2419 }
2420 rw_exit(&tp->tn_rwlock);
2421 } else {
2422 error = EINVAL;
2423 }
2424 break;
2425 case _PC_SATTR_ENABLED:
2426 case _PC_SATTR_EXISTS:
2427 *valp = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) &&
2428 (vp->v_type == VREG || vp->v_type == VDIR);
2429 error = 0;
2430 break;
2431 case _PC_TIMESTAMP_RESOLUTION:
2432 /* nanosecond timestamp resolution */
2433 *valp = 1L;
2434 error = 0;
2435 break;
2436 default:
2437 error = fs_pathconf(vp, cmd, valp, cr, ct);
2438 }
2439 return (error);
2440 }
2441
2442
2443 struct vnodeops *tmp_vnodeops;
2444
2445 const fs_operation_def_t tmp_vnodeops_template[] = {
2446 VOPNAME_OPEN, { .vop_open = tmp_open },
2447 VOPNAME_CLOSE, { .vop_close = tmp_close },
2448 VOPNAME_READ, { .vop_read = tmp_read },
2449 VOPNAME_WRITE, { .vop_write = tmp_write },
2450 VOPNAME_IOCTL, { .vop_ioctl = tmp_ioctl },
2451 VOPNAME_GETATTR, { .vop_getattr = tmp_getattr },
2452 VOPNAME_SETATTR, { .vop_setattr = tmp_setattr },
2453 VOPNAME_ACCESS, { .vop_access = tmp_access },
2454 VOPNAME_LOOKUP, { .vop_lookup = tmp_lookup },
2455 VOPNAME_CREATE, { .vop_create = tmp_create },
2456 VOPNAME_REMOVE, { .vop_remove = tmp_remove },
2457 VOPNAME_LINK, { .vop_link = tmp_link },
2458 VOPNAME_RENAME, { .vop_rename = tmp_rename },
2459 VOPNAME_MKDIR, { .vop_mkdir = tmp_mkdir },
2460 VOPNAME_RMDIR, { .vop_rmdir = tmp_rmdir },
2461 VOPNAME_READDIR, { .vop_readdir = tmp_readdir },
2462 VOPNAME_SYMLINK, { .vop_symlink = tmp_symlink },
2463 VOPNAME_READLINK, { .vop_readlink = tmp_readlink },
2464 VOPNAME_FSYNC, { .vop_fsync = tmp_fsync },
2465 VOPNAME_INACTIVE, { .vop_inactive = tmp_inactive },
2466 VOPNAME_FID, { .vop_fid = tmp_fid },
2467 VOPNAME_RWLOCK, { .vop_rwlock = tmp_rwlock },
2468 VOPNAME_RWUNLOCK, { .vop_rwunlock = tmp_rwunlock },
2469 VOPNAME_SEEK, { .vop_seek = tmp_seek },
2470 VOPNAME_SPACE, { .vop_space = tmp_space },
2471 VOPNAME_GETPAGE, { .vop_getpage = tmp_getpage },
2472 VOPNAME_PUTPAGE, { .vop_putpage = tmp_putpage },
2473 VOPNAME_MAP, { .vop_map = tmp_map },
2474 VOPNAME_ADDMAP, { .vop_addmap = tmp_addmap },
2475 VOPNAME_DELMAP, { .vop_delmap = tmp_delmap },
2476 VOPNAME_PATHCONF, { .vop_pathconf = tmp_pathconf },
2477 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
2478 NULL, NULL
2479 };