tmpfs_vnops.c revision 194124 
1/*	$NetBSD: tmpfs_vnops.c,v 1.39 2007/07/23 15:41:01 jmmv Exp $	*/
2
3/*-
4 * Copyright (c) 2005, 2006 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
9 * 2005 program.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33/*
34 * tmpfs vnode interface.
35 */
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD: head/sys/fs/tmpfs/tmpfs_vnops.c 194124 2009-06-13 20:21:08Z alc $");
38
39#include <sys/param.h>
40#include <sys/fcntl.h>
41#include <sys/lockf.h>
42#include <sys/namei.h>
43#include <sys/priv.h>
44#include <sys/proc.h>
45#include <sys/resourcevar.h>
46#include <sys/stat.h>
47#include <sys/systm.h>
48#include <sys/unistd.h>
49#include <sys/vnode.h>
50
51#include <vm/vm.h>
52#include <vm/vm_object.h>
53#include <vm/vm_page.h>
54#include <vm/vm_pager.h>
55
56#include <machine/_inttypes.h>
57
58#include <fs/fifofs/fifo.h>
59#include <fs/tmpfs/tmpfs_vnops.h>
60#include <fs/tmpfs/tmpfs.h>
61
62/* --------------------------------------------------------------------- */
63
64static int
65tmpfs_lookup(struct vop_cachedlookup_args *v)
66{
67	struct vnode *dvp = v->a_dvp;
68	struct vnode **vpp = v->a_vpp;
69	struct componentname *cnp = v->a_cnp;
70
71	int error;
72	struct tmpfs_dirent *de;
73	struct tmpfs_node *dnode;
74
75	dnode = VP_TO_TMPFS_DIR(dvp);
76	*vpp = NULLVP;
77
78	/* Check accessibility of requested node as a first step. */
79	error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_thread);
80	if (error != 0)
81		goto out;
82
83	/* We cannot be requesting the parent directory of the root node. */
84	MPASS(IMPLIES(dnode->tn_type == VDIR &&
85	    dnode->tn_dir.tn_parent == dnode,
86	    !(cnp->cn_flags & ISDOTDOT)));
87
88	if (cnp->cn_flags & ISDOTDOT) {
89		int ltype = 0;
90
91		ltype = VOP_ISLOCKED(dvp);
92		vhold(dvp);
93		VOP_UNLOCK(dvp, 0);
94		/* Allocate a new vnode on the matching entry. */
95		error = tmpfs_alloc_vp(dvp->v_mount, dnode->tn_dir.tn_parent,
96		    cnp->cn_lkflags, vpp);
97
98		vn_lock(dvp, ltype | LK_RETRY);
99		vdrop(dvp);
100	} else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
101		VREF(dvp);
102		*vpp = dvp;
103		error = 0;
104	} else {
105		de = tmpfs_dir_lookup(dnode, NULL, cnp);
106		if (de == NULL) {
107			/* The entry was not found in the directory.
108			 * This is OK if we are creating or renaming an
109			 * entry and are working on the last component of
110			 * the path name. */
111			if ((cnp->cn_flags & ISLASTCN) &&
112			    (cnp->cn_nameiop == CREATE || \
113			    cnp->cn_nameiop == RENAME)) {
114				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
115				    cnp->cn_thread);
116				if (error != 0)
117					goto out;
118
119				/* Keep the component name in the buffer for
120				 * future uses. */
121				cnp->cn_flags |= SAVENAME;
122
123				error = EJUSTRETURN;
124			} else
125				error = ENOENT;
126		} else {
127			struct tmpfs_node *tnode;
128
129			/* The entry was found, so get its associated
130			 * tmpfs_node. */
131			tnode = de->td_node;
132
133			/* If we are not at the last path component and
134			 * found a non-directory or non-link entry (which
135			 * may itself be pointing to a directory), raise
136			 * an error. */
137			if ((tnode->tn_type != VDIR &&
138			    tnode->tn_type != VLNK) &&
139			    !(cnp->cn_flags & ISLASTCN)) {
140				error = ENOTDIR;
141				goto out;
142			}
143
144			/* If we are deleting or renaming the entry, keep
145			 * track of its tmpfs_dirent so that it can be
146			 * easily deleted later. */
147			if ((cnp->cn_flags & ISLASTCN) &&
148			    (cnp->cn_nameiop == DELETE ||
149			    cnp->cn_nameiop == RENAME)) {
150				error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
151				    cnp->cn_thread);
152				if (error != 0)
153					goto out;
154
155				/* Allocate a new vnode on the matching entry. */
156				error = tmpfs_alloc_vp(dvp->v_mount, tnode,
157						cnp->cn_lkflags, vpp);
158				if (error != 0)
159					goto out;
160
161				if ((dnode->tn_mode & S_ISTXT) &&
162				  VOP_ACCESS(dvp, VADMIN, cnp->cn_cred, cnp->cn_thread) &&
163				  VOP_ACCESS(*vpp, VADMIN, cnp->cn_cred, cnp->cn_thread)) {
164					error = EPERM;
165					vput(*vpp);
166					*vpp = NULL;
167					goto out;
168				}
169				cnp->cn_flags |= SAVENAME;
170			} else {
171				error = tmpfs_alloc_vp(dvp->v_mount, tnode,
172						cnp->cn_lkflags, vpp);
173			}
174		}
175	}
176
177	/* Store the result of this lookup in the cache.  Avoid this if the
178	 * request was for creation, as it does not improve timings on
179	 * emprical tests. */
180	if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE)
181		cache_enter(dvp, *vpp, cnp);
182
183out:
184	/* If there were no errors, *vpp cannot be null and it must be
185	 * locked. */
186	MPASS(IFF(error == 0, *vpp != NULLVP && VOP_ISLOCKED(*vpp)));
187
188	return error;
189}
190
191/* --------------------------------------------------------------------- */
192
193static int
194tmpfs_create(struct vop_create_args *v)
195{
196	struct vnode *dvp = v->a_dvp;
197	struct vnode **vpp = v->a_vpp;
198	struct componentname *cnp = v->a_cnp;
199	struct vattr *vap = v->a_vap;
200
201	MPASS(vap->va_type == VREG || vap->va_type == VSOCK);
202
203	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
204}
205/* --------------------------------------------------------------------- */
206
207static int
208tmpfs_mknod(struct vop_mknod_args *v)
209{
210	struct vnode *dvp = v->a_dvp;
211	struct vnode **vpp = v->a_vpp;
212	struct componentname *cnp = v->a_cnp;
213	struct vattr *vap = v->a_vap;
214
215	if (vap->va_type != VBLK && vap->va_type != VCHR &&
216	    vap->va_type != VFIFO)
217		return EINVAL;
218
219	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
220}
221
222/* --------------------------------------------------------------------- */
223
224static int
225tmpfs_open(struct vop_open_args *v)
226{
227	struct vnode *vp = v->a_vp;
228	int mode = v->a_mode;
229
230	int error;
231	struct tmpfs_node *node;
232
233	MPASS(VOP_ISLOCKED(vp));
234
235	node = VP_TO_TMPFS_NODE(vp);
236
237	/* The file is still active but all its names have been removed
238	 * (e.g. by a "rmdir $(pwd)").  It cannot be opened any more as
239	 * it is about to die. */
240	if (node->tn_links < 1)
241		return (ENOENT);
242
243	/* If the file is marked append-only, deny write requests. */
244	if (node->tn_flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE)
245		error = EPERM;
246	else {
247		error = 0;
248		vnode_create_vobject(vp, node->tn_size, v->a_td);
249	}
250
251	MPASS(VOP_ISLOCKED(vp));
252	return error;
253}
254
255/* --------------------------------------------------------------------- */
256
257static int
258tmpfs_close(struct vop_close_args *v)
259{
260	struct vnode *vp = v->a_vp;
261
262	struct tmpfs_node *node;
263
264	MPASS(VOP_ISLOCKED(vp));
265
266	node = VP_TO_TMPFS_NODE(vp);
267
268	if (node->tn_links > 0) {
269		/* Update node times.  No need to do it if the node has
270		 * been deleted, because it will vanish after we return. */
271		tmpfs_update(vp);
272	}
273
274	return 0;
275}
276
277/* --------------------------------------------------------------------- */
278
279int
280tmpfs_access(struct vop_access_args *v)
281{
282	struct vnode *vp = v->a_vp;
283	accmode_t accmode = v->a_accmode;
284	struct ucred *cred = v->a_cred;
285
286	int error;
287	struct tmpfs_node *node;
288
289	MPASS(VOP_ISLOCKED(vp));
290
291	node = VP_TO_TMPFS_NODE(vp);
292
293	switch (vp->v_type) {
294	case VDIR:
295		/* FALLTHROUGH */
296	case VLNK:
297		/* FALLTHROUGH */
298	case VREG:
299		if (accmode & VWRITE && vp->v_mount->mnt_flag & MNT_RDONLY) {
300			error = EROFS;
301			goto out;
302		}
303		break;
304
305	case VBLK:
306		/* FALLTHROUGH */
307	case VCHR:
308		/* FALLTHROUGH */
309	case VSOCK:
310		/* FALLTHROUGH */
311	case VFIFO:
312		break;
313
314	default:
315		error = EINVAL;
316		goto out;
317	}
318
319	if (accmode & VWRITE && node->tn_flags & IMMUTABLE) {
320		error = EPERM;
321		goto out;
322	}
323
324	error = vaccess(vp->v_type, node->tn_mode, node->tn_uid,
325	    node->tn_gid, accmode, cred, NULL);
326
327out:
328	MPASS(VOP_ISLOCKED(vp));
329
330	return error;
331}
332
333/* --------------------------------------------------------------------- */
334
335int
336tmpfs_getattr(struct vop_getattr_args *v)
337{
338	struct vnode *vp = v->a_vp;
339	struct vattr *vap = v->a_vap;
340
341	struct tmpfs_node *node;
342
343	node = VP_TO_TMPFS_NODE(vp);
344
345	tmpfs_update(vp);
346
347	vap->va_type = vp->v_type;
348	vap->va_mode = node->tn_mode;
349	vap->va_nlink = node->tn_links;
350	vap->va_uid = node->tn_uid;
351	vap->va_gid = node->tn_gid;
352	vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
353	vap->va_fileid = node->tn_id;
354	vap->va_size = node->tn_size;
355	vap->va_blocksize = PAGE_SIZE;
356	vap->va_atime = node->tn_atime;
357	vap->va_mtime = node->tn_mtime;
358	vap->va_ctime = node->tn_ctime;
359	vap->va_birthtime = node->tn_birthtime;
360	vap->va_gen = node->tn_gen;
361	vap->va_flags = node->tn_flags;
362	vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
363		node->tn_rdev : NODEV;
364	vap->va_bytes = round_page(node->tn_size);
365	vap->va_filerev = 0;
366
367	return 0;
368}
369
370/* --------------------------------------------------------------------- */
371
372/* XXX Should this operation be atomic?  I think it should, but code in
373 * XXX other places (e.g., ufs) doesn't seem to be... */
374int
375tmpfs_setattr(struct vop_setattr_args *v)
376{
377	struct vnode *vp = v->a_vp;
378	struct vattr *vap = v->a_vap;
379	struct ucred *cred = v->a_cred;
380	struct thread *td = curthread;
381
382	int error;
383
384	MPASS(VOP_ISLOCKED(vp));
385
386	error = 0;
387
388	/* Abort if any unsettable attribute is given. */
389	if (vap->va_type != VNON ||
390	    vap->va_nlink != VNOVAL ||
391	    vap->va_fsid != VNOVAL ||
392	    vap->va_fileid != VNOVAL ||
393	    vap->va_blocksize != VNOVAL ||
394	    vap->va_gen != VNOVAL ||
395	    vap->va_rdev != VNOVAL ||
396	    vap->va_bytes != VNOVAL)
397		error = EINVAL;
398
399	if (error == 0 && (vap->va_flags != VNOVAL))
400		error = tmpfs_chflags(vp, vap->va_flags, cred, td);
401
402	if (error == 0 && (vap->va_size != VNOVAL))
403		error = tmpfs_chsize(vp, vap->va_size, cred, td);
404
405	if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL))
406		error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, td);
407
408	if (error == 0 && (vap->va_mode != (mode_t)VNOVAL))
409		error = tmpfs_chmod(vp, vap->va_mode, cred, td);
410
411	if (error == 0 && ((vap->va_atime.tv_sec != VNOVAL &&
412	    vap->va_atime.tv_nsec != VNOVAL) ||
413	    (vap->va_mtime.tv_sec != VNOVAL &&
414	    vap->va_mtime.tv_nsec != VNOVAL) ||
415	    (vap->va_birthtime.tv_sec != VNOVAL &&
416	    vap->va_birthtime.tv_nsec != VNOVAL)))
417		error = tmpfs_chtimes(vp, &vap->va_atime, &vap->va_mtime,
418			&vap->va_birthtime, vap->va_vaflags, cred, td);
419
420	/* Update the node times.  We give preference to the error codes
421	 * generated by this function rather than the ones that may arise
422	 * from tmpfs_update. */
423	tmpfs_update(vp);
424
425	MPASS(VOP_ISLOCKED(vp));
426
427	return error;
428}
429
430/* --------------------------------------------------------------------- */
431
432static int
433tmpfs_mappedread(vm_object_t vobj, vm_object_t tobj, size_t len, struct uio *uio)
434{
435	vm_pindex_t	idx;
436	vm_page_t	m;
437	vm_offset_t	offset;
438	off_t		addr;
439	size_t		tlen;
440	int		error;
441
442	addr = uio->uio_offset;
443	idx = OFF_TO_IDX(addr);
444	offset = addr & PAGE_MASK;
445	tlen = MIN(PAGE_SIZE - offset, len);
446
447	if ((vobj == NULL) || (vobj->resident_page_count == 0))
448		goto nocache;
449
450	VM_OBJECT_LOCK(vobj);
451lookupvpg:
452	if (((m = vm_page_lookup(vobj, idx)) != NULL) &&
453	    vm_page_is_valid(m, offset, tlen)) {
454		if (vm_page_sleep_if_busy(m, FALSE, "tmfsmr"))
455			goto lookupvpg;
456		vm_page_busy(m);
457		VM_OBJECT_UNLOCK(vobj);
458		error = uiomove_fromphys(&m, offset, tlen, uio);
459		VM_OBJECT_LOCK(vobj);
460		vm_page_wakeup(m);
461		VM_OBJECT_UNLOCK(vobj);
462		return	(error);
463	}
464	VM_OBJECT_UNLOCK(vobj);
465nocache:
466	VM_OBJECT_LOCK(tobj);
467	vm_object_pip_add(tobj, 1);
468	m = vm_page_grab(tobj, idx, VM_ALLOC_WIRED |
469	    VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
470	if (m->valid != VM_PAGE_BITS_ALL) {
471		if (vm_pager_has_page(tobj, idx, NULL, NULL)) {
472			error = vm_pager_get_pages(tobj, &m, 1, 0);
473			if (error != 0) {
474				printf("tmpfs get pages from pager error [read]\n");
475				goto out;
476			}
477		} else
478			vm_page_zero_invalid(m, TRUE);
479	}
480	VM_OBJECT_UNLOCK(tobj);
481	error = uiomove_fromphys(&m, offset, tlen, uio);
482	VM_OBJECT_LOCK(tobj);
483out:
484	vm_page_lock_queues();
485	vm_page_unwire(m, TRUE);
486	vm_page_unlock_queues();
487	vm_page_wakeup(m);
488	vm_object_pip_subtract(tobj, 1);
489	VM_OBJECT_UNLOCK(tobj);
490
491	return	(error);
492}
493
494static int
495tmpfs_read(struct vop_read_args *v)
496{
497	struct vnode *vp = v->a_vp;
498	struct uio *uio = v->a_uio;
499
500	struct tmpfs_node *node;
501	vm_object_t uobj;
502	size_t len;
503	int resid;
504
505	int error = 0;
506
507	node = VP_TO_TMPFS_NODE(vp);
508
509	if (vp->v_type != VREG) {
510		error = EISDIR;
511		goto out;
512	}
513
514	if (uio->uio_offset < 0) {
515		error = EINVAL;
516		goto out;
517	}
518
519	node->tn_status |= TMPFS_NODE_ACCESSED;
520
521	uobj = node->tn_reg.tn_aobj;
522	while ((resid = uio->uio_resid) > 0) {
523		error = 0;
524		if (node->tn_size <= uio->uio_offset)
525			break;
526		len = MIN(node->tn_size - uio->uio_offset, resid);
527		if (len == 0)
528			break;
529		error = tmpfs_mappedread(vp->v_object, uobj, len, uio);
530		if ((error != 0) || (resid == uio->uio_resid))
531			break;
532	}
533
534out:
535
536	return error;
537}
538
539/* --------------------------------------------------------------------- */
540
541static int
542tmpfs_mappedwrite(vm_object_t vobj, vm_object_t tobj, size_t len, struct uio *uio)
543{
544	vm_pindex_t	idx;
545	vm_page_t	vpg, tpg;
546	vm_offset_t	offset;
547	off_t		addr;
548	size_t		tlen;
549	int		error;
550
551	error = 0;
552
553	addr = uio->uio_offset;
554	idx = OFF_TO_IDX(addr);
555	offset = addr & PAGE_MASK;
556	tlen = MIN(PAGE_SIZE - offset, len);
557
558	if ((vobj == NULL) || (vobj->resident_page_count == 0)) {
559		vpg = NULL;
560		goto nocache;
561	}
562
563	VM_OBJECT_LOCK(vobj);
564lookupvpg:
565	if (((vpg = vm_page_lookup(vobj, idx)) != NULL) &&
566	    vm_page_is_valid(vpg, offset, tlen)) {
567		if (vm_page_sleep_if_busy(vpg, FALSE, "tmfsmw"))
568			goto lookupvpg;
569		vm_page_busy(vpg);
570		vm_page_lock_queues();
571		vm_page_undirty(vpg);
572		vm_page_unlock_queues();
573		VM_OBJECT_UNLOCK(vobj);
574		error = uiomove_fromphys(&vpg, offset, tlen, uio);
575	} else {
576		VM_OBJECT_UNLOCK(vobj);
577		vpg = NULL;
578	}
579nocache:
580	VM_OBJECT_LOCK(tobj);
581	vm_object_pip_add(tobj, 1);
582	tpg = vm_page_grab(tobj, idx, VM_ALLOC_WIRED |
583	    VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
584	if (tpg->valid != VM_PAGE_BITS_ALL) {
585		if (vm_pager_has_page(tobj, idx, NULL, NULL)) {
586			error = vm_pager_get_pages(tobj, &tpg, 1, 0);
587			if (error != 0) {
588				printf("tmpfs get pages from pager error [write]\n");
589				goto out;
590			}
591		} else
592			vm_page_zero_invalid(tpg, TRUE);
593	}
594	VM_OBJECT_UNLOCK(tobj);
595	if (vpg == NULL)
596		error = uiomove_fromphys(&tpg, offset, tlen, uio);
597	else {
598		KASSERT(vpg->valid == VM_PAGE_BITS_ALL, ("parts of vpg invalid"));
599		pmap_copy_page(vpg, tpg);
600	}
601	VM_OBJECT_LOCK(tobj);
602out:
603	if (vobj != NULL)
604		VM_OBJECT_LOCK(vobj);
605	vm_page_lock_queues();
606	if (error == 0) {
607		KASSERT(tpg->valid == VM_PAGE_BITS_ALL,
608		    ("parts of tpg invalid"));
609		vm_page_dirty(tpg);
610	}
611	vm_page_unwire(tpg, TRUE);
612	vm_page_unlock_queues();
613	vm_page_wakeup(tpg);
614	if (vpg != NULL)
615		vm_page_wakeup(vpg);
616	if (vobj != NULL)
617		VM_OBJECT_UNLOCK(vobj);
618	vm_object_pip_subtract(tobj, 1);
619	VM_OBJECT_UNLOCK(tobj);
620
621	return	(error);
622}
623
624static int
625tmpfs_write(struct vop_write_args *v)
626{
627	struct vnode *vp = v->a_vp;
628	struct uio *uio = v->a_uio;
629	int ioflag = v->a_ioflag;
630	struct thread *td = uio->uio_td;
631
632	boolean_t extended;
633	int error = 0;
634	off_t oldsize;
635	struct tmpfs_node *node;
636	vm_object_t uobj;
637	size_t len;
638	int resid;
639
640	node = VP_TO_TMPFS_NODE(vp);
641	oldsize = node->tn_size;
642
643	if (uio->uio_offset < 0 || vp->v_type != VREG) {
644		error = EINVAL;
645		goto out;
646	}
647
648	if (uio->uio_resid == 0) {
649		error = 0;
650		goto out;
651	}
652
653	if (ioflag & IO_APPEND)
654		uio->uio_offset = node->tn_size;
655
656	if (uio->uio_offset + uio->uio_resid >
657	  VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
658		return (EFBIG);
659
660	if (vp->v_type == VREG && td != NULL) {
661		PROC_LOCK(td->td_proc);
662		if (uio->uio_offset + uio->uio_resid >
663		  lim_cur(td->td_proc, RLIMIT_FSIZE)) {
664			psignal(td->td_proc, SIGXFSZ);
665			PROC_UNLOCK(td->td_proc);
666			return (EFBIG);
667		}
668		PROC_UNLOCK(td->td_proc);
669	}
670
671	extended = uio->uio_offset + uio->uio_resid > node->tn_size;
672	if (extended) {
673		error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid);
674		if (error != 0)
675			goto out;
676	}
677
678	uobj = node->tn_reg.tn_aobj;
679	while ((resid = uio->uio_resid) > 0) {
680		if (node->tn_size <= uio->uio_offset)
681			break;
682		len = MIN(node->tn_size - uio->uio_offset, resid);
683		if (len == 0)
684			break;
685		error = tmpfs_mappedwrite(vp->v_object, uobj, len, uio);
686		if ((error != 0) || (resid == uio->uio_resid))
687			break;
688	}
689
690	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED |
691	    (extended ? TMPFS_NODE_CHANGED : 0);
692
693	if (node->tn_mode & (S_ISUID | S_ISGID)) {
694		if (priv_check_cred(v->a_cred, PRIV_VFS_RETAINSUGID, 0))
695			node->tn_mode &= ~(S_ISUID | S_ISGID);
696	}
697
698	if (error != 0)
699		(void)tmpfs_reg_resize(vp, oldsize);
700
701out:
702	MPASS(IMPLIES(error == 0, uio->uio_resid == 0));
703	MPASS(IMPLIES(error != 0, oldsize == node->tn_size));
704
705	return error;
706}
707
708/* --------------------------------------------------------------------- */
709
710static int
711tmpfs_fsync(struct vop_fsync_args *v)
712{
713	struct vnode *vp = v->a_vp;
714
715	MPASS(VOP_ISLOCKED(vp));
716
717	tmpfs_update(vp);
718
719	return 0;
720}
721
722/* --------------------------------------------------------------------- */
723
724static int
725tmpfs_remove(struct vop_remove_args *v)
726{
727	struct vnode *dvp = v->a_dvp;
728	struct vnode *vp = v->a_vp;
729
730	int error;
731	struct tmpfs_dirent *de;
732	struct tmpfs_mount *tmp;
733	struct tmpfs_node *dnode;
734	struct tmpfs_node *node;
735
736	MPASS(VOP_ISLOCKED(dvp));
737	MPASS(VOP_ISLOCKED(vp));
738
739	if (vp->v_type == VDIR) {
740		error = EISDIR;
741		goto out;
742	}
743
744	dnode = VP_TO_TMPFS_DIR(dvp);
745	node = VP_TO_TMPFS_NODE(vp);
746	tmp = VFS_TO_TMPFS(vp->v_mount);
747	de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
748	MPASS(de != NULL);
749
750	/* Files marked as immutable or append-only cannot be deleted. */
751	if ((node->tn_flags & (IMMUTABLE | APPEND | NOUNLINK)) ||
752	    (dnode->tn_flags & APPEND)) {
753		error = EPERM;
754		goto out;
755	}
756
757	/* Remove the entry from the directory; as it is a file, we do not
758	 * have to change the number of hard links of the directory. */
759	tmpfs_dir_detach(dvp, de);
760
761	/* Free the directory entry we just deleted.  Note that the node
762	 * referred by it will not be removed until the vnode is really
763	 * reclaimed. */
764	tmpfs_free_dirent(tmp, de, TRUE);
765
766	if (node->tn_links > 0)
767		node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | \
768	    TMPFS_NODE_MODIFIED;
769	error = 0;
770
771out:
772
773	return error;
774}
775
776/* --------------------------------------------------------------------- */
777
778static int
779tmpfs_link(struct vop_link_args *v)
780{
781	struct vnode *dvp = v->a_tdvp;
782	struct vnode *vp = v->a_vp;
783	struct componentname *cnp = v->a_cnp;
784
785	int error;
786	struct tmpfs_dirent *de;
787	struct tmpfs_node *node;
788
789	MPASS(VOP_ISLOCKED(dvp));
790	MPASS(cnp->cn_flags & HASBUF);
791	MPASS(dvp != vp); /* XXX When can this be false? */
792
793	node = VP_TO_TMPFS_NODE(vp);
794
795	/* XXX: Why aren't the following two tests done by the caller? */
796
797	/* Hard links of directories are forbidden. */
798	if (vp->v_type == VDIR) {
799		error = EPERM;
800		goto out;
801	}
802
803	/* Cannot create cross-device links. */
804	if (dvp->v_mount != vp->v_mount) {
805		error = EXDEV;
806		goto out;
807	}
808
809	/* Ensure that we do not overflow the maximum number of links imposed
810	 * by the system. */
811	MPASS(node->tn_links <= LINK_MAX);
812	if (node->tn_links == LINK_MAX) {
813		error = EMLINK;
814		goto out;
815	}
816
817	/* We cannot create links of files marked immutable or append-only. */
818	if (node->tn_flags & (IMMUTABLE | APPEND)) {
819		error = EPERM;
820		goto out;
821	}
822
823	/* Allocate a new directory entry to represent the node. */
824	error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), node,
825	    cnp->cn_nameptr, cnp->cn_namelen, &de);
826	if (error != 0)
827		goto out;
828
829	/* Insert the new directory entry into the appropriate directory. */
830	tmpfs_dir_attach(dvp, de);
831
832	/* vp link count has changed, so update node times. */
833	node->tn_status |= TMPFS_NODE_CHANGED;
834	tmpfs_update(vp);
835
836	error = 0;
837
838out:
839	return error;
840}
841
842/* --------------------------------------------------------------------- */
843
844static int
845tmpfs_rename(struct vop_rename_args *v)
846{
847	struct vnode *fdvp = v->a_fdvp;
848	struct vnode *fvp = v->a_fvp;
849	struct componentname *fcnp = v->a_fcnp;
850	struct vnode *tdvp = v->a_tdvp;
851	struct vnode *tvp = v->a_tvp;
852	struct componentname *tcnp = v->a_tcnp;
853
854	char *newname;
855	int error;
856	struct tmpfs_dirent *de;
857	struct tmpfs_node *fdnode;
858	struct tmpfs_node *fnode;
859	struct tmpfs_node *tnode;
860	struct tmpfs_node *tdnode;
861
862	MPASS(VOP_ISLOCKED(tdvp));
863	MPASS(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp)));
864	MPASS(fcnp->cn_flags & HASBUF);
865	MPASS(tcnp->cn_flags & HASBUF);
866
867  	tnode = (tvp == NULL) ? NULL : VP_TO_TMPFS_NODE(tvp);
868
869	/* Disallow cross-device renames.
870	 * XXX Why isn't this done by the caller? */
871	if (fvp->v_mount != tdvp->v_mount ||
872	    (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
873		error = EXDEV;
874		goto out;
875	}
876
877	tdnode = VP_TO_TMPFS_DIR(tdvp);
878
879	/* If source and target are the same file, there is nothing to do. */
880	if (fvp == tvp) {
881		error = 0;
882		goto out;
883	}
884
885	/* If we need to move the directory between entries, lock the
886	 * source so that we can safely operate on it. */
887	if (tdvp != fdvp) {
888		error = vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
889		if (error != 0)
890			goto out;
891	}
892	fdnode = VP_TO_TMPFS_DIR(fdvp);
893	fnode = VP_TO_TMPFS_NODE(fvp);
894	de = tmpfs_dir_lookup(fdnode, fnode, fcnp);
895
896	/* Avoid manipulating '.' and '..' entries. */
897	if (de == NULL) {
898		MPASS(fvp->v_type == VDIR);
899		error = EINVAL;
900		goto out_locked;
901	}
902	MPASS(de->td_node == fnode);
903
904	/* If re-naming a directory to another preexisting directory
905	 * ensure that the target directory is empty so that its
906	 * removal causes no side effects.
907	 * Kern_rename gurantees the destination to be a directory
908	 * if the source is one. */
909	if (tvp != NULL) {
910		MPASS(tnode != NULL);
911
912		if ((tnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
913		    (tdnode->tn_flags & (APPEND | IMMUTABLE))) {
914			error = EPERM;
915			goto out_locked;
916		}
917
918		if (fnode->tn_type == VDIR && tnode->tn_type == VDIR) {
919			if (tnode->tn_size > 0) {
920				error = ENOTEMPTY;
921				goto out_locked;
922			}
923		} else if (fnode->tn_type == VDIR && tnode->tn_type != VDIR) {
924			error = ENOTDIR;
925			goto out_locked;
926		} else if (fnode->tn_type != VDIR && tnode->tn_type == VDIR) {
927			error = EISDIR;
928			goto out_locked;
929		} else {
930			MPASS(fnode->tn_type != VDIR &&
931				tnode->tn_type != VDIR);
932		}
933	}
934
935	if ((fnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))
936	    || (fdnode->tn_flags & (APPEND | IMMUTABLE))) {
937		error = EPERM;
938		goto out_locked;
939	}
940
941	/* Ensure that we have enough memory to hold the new name, if it
942	 * has to be changed. */
943	if (fcnp->cn_namelen != tcnp->cn_namelen ||
944	    bcmp(fcnp->cn_nameptr, tcnp->cn_nameptr, fcnp->cn_namelen) != 0) {
945		newname = malloc(tcnp->cn_namelen, M_TMPFSNAME, M_WAITOK);
946	} else
947		newname = NULL;
948
949	/* If the node is being moved to another directory, we have to do
950	 * the move. */
951	if (fdnode != tdnode) {
952		/* In case we are moving a directory, we have to adjust its
953		 * parent to point to the new parent. */
954		if (de->td_node->tn_type == VDIR) {
955			struct tmpfs_node *n;
956
957			/* Ensure the target directory is not a child of the
958			 * directory being moved.  Otherwise, we'd end up
959			 * with stale nodes. */
960			n = tdnode;
961			while (n != n->tn_dir.tn_parent) {
962				if (n == fnode) {
963					error = EINVAL;
964					if (newname != NULL)
965						    free(newname, M_TMPFSNAME);
966					goto out_locked;
967				}
968				n = n->tn_dir.tn_parent;
969			}
970
971			/* Adjust the parent pointer. */
972			TMPFS_VALIDATE_DIR(fnode);
973			de->td_node->tn_dir.tn_parent = tdnode;
974
975			/* As a result of changing the target of the '..'
976			 * entry, the link count of the source and target
977			 * directories has to be adjusted. */
978			fdnode->tn_links--;
979			tdnode->tn_links++;
980		}
981
982		/* Do the move: just remove the entry from the source directory
983		 * and insert it into the target one. */
984		tmpfs_dir_detach(fdvp, de);
985		tmpfs_dir_attach(tdvp, de);
986	}
987
988	/* If the name has changed, we need to make it effective by changing
989	 * it in the directory entry. */
990	if (newname != NULL) {
991		MPASS(tcnp->cn_namelen <= MAXNAMLEN);
992
993		free(de->td_name, M_TMPFSNAME);
994		de->td_namelen = (uint16_t)tcnp->cn_namelen;
995		memcpy(newname, tcnp->cn_nameptr, tcnp->cn_namelen);
996		de->td_name = newname;
997
998		fnode->tn_status |= TMPFS_NODE_CHANGED;
999		tdnode->tn_status |= TMPFS_NODE_MODIFIED;
1000	}
1001
1002	/* If we are overwriting an entry, we have to remove the old one
1003	 * from the target directory. */
1004	if (tvp != NULL) {
1005		/* Remove the old entry from the target directory. */
1006		de = tmpfs_dir_lookup(tdnode, tnode, tcnp);
1007		tmpfs_dir_detach(tdvp, de);
1008
1009		/* Free the directory entry we just deleted.  Note that the
1010		 * node referred by it will not be removed until the vnode is
1011		 * really reclaimed. */
1012		tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), de, TRUE);
1013	}
1014
1015	error = 0;
1016
1017out_locked:
1018	if (fdnode != tdnode)
1019		VOP_UNLOCK(fdvp, 0);
1020
1021out:
1022	/* Release target nodes. */
1023	/* XXX: I don't understand when tdvp can be the same as tvp, but
1024	 * other code takes care of this... */
1025	if (tdvp == tvp)
1026		vrele(tdvp);
1027	else
1028		vput(tdvp);
1029	if (tvp != NULL)
1030		vput(tvp);
1031
1032	/* Release source nodes. */
1033	vrele(fdvp);
1034	vrele(fvp);
1035
1036	return error;
1037}
1038
1039/* --------------------------------------------------------------------- */
1040
1041static int
1042tmpfs_mkdir(struct vop_mkdir_args *v)
1043{
1044	struct vnode *dvp = v->a_dvp;
1045	struct vnode **vpp = v->a_vpp;
1046	struct componentname *cnp = v->a_cnp;
1047	struct vattr *vap = v->a_vap;
1048
1049	MPASS(vap->va_type == VDIR);
1050
1051	return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
1052}
1053
1054/* --------------------------------------------------------------------- */
1055
1056static int
1057tmpfs_rmdir(struct vop_rmdir_args *v)
1058{
1059	struct vnode *dvp = v->a_dvp;
1060	struct vnode *vp = v->a_vp;
1061
1062	int error;
1063	struct tmpfs_dirent *de;
1064	struct tmpfs_mount *tmp;
1065	struct tmpfs_node *dnode;
1066	struct tmpfs_node *node;
1067
1068	MPASS(VOP_ISLOCKED(dvp));
1069	MPASS(VOP_ISLOCKED(vp));
1070
1071	tmp = VFS_TO_TMPFS(dvp->v_mount);
1072	dnode = VP_TO_TMPFS_DIR(dvp);
1073	node = VP_TO_TMPFS_DIR(vp);
1074
1075	/* Directories with more than two entries ('.' and '..') cannot be
1076	 * removed. */
1077	 if (node->tn_size > 0) {
1078		 error = ENOTEMPTY;
1079		 goto out;
1080	 }
1081
1082	if ((dnode->tn_flags & APPEND)
1083	    || (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))) {
1084		error = EPERM;
1085		goto out;
1086	}
1087
1088	/* This invariant holds only if we are not trying to remove "..".
1089	  * We checked for that above so this is safe now. */
1090	MPASS(node->tn_dir.tn_parent == dnode);
1091
1092	/* Get the directory entry associated with node (vp).  This was
1093	 * filled by tmpfs_lookup while looking up the entry. */
1094	de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
1095	MPASS(TMPFS_DIRENT_MATCHES(de,
1096	    v->a_cnp->cn_nameptr,
1097	    v->a_cnp->cn_namelen));
1098
1099	/* Check flags to see if we are allowed to remove the directory. */
1100	if (dnode->tn_flags & APPEND
1101		|| node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) {
1102		error = EPERM;
1103		goto out;
1104	}
1105
1106	/* Detach the directory entry from the directory (dnode). */
1107	tmpfs_dir_detach(dvp, de);
1108
1109	node->tn_links--;
1110	node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | \
1111	    TMPFS_NODE_MODIFIED;
1112	node->tn_dir.tn_parent->tn_links--;
1113	node->tn_dir.tn_parent->tn_status |= TMPFS_NODE_ACCESSED | \
1114	    TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1115
1116	cache_purge(dvp);
1117	cache_purge(vp);
1118
1119	/* Free the directory entry we just deleted.  Note that the node
1120	 * referred by it will not be removed until the vnode is really
1121	 * reclaimed. */
1122	tmpfs_free_dirent(tmp, de, TRUE);
1123
1124	/* Release the deleted vnode (will destroy the node, notify
1125	 * interested parties and clean it from the cache). */
1126
1127	dnode->tn_status |= TMPFS_NODE_CHANGED;
1128	tmpfs_update(dvp);
1129
1130	error = 0;
1131
1132out:
1133	return error;
1134}
1135
1136/* --------------------------------------------------------------------- */
1137
1138static int
1139tmpfs_symlink(struct vop_symlink_args *v)
1140{
1141	struct vnode *dvp = v->a_dvp;
1142	struct vnode **vpp = v->a_vpp;
1143	struct componentname *cnp = v->a_cnp;
1144	struct vattr *vap = v->a_vap;
1145	char *target = v->a_target;
1146
1147#ifdef notyet /* XXX FreeBSD BUG: kern_symlink is not setting VLNK */
1148	MPASS(vap->va_type == VLNK);
1149#else
1150	vap->va_type = VLNK;
1151#endif
1152
1153	return tmpfs_alloc_file(dvp, vpp, vap, cnp, target);
1154}
1155
1156/* --------------------------------------------------------------------- */
1157
1158static int
1159tmpfs_readdir(struct vop_readdir_args *v)
1160{
1161	struct vnode *vp = v->a_vp;
1162	struct uio *uio = v->a_uio;
1163	int *eofflag = v->a_eofflag;
1164	u_long **cookies = v->a_cookies;
1165	int *ncookies = v->a_ncookies;
1166
1167	int error;
1168	off_t startoff;
1169	off_t cnt = 0;
1170	struct tmpfs_node *node;
1171
1172	/* This operation only makes sense on directory nodes. */
1173	if (vp->v_type != VDIR)
1174		return ENOTDIR;
1175
1176	node = VP_TO_TMPFS_DIR(vp);
1177
1178	startoff = uio->uio_offset;
1179
1180	if (uio->uio_offset == TMPFS_DIRCOOKIE_DOT) {
1181		error = tmpfs_dir_getdotdent(node, uio);
1182		if (error != 0)
1183			goto outok;
1184		cnt++;
1185	}
1186
1187	if (uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT) {
1188		error = tmpfs_dir_getdotdotdent(node, uio);
1189		if (error != 0)
1190			goto outok;
1191		cnt++;
1192	}
1193
1194	error = tmpfs_dir_getdents(node, uio, &cnt);
1195
1196outok:
1197	MPASS(error >= -1);
1198
1199	if (error == -1)
1200		error = 0;
1201
1202	if (eofflag != NULL)
1203		*eofflag =
1204		    (error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF);
1205
1206	/* Update NFS-related variables. */
1207	if (error == 0 && cookies != NULL && ncookies != NULL) {
1208		off_t i;
1209		off_t off = startoff;
1210		struct tmpfs_dirent *de = NULL;
1211
1212		*ncookies = cnt;
1213		*cookies = malloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK);
1214
1215		for (i = 0; i < cnt; i++) {
1216			MPASS(off != TMPFS_DIRCOOKIE_EOF);
1217			if (off == TMPFS_DIRCOOKIE_DOT) {
1218				off = TMPFS_DIRCOOKIE_DOTDOT;
1219			} else {
1220				if (off == TMPFS_DIRCOOKIE_DOTDOT) {
1221					de = TAILQ_FIRST(&node->tn_dir.tn_dirhead);
1222				} else if (de != NULL) {
1223					de = TAILQ_NEXT(de, td_entries);
1224				} else {
1225					de = tmpfs_dir_lookupbycookie(node,
1226					    off);
1227					MPASS(de != NULL);
1228					de = TAILQ_NEXT(de, td_entries);
1229				}
1230				if (de == NULL)
1231					off = TMPFS_DIRCOOKIE_EOF;
1232				else
1233					off = tmpfs_dircookie(de);
1234			}
1235
1236			(*cookies)[i] = off;
1237		}
1238		MPASS(uio->uio_offset == off);
1239	}
1240
1241	return error;
1242}
1243
1244/* --------------------------------------------------------------------- */
1245
1246static int
1247tmpfs_readlink(struct vop_readlink_args *v)
1248{
1249	struct vnode *vp = v->a_vp;
1250	struct uio *uio = v->a_uio;
1251
1252	int error;
1253	struct tmpfs_node *node;
1254
1255	MPASS(uio->uio_offset == 0);
1256	MPASS(vp->v_type == VLNK);
1257
1258	node = VP_TO_TMPFS_NODE(vp);
1259
1260	error = uiomove(node->tn_link, MIN(node->tn_size, uio->uio_resid),
1261	    uio);
1262	node->tn_status |= TMPFS_NODE_ACCESSED;
1263
1264	return error;
1265}
1266
1267/* --------------------------------------------------------------------- */
1268
1269static int
1270tmpfs_inactive(struct vop_inactive_args *v)
1271{
1272	struct vnode *vp = v->a_vp;
1273	struct thread *l = v->a_td;
1274
1275	struct tmpfs_node *node;
1276
1277	MPASS(VOP_ISLOCKED(vp));
1278
1279	node = VP_TO_TMPFS_NODE(vp);
1280
1281	if (node->tn_links == 0)
1282		vrecycle(vp, l);
1283
1284	return 0;
1285}
1286
1287/* --------------------------------------------------------------------- */
1288
1289int
1290tmpfs_reclaim(struct vop_reclaim_args *v)
1291{
1292	struct vnode *vp = v->a_vp;
1293
1294	struct tmpfs_mount *tmp;
1295	struct tmpfs_node *node;
1296
1297	node = VP_TO_TMPFS_NODE(vp);
1298	tmp = VFS_TO_TMPFS(vp->v_mount);
1299
1300	vnode_destroy_vobject(vp);
1301	cache_purge(vp);
1302	tmpfs_free_vp(vp);
1303
1304	/* If the node referenced by this vnode was deleted by the user,
1305	 * we must free its associated data structures (now that the vnode
1306	 * is being reclaimed). */
1307	if (node->tn_links == 0)
1308		tmpfs_free_node(tmp, node);
1309
1310	MPASS(vp->v_data == NULL);
1311	return 0;
1312}
1313
1314/* --------------------------------------------------------------------- */
1315
1316static int
1317tmpfs_print(struct vop_print_args *v)
1318{
1319	struct vnode *vp = v->a_vp;
1320
1321	struct tmpfs_node *node;
1322
1323	node = VP_TO_TMPFS_NODE(vp);
1324
1325	printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%x, links %d\n",
1326	    node, node->tn_flags, node->tn_links);
1327	printf("\tmode 0%o, owner %d, group %d, size %" PRIdMAX
1328	    ", status 0x%x\n",
1329	    node->tn_mode, node->tn_uid, node->tn_gid,
1330	    (uintmax_t)node->tn_size, node->tn_status);
1331
1332	if (vp->v_type == VFIFO)
1333		fifo_printinfo(vp);
1334
1335	printf("\n");
1336
1337	return 0;
1338}
1339
1340/* --------------------------------------------------------------------- */
1341
1342static int
1343tmpfs_pathconf(struct vop_pathconf_args *v)
1344{
1345	int name = v->a_name;
1346	register_t *retval = v->a_retval;
1347
1348	int error;
1349
1350	error = 0;
1351
1352	switch (name) {
1353	case _PC_LINK_MAX:
1354		*retval = LINK_MAX;
1355		break;
1356
1357	case _PC_NAME_MAX:
1358		*retval = NAME_MAX;
1359		break;
1360
1361	case _PC_PATH_MAX:
1362		*retval = PATH_MAX;
1363		break;
1364
1365	case _PC_PIPE_BUF:
1366		*retval = PIPE_BUF;
1367		break;
1368
1369	case _PC_CHOWN_RESTRICTED:
1370		*retval = 1;
1371		break;
1372
1373	case _PC_NO_TRUNC:
1374		*retval = 1;
1375		break;
1376
1377	case _PC_SYNC_IO:
1378		*retval = 1;
1379		break;
1380
1381	case _PC_FILESIZEBITS:
1382		*retval = 0; /* XXX Don't know which value should I return. */
1383		break;
1384
1385	default:
1386		error = EINVAL;
1387	}
1388
1389	return error;
1390}
1391
1392static int
1393tmpfs_vptofh(struct vop_vptofh_args *ap)
1394{
1395	struct tmpfs_fid *tfhp;
1396	struct tmpfs_node *node;
1397
1398	tfhp = (struct tmpfs_fid *)ap->a_fhp;
1399	node = VP_TO_TMPFS_NODE(ap->a_vp);
1400
1401	tfhp->tf_len = sizeof(struct tmpfs_fid);
1402	tfhp->tf_id = node->tn_id;
1403	tfhp->tf_gen = node->tn_gen;
1404
1405	return (0);
1406}
1407
1408/* --------------------------------------------------------------------- */
1409
1410/*
1411 * vnode operations vector used for files stored in a tmpfs file system.
1412 */
1413struct vop_vector tmpfs_vnodeop_entries = {
1414	.vop_default =			&default_vnodeops,
1415	.vop_lookup =			vfs_cache_lookup,
1416	.vop_cachedlookup =		tmpfs_lookup,
1417	.vop_create =			tmpfs_create,
1418	.vop_mknod =			tmpfs_mknod,
1419	.vop_open =			tmpfs_open,
1420	.vop_close =			tmpfs_close,
1421	.vop_access =			tmpfs_access,
1422	.vop_getattr =			tmpfs_getattr,
1423	.vop_setattr =			tmpfs_setattr,
1424	.vop_read =			tmpfs_read,
1425	.vop_write =			tmpfs_write,
1426	.vop_fsync =			tmpfs_fsync,
1427	.vop_remove =			tmpfs_remove,
1428	.vop_link =			tmpfs_link,
1429	.vop_rename =			tmpfs_rename,
1430	.vop_mkdir =			tmpfs_mkdir,
1431	.vop_rmdir =			tmpfs_rmdir,
1432	.vop_symlink =			tmpfs_symlink,
1433	.vop_readdir =			tmpfs_readdir,
1434	.vop_readlink =			tmpfs_readlink,
1435	.vop_inactive =			tmpfs_inactive,
1436	.vop_reclaim =			tmpfs_reclaim,
1437	.vop_print =			tmpfs_print,
1438	.vop_pathconf =			tmpfs_pathconf,
1439	.vop_vptofh =			tmpfs_vptofh,
1440	.vop_bmap =			VOP_EOPNOTSUPP,
1441};
1442
1443