chfs_vfsops.c revision 1.14 
1/*	$NetBSD: chfs_vfsops.c,v 1.14 2014/11/09 18:23:28 maxv Exp $	*/
2
3/*-
4 * Copyright (c) 2010 Department of Software Engineering,
5 *		      University of Szeged, Hungary
6 * Copyright (C) 2010 Tamas Toth <ttoth@inf.u-szeged.hu>
7 * Copyright (C) 2010 Adam Hoka <ahoka@NetBSD.org>
8 * All rights reserved.
9 *
10 * This code is derived from software contributed to The NetBSD Foundation
11 * by the Department of Software Engineering, University of Szeged, Hungary
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 *    notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 *    notice, this list of conditions and the following disclaimer in the
20 *    documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35#include <sys/cdefs.h>
36
37#include <sys/param.h>
38#include <sys/types.h>
39#include <sys/kmem.h>
40#include <sys/mount.h>
41#include <sys/stat.h>
42#include <sys/systm.h>
43#include <sys/proc.h>
44#include <sys/module.h>
45#include <sys/namei.h>
46#include <sys/fcntl.h>
47#include <sys/conf.h>
48#include <sys/buf.h>
49//XXX needed just for debugging
50#include <sys/fstrans.h>
51#include <sys/sleepq.h>
52#include <sys/lockdebug.h>
53#include <sys/ktrace.h>
54
55#include <uvm/uvm.h>
56#include <uvm/uvm_pager.h>
57#include <ufs/ufs/dir.h>
58#include <ufs/ufs/ufs_extern.h>
59#include <miscfs/genfs/genfs.h>
60#include <miscfs/genfs/genfs_node.h>
61#include <miscfs/specfs/specdev.h>
62#include "chfs.h"
63#include "chfs_args.h"
64
65MODULE(MODULE_CLASS_VFS, chfs, "flash");
66
67/* --------------------------------------------------------------------- */
68/* functions */
69
70static int chfs_mount(struct mount *, const char *, void *, size_t *);
71static int chfs_unmount(struct mount *, int);
72static int chfs_root(struct mount *, struct vnode **);
73static int chfs_vget(struct mount *, ino_t, struct vnode **);
74static int chfs_fhtovp(struct mount *, struct fid *, struct vnode **);
75static int chfs_vptofh(struct vnode *, struct fid *, size_t *);
76static int chfs_start(struct mount *, int);
77static int chfs_statvfs(struct mount *, struct statvfs *);
78static int chfs_sync(struct mount *, int, kauth_cred_t);
79static void chfs_init(void);
80static void chfs_reinit(void);
81static void chfs_done(void);
82static int chfs_snapshot(struct mount *, struct vnode *,
83    struct timespec *);
84
85/* --------------------------------------------------------------------- */
86/* structures */
87
88int
89chfs_gop_alloc(struct vnode *vp, off_t off, off_t len,  int flags,
90    kauth_cred_t cred)
91{
92	return (0);
93}
94
95const struct genfs_ops chfs_genfsops = {
96	.gop_size = genfs_size,
97	.gop_alloc = chfs_gop_alloc,
98	.gop_write = genfs_gop_write,
99	.gop_markupdate = ufs_gop_markupdate,
100};
101
102struct pool chfs_inode_pool;
103
104/* for looking up the major for flash */
105extern const struct cdevsw flash_cdevsw;
106
107/* --------------------------------------------------------------------- */
108
109static int
110chfs_mount(struct mount *mp,
111    const char *path, void *data, size_t *data_len)
112{
113	struct lwp *l = curlwp;
114	struct nameidata nd;
115	struct pathbuf *pb;
116	struct vnode *devvp = NULL;
117	struct ufs_args *args = data;
118	struct ufsmount *ump = NULL;
119	struct chfs_mount *chmp;
120	int err = 0;
121	int xflags;
122
123	dbg("mount()\n");
124
125	if (args == NULL)
126		return EINVAL;
127	if (*data_len < sizeof *args)
128		return EINVAL;
129
130	if (mp->mnt_flag & MNT_GETARGS) {
131		ump = VFSTOUFS(mp);
132		if (ump == NULL)
133			return EIO;
134		memset(args, 0, sizeof *args);
135		args->fspec = NULL;
136		*data_len = sizeof *args;
137		return 0;
138	}
139
140	if (mp->mnt_flag & MNT_UPDATE) {
141		/* XXX: There is no support yet to update file system
142		 * settings.  Should be added. */
143
144		return ENODEV;
145	}
146
147	if (args->fspec != NULL) {
148		err = pathbuf_copyin(args->fspec, &pb);
149		if (err) {
150			return err;
151		}
152		/* Look up the name and verify that it's sane. */
153		NDINIT(&nd, LOOKUP, FOLLOW, pb);
154		err = namei(&nd);
155		pathbuf_destroy(pb);
156		if (err)
157			return err;
158		devvp = nd.ni_vp;
159
160		/* Be sure this is a valid block device */
161		if (devvp->v_type != VBLK)
162			err = ENOTBLK;
163		else if (bdevsw_lookup(devvp->v_rdev) == NULL)
164			err = ENXIO;
165	}
166
167	if (err) {
168		vrele(devvp);
169		return (err);
170	}
171
172	if (mp->mnt_flag & MNT_RDONLY)
173		xflags = FREAD;
174	else
175		xflags = FREAD|FWRITE;
176
177	err = VOP_OPEN(devvp, xflags, FSCRED);
178	if (err)
179		goto fail;
180
181	/* call CHFS mount function */
182	err = chfs_mountfs(devvp, mp);
183	if (err) {
184		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
185		(void)VOP_CLOSE(devvp, xflags, NOCRED);
186		VOP_UNLOCK(devvp);
187		goto fail;
188	}
189
190	ump = VFSTOUFS(mp);
191	chmp = ump->um_chfs;
192
193	vfs_getnewfsid(mp);
194	chmp->chm_fsmp = mp;
195
196	return set_statvfs_info(path,
197	    UIO_USERSPACE, args->fspec,
198	    UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
199
200fail:
201	vrele(devvp);
202	return (err);
203}
204
205/* chfs_mountfs - init CHFS */
206int
207chfs_mountfs(struct vnode *devvp, struct mount *mp)
208{
209	struct lwp *l = curlwp;
210	kauth_cred_t cred;
211	devmajor_t flash_major;
212	dev_t dev;
213	struct ufsmount* ump = NULL;
214	struct chfs_mount* chmp;
215	struct vnode *vp;
216	int err = 0;
217
218	dbg("mountfs()\n");
219
220	dev = devvp->v_rdev;
221	cred = l ? l->l_cred : NOCRED;
222
223	/* Flush out any old buffers remaining from a previous use. */
224	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
225	err = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
226	VOP_UNLOCK(devvp);
227	if (err)
228		return (err);
229
230	/* Setup device. */
231	flash_major = cdevsw_lookup_major(&flash_cdevsw);
232
233	if (devvp->v_type != VBLK)
234		err = ENOTBLK;
235	else if (bdevsw_lookup(dev) == NULL)
236		err = ENXIO;
237	else if (major(dev) != flash_major) {
238		dbg("major(dev): %d, flash_major: %d\n",
239		    major(dev), flash_major);
240		err = ENODEV;
241	}
242	if (err) {
243		vrele(devvp);
244		return (err);
245	}
246
247	/* Connect CHFS to UFS. */
248	ump = kmem_zalloc(sizeof(struct ufsmount), KM_SLEEP);
249
250	ump->um_fstype = UFS1;
251	ump->um_chfs = kmem_zalloc(sizeof(struct chfs_mount), KM_SLEEP);
252	mutex_init(&ump->um_lock, MUTEX_DEFAULT, IPL_NONE);
253
254	chmp = ump->um_chfs;
255
256	/* Initialize erase block handler. */
257	chmp->chm_ebh = kmem_alloc(sizeof(struct chfs_ebh), KM_SLEEP);
258
259	dbg("[]opening flash: %u\n", (unsigned int)devvp->v_rdev);
260	err = ebh_open(chmp->chm_ebh, devvp->v_rdev);
261	if (err) {
262		dbg("error while opening flash\n");
263		goto fail;
264	}
265
266	//TODO check flash sizes
267
268	/* Initialize vnode cache's hashtable and eraseblock array. */
269	chmp->chm_gbl_version = 0;
270	chmp->chm_vnocache_hash = chfs_vnocache_hash_init();
271
272	chmp->chm_blocks = kmem_zalloc(chmp->chm_ebh->peb_nr *
273	    sizeof(struct chfs_eraseblock), KM_SLEEP);
274
275	/* Initialize mutexes. */
276	mutex_init(&chmp->chm_lock_mountfields, MUTEX_DEFAULT, IPL_NONE);
277	mutex_init(&chmp->chm_lock_sizes, MUTEX_DEFAULT, IPL_NONE);
278	mutex_init(&chmp->chm_lock_vnocache, MUTEX_DEFAULT, IPL_NONE);
279
280	/* Initialize read/write contants. (from UFS) */
281	chmp->chm_fs_bmask = -4096;
282	chmp->chm_fs_bsize = 4096;
283	chmp->chm_fs_qbmask = 4095;
284	chmp->chm_fs_bshift = 12;
285	chmp->chm_fs_fmask = -2048;
286	chmp->chm_fs_qfmask = 2047;
287
288	/* Initialize writebuffer. */
289	chmp->chm_wbuf_pagesize = chmp->chm_ebh->flash_if->page_size;
290	dbg("wbuf size: %zu\n", chmp->chm_wbuf_pagesize);
291	chmp->chm_wbuf = kmem_alloc(chmp->chm_wbuf_pagesize, KM_SLEEP);
292	rw_init(&chmp->chm_lock_wbuf);
293
294	/* Initialize queues. */
295	TAILQ_INIT(&chmp->chm_free_queue);
296	TAILQ_INIT(&chmp->chm_clean_queue);
297	TAILQ_INIT(&chmp->chm_dirty_queue);
298	TAILQ_INIT(&chmp->chm_very_dirty_queue);
299	TAILQ_INIT(&chmp->chm_erasable_pending_wbuf_queue);
300	TAILQ_INIT(&chmp->chm_erase_pending_queue);
301
302	/* Initialize flash-specific constants. */
303	chfs_calc_trigger_levels(chmp);
304
305	/* Initialize sizes. */
306	chmp->chm_nr_free_blocks = 0;
307	chmp->chm_nr_erasable_blocks = 0;
308	chmp->chm_max_vno = 2;
309	chmp->chm_checked_vno = 2;
310	chmp->chm_unchecked_size = 0;
311	chmp->chm_used_size = 0;
312	chmp->chm_dirty_size = 0;
313	chmp->chm_wasted_size = 0;
314	chmp->chm_free_size = chmp->chm_ebh->eb_size * chmp->chm_ebh->peb_nr;
315
316	/* Build filesystem. */
317	err = chfs_build_filesystem(chmp);
318
319	if (err) {
320		/* Armageddon and return. */
321		chfs_vnocache_hash_destroy(chmp->chm_vnocache_hash);
322		ebh_close(chmp->chm_ebh);
323		err = EIO;
324		goto fail;
325	}
326
327	/* Initialize UFS. */
328	mp->mnt_data = ump;
329	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
330	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_CHFS);
331	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
332	mp->mnt_stat.f_namemax = MAXNAMLEN;
333	mp->mnt_flag |= MNT_LOCAL;
334	mp->mnt_fs_bshift = PAGE_SHIFT;
335	mp->mnt_dev_bshift = DEV_BSHIFT;
336	mp->mnt_iflag |= IMNT_MPSAFE;
337	ump->um_flags = 0;
338	ump->um_mountp = mp;
339	ump->um_dev = dev;
340	ump->um_devvp = devvp;
341	ump->um_maxfilesize = 1048512 * 1024;
342
343	/* Allocate the root vnode. */
344	err = VFS_VGET(mp, CHFS_ROOTINO, &vp);
345	if (err) {
346		dbg("error: %d while allocating root node\n", err);
347		return err;
348	}
349	vput(vp);
350
351	/* Start GC. */
352	chfs_gc_thread_start(chmp);
353	mutex_enter(&chmp->chm_lock_mountfields);
354	chfs_gc_trigger(chmp);
355	mutex_exit(&chmp->chm_lock_mountfields);
356
357	spec_node_setmountedfs(devvp, mp);
358	return 0;
359
360fail:
361	kmem_free(chmp->chm_ebh, sizeof(struct chfs_ebh));
362	kmem_free(chmp, sizeof(struct chfs_mount));
363	kmem_free(ump, sizeof(struct ufsmount));
364	return err;
365}
366
367/* --------------------------------------------------------------------- */
368
369static int
370chfs_unmount(struct mount *mp, int mntflags)
371{
372	int flags = 0, i = 0;
373	struct ufsmount *ump;
374	struct chfs_mount *chmp;
375
376	if (mntflags & MNT_FORCE)
377		flags |= FORCECLOSE;
378
379	dbg("[START]\n");
380
381	ump = VFSTOUFS(mp);
382	chmp = ump->um_chfs;
383
384	/* Stop GC. */
385	chfs_gc_thread_stop(chmp);
386
387	/* Flush everyt buffer. */
388	(void)vflush(mp, NULLVP, flags);
389
390	if (chmp->chm_wbuf_len) {
391		mutex_enter(&chmp->chm_lock_mountfields);
392		chfs_flush_pending_wbuf(chmp);
393		mutex_exit(&chmp->chm_lock_mountfields);
394	}
395
396	/* Free node references. */
397	for (i = 0; i < chmp->chm_ebh->peb_nr; i++) {
398		chfs_free_node_refs(&chmp->chm_blocks[i]);
399	}
400
401	/* Destroy vnode cache hashtable. */
402	chfs_vnocache_hash_destroy(chmp->chm_vnocache_hash);
403
404	/* Close eraseblock handler. */
405	ebh_close(chmp->chm_ebh);
406
407	/* Destroy mutexes. */
408	rw_destroy(&chmp->chm_lock_wbuf);
409	mutex_destroy(&chmp->chm_lock_vnocache);
410	mutex_destroy(&chmp->chm_lock_sizes);
411	mutex_destroy(&chmp->chm_lock_mountfields);
412
413	/* Unmount UFS. */
414	if (ump->um_devvp->v_type != VBAD) {
415		spec_node_setmountedfs(ump->um_devvp, NULL);
416	}
417	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
418	(void)VOP_CLOSE(ump->um_devvp, FREAD|FWRITE, NOCRED);
419	vput(ump->um_devvp);
420
421	mutex_destroy(&ump->um_lock);
422
423	/* Everything done. */
424	kmem_free(ump, sizeof(struct ufsmount));
425	mp->mnt_data = NULL;
426	mp->mnt_flag &= ~MNT_LOCAL;
427	dbg("[END]\n");
428	return (0);
429}
430
431/* --------------------------------------------------------------------- */
432
433static int
434chfs_root(struct mount *mp, struct vnode **vpp)
435{
436	struct vnode *vp;
437	int error;
438
439	if ((error = VFS_VGET(mp, (ino_t)UFS_ROOTINO, &vp)) != 0)
440		return error;
441	*vpp = vp;
442	return 0;
443}
444
445/* --------------------------------------------------------------------- */
446
447extern rb_tree_ops_t frag_rbtree_ops;
448
449static int
450chfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
451{
452	struct chfs_mount *chmp;
453	struct chfs_inode *ip;
454	struct ufsmount *ump;
455	struct vnode *vp;
456	dev_t dev;
457	int error;
458	struct chfs_vnode_cache* chvc = NULL;
459	struct chfs_node_ref* nref = NULL;
460	struct buf *bp;
461
462	dbg("vget() | ino: %llu\n", (unsigned long long)ino);
463
464	ump = VFSTOUFS(mp);
465	dev = ump->um_dev;
466retry:
467	if (!vpp) {
468		vpp = kmem_alloc(sizeof(struct vnode*), KM_SLEEP);
469	}
470
471	/* Get node from inode hash. */
472	if ((*vpp = chfs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) {
473		return 0;
474	}
475
476	/* Allocate a new vnode/inode. */
477	if ((error = getnewvnode(VT_CHFS,
478		    mp, chfs_vnodeop_p, NULL, &vp)) != 0) {
479		*vpp = NULL;
480		return (error);
481	}
482	ip = pool_get(&chfs_inode_pool, PR_WAITOK);
483
484	mutex_enter(&chfs_hashlock);
485	if ((*vpp = chfs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) {
486		mutex_exit(&chfs_hashlock);
487		ungetnewvnode(vp);
488		pool_put(&chfs_inode_pool, ip);
489		goto retry;
490	}
491
492	vp->v_vflag |= VV_LOCKSWORK;
493
494	/* Initialize vnode/inode. */
495	memset(ip, 0, sizeof(*ip));
496	vp->v_data = ip;
497	ip->vp = vp;
498	ip->ch_type = VTTOCHT(vp->v_type);
499	ip->ump = ump;
500	ip->chmp = chmp = ump->um_chfs;
501	ip->dev = dev;
502	ip->ino = ino;
503	vp->v_mount = mp;
504	genfs_node_init(vp, &chfs_genfsops);
505
506	rb_tree_init(&ip->fragtree, &frag_rbtree_ops);
507
508	chfs_ihashins(ip);
509	mutex_exit(&chfs_hashlock);
510
511	/* Set root inode. */
512	if (ino == CHFS_ROOTINO) {
513		dbg("SETROOT\n");
514		vp->v_vflag |= VV_ROOT;
515		vp->v_type = VDIR;
516		ip->ch_type = CHT_DIR;
517		ip->mode = IFMT | IEXEC | IWRITE | IREAD;
518		ip->iflag |= (IN_ACCESS | IN_CHANGE | IN_UPDATE);
519		chfs_update(vp, NULL, NULL, UPDATE_WAIT);
520		TAILQ_INIT(&ip->dents);
521		chfs_set_vnode_size(vp, 512);
522	}
523
524	mutex_enter(&chmp->chm_lock_vnocache);
525	chvc = chfs_vnode_cache_get(chmp, ino);
526	mutex_exit(&chmp->chm_lock_vnocache);
527	if (!chvc) {
528		dbg("!chvc\n");
529		/* Initialize the corresponding vnode cache. */
530		/* XXX, we cant alloc under a lock, refactor this! */
531		chvc = chfs_vnode_cache_alloc(ino);
532		mutex_enter(&chmp->chm_lock_vnocache);
533		if (ino == CHFS_ROOTINO) {
534			chvc->nlink = 2;
535			chvc->pvno = CHFS_ROOTINO;
536			chvc->state = VNO_STATE_CHECKEDABSENT;
537		}
538		chfs_vnode_cache_add(chmp, chvc);
539		mutex_exit(&chmp->chm_lock_vnocache);
540
541		ip->chvc = chvc;
542		TAILQ_INIT(&ip->dents);
543	} else {
544		dbg("chvc\n");
545		ip->chvc = chvc;
546		/* We had a vnode cache, the node is already on flash, so read it */
547		if (ino == CHFS_ROOTINO) {
548			chvc->pvno = CHFS_ROOTINO;
549			TAILQ_INIT(&chvc->scan_dirents);
550		} else {
551			chfs_readvnode(mp, ino, &vp);
552		}
553
554		mutex_enter(&chmp->chm_lock_mountfields);
555		/* Initialize type specific things. */
556		switch (ip->ch_type) {
557		case CHT_DIR:
558			/* Read every dirent. */
559			nref = chvc->dirents;
560			while (nref &&
561			    (struct chfs_vnode_cache *)nref != chvc) {
562				chfs_readdirent(mp, nref, ip);
563				nref = nref->nref_next;
564			}
565			chfs_set_vnode_size(vp, 512);
566			break;
567		case CHT_REG:
568			/* FALLTHROUGH */
569		case CHT_SOCK:
570			/* Collect data. */
571			dbg("read_inode_internal | ino: %llu\n",
572				(unsigned long long)ip->ino);
573			error = chfs_read_inode(chmp, ip);
574			if (error) {
575				vput(vp);
576				*vpp = NULL;
577				mutex_exit(&chmp->chm_lock_mountfields);
578				return (error);
579			}
580			break;
581		case CHT_LNK:
582			/* Collect data. */
583			dbg("read_inode_internal | ino: %llu\n",
584				(unsigned long long)ip->ino);
585			error = chfs_read_inode_internal(chmp, ip);
586			if (error) {
587				vput(vp);
588				*vpp = NULL;
589				mutex_exit(&chmp->chm_lock_mountfields);
590				return (error);
591			}
592
593			/* Set link. */
594			dbg("size: %llu\n", (unsigned long long)ip->size);
595			bp = getiobuf(vp, true);
596			bp->b_blkno = 0;
597			bp->b_bufsize = bp->b_resid =
598			    bp->b_bcount = ip->size;
599			bp->b_data = kmem_alloc(ip->size, KM_SLEEP);
600			chfs_read_data(chmp, vp, bp);
601			if (!ip->target)
602				ip->target = kmem_alloc(ip->size,
603				    KM_SLEEP);
604			memcpy(ip->target, bp->b_data, ip->size);
605			kmem_free(bp->b_data, ip->size);
606			putiobuf(bp);
607
608			break;
609		case CHT_CHR:
610			/* FALLTHROUGH */
611		case CHT_BLK:
612			/* FALLTHROUGH */
613		case CHT_FIFO:
614			/* Collect data. */
615			dbg("read_inode_internal | ino: %llu\n",
616				(unsigned long long)ip->ino);
617			error = chfs_read_inode_internal(chmp, ip);
618			if (error) {
619				vput(vp);
620				*vpp = NULL;
621				mutex_exit(&chmp->chm_lock_mountfields);
622				return (error);
623			}
624
625			/* Set device. */
626			bp = getiobuf(vp, true);
627			bp->b_blkno = 0;
628			bp->b_bufsize = bp->b_resid =
629			    bp->b_bcount = sizeof(dev_t);
630			bp->b_data = kmem_alloc(sizeof(dev_t), KM_SLEEP);
631			chfs_read_data(chmp, vp, bp);
632			memcpy(&ip->rdev,
633			    bp->b_data, sizeof(dev_t));
634			kmem_free(bp->b_data, sizeof(dev_t));
635			putiobuf(bp);
636			/* Set specific operations. */
637			if (ip->ch_type == CHT_FIFO) {
638				vp->v_op = chfs_fifoop_p;
639			} else {
640				vp->v_op = chfs_specop_p;
641				spec_node_init(vp, ip->rdev);
642			}
643
644		    break;
645		case CHT_BLANK:
646			/* FALLTHROUGH */
647		case CHT_BAD:
648			break;
649		}
650		mutex_exit(&chmp->chm_lock_mountfields);
651
652	}
653
654	/* Finish inode initalization. */
655	ip->devvp = ump->um_devvp;
656	vref(ip->devvp);
657
658	uvm_vnp_setsize(vp, ip->size);
659	*vpp = vp;
660
661	return 0;
662}
663
664/* --------------------------------------------------------------------- */
665
666static int
667chfs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
668{
669	return ENODEV;
670}
671
672/* --------------------------------------------------------------------- */
673
674static int
675chfs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
676{
677	return ENODEV;
678}
679
680/* --------------------------------------------------------------------- */
681
682static int
683chfs_start(struct mount *mp, int flags)
684{
685	return 0;
686}
687
688/* --------------------------------------------------------------------- */
689
690static int
691chfs_statvfs(struct mount *mp, struct statvfs *sbp)
692{
693 	struct chfs_mount *chmp;
694	struct ufsmount *ump;
695	dbg("statvfs\n");
696
697	ump = VFSTOUFS(mp);
698	chmp = ump->um_chfs;
699
700	sbp->f_flag   = mp->mnt_flag;
701	sbp->f_bsize  = chmp->chm_ebh->eb_size;
702	sbp->f_frsize = chmp->chm_ebh->eb_size;
703	sbp->f_iosize = chmp->chm_ebh->eb_size;
704
705	sbp->f_blocks = chmp->chm_ebh->peb_nr;
706	sbp->f_files  = 0;
707	sbp->f_bavail = chmp->chm_nr_free_blocks - chmp->chm_resv_blocks_write;
708
709	sbp->f_bfree = chmp->chm_nr_free_blocks;
710	sbp->f_bresvd = chmp->chm_resv_blocks_write;
711
712	/* FFS specific */
713	sbp->f_ffree  = 0;
714	sbp->f_favail = 0;
715	sbp->f_fresvd = 0;
716
717	copy_statvfs_info(sbp, mp);
718
719	return 0;
720}
721
722/* --------------------------------------------------------------------- */
723
724static int
725chfs_sync(struct mount *mp, int waitfor,
726    kauth_cred_t uc)
727{
728	return 0;
729}
730
731/* --------------------------------------------------------------------- */
732
733static void
734chfs_init(void)
735{
736	/* Initialize pools and inode hash. */
737	chfs_alloc_pool_caches();
738	chfs_ihashinit();
739	pool_init(&chfs_inode_pool, sizeof(struct chfs_inode), 0, 0, 0,
740	    "chfsinopl", &pool_allocator_nointr, IPL_NONE);
741	ufs_init();
742}
743
744/* --------------------------------------------------------------------- */
745
746static void
747chfs_reinit(void)
748{
749	chfs_ihashreinit();
750	ufs_reinit();
751}
752
753/* --------------------------------------------------------------------- */
754
755static void
756chfs_done(void)
757{
758	ufs_done();
759	chfs_ihashdone();
760	pool_destroy(&chfs_inode_pool);
761	chfs_destroy_pool_caches();
762}
763
764/* --------------------------------------------------------------------- */
765
766static int
767chfs_snapshot(struct mount *mp, struct vnode *vp,
768    struct timespec *ctime)
769{
770	return ENODEV;
771}
772
773/* --------------------------------------------------------------------- */
774
775/*
776 * chfs vfs operations.
777 */
778
779extern const struct vnodeopv_desc chfs_fifoop_opv_desc;
780extern const struct vnodeopv_desc chfs_specop_opv_desc;
781extern const struct vnodeopv_desc chfs_vnodeop_opv_desc;
782
783const struct vnodeopv_desc * const chfs_vnodeopv_descs[] = {
784	&chfs_fifoop_opv_desc,
785	&chfs_specop_opv_desc,
786	&chfs_vnodeop_opv_desc,
787	NULL,
788};
789
790struct vfsops chfs_vfsops = {
791	.vfs_name = MOUNT_CHFS,
792	.vfs_min_mount_data = sizeof (struct chfs_args),
793	.vfs_mount = chfs_mount,
794	.vfs_start = chfs_start,
795	.vfs_unmount = chfs_unmount,
796	.vfs_root = chfs_root,
797	.vfs_quotactl = ufs_quotactl,
798	.vfs_statvfs = chfs_statvfs,
799	.vfs_sync = chfs_sync,
800	.vfs_vget = chfs_vget,
801	.vfs_fhtovp = chfs_fhtovp,
802	.vfs_vptofh = chfs_vptofh,
803	.vfs_init = chfs_init,
804	.vfs_reinit = chfs_reinit,
805	.vfs_done = chfs_done,
806	.vfs_snapshot = chfs_snapshot,
807	.vfs_extattrctl = vfs_stdextattrctl,
808	.vfs_suspendctl = (void *)eopnotsupp,
809	.vfs_renamelock_enter = genfs_renamelock_enter,
810	.vfs_renamelock_exit = genfs_renamelock_exit,
811	.vfs_fsync = (void *)eopnotsupp,
812	.vfs_opv_descs = chfs_vnodeopv_descs
813};
814
815/* For using CHFS as a module. */
816static int
817chfs_modcmd(modcmd_t cmd, void *arg)
818{
819	switch (cmd) {
820	case MODULE_CMD_INIT:
821		return vfs_attach(&chfs_vfsops);
822	case MODULE_CMD_FINI:
823		return vfs_detach(&chfs_vfsops);
824	default:
825		return ENOTTY;
826	}
827}
828