1/*	$NetBSD: msdosfs_vfsops.c,v 1.93.6.1 2012/07/05 17:36:31 riz Exp $	*/
2
3/*-
4 * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
5 * Copyright (C) 1994, 1995, 1997 TooLs GmbH.
6 * All rights reserved.
7 * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 *    must display the following acknowledgement:
19 *	This product includes software developed by TooLs GmbH.
20 * 4. The name of TooLs GmbH may not be used to endorse or promote products
21 *    derived from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
29 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
30 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
31 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
32 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34/*
35 * Written by Paul Popelka (paulp@uts.amdahl.com)
36 *
37 * You can do anything you want with this software, just don't say you wrote
38 * it, and don't remove this notice.
39 *
40 * This software is provided "as is".
41 *
42 * The author supplies this software to be publicly redistributed on the
43 * understanding that the author is not responsible for the correct
44 * functioning of this software in any circumstances and is not liable for
45 * any damages caused by this software.
46 *
47 * October 1992
48 */
49
50#include <sys/cdefs.h>
51__KERNEL_RCSID(0, "$NetBSD: msdosfs_vfsops.c,v 1.93.6.1 2012/07/05 17:36:31 riz Exp $");
52
53#if defined(_KERNEL_OPT)
54#include "opt_compat_netbsd.h"
55#endif
56
57#include <sys/param.h>
58#include <sys/systm.h>
59#include <sys/sysctl.h>
60#include <sys/namei.h>
61#include <sys/proc.h>
62#include <sys/kernel.h>
63#include <sys/vnode.h>
64#include <miscfs/genfs/genfs.h>
65#include <miscfs/specfs/specdev.h> /* XXX */	/* defines v_rdev */
66#include <sys/mount.h>
67#include <sys/buf.h>
68#include <sys/file.h>
69#include <sys/device.h>
70#include <sys/disklabel.h>
71#include <sys/disk.h>
72#include <sys/fstrans.h>
73#include <sys/ioctl.h>
74#include <sys/malloc.h>
75#include <sys/dirent.h>
76#include <sys/stat.h>
77#include <sys/conf.h>
78#include <sys/kauth.h>
79#include <sys/module.h>
80
81#include <fs/msdosfs/bpb.h>
82#include <fs/msdosfs/bootsect.h>
83#include <fs/msdosfs/direntry.h>
84#include <fs/msdosfs/denode.h>
85#include <fs/msdosfs/msdosfsmount.h>
86#include <fs/msdosfs/fat.h>
87
88MODULE(MODULE_CLASS_VFS, msdos, NULL);
89
90#ifdef MSDOSFS_DEBUG
91#define DPRINTF(a) uprintf a
92#else
93#define DPRINTF(a)
94#endif
95
96#define MSDOSFS_NAMEMAX(pmp) \
97	(pmp)->pm_flags & MSDOSFSMNT_LONGNAME ? WIN_MAXLEN : 12
98
99VFS_PROTOS(msdosfs);
100
101int msdosfs_mountfs(struct vnode *, struct mount *, struct lwp *,
102    struct msdosfs_args *);
103
104static int update_mp(struct mount *, struct msdosfs_args *);
105
106MALLOC_JUSTDEFINE(M_MSDOSFSMNT, "MSDOSFS mount", "MSDOS FS mount structure");
107MALLOC_JUSTDEFINE(M_MSDOSFSFAT, "MSDOSFS fat", "MSDOS FS fat table");
108MALLOC_JUSTDEFINE(M_MSDOSFSTMP, "MSDOSFS temp", "MSDOS FS temp. structures");
109
110#define ROOTNAME "root_device"
111
112static struct sysctllog *msdosfs_sysctl_log;
113
114extern const struct vnodeopv_desc msdosfs_vnodeop_opv_desc;
115
116const struct vnodeopv_desc * const msdosfs_vnodeopv_descs[] = {
117	&msdosfs_vnodeop_opv_desc,
118	NULL,
119};
120
121struct vfsops msdosfs_vfsops = {
122	MOUNT_MSDOS,
123	sizeof (struct msdosfs_args),
124	msdosfs_mount,
125	msdosfs_start,
126	msdosfs_unmount,
127	msdosfs_root,
128	(void *)eopnotsupp,		/* vfs_quotactl */
129	msdosfs_statvfs,
130	msdosfs_sync,
131	msdosfs_vget,
132	msdosfs_fhtovp,
133	msdosfs_vptofh,
134	msdosfs_init,
135	msdosfs_reinit,
136	msdosfs_done,
137	msdosfs_mountroot,
138	(int (*)(struct mount *, struct vnode *, struct timespec *)) eopnotsupp,
139	vfs_stdextattrctl,
140	msdosfs_suspendctl,
141	genfs_renamelock_enter,
142	genfs_renamelock_exit,
143	(void *)eopnotsupp,
144	msdosfs_vnodeopv_descs,
145	0,
146	{ NULL, NULL },
147};
148
149static int
150msdos_modcmd(modcmd_t cmd, void *arg)
151{
152	int error;
153
154	switch (cmd) {
155	case MODULE_CMD_INIT:
156		error = vfs_attach(&msdosfs_vfsops);
157		if (error != 0)
158			break;
159		sysctl_createv(&msdosfs_sysctl_log, 0, NULL, NULL,
160			       CTLFLAG_PERMANENT,
161			       CTLTYPE_NODE, "vfs", NULL,
162			       NULL, 0, NULL, 0,
163			       CTL_VFS, CTL_EOL);
164		sysctl_createv(&msdosfs_sysctl_log, 0, NULL, NULL,
165			       CTLFLAG_PERMANENT,
166			       CTLTYPE_NODE, "msdosfs",
167			       SYSCTL_DESCR("MS-DOS file system"),
168			       NULL, 0, NULL, 0,
169			       CTL_VFS, 4, CTL_EOL);
170		/*
171		 * XXX the "4" above could be dynamic, thereby eliminating one
172		 * more instance of the "number to vfs" mapping problem, but
173		 * "4" is the order as taken from sys/mount.h
174		 */
175		break;
176	case MODULE_CMD_FINI:
177		error = vfs_detach(&msdosfs_vfsops);
178		if (error != 0)
179			break;
180		sysctl_teardown(&msdosfs_sysctl_log);
181		break;
182	default:
183		error = ENOTTY;
184		break;
185	}
186
187	return (error);
188}
189
190static int
191update_mp(struct mount *mp, struct msdosfs_args *argp)
192{
193	struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
194	int error;
195
196	pmp->pm_gid = argp->gid;
197	pmp->pm_uid = argp->uid;
198	pmp->pm_mask = argp->mask & ALLPERMS;
199	pmp->pm_dirmask = argp->dirmask & ALLPERMS;
200	pmp->pm_gmtoff = argp->gmtoff;
201	pmp->pm_flags |= argp->flags & MSDOSFSMNT_MNTOPT;
202
203	/*
204	 * GEMDOS knows nothing about win95 long filenames
205	 */
206	if (pmp->pm_flags & MSDOSFSMNT_GEMDOSFS)
207		pmp->pm_flags |= MSDOSFSMNT_NOWIN95;
208
209	if (pmp->pm_flags & MSDOSFSMNT_NOWIN95)
210		pmp->pm_flags |= MSDOSFSMNT_SHORTNAME;
211	else if (!(pmp->pm_flags &
212	    (MSDOSFSMNT_SHORTNAME | MSDOSFSMNT_LONGNAME))) {
213		struct vnode *rtvp;
214
215		/*
216		 * Try to divine whether to support Win'95 long filenames
217		 */
218		if (FAT32(pmp))
219			pmp->pm_flags |= MSDOSFSMNT_LONGNAME;
220		else {
221			if ((error = msdosfs_root(mp, &rtvp)) != 0)
222				return error;
223			pmp->pm_flags |= findwin95(VTODE(rtvp))
224				? MSDOSFSMNT_LONGNAME
225					: MSDOSFSMNT_SHORTNAME;
226			vput(rtvp);
227		}
228	}
229
230	mp->mnt_stat.f_namemax = MSDOSFS_NAMEMAX(pmp);
231
232	return 0;
233}
234
235int
236msdosfs_mountroot(void)
237{
238	struct mount *mp;
239	struct lwp *l = curlwp;	/* XXX */
240	int error;
241	struct msdosfs_args args;
242
243	if (device_class(root_device) != DV_DISK)
244		return (ENODEV);
245
246	if ((error = vfs_rootmountalloc(MOUNT_MSDOS, "root_device", &mp))) {
247		vrele(rootvp);
248		return (error);
249	}
250
251	args.flags = MSDOSFSMNT_VERSIONED;
252	args.uid = 0;
253	args.gid = 0;
254	args.mask = 0777;
255	args.version = MSDOSFSMNT_VERSION;
256	args.dirmask = 0777;
257
258	if ((error = msdosfs_mountfs(rootvp, mp, l, &args)) != 0) {
259		vfs_unbusy(mp, false, NULL);
260		vfs_destroy(mp);
261		return (error);
262	}
263
264	if ((error = update_mp(mp, &args)) != 0) {
265		(void)msdosfs_unmount(mp, 0);
266		vfs_unbusy(mp, false, NULL);
267		vfs_destroy(mp);
268		vrele(rootvp);
269		return (error);
270	}
271
272	mutex_enter(&mountlist_lock);
273	CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
274	mutex_exit(&mountlist_lock);
275	(void)msdosfs_statvfs(mp, &mp->mnt_stat);
276	vfs_unbusy(mp, false, NULL);
277	return (0);
278}
279
280/*
281 * mp - path - addr in user space of mount point (ie /usr or whatever)
282 * data - addr in user space of mount params including the name of the block
283 * special file to treat as a filesystem.
284 */
285int
286msdosfs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
287{
288	struct lwp *l = curlwp;
289	struct vnode *devvp;	  /* vnode for blk device to mount */
290	struct msdosfs_args *args = data; /* holds data from mount request */
291	/* msdosfs specific mount control block */
292	struct msdosfsmount *pmp = NULL;
293	int error, flags;
294	mode_t accessmode;
295
296	if (args == NULL)
297		return EINVAL;
298	if (*data_len < sizeof *args)
299		return EINVAL;
300
301	if (mp->mnt_flag & MNT_GETARGS) {
302		pmp = VFSTOMSDOSFS(mp);
303		if (pmp == NULL)
304			return EIO;
305		args->fspec = NULL;
306		args->uid = pmp->pm_uid;
307		args->gid = pmp->pm_gid;
308		args->mask = pmp->pm_mask;
309		args->flags = pmp->pm_flags;
310		args->version = MSDOSFSMNT_VERSION;
311		args->dirmask = pmp->pm_dirmask;
312		args->gmtoff = pmp->pm_gmtoff;
313		*data_len = sizeof *args;
314		return 0;
315	}
316
317	/*
318	 * If not versioned (i.e. using old mount_msdos(8)), fill in
319	 * the additional structure items with suitable defaults.
320	 */
321	if ((args->flags & MSDOSFSMNT_VERSIONED) == 0) {
322		args->version = 1;
323		args->dirmask = args->mask;
324	}
325
326	/*
327	 * Reset GMT offset for pre-v3 mount structure args.
328	 */
329	if (args->version < 3)
330		args->gmtoff = 0;
331
332	/*
333	 * If updating, check whether changing from read-only to
334	 * read/write; if there is no device name, that's all we do.
335	 */
336	if (mp->mnt_flag & MNT_UPDATE) {
337		pmp = VFSTOMSDOSFS(mp);
338		error = 0;
339		if (!(pmp->pm_flags & MSDOSFSMNT_RONLY) &&
340		    (mp->mnt_flag & MNT_RDONLY)) {
341			flags = WRITECLOSE;
342			if (mp->mnt_flag & MNT_FORCE)
343				flags |= FORCECLOSE;
344			error = vflush(mp, NULLVP, flags);
345		}
346		if (!error && (mp->mnt_flag & MNT_RELOAD))
347			/* not yet implemented */
348			error = EOPNOTSUPP;
349		if (error) {
350			DPRINTF(("vflush %d\n", error));
351			return (error);
352		}
353		if ((pmp->pm_flags & MSDOSFSMNT_RONLY) &&
354		    (mp->mnt_iflag & IMNT_WANTRDWR)) {
355			/*
356			 * If upgrade to read-write by non-root, then verify
357			 * that user has necessary permissions on the device.
358			 *
359			 * Permission to update a mount is checked higher, so
360			 * here we presume updating the mount is okay (for
361			 * example, as far as securelevel goes) which leaves us
362			 * with the normal check.
363			 */
364			devvp = pmp->pm_devvp;
365			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
366			error = genfs_can_mount(devvp, VREAD | VWRITE,
367			    l->l_cred);
368			VOP_UNLOCK(devvp);
369			DPRINTF(("genfs_can_mount %d\n", error));
370			if (error)
371				return (error);
372
373			pmp->pm_flags &= ~MSDOSFSMNT_RONLY;
374		}
375		if (args->fspec == NULL) {
376			DPRINTF(("missing fspec\n"));
377			return EINVAL;
378		}
379	}
380	/*
381	 * Not an update, or updating the name: look up the name
382	 * and verify that it refers to a sensible block device.
383	 */
384	error = namei_simple_user(args->fspec,
385				NSM_FOLLOW_NOEMULROOT, &devvp);
386	if (error != 0) {
387		DPRINTF(("namei %d\n", error));
388		return (error);
389	}
390
391	if (devvp->v_type != VBLK) {
392		DPRINTF(("not block\n"));
393		vrele(devvp);
394		return (ENOTBLK);
395	}
396	if (bdevsw_lookup(devvp->v_rdev) == NULL) {
397		DPRINTF(("no block switch\n"));
398		vrele(devvp);
399		return (ENXIO);
400	}
401	/*
402	 * If mount by non-root, then verify that user has necessary
403	 * permissions on the device.
404	 */
405	accessmode = VREAD;
406	if ((mp->mnt_flag & MNT_RDONLY) == 0)
407		accessmode |= VWRITE;
408	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
409	error = genfs_can_mount(devvp, accessmode, l->l_cred);
410	VOP_UNLOCK(devvp);
411	if (error) {
412		DPRINTF(("genfs_can_mount %d\n", error));
413		vrele(devvp);
414		return (error);
415	}
416	if ((mp->mnt_flag & MNT_UPDATE) == 0) {
417		int xflags;
418
419		if (mp->mnt_flag & MNT_RDONLY)
420			xflags = FREAD;
421		else
422			xflags = FREAD|FWRITE;
423		vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
424		error = VOP_OPEN(devvp, xflags, FSCRED);
425		VOP_UNLOCK(devvp);
426		if (error) {
427			DPRINTF(("VOP_OPEN %d\n", error));
428			goto fail;
429		}
430		error = msdosfs_mountfs(devvp, mp, l, args);
431		if (error) {
432			DPRINTF(("msdosfs_mountfs %d\n", error));
433			vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
434			(void) VOP_CLOSE(devvp, xflags, NOCRED);
435			VOP_UNLOCK(devvp);
436			goto fail;
437		}
438#ifdef MSDOSFS_DEBUG		/* only needed for the printf below */
439		pmp = VFSTOMSDOSFS(mp);
440#endif
441	} else {
442		vrele(devvp);
443		if (devvp != pmp->pm_devvp) {
444			DPRINTF(("devvp %p pmp %p\n",
445			    devvp, pmp->pm_devvp));
446			return (EINVAL);	/* needs translation */
447		}
448	}
449	if ((error = update_mp(mp, args)) != 0) {
450		msdosfs_unmount(mp, MNT_FORCE);
451		DPRINTF(("update_mp %d\n", error));
452		return error;
453	}
454
455#ifdef MSDOSFS_DEBUG
456	printf("msdosfs_mount(): mp %p, pmp %p, inusemap %p\n", mp, pmp, pmp->pm_inusemap);
457#endif
458	return set_statvfs_info(path, UIO_USERSPACE, args->fspec, UIO_USERSPACE,
459	    mp->mnt_op->vfs_name, mp, l);
460
461fail:
462	vrele(devvp);
463	return (error);
464}
465
466int
467msdosfs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l, struct msdosfs_args *argp)
468{
469	struct msdosfsmount *pmp;
470	struct buf *bp;
471	dev_t dev = devvp->v_rdev;
472	union bootsector *bsp;
473	struct byte_bpb33 *b33;
474	struct byte_bpb50 *b50;
475	struct byte_bpb710 *b710;
476	uint8_t SecPerClust;
477	int	ronly, error, tmp;
478	int	bsize;
479	uint64_t psize;
480	unsigned secsize;
481
482	/* Flush out any old buffers remaining from a previous use. */
483	if ((error = vinvalbuf(devvp, V_SAVE, l->l_cred, l, 0, 0)) != 0)
484		return (error);
485
486	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
487
488	bp  = NULL; /* both used in error_exit */
489	pmp = NULL;
490
491	error = fstrans_mount(mp);
492	if (error)
493		goto error_exit;
494
495	error = getdisksize(devvp, &psize, &secsize);
496	if (error || secsize == 0) {
497		if (argp->flags & MSDOSFSMNT_GEMDOSFS)
498			goto error_exit;
499
500		/* ok, so it failed.  we most likely don't need the info */
501		secsize = DEV_BSIZE;
502		psize = 0;
503		error = 0;
504	}
505
506	if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
507		bsize = secsize;
508		if (bsize != 512) {
509			DPRINTF(("Invalid block bsize %d for gemdos\n", bsize));
510			error = EINVAL;
511			goto error_exit;
512		}
513	} else
514		bsize = 0;
515
516	/*
517	 * Read the boot sector of the filesystem, and then check the
518	 * boot signature.  If not a dos boot sector then error out.
519	 */
520	if ((error = bread(devvp, 0, secsize, NOCRED, 0, &bp)) != 0)
521		goto error_exit;
522	bsp = (union bootsector *)bp->b_data;
523	b33 = (struct byte_bpb33 *)bsp->bs33.bsBPB;
524	b50 = (struct byte_bpb50 *)bsp->bs50.bsBPB;
525	b710 = (struct byte_bpb710 *)bsp->bs710.bsBPB;
526
527	if (!(argp->flags & MSDOSFSMNT_GEMDOSFS)) {
528		if (bsp->bs50.bsBootSectSig0 != BOOTSIG0
529		    || bsp->bs50.bsBootSectSig1 != BOOTSIG1) {
530			DPRINTF(("bootsig0 %d bootsig1 %d\n",
531			    bsp->bs50.bsBootSectSig0,
532			    bsp->bs50.bsBootSectSig1));
533			error = EINVAL;
534			goto error_exit;
535		}
536	}
537
538	pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK);
539	memset(pmp, 0, sizeof *pmp);
540	pmp->pm_mountp = mp;
541
542	/*
543	 * Compute several useful quantities from the bpb in the
544	 * bootsector.  Copy in the dos 5 variant of the bpb then fix up
545	 * the fields that are different between dos 5 and dos 3.3.
546	 */
547	SecPerClust = b50->bpbSecPerClust;
548	pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec);
549	pmp->pm_ResSectors = getushort(b50->bpbResSectors);
550	pmp->pm_FATs = b50->bpbFATs;
551	pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts);
552	pmp->pm_Sectors = getushort(b50->bpbSectors);
553	pmp->pm_FATsecs = getushort(b50->bpbFATsecs);
554	pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack);
555	pmp->pm_Heads = getushort(b50->bpbHeads);
556	pmp->pm_Media = b50->bpbMedia;
557
558	if (!(argp->flags & MSDOSFSMNT_GEMDOSFS)) {
559		/* XXX - We should probably check more values here */
560    		if (!pmp->pm_BytesPerSec || !SecPerClust
561	    		|| pmp->pm_SecPerTrack > 63) {
562			DPRINTF(("bytespersec %d secperclust %d "
563			    "secpertrack %d\n",
564			    pmp->pm_BytesPerSec, SecPerClust,
565			    pmp->pm_SecPerTrack));
566			error = EINVAL;
567			goto error_exit;
568		}
569	}
570
571	if (pmp->pm_Sectors == 0) {
572		pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs);
573		pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors);
574	} else {
575		pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs);
576		pmp->pm_HugeSectors = pmp->pm_Sectors;
577	}
578
579	if (pmp->pm_RootDirEnts == 0) {
580		unsigned short vers = getushort(b710->bpbFSVers);
581		/*
582		 * Some say that bsBootSectSig[23] must be zero, but
583		 * Windows does not require this and some digital cameras
584		 * do not set these to zero.  Therefore, do not insist.
585		 */
586		if (pmp->pm_Sectors || pmp->pm_FATsecs || vers) {
587			DPRINTF(("sectors %d fatsecs %lu vers %d\n",
588			    pmp->pm_Sectors, pmp->pm_FATsecs, vers));
589			error = EINVAL;
590			goto error_exit;
591		}
592		pmp->pm_fatmask = FAT32_MASK;
593		pmp->pm_fatmult = 4;
594		pmp->pm_fatdiv = 1;
595		pmp->pm_FATsecs = getulong(b710->bpbBigFATsecs);
596
597		/* mirrorring is enabled if the FATMIRROR bit is not set */
598		if ((getushort(b710->bpbExtFlags) & FATMIRROR) == 0)
599			pmp->pm_flags |= MSDOSFS_FATMIRROR;
600		else
601			pmp->pm_curfat = getushort(b710->bpbExtFlags) & FATNUM;
602	} else
603		pmp->pm_flags |= MSDOSFS_FATMIRROR;
604
605	if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
606		if (FAT32(pmp)) {
607			DPRINTF(("fat32 for gemdos\n"));
608			/*
609			 * GEMDOS doesn't know fat32.
610			 */
611			error = EINVAL;
612			goto error_exit;
613		}
614
615		/*
616		 * Check a few values (could do some more):
617		 * - logical sector size: power of 2, >= block size
618		 * - sectors per cluster: power of 2, >= 1
619		 * - number of sectors:   >= 1, <= size of partition
620		 */
621		if ( (SecPerClust == 0)
622		  || (SecPerClust & (SecPerClust - 1))
623		  || (pmp->pm_BytesPerSec < bsize)
624		  || (pmp->pm_BytesPerSec & (pmp->pm_BytesPerSec - 1))
625		  || (pmp->pm_HugeSectors == 0)
626		  || (pmp->pm_HugeSectors * (pmp->pm_BytesPerSec / bsize)
627		      > psize)) {
628			DPRINTF(("consistency checks for gemdos\n"));
629			error = EINVAL;
630			goto error_exit;
631		}
632		/*
633		 * XXX - Many parts of the msdos fs driver seem to assume that
634		 * the number of bytes per logical sector (BytesPerSec) will
635		 * always be the same as the number of bytes per disk block
636		 * Let's pretend it is.
637		 */
638		tmp = pmp->pm_BytesPerSec / bsize;
639		pmp->pm_BytesPerSec  = bsize;
640		pmp->pm_HugeSectors *= tmp;
641		pmp->pm_HiddenSects *= tmp;
642		pmp->pm_ResSectors  *= tmp;
643		pmp->pm_Sectors     *= tmp;
644		pmp->pm_FATsecs     *= tmp;
645		SecPerClust         *= tmp;
646	}
647
648	/* Check that fs has nonzero FAT size */
649	if (pmp->pm_FATsecs == 0) {
650		DPRINTF(("FATsecs is 0\n"));
651		error = EINVAL;
652		goto error_exit;
653	}
654
655	pmp->pm_fatblk = pmp->pm_ResSectors;
656	if (FAT32(pmp)) {
657		pmp->pm_rootdirblk = getulong(b710->bpbRootClust);
658		pmp->pm_firstcluster = pmp->pm_fatblk
659			+ (pmp->pm_FATs * pmp->pm_FATsecs);
660		pmp->pm_fsinfo = getushort(b710->bpbFSInfo);
661	} else {
662		pmp->pm_rootdirblk = pmp->pm_fatblk +
663			(pmp->pm_FATs * pmp->pm_FATsecs);
664		pmp->pm_rootdirsize = (pmp->pm_RootDirEnts * sizeof(struct direntry)
665				       + pmp->pm_BytesPerSec - 1)
666			/ pmp->pm_BytesPerSec;/* in sectors */
667		pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize;
668	}
669
670	pmp->pm_nmbrofclusters = (pmp->pm_HugeSectors - pmp->pm_firstcluster) /
671	    SecPerClust;
672	pmp->pm_maxcluster = pmp->pm_nmbrofclusters + 1;
673	pmp->pm_fatsize = pmp->pm_FATsecs * pmp->pm_BytesPerSec;
674
675	if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
676		if (pmp->pm_nmbrofclusters <= (0xff0 - 2)) {
677			pmp->pm_fatmask = FAT12_MASK;
678			pmp->pm_fatmult = 3;
679			pmp->pm_fatdiv = 2;
680		} else {
681			pmp->pm_fatmask = FAT16_MASK;
682			pmp->pm_fatmult = 2;
683			pmp->pm_fatdiv = 1;
684		}
685	} else if (pmp->pm_fatmask == 0) {
686		if (pmp->pm_maxcluster
687		    <= ((CLUST_RSRVD - CLUST_FIRST) & FAT12_MASK)) {
688			/*
689			 * This will usually be a floppy disk. This size makes
690			 * sure that one fat entry will not be split across
691			 * multiple blocks.
692			 */
693			pmp->pm_fatmask = FAT12_MASK;
694			pmp->pm_fatmult = 3;
695			pmp->pm_fatdiv = 2;
696		} else {
697			pmp->pm_fatmask = FAT16_MASK;
698			pmp->pm_fatmult = 2;
699			pmp->pm_fatdiv = 1;
700		}
701	}
702	if (FAT12(pmp))
703		pmp->pm_fatblocksize = 3 * pmp->pm_BytesPerSec;
704	else
705		pmp->pm_fatblocksize = MAXBSIZE;
706
707	pmp->pm_fatblocksec = pmp->pm_fatblocksize / pmp->pm_BytesPerSec;
708	pmp->pm_bnshift = ffs(pmp->pm_BytesPerSec) - 1;
709
710	/*
711	 * Compute mask and shift value for isolating cluster relative byte
712	 * offsets and cluster numbers from a file offset.
713	 */
714	pmp->pm_bpcluster = SecPerClust * pmp->pm_BytesPerSec;
715	pmp->pm_crbomask = pmp->pm_bpcluster - 1;
716	pmp->pm_cnshift = ffs(pmp->pm_bpcluster) - 1;
717
718	/*
719	 * Check for valid cluster size
720	 * must be a power of 2
721	 */
722	if (pmp->pm_bpcluster ^ (1 << pmp->pm_cnshift)) {
723		DPRINTF(("bpcluster %lu cnshift %lu\n",
724		    pmp->pm_bpcluster, pmp->pm_cnshift));
725		error = EINVAL;
726		goto error_exit;
727	}
728
729	/*
730	 * Release the bootsector buffer.
731	 */
732	brelse(bp, BC_AGE);
733	bp = NULL;
734
735	/*
736	 * Check FSInfo.
737	 */
738	if (pmp->pm_fsinfo) {
739		struct fsinfo *fp;
740
741		/*
742		 * XXX	If the fsinfo block is stored on media with
743		 *	2KB or larger sectors, is the fsinfo structure
744		 *	padded at the end or in the middle?
745		 */
746		if ((error = bread(devvp, de_bn2kb(pmp, pmp->pm_fsinfo),
747		    pmp->pm_BytesPerSec, NOCRED, 0, &bp)) != 0)
748			goto error_exit;
749		fp = (struct fsinfo *)bp->b_data;
750		if (!memcmp(fp->fsisig1, "RRaA", 4)
751		    && !memcmp(fp->fsisig2, "rrAa", 4)
752		    && !memcmp(fp->fsisig3, "\0\0\125\252", 4)
753		    && !memcmp(fp->fsisig4, "\0\0\125\252", 4))
754			pmp->pm_nxtfree = getulong(fp->fsinxtfree);
755		else
756			pmp->pm_fsinfo = 0;
757		brelse(bp, 0);
758		bp = NULL;
759	}
760
761	/*
762	 * Check and validate (or perhaps invalidate?) the fsinfo structure?
763	 * XXX
764	 */
765	if (pmp->pm_fsinfo) {
766		if (pmp->pm_nxtfree == (u_long)-1)
767			pmp->pm_fsinfo = 0;
768	}
769
770	/*
771	 * Allocate memory for the bitmap of allocated clusters, and then
772	 * fill it in.
773	 */
774	pmp->pm_inusemap = malloc(((pmp->pm_maxcluster + N_INUSEBITS - 1)
775				   / N_INUSEBITS)
776				  * sizeof(*pmp->pm_inusemap),
777				  M_MSDOSFSFAT, M_WAITOK);
778
779	/*
780	 * fillinusemap() needs pm_devvp.
781	 */
782	pmp->pm_dev = dev;
783	pmp->pm_devvp = devvp;
784
785	/*
786	 * Have the inuse map filled in.
787	 */
788	if ((error = fillinusemap(pmp)) != 0) {
789		DPRINTF(("fillinusemap %d\n", error));
790		goto error_exit;
791	}
792
793	/*
794	 * If they want fat updates to be synchronous then let them suffer
795	 * the performance degradation in exchange for the on disk copy of
796	 * the fat being correct just about all the time.  I suppose this
797	 * would be a good thing to turn on if the kernel is still flakey.
798	 */
799	if (mp->mnt_flag & MNT_SYNCHRONOUS)
800		pmp->pm_flags |= MSDOSFSMNT_WAITONFAT;
801
802	/*
803	 * Finish up.
804	 */
805	if (ronly)
806		pmp->pm_flags |= MSDOSFSMNT_RONLY;
807	else
808		pmp->pm_fmod = 1;
809	mp->mnt_data = pmp;
810	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
811	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_MSDOS);
812	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
813	mp->mnt_stat.f_namemax = MSDOSFS_NAMEMAX(pmp);
814	mp->mnt_flag |= MNT_LOCAL;
815	mp->mnt_dev_bshift = pmp->pm_bnshift;
816	mp->mnt_fs_bshift = pmp->pm_cnshift;
817
818	/*
819	 * If we ever do quotas for DOS filesystems this would be a place
820	 * to fill in the info in the msdosfsmount structure. You dolt,
821	 * quotas on dos filesystems make no sense because files have no
822	 * owners on dos filesystems. of course there is some empty space
823	 * in the directory entry where we could put uid's and gid's.
824	 */
825
826	devvp->v_specmountpoint = mp;
827
828	return (0);
829
830error_exit:
831	fstrans_unmount(mp);
832	if (bp)
833		brelse(bp, BC_AGE);
834	if (pmp) {
835		if (pmp->pm_inusemap)
836			free(pmp->pm_inusemap, M_MSDOSFSFAT);
837		free(pmp, M_MSDOSFSMNT);
838		mp->mnt_data = NULL;
839	}
840	return (error);
841}
842
843int
844msdosfs_start(struct mount *mp, int flags)
845{
846
847	return (0);
848}
849
850/*
851 * Unmount the filesystem described by mp.
852 */
853int
854msdosfs_unmount(struct mount *mp, int mntflags)
855{
856	struct msdosfsmount *pmp;
857	int error, flags;
858
859	flags = 0;
860	if (mntflags & MNT_FORCE)
861		flags |= FORCECLOSE;
862	if ((error = vflush(mp, NULLVP, flags)) != 0)
863		return (error);
864	pmp = VFSTOMSDOSFS(mp);
865	if (pmp->pm_devvp->v_type != VBAD)
866		pmp->pm_devvp->v_specmountpoint = NULL;
867#ifdef MSDOSFS_DEBUG
868	{
869		struct vnode *vp = pmp->pm_devvp;
870
871		printf("msdosfs_umount(): just before calling VOP_CLOSE()\n");
872		printf("flag %08x, usecount %d, writecount %d, holdcnt %d\n",
873		    vp->v_vflag | vp->v_iflag | vp->v_uflag, vp->v_usecount,
874		    vp->v_writecount, vp->v_holdcnt);
875		printf("mount %p, op %p\n",
876		    vp->v_mount, vp->v_op);
877		printf("freef %p, freeb %p, mount %p\n",
878		    vp->v_freelist.tqe_next, vp->v_freelist.tqe_prev,
879		    vp->v_mount);
880		printf("cleanblkhd %p, dirtyblkhd %p, numoutput %d, type %d\n",
881		    vp->v_cleanblkhd.lh_first,
882		    vp->v_dirtyblkhd.lh_first,
883		    vp->v_numoutput, vp->v_type);
884		printf("union %p, tag %d, data[0] %08x, data[1] %08x\n",
885		    vp->v_socket, vp->v_tag,
886		    ((u_int *)vp->v_data)[0],
887		    ((u_int *)vp->v_data)[1]);
888	}
889#endif
890	vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY);
891	(void) VOP_CLOSE(pmp->pm_devvp,
892	    pmp->pm_flags & MSDOSFSMNT_RONLY ? FREAD : FREAD|FWRITE, NOCRED);
893	vput(pmp->pm_devvp);
894	msdosfs_fh_destroy(pmp);
895	free(pmp->pm_inusemap, M_MSDOSFSFAT);
896	free(pmp, M_MSDOSFSMNT);
897	mp->mnt_data = NULL;
898	mp->mnt_flag &= ~MNT_LOCAL;
899	fstrans_unmount(mp);
900	return (0);
901}
902
903int
904msdosfs_root(struct mount *mp, struct vnode **vpp)
905{
906	struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
907	struct denode *ndep;
908	int error;
909
910#ifdef MSDOSFS_DEBUG
911	printf("msdosfs_root(); mp %p, pmp %p\n", mp, pmp);
912#endif
913	if ((error = deget(pmp, MSDOSFSROOT, MSDOSFSROOT_OFS, &ndep)) != 0)
914		return (error);
915	*vpp = DETOV(ndep);
916	return (0);
917}
918
919int
920msdosfs_statvfs(struct mount *mp, struct statvfs *sbp)
921{
922	struct msdosfsmount *pmp;
923
924	pmp = VFSTOMSDOSFS(mp);
925	sbp->f_bsize = pmp->pm_bpcluster;
926	sbp->f_frsize = sbp->f_bsize;
927	sbp->f_iosize = pmp->pm_bpcluster;
928	sbp->f_blocks = pmp->pm_nmbrofclusters;
929	sbp->f_bfree = pmp->pm_freeclustercount;
930	sbp->f_bavail = pmp->pm_freeclustercount;
931	sbp->f_bresvd = 0;
932	sbp->f_files = pmp->pm_RootDirEnts;			/* XXX */
933	sbp->f_ffree = 0;	/* what to put in here? */
934	sbp->f_favail = 0;	/* what to put in here? */
935	sbp->f_fresvd = 0;
936	copy_statvfs_info(sbp, mp);
937	return (0);
938}
939
940int
941msdosfs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
942{
943	struct vnode *vp, *mvp;
944	struct denode *dep;
945	struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
946	int error, allerror = 0;
947
948	/*
949	 * If we ever switch to not updating all of the fats all the time,
950	 * this would be the place to update them from the first one.
951	 */
952	if (pmp->pm_fmod != 0) {
953		if (pmp->pm_flags & MSDOSFSMNT_RONLY)
954			panic("msdosfs_sync: rofs mod");
955		else {
956			/* update fats here */
957		}
958	}
959	/* Allocate a marker vnode. */
960	mvp = vnalloc(mp);
961	fstrans_start(mp, FSTRANS_SHARED);
962	/*
963	 * Write back each (modified) denode.
964	 */
965	mutex_enter(&mntvnode_lock);
966loop:
967	for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) {
968		vmark(mvp, vp);
969		if (vp->v_mount != mp || vismarker(vp))
970			continue;
971		mutex_enter(vp->v_interlock);
972		dep = VTODE(vp);
973		if (waitfor == MNT_LAZY || vp->v_type == VNON ||
974		    dep == NULL || (((dep->de_flag &
975		    (DE_ACCESS | DE_CREATE | DE_UPDATE | DE_MODIFIED)) == 0) &&
976		     (LIST_EMPTY(&vp->v_dirtyblkhd) &&
977		      UVM_OBJ_IS_CLEAN(&vp->v_uobj)))) {
978			mutex_exit(vp->v_interlock);
979			continue;
980		}
981		mutex_exit(&mntvnode_lock);
982		error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT);
983		if (error) {
984			mutex_enter(&mntvnode_lock);
985			if (error == ENOENT) {
986				(void)vunmark(mvp);
987				goto loop;
988			}
989			continue;
990		}
991		if ((error = VOP_FSYNC(vp, cred,
992		    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0)) != 0)
993			allerror = error;
994		vput(vp);
995		mutex_enter(&mntvnode_lock);
996	}
997	mutex_exit(&mntvnode_lock);
998	vnfree(mvp);
999
1000	/*
1001	 * Force stale file system control information to be flushed.
1002	 */
1003	if ((error = VOP_FSYNC(pmp->pm_devvp, cred,
1004	    waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0)) != 0)
1005		allerror = error;
1006	fstrans_done(mp);
1007	return (allerror);
1008}
1009
1010int
1011msdosfs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
1012{
1013	struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
1014	struct defid defh;
1015	struct denode *dep;
1016	uint32_t gen;
1017	int error;
1018
1019	if (fhp->fid_len != sizeof(struct defid)) {
1020		DPRINTF(("fid_len %d %zd\n", fhp->fid_len,
1021		    sizeof(struct defid)));
1022		return EINVAL;
1023	}
1024	memcpy(&defh, fhp, sizeof(defh));
1025	error = msdosfs_fh_lookup(pmp, defh.defid_dirclust, defh.defid_dirofs,
1026	    &gen);
1027	if (error == 0 && gen != defh.defid_gen)
1028		error = ESTALE;
1029	if (error) {
1030		*vpp = NULLVP;
1031		return error;
1032	}
1033	error = deget(pmp, defh.defid_dirclust, defh.defid_dirofs, &dep);
1034	if (error) {
1035		DPRINTF(("deget %d\n", error));
1036		*vpp = NULLVP;
1037		return (error);
1038	}
1039	*vpp = DETOV(dep);
1040	return (0);
1041}
1042
1043int
1044msdosfs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
1045{
1046	struct msdosfsmount *pmp = VFSTOMSDOSFS(vp->v_mount);
1047	struct denode *dep;
1048	struct defid defh;
1049	int error;
1050
1051	if (*fh_size < sizeof(struct defid)) {
1052		*fh_size = sizeof(struct defid);
1053		return E2BIG;
1054	}
1055	*fh_size = sizeof(struct defid);
1056	dep = VTODE(vp);
1057	memset(&defh, 0, sizeof(defh));
1058	defh.defid_len = sizeof(struct defid);
1059	defh.defid_dirclust = dep->de_dirclust;
1060	defh.defid_dirofs = dep->de_diroffset;
1061	error = msdosfs_fh_enter(pmp, dep->de_dirclust, dep->de_diroffset,
1062	     &defh.defid_gen);
1063	if (error == 0)
1064		memcpy(fhp, &defh, sizeof(defh));
1065	return error;
1066}
1067
1068int
1069msdosfs_vget(struct mount *mp, ino_t ino,
1070    struct vnode **vpp)
1071{
1072
1073	return (EOPNOTSUPP);
1074}
1075
1076int
1077msdosfs_suspendctl(struct mount *mp, int cmd)
1078{
1079	int error;
1080	struct lwp *l = curlwp;
1081
1082	switch (cmd) {
1083	case SUSPEND_SUSPEND:
1084		if ((error = fstrans_setstate(mp, FSTRANS_SUSPENDING)) != 0)
1085			return error;
1086		error = msdosfs_sync(mp, MNT_WAIT, l->l_proc->p_cred);
1087		if (error == 0)
1088			error = fstrans_setstate(mp, FSTRANS_SUSPENDED);
1089		if (error != 0) {
1090			(void) fstrans_setstate(mp, FSTRANS_NORMAL);
1091			return error;
1092		}
1093		return 0;
1094
1095	case SUSPEND_RESUME:
1096		return fstrans_setstate(mp, FSTRANS_NORMAL);
1097
1098	default:
1099		return EINVAL;
1100	}
1101}
1102