1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
24 * Copyright 2015 Joyent, Inc.
25 */
26
27 #include <sys/types.h>
28 #include <sys/param.h>
29 #include <sys/sysmacros.h>
30 #include <sys/kmem.h>
31 #include <sys/time.h>
32 #include <sys/pathname.h>
33 #include <sys/vfs.h>
34 #include <sys/vfs_opreg.h>
35 #include <sys/vnode.h>
36 #include <sys/stat.h>
37 #include <sys/uio.h>
38 #include <sys/stat.h>
39 #include <sys/errno.h>
40 #include <sys/cmn_err.h>
41 #include <sys/cred.h>
42 #include <sys/statvfs.h>
43 #include <sys/mount.h>
44 #include <sys/debug.h>
45 #include <sys/systm.h>
46 #include <sys/mntent.h>
47 #include <fs/fs_subr.h>
48 #include <vm/page.h>
49 #include <vm/anon.h>
50 #include <sys/model.h>
51 #include <sys/policy.h>
52
53 #include <sys/fs/swapnode.h>
54 #include <sys/fs/tmp.h>
55 #include <sys/fs/tmpnode.h>
56
57 static int tmpfsfstype;
58
59 /*
60 * tmpfs vfs operations.
61 */
62 static int tmpfsinit(int, char *);
63 static int tmp_mount(struct vfs *, struct vnode *,
64 struct mounta *, struct cred *);
65 static int tmp_unmount(struct vfs *, int, struct cred *);
66 static int tmp_root(struct vfs *, struct vnode **);
67 static int tmp_statvfs(struct vfs *, struct statvfs64 *);
68 static int tmp_vget(struct vfs *, struct vnode **, struct fid *);
69
70 /*
71 * Loadable module wrapper
72 */
73 #include <sys/modctl.h>
74
75 static mntopts_t tmpfs_proto_opttbl;
76
77 static vfsdef_t vfw = {
78 VFSDEF_VERSION,
79 "tmpfs",
80 tmpfsinit,
81 VSW_HASPROTO|VSW_CANREMOUNT|VSW_STATS|VSW_ZMOUNT,
82 &tmpfs_proto_opttbl
83 };
84
85 /*
86 * in-kernel mnttab options
87 */
88 static char *xattr_cancel[] = { MNTOPT_NOXATTR, NULL };
89 static char *noxattr_cancel[] = { MNTOPT_XATTR, NULL };
90
91 static mntopt_t tmpfs_options[] = {
92 /* Option name Cancel Opt Arg Flags Data */
93 { MNTOPT_XATTR, xattr_cancel, NULL, MO_DEFAULT, NULL},
94 { MNTOPT_NOXATTR, noxattr_cancel, NULL, NULL, NULL},
95 { "size", NULL, "0", MO_HASVALUE, NULL},
96 { "mode", NULL, NULL, MO_HASVALUE, NULL}
97 };
98
99
100 static mntopts_t tmpfs_proto_opttbl = {
101 sizeof (tmpfs_options) / sizeof (mntopt_t),
102 tmpfs_options
103 };
104
105 /*
106 * Module linkage information
107 */
108 static struct modlfs modlfs = {
109 &mod_fsops, "filesystem for tmpfs", &vfw
110 };
111
112 static struct modlinkage modlinkage = {
113 MODREV_1, &modlfs, NULL
114 };
115
116 int
117 _init()
118 {
119 return (mod_install(&modlinkage));
120 }
121
122 int
123 _fini()
124 {
125 int error;
126
127 error = mod_remove(&modlinkage);
128 if (error)
129 return (error);
130 /*
131 * Tear down the operations vectors
132 */
133 (void) vfs_freevfsops_by_type(tmpfsfstype);
134 vn_freevnodeops(tmp_vnodeops);
135 return (0);
136 }
137
138 int
139 _info(struct modinfo *modinfop)
140 {
141 return (mod_info(&modlinkage, modinfop));
142 }
143
144 /*
145 * The following are patchable variables limiting the amount of system
146 * resources tmpfs can use.
147 *
148 * tmpfs_maxkmem limits the amount of kernel kmem_alloc memory
149 * tmpfs can use for it's data structures (e.g. tmpnodes, directory entries)
150 * It is not determined by setting a hard limit but rather as a percentage of
151 * physical memory which is determined when tmpfs is first used in the system.
152 *
153 * tmpfs_minfree is the minimum amount of swap space that tmpfs leaves for
154 * the rest of the system. In other words, if the amount of free swap space
155 * in the system (i.e. anoninfo.ani_free) drops below tmpfs_minfree, tmpfs
156 * anon allocations will fail.
157 *
158 * There is also a per mount limit on the amount of swap space
159 * (tmount.tm_anonmax) settable via a mount option.
160 */
161 volatile size_t tmpfs_maxkmem = 0;
162 volatile size_t tmpfs_minfree = 0;
163 size_t tmp_kmemspace; /* bytes of kernel heap used by all tmpfs */
164
165 static major_t tmpfs_major;
166 static minor_t tmpfs_minor;
167 static kmutex_t tmpfs_minor_lock;
168
169 /*
170 * initialize global tmpfs locks and such
171 * called when loading tmpfs module
172 */
173 static int
174 tmpfsinit(int fstype, char *name)
175 {
176 static const fs_operation_def_t tmp_vfsops_template[] = {
177 VFSNAME_MOUNT, { .vfs_mount = tmp_mount },
178 VFSNAME_UNMOUNT, { .vfs_unmount = tmp_unmount },
179 VFSNAME_ROOT, { .vfs_root = tmp_root },
180 VFSNAME_STATVFS, { .vfs_statvfs = tmp_statvfs },
181 VFSNAME_VGET, { .vfs_vget = tmp_vget },
182 NULL, NULL
183 };
184 int error;
185 extern void tmpfs_hash_init();
186
187 tmpfs_hash_init();
188 tmpfsfstype = fstype;
189 ASSERT(tmpfsfstype != 0);
190
191 error = vfs_setfsops(fstype, tmp_vfsops_template, NULL);
192 if (error != 0) {
193 cmn_err(CE_WARN, "tmpfsinit: bad vfs ops template");
194 return (error);
195 }
196
197 error = vn_make_ops(name, tmp_vnodeops_template, &tmp_vnodeops);
198 if (error != 0) {
199 (void) vfs_freevfsops_by_type(fstype);
200 cmn_err(CE_WARN, "tmpfsinit: bad vnode ops template");
201 return (error);
202 }
203
204 /*
205 * tmpfs_minfree doesn't need to be some function of configured
206 * swap space since it really is an absolute limit of swap space
207 * which still allows other processes to execute.
208 */
209 if (tmpfs_minfree == 0) {
210 /*
211 * Set if not patched
212 */
213 tmpfs_minfree = btopr(TMPMINFREE);
214 }
215
216 /*
217 * The maximum amount of space tmpfs can allocate is
218 * TMPMAXPROCKMEM percent of kernel memory
219 */
220 if (tmpfs_maxkmem == 0)
221 tmpfs_maxkmem = MAX(PAGESIZE, kmem_maxavail() / TMPMAXFRACKMEM);
222
223 if ((tmpfs_major = getudev()) == (major_t)-1) {
224 cmn_err(CE_WARN, "tmpfsinit: Can't get unique device number.");
225 tmpfs_major = 0;
226 }
227 mutex_init(&tmpfs_minor_lock, NULL, MUTEX_DEFAULT, NULL);
228 return (0);
229 }
230
231 static int
232 tmp_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
233 {
234 struct tmount *tm = NULL;
235 struct tmpnode *tp;
236 struct pathname dpn;
237 int error;
238 pgcnt_t anonmax;
239 struct vattr rattr;
240 int got_attrs;
241 boolean_t mode_arg = B_FALSE;
242 mode_t root_mode = 0777;
243 char *argstr;
244
245 if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
246 return (error);
247
248 if (mvp->v_type != VDIR)
249 return (ENOTDIR);
250
251 mutex_enter(&mvp->v_lock);
252 if ((uap->flags & MS_REMOUNT) == 0 && (uap->flags & MS_OVERLAY) == 0 &&
253 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
254 mutex_exit(&mvp->v_lock);
255 return (EBUSY);
256 }
257 mutex_exit(&mvp->v_lock);
258
259 /*
260 * Having the resource be anything but "swap" doesn't make sense.
261 */
262 vfs_setresource(vfsp, "swap", 0);
263
264 /*
265 * now look for options we understand...
266 */
267
268 /* tmpfs doesn't support read-only mounts */
269 if (vfs_optionisset(vfsp, MNTOPT_RO, NULL)) {
270 error = EINVAL;
271 goto out;
272 }
273
274 /*
275 * tm_anonmax is set according to the mount arguments
276 * if any. Otherwise, it is set to a maximum value.
277 */
278 if (vfs_optionisset(vfsp, "size", &argstr)) {
279 if ((error = tmp_convnum(argstr, &anonmax)) != 0)
280 goto out;
281 } else {
282 anonmax = ULONG_MAX;
283 }
284
285 /*
286 * The "mode" mount argument allows the operator to override the
287 * permissions of the root of the tmpfs mount.
288 */
289 if (vfs_optionisset(vfsp, "mode", &argstr)) {
290 if ((error = tmp_convmode(argstr, &root_mode)) != 0) {
291 goto out;
292 }
293 mode_arg = B_TRUE;
294 }
295
296 if (error = pn_get(uap->dir,
297 (uap->flags & MS_SYSSPACE) ? UIO_SYSSPACE : UIO_USERSPACE, &dpn))
298 goto out;
299
300 if (uap->flags & MS_REMOUNT) {
301 tm = (struct tmount *)VFSTOTM(vfsp);
302
303 /*
304 * If we change the size so its less than what is currently
305 * being used, we allow that. The file system will simply be
306 * full until enough files have been removed to get below the
307 * new max.
308 */
309 mutex_enter(&tm->tm_contents);
310 tm->tm_anonmax = anonmax;
311 mutex_exit(&tm->tm_contents);
312 goto out;
313 }
314
315 if ((tm = tmp_memalloc(sizeof (struct tmount), 0)) == NULL) {
316 pn_free(&dpn);
317 error = ENOMEM;
318 goto out;
319 }
320
321 /*
322 * find an available minor device number for this mount
323 */
324 mutex_enter(&tmpfs_minor_lock);
325 do {
326 tmpfs_minor = (tmpfs_minor + 1) & L_MAXMIN32;
327 tm->tm_dev = makedevice(tmpfs_major, tmpfs_minor);
328 } while (vfs_devismounted(tm->tm_dev));
329 mutex_exit(&tmpfs_minor_lock);
330
331 /*
332 * Set but don't bother entering the mutex
333 * (tmount not on mount list yet)
334 */
335 mutex_init(&tm->tm_contents, NULL, MUTEX_DEFAULT, NULL);
336 mutex_init(&tm->tm_renamelck, NULL, MUTEX_DEFAULT, NULL);
337
338 tm->tm_vfsp = vfsp;
339 tm->tm_anonmax = anonmax;
340
341 vfsp->vfs_data = (caddr_t)tm;
342 vfsp->vfs_fstype = tmpfsfstype;
343 vfsp->vfs_dev = tm->tm_dev;
344 vfsp->vfs_bsize = PAGESIZE;
345 vfsp->vfs_flag |= VFS_NOTRUNC;
346 vfs_make_fsid(&vfsp->vfs_fsid, tm->tm_dev, tmpfsfstype);
347 tm->tm_mntpath = tmp_memalloc(dpn.pn_pathlen + 1, TMP_MUSTHAVE);
348 (void) strcpy(tm->tm_mntpath, dpn.pn_path);
349
350 /*
351 * allocate and initialize root tmpnode structure
352 */
353 bzero(&rattr, sizeof (struct vattr));
354 rattr.va_mode = (mode_t)(S_IFDIR | root_mode);
355 rattr.va_type = VDIR;
356 rattr.va_rdev = 0;
357 tp = tmp_memalloc(sizeof (struct tmpnode), TMP_MUSTHAVE);
358 tmpnode_init(tm, tp, &rattr, cr);
359
360 /*
361 * Get the mode, uid, and gid from the underlying mount point.
362 */
363 rattr.va_mask = AT_MODE|AT_UID|AT_GID; /* Hint to getattr */
364 got_attrs = VOP_GETATTR(mvp, &rattr, 0, cr, NULL);
365
366 rw_enter(&tp->tn_rwlock, RW_WRITER);
367 TNTOV(tp)->v_flag |= VROOT;
368
369 /*
370 * If the getattr succeeded, use its results. Otherwise allow
371 * the previously set hardwired defaults to prevail.
372 */
373 if (got_attrs == 0) {
374 if (!mode_arg) {
375 /*
376 * Only use the underlying mount point for the
377 * mode if the "mode" mount argument was not
378 * provided.
379 */
380 tp->tn_mode = rattr.va_mode;
381 }
382 tp->tn_uid = rattr.va_uid;
383 tp->tn_gid = rattr.va_gid;
384 }
385
386 /*
387 * initialize linked list of tmpnodes so that the back pointer of
388 * the root tmpnode always points to the last one on the list
389 * and the forward pointer of the last node is null
390 */
391 tp->tn_back = tp;
392 tp->tn_forw = NULL;
393 tp->tn_nlink = 0;
394 tm->tm_rootnode = tp;
395
396 tdirinit(tp, tp);
397
398 rw_exit(&tp->tn_rwlock);
399
400 pn_free(&dpn);
401 error = 0;
402
403 out:
404 if (error == 0)
405 vfs_set_feature(vfsp, VFSFT_SYSATTR_VIEWS);
406
407 return (error);
408 }
409
410 static int
411 tmp_unmount(struct vfs *vfsp, int flag, struct cred *cr)
412 {
413 struct tmount *tm = (struct tmount *)VFSTOTM(vfsp);
414 struct tmpnode *tnp, *cancel;
415 struct vnode *vp;
416 int error;
417
418 if ((error = secpolicy_fs_unmount(cr, vfsp)) != 0)
419 return (error);
420
421 /*
422 * forced unmount is not supported by this file system
423 * and thus, ENOTSUP, is being returned.
424 */
425 if (flag & MS_FORCE)
426 return (ENOTSUP);
427
428 mutex_enter(&tm->tm_contents);
429
430 /*
431 * If there are no open files, only the root node should have
432 * a reference count.
433 * With tm_contents held, nothing can be added or removed.
434 * There may be some dirty pages. To prevent fsflush from
435 * disrupting the unmount, put a hold on each node while scanning.
436 * If we find a previously referenced node, undo the holds we have
437 * placed and fail EBUSY.
438 */
439 tnp = tm->tm_rootnode;
440 if (TNTOV(tnp)->v_count > 1) {
441 mutex_exit(&tm->tm_contents);
442 return (EBUSY);
443 }
444
445 for (tnp = tnp->tn_forw; tnp; tnp = tnp->tn_forw) {
446 if ((vp = TNTOV(tnp))->v_count > 0) {
447 cancel = tm->tm_rootnode->tn_forw;
448 while (cancel != tnp) {
449 vp = TNTOV(cancel);
450 ASSERT(vp->v_count > 0);
451 VN_RELE(vp);
452 cancel = cancel->tn_forw;
453 }
454 mutex_exit(&tm->tm_contents);
455 return (EBUSY);
456 }
457 VN_HOLD(vp);
458 }
459
460 /*
461 * We can drop the mutex now because no one can find this mount
462 */
463 mutex_exit(&tm->tm_contents);
464
465 /*
466 * Free all kmemalloc'd and anonalloc'd memory associated with
467 * this filesystem. To do this, we go through the file list twice,
468 * once to remove all the directory entries, and then to remove
469 * all the files. We do this because there is useful code in
470 * tmpnode_free which assumes that the directory entry has been
471 * removed before the file.
472 */
473 /*
474 * Remove all directory entries
475 */
476 for (tnp = tm->tm_rootnode; tnp; tnp = tnp->tn_forw) {
477 rw_enter(&tnp->tn_rwlock, RW_WRITER);
478 if (tnp->tn_type == VDIR)
479 tdirtrunc(tnp);
480 if (tnp->tn_vnode->v_flag & V_XATTRDIR) {
481 /*
482 * Account for implicit attrdir reference.
483 */
484 ASSERT(tnp->tn_nlink > 0);
485 DECR_COUNT(&tnp->tn_nlink, &tnp->tn_tlock);
486 }
487 rw_exit(&tnp->tn_rwlock);
488 }
489
490 ASSERT(tm->tm_rootnode);
491
492 /*
493 * All links are gone, v_count is keeping nodes in place.
494 * VN_RELE should make the node disappear, unless somebody
495 * is holding pages against it. Nap and retry until it disappears.
496 *
497 * We re-acquire the lock to prevent others who have a HOLD on
498 * a tmpnode via its pages or anon slots from blowing it away
499 * (in tmp_inactive) while we're trying to get to it here. Once
500 * we have a HOLD on it we know it'll stick around.
501 *
502 */
503 mutex_enter(&tm->tm_contents);
504 /*
505 * Remove all the files (except the rootnode) backwards.
506 */
507 while ((tnp = tm->tm_rootnode->tn_back) != tm->tm_rootnode) {
508 mutex_exit(&tm->tm_contents);
509 /*
510 * Inhibit tmp_inactive from touching attribute directory
511 * as all nodes will be released here.
512 * Note we handled the link count in pass 2 above.
513 */
514 rw_enter(&tnp->tn_rwlock, RW_WRITER);
515 tnp->tn_xattrdp = NULL;
516 rw_exit(&tnp->tn_rwlock);
517 vp = TNTOV(tnp);
518 VN_RELE(vp);
519 mutex_enter(&tm->tm_contents);
520 /*
521 * It's still there after the RELE. Someone else like pageout
522 * has a hold on it so wait a bit and then try again - we know
523 * they'll give it up soon.
524 */
525 if (tnp == tm->tm_rootnode->tn_back) {
526 VN_HOLD(vp);
527 mutex_exit(&tm->tm_contents);
528 delay(hz / 4);
529 mutex_enter(&tm->tm_contents);
530 }
531 }
532 mutex_exit(&tm->tm_contents);
533
534 tm->tm_rootnode->tn_xattrdp = NULL;
535 VN_RELE(TNTOV(tm->tm_rootnode));
536
537 ASSERT(tm->tm_mntpath);
538
539 tmp_memfree(tm->tm_mntpath, strlen(tm->tm_mntpath) + 1);
540
541 ASSERT(tm->tm_anonmem == 0);
542
543 mutex_destroy(&tm->tm_contents);
544 mutex_destroy(&tm->tm_renamelck);
545 tmp_memfree(tm, sizeof (struct tmount));
546
547 return (0);
548 }
549
550 /*
551 * return root tmpnode for given vnode
552 */
553 static int
554 tmp_root(struct vfs *vfsp, struct vnode **vpp)
555 {
556 struct tmount *tm = (struct tmount *)VFSTOTM(vfsp);
557 struct tmpnode *tp = tm->tm_rootnode;
558 struct vnode *vp;
559
560 ASSERT(tp);
561
562 vp = TNTOV(tp);
563 VN_HOLD(vp);
564 *vpp = vp;
565 return (0);
566 }
567
568 static int
569 tmp_statvfs(struct vfs *vfsp, struct statvfs64 *sbp)
570 {
571 struct tmount *tm = (struct tmount *)VFSTOTM(vfsp);
572 ulong_t blocks;
573 dev32_t d32;
574 zoneid_t eff_zid;
575 struct zone *zp;
576
577 /*
578 * The file system may have been mounted by the global zone on
579 * behalf of the non-global zone. In that case, the tmount zone_id
580 * will be the global zone. We still want to show the swap cap inside
581 * the zone in this case, even though the file system was mounted by
582 * the global zone.
583 */
584 if (curproc->p_zone->zone_id != GLOBAL_ZONEUNIQID)
585 zp = curproc->p_zone;
586 else
587 zp = tm->tm_vfsp->vfs_zone;
588
589 if (zp == NULL)
590 eff_zid = GLOBAL_ZONEUNIQID;
591 else
592 eff_zid = zp->zone_id;
593
594 sbp->f_bsize = PAGESIZE;
595 sbp->f_frsize = PAGESIZE;
596
597 /*
598 * Find the amount of available physical and memory swap
599 */
600 mutex_enter(&anoninfo_lock);
601 ASSERT(k_anoninfo.ani_max >= k_anoninfo.ani_phys_resv);
602 blocks = (ulong_t)CURRENT_TOTAL_AVAILABLE_SWAP;
603 mutex_exit(&anoninfo_lock);
604
605 /*
606 * If tm_anonmax for this mount is less than the available swap space
607 * (minus the amount tmpfs can't use), use that instead
608 */
609 if (blocks > tmpfs_minfree)
610 sbp->f_bfree = MIN(blocks - tmpfs_minfree,
611 tm->tm_anonmax - tm->tm_anonmem);
612 else
613 sbp->f_bfree = 0;
614
615 sbp->f_bavail = sbp->f_bfree;
616
617 /*
618 * Total number of blocks is what's available plus what's been used
619 */
620 sbp->f_blocks = (fsblkcnt64_t)(sbp->f_bfree + tm->tm_anonmem);
621
622 if (eff_zid != GLOBAL_ZONEUNIQID &&
623 zp->zone_max_swap_ctl != UINT64_MAX) {
624 /*
625 * If the fs is used by a non-global zone with a swap cap,
626 * then report the capped size.
627 */
628 rctl_qty_t cap, used;
629 pgcnt_t pgcap, pgused;
630
631 mutex_enter(&zp->zone_mem_lock);
632 cap = zp->zone_max_swap_ctl;
633 used = zp->zone_max_swap;
634 mutex_exit(&zp->zone_mem_lock);
635
636 pgcap = btop(cap);
637 pgused = btop(used);
638
639 sbp->f_bfree = MIN(pgcap - pgused, sbp->f_bfree);
640 sbp->f_bavail = sbp->f_bfree;
641 sbp->f_blocks = MIN(pgcap, sbp->f_blocks);
642 }
643
644 /*
645 * The maximum number of files available is approximately the number
646 * of tmpnodes we can allocate from the remaining kernel memory
647 * available to tmpfs. This is fairly inaccurate since it doesn't
648 * take into account the names stored in the directory entries.
649 */
650 if (tmpfs_maxkmem > tmp_kmemspace)
651 sbp->f_ffree = (tmpfs_maxkmem - tmp_kmemspace) /
652 (sizeof (struct tmpnode) + sizeof (struct tdirent));
653 else
654 sbp->f_ffree = 0;
655
656 sbp->f_files = tmpfs_maxkmem /
657 (sizeof (struct tmpnode) + sizeof (struct tdirent));
658 sbp->f_favail = (fsfilcnt64_t)(sbp->f_ffree);
659 (void) cmpldev(&d32, vfsp->vfs_dev);
660 sbp->f_fsid = d32;
661 (void) strcpy(sbp->f_basetype, vfssw[tmpfsfstype].vsw_name);
662 (void) strncpy(sbp->f_fstr, tm->tm_mntpath, sizeof (sbp->f_fstr));
663 /*
664 * ensure null termination
665 */
666 sbp->f_fstr[sizeof (sbp->f_fstr) - 1] = '\0';
667 sbp->f_flag = vf_to_stf(vfsp->vfs_flag);
668 sbp->f_namemax = MAXNAMELEN - 1;
669 return (0);
670 }
671
672 static int
673 tmp_vget(struct vfs *vfsp, struct vnode **vpp, struct fid *fidp)
674 {
675 struct tfid *tfid;
676 struct tmount *tm = (struct tmount *)VFSTOTM(vfsp);
677 struct tmpnode *tp = NULL;
678
679 tfid = (struct tfid *)fidp;
680 *vpp = NULL;
681
682 mutex_enter(&tm->tm_contents);
683 for (tp = tm->tm_rootnode; tp; tp = tp->tn_forw) {
684 mutex_enter(&tp->tn_tlock);
685 if (tp->tn_nodeid == tfid->tfid_ino) {
686 /*
687 * If the gen numbers don't match we know the
688 * file won't be found since only one tmpnode
689 * can have this number at a time.
690 */
691 if (tp->tn_gen != tfid->tfid_gen || tp->tn_nlink == 0) {
692 mutex_exit(&tp->tn_tlock);
693 mutex_exit(&tm->tm_contents);
694 return (0);
695 }
696 *vpp = (struct vnode *)TNTOV(tp);
697
698 VN_HOLD(*vpp);
699
700 if ((tp->tn_mode & S_ISVTX) &&
701 !(tp->tn_mode & (S_IXUSR | S_IFDIR))) {
702 mutex_enter(&(*vpp)->v_lock);
703 (*vpp)->v_flag |= VISSWAP;
704 mutex_exit(&(*vpp)->v_lock);
705 }
706 mutex_exit(&tp->tn_tlock);
707 mutex_exit(&tm->tm_contents);
708 return (0);
709 }
710 mutex_exit(&tp->tn_tlock);
711 }
712 mutex_exit(&tm->tm_contents);
713 return (0);
714 }