1998-03-20 02:33:42 +00:00
|
|
|
/* $Id: msdosfs_vfsops.c,v 1.30 1998/03/08 09:57:48 julian Exp $ */
|
1998-02-18 09:28:47 +00:00
|
|
|
/* $NetBSD: msdosfs_vfsops.c,v 1.51 1997/11/17 15:36:58 ws Exp $ */
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
/*-
|
1998-02-18 09:28:47 +00:00
|
|
|
* Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
|
|
|
|
* Copyright (C) 1994, 1995, 1997 TooLs GmbH.
|
1994-09-19 15:41:57 +00:00
|
|
|
* All rights reserved.
|
|
|
|
* Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by TooLs GmbH.
|
|
|
|
* 4. The name of TooLs GmbH may not be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
|
|
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
* IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* Written by Paul Popelka (paulp@uts.amdahl.com)
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1994-09-19 15:41:57 +00:00
|
|
|
* You can do anything you want with this software, just don't say you wrote
|
|
|
|
* it, and don't remove this notice.
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1994-09-19 15:41:57 +00:00
|
|
|
* This software is provided "as is".
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1994-09-19 15:41:57 +00:00
|
|
|
* The author supplies this software to be publicly redistributed on the
|
|
|
|
* understanding that the author is not responsible for the correct
|
|
|
|
* functioning of this software in any circumstances and is not liable for
|
|
|
|
* any damages caused by this software.
|
1995-05-30 08:16:23 +00:00
|
|
|
*
|
1994-09-19 15:41:57 +00:00
|
|
|
* October 1992
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/namei.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/vnode.h>
|
|
|
|
#include <miscfs/specfs/specdev.h> /* XXX */ /* defines v_rdev */
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <sys/buf.h>
|
1997-03-23 03:37:54 +00:00
|
|
|
#include <sys/fcntl.h>
|
1994-09-19 15:41:57 +00:00
|
|
|
#include <sys/malloc.h>
|
1998-02-18 09:28:47 +00:00
|
|
|
#include <sys/stat.h> /* defines ALLPERMS */
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
#include <msdosfs/bpb.h>
|
|
|
|
#include <msdosfs/bootsect.h>
|
|
|
|
#include <msdosfs/direntry.h>
|
|
|
|
#include <msdosfs/denode.h>
|
|
|
|
#include <msdosfs/msdosfsmount.h>
|
|
|
|
#include <msdosfs/fat.h>
|
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
MALLOC_DEFINE(M_MSDOSFSMNT, "MSDOSFS mount", "MSDOSFS mount structure");
|
|
|
|
static MALLOC_DEFINE(M_MSDOSFSFAT, "MSDOSFS FAT", "MSDOSFS file allocation table");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
static int update_mp __P((struct mount *mp, struct msdosfs_args *argp));
|
1995-11-16 11:48:10 +00:00
|
|
|
static int mountmsdosfs __P((struct vnode *devvp, struct mount *mp,
|
1998-02-18 09:28:47 +00:00
|
|
|
struct proc *p, struct msdosfs_args *argp));
|
1995-11-16 11:48:10 +00:00
|
|
|
static int msdosfs_fhtovp __P((struct mount *, struct fid *,
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr *, struct vnode **, int *,
|
1995-11-16 11:48:10 +00:00
|
|
|
struct ucred **));
|
|
|
|
static int msdosfs_mount __P((struct mount *, char *, caddr_t,
|
|
|
|
struct nameidata *, struct proc *));
|
|
|
|
static int msdosfs_quotactl __P((struct mount *, int, uid_t, caddr_t,
|
|
|
|
struct proc *));
|
|
|
|
static int msdosfs_root __P((struct mount *, struct vnode **));
|
|
|
|
static int msdosfs_start __P((struct mount *, int, struct proc *));
|
|
|
|
static int msdosfs_statfs __P((struct mount *, struct statfs *,
|
|
|
|
struct proc *));
|
|
|
|
static int msdosfs_sync __P((struct mount *, int, struct ucred *,
|
|
|
|
struct proc *));
|
|
|
|
static int msdosfs_unmount __P((struct mount *, int, struct proc *));
|
|
|
|
static int msdosfs_vget __P((struct mount *mp, ino_t ino,
|
|
|
|
struct vnode **vpp));
|
|
|
|
static int msdosfs_vptofh __P((struct vnode *, struct fid *));
|
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
static int
|
|
|
|
update_mp(mp, argp)
|
|
|
|
struct mount *mp;
|
|
|
|
struct msdosfs_args *argp;
|
|
|
|
{
|
|
|
|
struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
pmp->pm_gid = argp->gid;
|
|
|
|
pmp->pm_uid = argp->uid;
|
|
|
|
pmp->pm_mask = argp->mask & ALLPERMS;
|
|
|
|
pmp->pm_flags |= argp->flags & MSDOSFSMNT_MNTOPT;
|
1998-02-23 16:44:37 +00:00
|
|
|
if (pmp->pm_flags & MSDOSFSMNT_U2WTABLE) {
|
1998-02-22 15:09:54 +00:00
|
|
|
bcopy(argp->u2w, pmp->pm_u2w, sizeof(pmp->pm_u2w));
|
1998-02-23 16:44:37 +00:00
|
|
|
bcopy(argp->d2u, pmp->pm_d2u, sizeof(pmp->pm_d2u));
|
|
|
|
bcopy(argp->u2d, pmp->pm_u2d, sizeof(pmp->pm_u2d));
|
|
|
|
}
|
|
|
|
if (pmp->pm_flags & MSDOSFSMNT_ULTABLE) {
|
1998-02-23 09:59:08 +00:00
|
|
|
bcopy(argp->ul, pmp->pm_ul, sizeof(pmp->pm_ul));
|
1998-02-23 16:44:37 +00:00
|
|
|
bcopy(argp->lu, pmp->pm_lu, sizeof(pmp->pm_lu));
|
|
|
|
}
|
1998-02-18 09:28:47 +00:00
|
|
|
|
|
|
|
#ifndef __FreeBSD__
|
|
|
|
/*
|
|
|
|
* GEMDOS knows nothing (yet) about win95
|
|
|
|
*/
|
|
|
|
if (pmp->pm_flags & MSDOSFSMNT_GEMDOSFS)
|
|
|
|
pmp->pm_flags |= MSDOSFSMNT_NOWIN95;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (pmp->pm_flags & MSDOSFSMNT_NOWIN95)
|
|
|
|
pmp->pm_flags |= MSDOSFSMNT_SHORTNAME;
|
|
|
|
else if (!(pmp->pm_flags &
|
|
|
|
(MSDOSFSMNT_SHORTNAME | MSDOSFSMNT_LONGNAME))) {
|
|
|
|
struct vnode *rootvp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to divine whether to support Win'95 long filenames
|
|
|
|
*/
|
|
|
|
if (FAT32(pmp))
|
|
|
|
pmp->pm_flags |= MSDOSFSMNT_LONGNAME;
|
|
|
|
else {
|
|
|
|
if ((error = msdosfs_root(mp, &rootvp)) != 0)
|
|
|
|
return error;
|
|
|
|
pmp->pm_flags |= findwin95(VTODE(rootvp))
|
|
|
|
? MSDOSFSMNT_LONGNAME
|
|
|
|
: MSDOSFSMNT_SHORTNAME;
|
|
|
|
vput(rootvp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef __FreeBSD__
|
|
|
|
int
|
|
|
|
msdosfs_mountroot()
|
|
|
|
{
|
|
|
|
register struct mount *mp;
|
|
|
|
struct proc *p = curproc; /* XXX */
|
|
|
|
size_t size;
|
|
|
|
int error;
|
|
|
|
struct msdosfs_args args;
|
|
|
|
|
|
|
|
if (root_device->dv_class != DV_DISK)
|
|
|
|
return (ENODEV);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get vnodes for swapdev and rootdev.
|
|
|
|
*/
|
|
|
|
if (bdevvp(rootdev, &rootvp))
|
|
|
|
panic("msdosfs_mountroot: can't setup rootvp");
|
|
|
|
|
|
|
|
mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK);
|
|
|
|
bzero((char *)mp, (u_long)sizeof(struct mount));
|
|
|
|
mp->mnt_op = &msdosfs_vfsops;
|
|
|
|
mp->mnt_flag = 0;
|
|
|
|
LIST_INIT(&mp->mnt_vnodelist);
|
|
|
|
|
|
|
|
args.flags = 0;
|
|
|
|
args.uid = 0;
|
|
|
|
args.gid = 0;
|
|
|
|
args.mask = 0777;
|
|
|
|
|
|
|
|
if ((error = mountmsdosfs(rootvp, mp, p, &args)) != 0) {
|
|
|
|
free(mp, M_MOUNT);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((error = update_mp(mp, &args)) != 0) {
|
|
|
|
(void)msdosfs_unmount(mp, 0, p);
|
|
|
|
free(mp, M_MOUNT);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((error = vfs_lock(mp)) != 0) {
|
|
|
|
(void)msdosfs_unmount(mp, 0, p);
|
|
|
|
free(mp, M_MOUNT);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
|
|
|
|
mp->mnt_vnodecovered = NULLVP;
|
|
|
|
(void) copystr("/", mp->mnt_stat.f_mntonname, MNAMELEN - 1,
|
|
|
|
&size);
|
|
|
|
bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
|
|
|
|
(void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
|
|
|
|
&size);
|
|
|
|
bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
|
|
|
|
(void)msdosfs_statfs(mp, &mp->mnt_stat, p);
|
|
|
|
vfs_unlock(mp);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1994-09-19 15:41:57 +00:00
|
|
|
/*
|
1995-05-30 08:16:23 +00:00
|
|
|
* mp - path - addr in user space of mount point (ie /usr or whatever)
|
1994-09-19 15:41:57 +00:00
|
|
|
* data - addr in user space of mount params including the name of the block
|
1995-05-30 08:16:23 +00:00
|
|
|
* special file to treat as a filesystem.
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_mount(mp, path, data, ndp, p)
|
|
|
|
struct mount *mp;
|
|
|
|
char *path;
|
|
|
|
caddr_t data;
|
|
|
|
struct nameidata *ndp;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
struct vnode *devvp; /* vnode for blk device to mount */
|
|
|
|
struct msdosfs_args args; /* will hold data from mount request */
|
1998-02-18 09:28:47 +00:00
|
|
|
/* msdosfs specific mount control block */
|
|
|
|
struct msdosfsmount *pmp = NULL;
|
|
|
|
size_t size;
|
1994-09-19 15:41:57 +00:00
|
|
|
int error, flags;
|
1998-02-18 09:28:47 +00:00
|
|
|
mode_t accessmode;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
error = copyin(data, (caddr_t)&args, sizeof(struct msdosfs_args));
|
1994-09-27 20:42:59 +00:00
|
|
|
if (error)
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
|
|
|
if (args.magic != MSDOSFS_ARGSMAGIC) {
|
|
|
|
printf("Old mount_msdosfs, flags=%d\n", args.flags);
|
|
|
|
args.flags = 0;
|
|
|
|
}
|
1994-09-19 15:41:57 +00:00
|
|
|
/*
|
1998-02-18 09:28:47 +00:00
|
|
|
* If updating, check whether changing from read-only to
|
|
|
|
* read/write; if there is no device name, that's all we do.
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
|
|
|
if (mp->mnt_flag & MNT_UPDATE) {
|
1998-02-18 09:28:47 +00:00
|
|
|
pmp = VFSTOMSDOSFS(mp);
|
1994-09-19 15:41:57 +00:00
|
|
|
error = 0;
|
1998-02-18 09:28:47 +00:00
|
|
|
if (!(pmp->pm_flags & MSDOSFSMNT_RONLY) && (mp->mnt_flag & MNT_RDONLY)) {
|
1994-09-19 15:41:57 +00:00
|
|
|
flags = WRITECLOSE;
|
|
|
|
if (mp->mnt_flag & MNT_FORCE)
|
|
|
|
flags |= FORCECLOSE;
|
|
|
|
error = vflush(mp, NULLVP, flags);
|
|
|
|
}
|
|
|
|
if (!error && (mp->mnt_flag & MNT_RELOAD))
|
|
|
|
/* not yet implemented */
|
1998-02-18 09:28:47 +00:00
|
|
|
error = EOPNOTSUPP;
|
1994-09-19 15:41:57 +00:00
|
|
|
if (error)
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
|
|
|
if ((pmp->pm_flags & MSDOSFSMNT_RONLY) && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
|
|
|
|
/*
|
|
|
|
* If upgrade to read-write by non-root, then verify
|
|
|
|
* that user has necessary permissions on the device.
|
|
|
|
*/
|
|
|
|
if (p->p_ucred->cr_uid != 0) {
|
|
|
|
devvp = pmp->pm_devvp;
|
|
|
|
vn_lock(devvp, LK_EXCLUSIVE, p);
|
|
|
|
error = VOP_ACCESS(devvp, VREAD | VWRITE,
|
|
|
|
p->p_ucred, p);
|
|
|
|
if (error) {
|
|
|
|
VOP_UNLOCK(devvp, 0, p);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
VOP_UNLOCK(devvp, 0, p);
|
|
|
|
}
|
|
|
|
pmp->pm_flags &= ~MSDOSFSMNT_RONLY;
|
|
|
|
}
|
1994-09-19 15:41:57 +00:00
|
|
|
if (args.fspec == 0) {
|
1998-02-18 09:28:47 +00:00
|
|
|
#ifdef __notyet__ /* doesn't work correctly with current mountd XXX */
|
|
|
|
if (args.flags & MSDOSFSMNT_MNTOPT) {
|
|
|
|
pmp->pm_flags &= ~MSDOSFSMNT_MNTOPT;
|
|
|
|
pmp->pm_flags |= args.flags & MSDOSFSMNT_MNTOPT;
|
|
|
|
if (pmp->pm_flags & MSDOSFSMNT_NOWIN95)
|
|
|
|
pmp->pm_flags |= MSDOSFSMNT_SHORTNAME;
|
|
|
|
}
|
|
|
|
#endif
|
1994-09-19 15:41:57 +00:00
|
|
|
/*
|
|
|
|
* Process export requests.
|
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
return (vfs_export(mp, &pmp->pm_export, &args.export));
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
1998-02-18 09:28:47 +00:00
|
|
|
* Not an update, or updating the name: look up the name
|
|
|
|
* and verify that it refers to a sensible block device.
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
|
|
|
NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
|
|
|
|
error = namei(ndp);
|
1998-02-18 09:28:47 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
1994-09-19 15:41:57 +00:00
|
|
|
devvp = ndp->ni_vp;
|
1998-02-18 09:28:47 +00:00
|
|
|
|
1994-09-19 15:41:57 +00:00
|
|
|
if (devvp->v_type != VBLK) {
|
|
|
|
vrele(devvp);
|
1998-02-18 09:28:47 +00:00
|
|
|
return (ENOTBLK);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
if (major(devvp->v_rdev) >= nblkdev) {
|
|
|
|
vrele(devvp);
|
1998-02-18 09:28:47 +00:00
|
|
|
return (ENXIO);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
/*
|
1998-02-18 09:28:47 +00:00
|
|
|
* If mount by non-root, then verify that user has necessary
|
|
|
|
* permissions on the device.
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
if (p->p_ucred->cr_uid != 0) {
|
|
|
|
accessmode = VREAD;
|
|
|
|
if ((mp->mnt_flag & MNT_RDONLY) == 0)
|
|
|
|
accessmode |= VWRITE;
|
|
|
|
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
|
|
|
|
error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p);
|
|
|
|
if (error) {
|
|
|
|
vput(devvp);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
VOP_UNLOCK(devvp, 0, p);
|
|
|
|
}
|
|
|
|
if ((mp->mnt_flag & MNT_UPDATE) == 0) {
|
|
|
|
error = mountmsdosfs(devvp, mp, p, &args);
|
|
|
|
#ifdef MSDOSFS_DEBUG /* only needed for the printf below */
|
|
|
|
pmp = VFSTOMSDOSFS(mp);
|
|
|
|
#endif
|
|
|
|
} else {
|
1994-09-19 15:41:57 +00:00
|
|
|
if (devvp != pmp->pm_devvp)
|
1998-02-18 09:28:47 +00:00
|
|
|
error = EINVAL; /* XXX needs translation */
|
1994-09-19 15:41:57 +00:00
|
|
|
else
|
|
|
|
vrele(devvp);
|
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
vrele(devvp);
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = update_mp(mp, &args);
|
|
|
|
if (error) {
|
|
|
|
msdosfs_unmount(mp, MNT_FORCE, p);
|
1994-09-19 15:41:57 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
(void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
|
|
|
|
bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
|
|
|
|
(void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
|
|
|
|
&size);
|
|
|
|
bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
|
1994-09-19 15:41:57 +00:00
|
|
|
(void) msdosfs_statfs(mp, &mp->mnt_stat, p);
|
|
|
|
#ifdef MSDOSFS_DEBUG
|
1994-10-02 17:48:58 +00:00
|
|
|
printf("msdosfs_mount(): mp %p, pmp %p, inusemap %p\n", mp, pmp, pmp->pm_inusemap);
|
1994-09-19 15:41:57 +00:00
|
|
|
#endif
|
1998-02-18 09:28:47 +00:00
|
|
|
return (0);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1998-02-18 09:28:47 +00:00
|
|
|
mountmsdosfs(devvp, mp, p, argp)
|
1994-09-19 15:41:57 +00:00
|
|
|
struct vnode *devvp;
|
|
|
|
struct mount *mp;
|
|
|
|
struct proc *p;
|
1998-02-18 09:28:47 +00:00
|
|
|
struct msdosfs_args *argp;
|
1994-09-19 15:41:57 +00:00
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
struct msdosfsmount *pmp;
|
|
|
|
struct buf *bp;
|
1994-09-19 15:41:57 +00:00
|
|
|
dev_t dev = devvp->v_rdev;
|
1998-02-18 09:28:47 +00:00
|
|
|
#ifndef __FreeBSD__
|
|
|
|
struct partinfo dpart;
|
|
|
|
#endif
|
1994-09-19 15:41:57 +00:00
|
|
|
union bootsector *bsp;
|
|
|
|
struct byte_bpb33 *b33;
|
|
|
|
struct byte_bpb50 *b50;
|
1998-02-18 09:28:47 +00:00
|
|
|
struct byte_bpb710 *b710;
|
|
|
|
u_int8_t SecPerClust;
|
|
|
|
int ronly, error;
|
|
|
|
int bsize = 0, dtype = 0, tmp;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
/*
|
1998-02-18 09:28:47 +00:00
|
|
|
* Disallow multiple mounts of the same device.
|
|
|
|
* Disallow mounting of a device that is currently in use
|
|
|
|
* (except for root, which might share swap device for miniroot).
|
|
|
|
* Flush out any old buffers remaining from a previous use.
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
1994-09-27 20:42:59 +00:00
|
|
|
error = vfs_mountedon(devvp);
|
|
|
|
if (error)
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
|
|
|
if (vcount(devvp) > 1 && devvp != rootvp)
|
|
|
|
return (EBUSY);
|
|
|
|
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
|
1994-09-27 20:42:59 +00:00
|
|
|
error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0);
|
1998-02-18 09:28:47 +00:00
|
|
|
VOP_UNLOCK(devvp, 0, p);
|
1994-09-27 20:42:59 +00:00
|
|
|
if (error)
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
1994-09-19 15:41:57 +00:00
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
|
|
|
|
error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
|
1994-09-27 20:42:59 +00:00
|
|
|
if (error)
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
|
|
|
|
|
|
|
bp = NULL; /* both used in error_exit */
|
|
|
|
pmp = NULL;
|
|
|
|
|
|
|
|
#ifndef __FreeBSD__
|
|
|
|
if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
|
|
|
|
/*
|
|
|
|
* We need the disklabel to calculate the size of a FAT entry
|
|
|
|
* later on. Also make sure the partition contains a filesystem
|
|
|
|
* of type FS_MSDOS. This doesn't work for floppies, so we have
|
|
|
|
* to check for them too.
|
|
|
|
*
|
|
|
|
* At least some parts of the msdos fs driver seem to assume
|
|
|
|
* that the size of a disk block will always be 512 bytes.
|
|
|
|
* Let's check it...
|
|
|
|
*/
|
|
|
|
error = VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart,
|
|
|
|
FREAD, NOCRED, p);
|
|
|
|
if (error)
|
|
|
|
goto error_exit;
|
|
|
|
tmp = dpart.part->p_fstype;
|
|
|
|
dtype = dpart.disklab->d_type;
|
|
|
|
bsize = dpart.disklab->d_secsize;
|
|
|
|
if (bsize != 512 || (dtype!=DTYPE_FLOPPY && tmp!=FS_MSDOS)) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
1998-02-18 09:28:47 +00:00
|
|
|
* Read the boot sector of the filesystem, and then check the
|
|
|
|
* boot signature. If not a dos boot sector then error out.
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
1996-06-14 11:02:28 +00:00
|
|
|
#ifdef PC98
|
1998-02-18 09:28:47 +00:00
|
|
|
error = bread(devvp, 0, 1024, NOCRED, &bp);
|
1996-06-14 11:02:28 +00:00
|
|
|
#else
|
1998-02-18 09:28:47 +00:00
|
|
|
error = bread(devvp, 0, 512, NOCRED, &bp);
|
1996-06-14 11:02:28 +00:00
|
|
|
#endif
|
1994-09-27 20:42:59 +00:00
|
|
|
if (error)
|
1994-09-19 15:41:57 +00:00
|
|
|
goto error_exit;
|
1998-02-18 09:28:47 +00:00
|
|
|
bp->b_flags |= B_AGE;
|
|
|
|
bsp = (union bootsector *)bp->b_data;
|
|
|
|
b33 = (struct byte_bpb33 *)bsp->bs33.bsBPB;
|
|
|
|
b50 = (struct byte_bpb50 *)bsp->bs50.bsBPB;
|
|
|
|
b710 = (struct byte_bpb710 *)bsp->bs710.bsPBP;
|
|
|
|
|
|
|
|
#ifndef __FreeBSD__
|
|
|
|
if (!(argp->flags & MSDOSFSMNT_GEMDOSFS)) {
|
|
|
|
#endif
|
|
|
|
#ifdef PC98
|
1998-02-23 14:57:50 +00:00
|
|
|
if ((bsp->bs50.bsBootSectSig0 != BOOTSIG0
|
|
|
|
|| bsp->bs50.bsBootSectSig1 != BOOTSIG1)
|
|
|
|
&& (bsp->bs50.bsBootSectSig0 != 0 /* PC98 DOS 3.3x */
|
|
|
|
|| bsp->bs50.bsBootSectSig1 != 0)
|
|
|
|
&& (bsp->bs50.bsBootSectSig0 != 0x90 /* PC98 DOS 5.0 */
|
|
|
|
|| bsp->bs50.bsBootSectSig1 != 0x3d)
|
|
|
|
&& (bsp->bs50.bsBootSectSig0 != 0x46 /* PC98 DOS 3.3B */
|
|
|
|
|| bsp->bs50.bsBootSectSig1 != 0xfa)) {
|
1996-06-14 11:02:28 +00:00
|
|
|
#else
|
1998-02-18 09:28:47 +00:00
|
|
|
if (bsp->bs50.bsBootSectSig0 != BOOTSIG0
|
|
|
|
|| bsp->bs50.bsBootSectSig1 != BOOTSIG1) {
|
1996-06-14 11:02:28 +00:00
|
|
|
#endif
|
1998-02-18 09:28:47 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
#ifndef __FreeBSD__
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK);
|
|
|
|
bzero((caddr_t)pmp, sizeof *pmp);
|
|
|
|
pmp->pm_mountp = mp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute several useful quantities from the bpb in the
|
|
|
|
* bootsector. Copy in the dos 5 variant of the bpb then fix up
|
|
|
|
* the fields that are different between dos 5 and dos 3.3.
|
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
SecPerClust = b50->bpbSecPerClust;
|
1994-09-19 15:41:57 +00:00
|
|
|
pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec);
|
|
|
|
pmp->pm_ResSectors = getushort(b50->bpbResSectors);
|
|
|
|
pmp->pm_FATs = b50->bpbFATs;
|
|
|
|
pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts);
|
|
|
|
pmp->pm_Sectors = getushort(b50->bpbSectors);
|
|
|
|
pmp->pm_FATsecs = getushort(b50->bpbFATsecs);
|
|
|
|
pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack);
|
|
|
|
pmp->pm_Heads = getushort(b50->bpbHeads);
|
1998-02-18 09:28:47 +00:00
|
|
|
pmp->pm_Media = b50->bpbMedia;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
#ifndef __FreeBSD__
|
|
|
|
if (!(argp->flags & MSDOSFSMNT_GEMDOSFS)) {
|
|
|
|
#endif
|
|
|
|
/* XXX - We should probably check more values here */
|
|
|
|
if (!pmp->pm_BytesPerSec || !SecPerClust
|
|
|
|
|| !pmp->pm_Heads || pmp->pm_Heads > 255
|
1996-06-14 11:02:28 +00:00
|
|
|
#ifdef PC98
|
1998-02-18 09:28:47 +00:00
|
|
|
|| !pmp->pm_SecPerTrack || pmp->pm_SecPerTrack > 255) {
|
1996-06-14 11:02:28 +00:00
|
|
|
#else
|
1998-02-18 09:28:47 +00:00
|
|
|
|| !pmp->pm_SecPerTrack || pmp->pm_SecPerTrack > 63) {
|
1996-06-14 11:02:28 +00:00
|
|
|
#endif
|
1998-02-18 09:28:47 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
#ifndef __FreeBSD__
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
1998-02-18 09:28:47 +00:00
|
|
|
#endif
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
if (pmp->pm_Sectors == 0) {
|
|
|
|
pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs);
|
|
|
|
pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors);
|
|
|
|
} else {
|
|
|
|
pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs);
|
|
|
|
pmp->pm_HugeSectors = pmp->pm_Sectors;
|
|
|
|
}
|
1998-02-18 09:28:47 +00:00
|
|
|
if (pmp->pm_HugeSectors > 0xffffffff / pmp->pm_BytesPerSec + 1) {
|
|
|
|
/*
|
|
|
|
* We cannot deal currently with this size of disk
|
|
|
|
* due to fileid limitations (see msdosfs_getattr and
|
|
|
|
* msdosfs_readdir)
|
|
|
|
*/
|
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pmp->pm_RootDirEnts == 0) {
|
|
|
|
if (bsp->bs710.bsBootSectSig2 != BOOTSIG2
|
|
|
|
|| bsp->bs710.bsBootSectSig3 != BOOTSIG3
|
|
|
|
|| pmp->pm_Sectors
|
|
|
|
|| pmp->pm_FATsecs
|
|
|
|
|| getushort(b710->bpbFSVers)) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
pmp->pm_fatmask = FAT32_MASK;
|
|
|
|
pmp->pm_fatmult = 4;
|
|
|
|
pmp->pm_fatdiv = 1;
|
|
|
|
pmp->pm_FATsecs = getulong(b710->bpbBigFATsecs);
|
|
|
|
if (getushort(b710->bpbExtFlags) & FATMIRROR)
|
|
|
|
pmp->pm_curfat = getushort(b710->bpbExtFlags) & FATNUM;
|
|
|
|
else
|
|
|
|
pmp->pm_flags |= MSDOSFS_FATMIRROR;
|
|
|
|
} else
|
|
|
|
pmp->pm_flags |= MSDOSFS_FATMIRROR;
|
|
|
|
|
|
|
|
#ifndef __FreeBSD__
|
|
|
|
if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
|
|
|
|
if (FAT32(pmp)) {
|
|
|
|
/*
|
|
|
|
* GEMDOS doesn't know fat32.
|
|
|
|
*/
|
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check a few values (could do some more):
|
|
|
|
* - logical sector size: power of 2, >= block size
|
|
|
|
* - sectors per cluster: power of 2, >= 1
|
|
|
|
* - number of sectors: >= 1, <= size of partition
|
|
|
|
*/
|
|
|
|
if ( (SecPerClust == 0)
|
|
|
|
|| (SecPerClust & (SecPerClust - 1))
|
|
|
|
|| (pmp->pm_BytesPerSec < bsize)
|
|
|
|
|| (pmp->pm_BytesPerSec & (pmp->pm_BytesPerSec - 1))
|
|
|
|
|| (pmp->pm_HugeSectors == 0)
|
|
|
|
|| (pmp->pm_HugeSectors * (pmp->pm_BytesPerSec / bsize)
|
|
|
|
> dpart.part->p_size)
|
|
|
|
) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* XXX - Many parts of the msdos fs driver seem to assume that
|
|
|
|
* the number of bytes per logical sector (BytesPerSec) will
|
|
|
|
* always be the same as the number of bytes per disk block
|
|
|
|
* Let's pretend it is.
|
|
|
|
*/
|
|
|
|
tmp = pmp->pm_BytesPerSec / bsize;
|
|
|
|
pmp->pm_BytesPerSec = bsize;
|
|
|
|
pmp->pm_HugeSectors *= tmp;
|
|
|
|
pmp->pm_HiddenSects *= tmp;
|
|
|
|
pmp->pm_ResSectors *= tmp;
|
|
|
|
pmp->pm_Sectors *= tmp;
|
|
|
|
pmp->pm_FATsecs *= tmp;
|
|
|
|
SecPerClust *= tmp;
|
|
|
|
}
|
|
|
|
#endif
|
1994-09-19 15:41:57 +00:00
|
|
|
pmp->pm_fatblk = pmp->pm_ResSectors;
|
1998-02-18 09:28:47 +00:00
|
|
|
if (FAT32(pmp)) {
|
|
|
|
pmp->pm_rootdirblk = getulong(b710->bpbRootClust);
|
|
|
|
pmp->pm_firstcluster = pmp->pm_fatblk
|
|
|
|
+ (pmp->pm_FATs * pmp->pm_FATsecs);
|
|
|
|
pmp->pm_fsinfo = getushort(b710->bpbFSInfo);
|
|
|
|
} else {
|
|
|
|
pmp->pm_rootdirblk = pmp->pm_fatblk +
|
|
|
|
(pmp->pm_FATs * pmp->pm_FATsecs);
|
|
|
|
pmp->pm_rootdirsize = (pmp->pm_RootDirEnts * sizeof(struct direntry)
|
|
|
|
+ pmp->pm_BytesPerSec - 1)
|
|
|
|
/ pmp->pm_BytesPerSec;/* in sectors */
|
|
|
|
pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize;
|
|
|
|
}
|
|
|
|
|
1994-09-19 15:41:57 +00:00
|
|
|
pmp->pm_nmbrofclusters = (pmp->pm_HugeSectors - pmp->pm_firstcluster) /
|
1998-02-18 09:28:47 +00:00
|
|
|
SecPerClust;
|
1994-09-19 15:41:57 +00:00
|
|
|
pmp->pm_maxcluster = pmp->pm_nmbrofclusters + 1;
|
|
|
|
pmp->pm_fatsize = pmp->pm_FATsecs * pmp->pm_BytesPerSec;
|
1998-02-18 09:28:47 +00:00
|
|
|
|
|
|
|
#ifndef __FreeBSD__
|
|
|
|
if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
|
|
|
|
if ((pmp->pm_nmbrofclusters <= (0xff0 - 2))
|
|
|
|
&& ((dtype == DTYPE_FLOPPY) || ((dtype == DTYPE_VNODE)
|
|
|
|
&& ((pmp->pm_Heads == 1) || (pmp->pm_Heads == 2))))
|
|
|
|
) {
|
|
|
|
pmp->pm_fatmask = FAT12_MASK;
|
|
|
|
pmp->pm_fatmult = 3;
|
|
|
|
pmp->pm_fatdiv = 2;
|
|
|
|
} else {
|
|
|
|
pmp->pm_fatmask = FAT16_MASK;
|
|
|
|
pmp->pm_fatmult = 2;
|
|
|
|
pmp->pm_fatdiv = 1;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
if (pmp->pm_fatmask == 0) {
|
|
|
|
if (pmp->pm_maxcluster
|
|
|
|
<= ((CLUST_RSRVD - CLUST_FIRST) & FAT12_MASK)) {
|
|
|
|
/*
|
|
|
|
* This will usually be a floppy disk. This size makes
|
|
|
|
* sure that one fat entry will not be split across
|
|
|
|
* multiple blocks.
|
|
|
|
*/
|
|
|
|
pmp->pm_fatmask = FAT12_MASK;
|
|
|
|
pmp->pm_fatmult = 3;
|
|
|
|
pmp->pm_fatdiv = 2;
|
|
|
|
} else {
|
|
|
|
pmp->pm_fatmask = FAT16_MASK;
|
|
|
|
pmp->pm_fatmult = 2;
|
|
|
|
pmp->pm_fatdiv = 1;
|
|
|
|
}
|
|
|
|
}
|
1994-09-19 15:41:57 +00:00
|
|
|
if (FAT12(pmp))
|
|
|
|
pmp->pm_fatblocksize = 3 * pmp->pm_BytesPerSec;
|
|
|
|
else
|
|
|
|
pmp->pm_fatblocksize = MAXBSIZE;
|
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
pmp->pm_fatblocksec = pmp->pm_fatblocksize / pmp->pm_BytesPerSec;
|
|
|
|
pmp->pm_bnshift = ffs(pmp->pm_BytesPerSec) - 1;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute mask and shift value for isolating cluster relative byte
|
|
|
|
* offsets and cluster numbers from a file offset.
|
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
pmp->pm_bpcluster = SecPerClust * pmp->pm_BytesPerSec;
|
|
|
|
pmp->pm_crbomask = pmp->pm_bpcluster - 1;
|
|
|
|
pmp->pm_cnshift = ffs(pmp->pm_bpcluster) - 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for valid cluster size
|
|
|
|
* must be a power of 2
|
|
|
|
*/
|
|
|
|
if (pmp->pm_bpcluster ^ (1 << pmp->pm_cnshift)) {
|
1994-09-19 15:41:57 +00:00
|
|
|
error = EINVAL;
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
/*
|
|
|
|
* Release the bootsector buffer.
|
|
|
|
*/
|
|
|
|
brelse(bp);
|
|
|
|
bp = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check FSInfo.
|
|
|
|
*/
|
|
|
|
if (pmp->pm_fsinfo) {
|
|
|
|
struct fsinfo *fp;
|
|
|
|
|
|
|
|
if ((error = bread(devvp, pmp->pm_fsinfo, 1024, NOCRED, &bp)) != 0)
|
|
|
|
goto error_exit;
|
|
|
|
fp = (struct fsinfo *)bp->b_data;
|
|
|
|
if (!bcmp(fp->fsisig1, "RRaA", 4)
|
|
|
|
&& !bcmp(fp->fsisig2, "rrAa", 4)
|
|
|
|
&& !bcmp(fp->fsisig3, "\0\0\125\252", 4)
|
|
|
|
&& !bcmp(fp->fsisig4, "\0\0\125\252", 4))
|
|
|
|
pmp->pm_nxtfree = getulong(fp->fsinxtfree);
|
|
|
|
else
|
|
|
|
pmp->pm_fsinfo = 0;
|
|
|
|
brelse(bp);
|
|
|
|
bp = NULL;
|
1996-06-14 11:02:28 +00:00
|
|
|
}
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
/*
|
1998-02-18 09:28:47 +00:00
|
|
|
* Check and validate (or perhaps invalidate?) the fsinfo structure? XXX
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate memory for the bitmap of allocated clusters, and then
|
|
|
|
* fill it in.
|
|
|
|
*/
|
|
|
|
pmp->pm_inusemap = malloc(((pmp->pm_maxcluster + N_INUSEBITS - 1)
|
|
|
|
/ N_INUSEBITS)
|
|
|
|
* sizeof(*pmp->pm_inusemap),
|
|
|
|
M_MSDOSFSFAT, M_WAITOK);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fillinusemap() needs pm_devvp.
|
|
|
|
*/
|
|
|
|
pmp->pm_dev = dev;
|
|
|
|
pmp->pm_devvp = devvp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Have the inuse map filled in.
|
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
if ((error = fillinusemap(pmp)) != 0)
|
1994-09-19 15:41:57 +00:00
|
|
|
goto error_exit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If they want fat updates to be synchronous then let them suffer
|
|
|
|
* the performance degradation in exchange for the on disk copy of
|
|
|
|
* the fat being correct just about all the time. I suppose this
|
|
|
|
* would be a good thing to turn on if the kernel is still flakey.
|
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
if (mp->mnt_flag & MNT_SYNCHRONOUS)
|
|
|
|
pmp->pm_flags |= MSDOSFSMNT_WAITONFAT;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Finish up.
|
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
if (ronly)
|
|
|
|
pmp->pm_flags |= MSDOSFSMNT_RONLY;
|
|
|
|
else
|
1994-09-19 15:41:57 +00:00
|
|
|
pmp->pm_fmod = 1;
|
|
|
|
mp->mnt_data = (qaddr_t) pmp;
|
1997-02-26 14:23:16 +00:00
|
|
|
mp->mnt_stat.f_fsid.val[0] = (long)dev;
|
|
|
|
mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
|
1997-03-18 19:50:12 +00:00
|
|
|
mp->mnt_flag |= MNT_LOCAL;
|
1998-03-08 09:59:44 +00:00
|
|
|
devvp->v_specmountpoint = mp;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
error_exit:
|
|
|
|
if (bp)
|
|
|
|
brelse(bp);
|
|
|
|
(void) VOP_CLOSE(devvp, ronly ? FREAD : FREAD | FWRITE, NOCRED, p);
|
1994-09-19 15:41:57 +00:00
|
|
|
if (pmp) {
|
|
|
|
if (pmp->pm_inusemap)
|
1998-02-18 09:28:47 +00:00
|
|
|
free(pmp->pm_inusemap, M_MSDOSFSFAT);
|
|
|
|
free(pmp, M_MSDOSFSMNT);
|
|
|
|
mp->mnt_data = (qaddr_t)0;
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_start(mp, flags, p)
|
|
|
|
struct mount *mp;
|
|
|
|
int flags;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
|
|
|
|
return (0);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unmount the filesystem described by mp.
|
|
|
|
*/
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_unmount(mp, mntflags, p)
|
|
|
|
struct mount *mp;
|
|
|
|
int mntflags;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
struct msdosfsmount *pmp;
|
|
|
|
int error, flags;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
flags = 0;
|
|
|
|
if (mntflags & MNT_FORCE)
|
1994-09-19 15:41:57 +00:00
|
|
|
flags |= FORCECLOSE;
|
1994-09-27 20:42:59 +00:00
|
|
|
error = vflush(mp, NULLVP, flags);
|
|
|
|
if (error)
|
1994-09-19 15:41:57 +00:00
|
|
|
return error;
|
1998-02-18 09:28:47 +00:00
|
|
|
pmp = VFSTOMSDOSFS(mp);
|
1998-03-08 09:59:44 +00:00
|
|
|
pmp->pm_devvp->v_specmountpoint = NULL;
|
1998-02-18 09:28:47 +00:00
|
|
|
#ifdef MSDOSFS_DEBUG
|
|
|
|
{
|
|
|
|
struct vnode *vp = pmp->pm_devvp;
|
|
|
|
|
|
|
|
printf("msdosfs_umount(): just before calling VOP_CLOSE()\n");
|
|
|
|
printf("flag %08lx, usecount %d, writecount %d, holdcnt %ld\n",
|
|
|
|
vp->v_flag, vp->v_usecount, vp->v_writecount, vp->v_holdcnt);
|
|
|
|
printf("lastr %d, id %lu, mount %p, op %p\n",
|
|
|
|
vp->v_lastr, vp->v_id, vp->v_mount, vp->v_op);
|
|
|
|
printf("freef %p, freeb %p, mount %p\n",
|
|
|
|
vp->v_freelist.tqe_next, vp->v_freelist.tqe_prev,
|
|
|
|
vp->v_mount);
|
|
|
|
printf("cleanblkhd %p, dirtyblkhd %p, numoutput %ld, type %d\n",
|
|
|
|
vp->v_cleanblkhd.lh_first,
|
|
|
|
vp->v_dirtyblkhd.lh_first,
|
|
|
|
vp->v_numoutput, vp->v_type);
|
|
|
|
printf("union %p, tag %d, data[0] %08x, data[1] %08x\n",
|
|
|
|
vp->v_socket, vp->v_tag,
|
|
|
|
((u_int *)vp->v_data)[0],
|
|
|
|
((u_int *)vp->v_data)[1]);
|
|
|
|
}
|
|
|
|
#endif
|
1998-03-08 09:59:44 +00:00
|
|
|
error = VOP_CLOSE(pmp->pm_devvp,
|
|
|
|
(pmp->pm_flags&MSDOSFSMNT_RONLY) ? FREAD : FREAD | FWRITE,
|
|
|
|
NOCRED, p);
|
1994-09-19 15:41:57 +00:00
|
|
|
vrele(pmp->pm_devvp);
|
1998-02-18 09:28:47 +00:00
|
|
|
free(pmp->pm_inusemap, M_MSDOSFSFAT);
|
|
|
|
free(pmp, M_MSDOSFSMNT);
|
|
|
|
mp->mnt_data = (qaddr_t)0;
|
1997-03-18 19:50:12 +00:00
|
|
|
mp->mnt_flag &= ~MNT_LOCAL;
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_root(mp, vpp)
|
|
|
|
struct mount *mp;
|
|
|
|
struct vnode **vpp;
|
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
|
1994-09-19 15:41:57 +00:00
|
|
|
struct denode *ndep;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
#ifdef MSDOSFS_DEBUG
|
1998-02-18 09:28:47 +00:00
|
|
|
printf("msdosfs_root(); mp %p, pmp %p\n", mp, pmp);
|
1994-09-19 15:41:57 +00:00
|
|
|
#endif
|
1998-02-18 09:28:47 +00:00
|
|
|
error = deget(pmp, MSDOSFSROOT, MSDOSFSROOT_OFS, &ndep);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
*vpp = DETOV(ndep);
|
|
|
|
return (0);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_quotactl(mp, cmds, uid, arg, p)
|
|
|
|
struct mount *mp;
|
|
|
|
int cmds;
|
|
|
|
uid_t uid;
|
|
|
|
caddr_t arg;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
return EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_statfs(mp, sbp, p)
|
|
|
|
struct mount *mp;
|
|
|
|
struct statfs *sbp;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
struct msdosfsmount *pmp;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
pmp = VFSTOMSDOSFS(mp);
|
1994-09-19 15:41:57 +00:00
|
|
|
sbp->f_bsize = pmp->pm_bpcluster;
|
|
|
|
sbp->f_iosize = pmp->pm_bpcluster;
|
|
|
|
sbp->f_blocks = pmp->pm_nmbrofclusters;
|
|
|
|
sbp->f_bfree = pmp->pm_freeclustercount;
|
|
|
|
sbp->f_bavail = pmp->pm_freeclustercount;
|
|
|
|
sbp->f_files = pmp->pm_RootDirEnts; /* XXX */
|
|
|
|
sbp->f_ffree = 0; /* what to put in here? */
|
|
|
|
if (sbp != &mp->mnt_stat) {
|
1997-02-26 14:23:16 +00:00
|
|
|
sbp->f_type = mp->mnt_vfc->vfc_typenum;
|
1998-02-18 09:28:47 +00:00
|
|
|
bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
|
|
|
|
bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
1998-02-18 09:28:47 +00:00
|
|
|
strncpy(sbp->f_fstypename, mp->mnt_vfc->vfc_name, MFSNAMELEN);
|
|
|
|
return (0);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_sync(mp, waitfor, cred, p)
|
|
|
|
struct mount *mp;
|
|
|
|
int waitfor;
|
|
|
|
struct ucred *cred;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
struct vnode *vp, *nvp;
|
1994-09-19 15:41:57 +00:00
|
|
|
struct denode *dep;
|
1998-02-18 09:28:47 +00:00
|
|
|
struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
|
|
|
|
int error, allerror = 0;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we ever switch to not updating all of the fats all the time,
|
|
|
|
* this would be the place to update them from the first one.
|
|
|
|
*/
|
1998-02-18 09:28:47 +00:00
|
|
|
if (pmp->pm_fmod != 0)
|
|
|
|
if (pmp->pm_flags & MSDOSFSMNT_RONLY)
|
1994-09-19 15:41:57 +00:00
|
|
|
panic("msdosfs_sync: rofs mod");
|
|
|
|
else {
|
|
|
|
/* update fats here */
|
|
|
|
}
|
|
|
|
/*
|
1998-02-18 09:28:47 +00:00
|
|
|
* Write back each (modified) denode.
|
1994-09-19 15:41:57 +00:00
|
|
|
*/
|
1997-02-26 14:23:16 +00:00
|
|
|
simple_lock(&mntvnode_slock);
|
1994-09-19 15:41:57 +00:00
|
|
|
loop:
|
1998-02-18 09:28:47 +00:00
|
|
|
for (vp = mp->mnt_vnodelist.lh_first;
|
|
|
|
vp != NULL;
|
|
|
|
vp = nvp) {
|
|
|
|
/*
|
|
|
|
* If the vnode that we are about to sync is no longer
|
|
|
|
* assoicated with this mount point, start over.
|
|
|
|
*/
|
|
|
|
if (vp->v_mount != mp)
|
1994-09-19 15:41:57 +00:00
|
|
|
goto loop;
|
1998-02-18 09:28:47 +00:00
|
|
|
|
1997-02-26 14:23:16 +00:00
|
|
|
simple_lock(&vp->v_interlock);
|
1998-02-18 09:28:47 +00:00
|
|
|
nvp = vp->v_mntvnodes.le_next;
|
1994-09-19 15:41:57 +00:00
|
|
|
dep = VTODE(vp);
|
1998-03-08 09:59:44 +00:00
|
|
|
if (vp->v_type == VNON
|
|
|
|
|| (waitfor == MNT_LAZY) /* can this happen with msdosfs? */
|
|
|
|
|| (((dep->de_flag &
|
|
|
|
(DE_ACCESS | DE_CREATE | DE_UPDATE | DE_MODIFIED)) == 0)
|
|
|
|
&& (vp->v_dirtyblkhd.lh_first == NULL))) {
|
1997-02-26 14:23:16 +00:00
|
|
|
simple_unlock(&vp->v_interlock);
|
1994-09-19 15:41:57 +00:00
|
|
|
continue;
|
1997-02-26 14:23:16 +00:00
|
|
|
}
|
|
|
|
simple_unlock(&mntvnode_slock);
|
|
|
|
error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p);
|
|
|
|
if (error) {
|
|
|
|
simple_lock(&mntvnode_slock);
|
|
|
|
if (error == ENOENT)
|
|
|
|
goto loop;
|
|
|
|
continue;
|
|
|
|
}
|
1994-09-27 20:42:59 +00:00
|
|
|
error = VOP_FSYNC(vp, cred, waitfor, p);
|
|
|
|
if (error)
|
1994-09-19 15:41:57 +00:00
|
|
|
allerror = error;
|
1997-02-26 14:23:16 +00:00
|
|
|
VOP_UNLOCK(vp, 0, p);
|
|
|
|
vrele(vp); /* done with this one */
|
|
|
|
simple_lock(&mntvnode_slock);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
1997-02-26 14:23:16 +00:00
|
|
|
simple_unlock(&mntvnode_slock);
|
1994-09-19 15:41:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush filesystem control info.
|
|
|
|
*/
|
1994-09-27 20:42:59 +00:00
|
|
|
error = VOP_FSYNC(pmp->pm_devvp, cred, waitfor, p);
|
|
|
|
if (error)
|
1994-09-19 15:41:57 +00:00
|
|
|
allerror = error;
|
1998-02-18 09:28:47 +00:00
|
|
|
return (allerror);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp)
|
|
|
|
struct mount *mp;
|
|
|
|
struct fid *fhp;
|
1997-08-16 19:16:27 +00:00
|
|
|
struct sockaddr *nam;
|
1994-09-19 15:41:57 +00:00
|
|
|
struct vnode **vpp;
|
|
|
|
int *exflagsp;
|
|
|
|
struct ucred **credanonp;
|
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
|
1994-09-19 15:41:57 +00:00
|
|
|
struct defid *defhp = (struct defid *) fhp;
|
|
|
|
struct denode *dep;
|
|
|
|
struct netcred *np;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
np = vfs_export_lookup(mp, &pmp->pm_export, nam);
|
|
|
|
if (np == NULL)
|
1998-02-18 09:28:47 +00:00
|
|
|
return (EACCES);
|
|
|
|
error = deget(pmp, defhp->defid_dirclust, defhp->defid_dirofs, &dep);
|
1994-09-19 15:41:57 +00:00
|
|
|
if (error) {
|
|
|
|
*vpp = NULLVP;
|
1998-02-18 09:28:47 +00:00
|
|
|
return (error);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
*vpp = DETOV(dep);
|
|
|
|
*exflagsp = np->netc_exflags;
|
|
|
|
*credanonp = &np->netc_anon;
|
1998-02-18 09:28:47 +00:00
|
|
|
return (0);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_vptofh(vp, fhp)
|
|
|
|
struct vnode *vp;
|
|
|
|
struct fid *fhp;
|
|
|
|
{
|
1998-02-18 09:28:47 +00:00
|
|
|
struct denode *dep;
|
|
|
|
struct defid *defhp;
|
1994-09-19 15:41:57 +00:00
|
|
|
|
1998-02-18 09:28:47 +00:00
|
|
|
dep = VTODE(vp);
|
|
|
|
defhp = (struct defid *)fhp;
|
1994-09-19 15:41:57 +00:00
|
|
|
defhp->defid_len = sizeof(struct defid);
|
|
|
|
defhp->defid_dirclust = dep->de_dirclust;
|
|
|
|
defhp->defid_dirofs = dep->de_diroffset;
|
1998-02-18 09:28:47 +00:00
|
|
|
/* defhp->defid_gen = dep->de_gen; */
|
|
|
|
return (0);
|
1994-09-19 15:41:57 +00:00
|
|
|
}
|
|
|
|
|
1995-11-07 14:06:45 +00:00
|
|
|
static int
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_vget(mp, ino, vpp)
|
|
|
|
struct mount *mp;
|
|
|
|
ino_t ino;
|
|
|
|
struct vnode **vpp;
|
|
|
|
{
|
|
|
|
return EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
1995-11-07 14:10:19 +00:00
|
|
|
static struct vfsops msdosfs_vfsops = {
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_mount,
|
|
|
|
msdosfs_start,
|
|
|
|
msdosfs_unmount,
|
|
|
|
msdosfs_root,
|
|
|
|
msdosfs_quotactl,
|
|
|
|
msdosfs_statfs,
|
|
|
|
msdosfs_sync,
|
|
|
|
msdosfs_vget,
|
The intent is to get rid of WILLRELE in vnode_if.src by making
a complement to all ops that return a vpp, VFS_VRELE. This is
initially only for file systems that implement the following ops
that do a WILLRELE:
vop_create, vop_whiteout, vop_mknod, vop_remove, vop_link,
vop_rename, vop_mkdir, vop_rmdir, vop_symlink
This is initial DNA that doesn't do anything yet. VFS_VRELE is
implemented but not called.
A default vfs_vrele was created for fs implementations that use the
standard vnode management routines.
VFS_VRELE implementations were made for the following file systems:
Standard (vfs_vrele)
ffs mfs nfs msdosfs devfs ext2fs
Custom
union umapfs
Just EOPNOTSUPP
fdesc procfs kernfs portal cd9660
These implementations may change as VOP changes are implemented.
In the next phase, in the vop implementations calls to vrele and the vrele
part of vput will be moved to the top layer vfs_vnops and made visible
to all layers. vput will be replaced by unlock in these cases. Unlocking
will still be done in the per fs layer but the refcount decrement will be
triggered at the top because it doesn't hurt to hold a vnode reference a
little longer. This will have minimal impact on the structure of the
existing code.
This will only be done for vnode arguments that are released by the various
fs vop implementations.
Wider use of VFS_VRELE will likely require restructuring of the code.
Reviewed by: phk, dyson, terry et. al.
Submitted by: Michael Hancock <michaelh@cet.co.jp>
1998-03-01 22:46:53 +00:00
|
|
|
vfs_vrele,
|
1994-09-19 15:41:57 +00:00
|
|
|
msdosfs_fhtovp,
|
|
|
|
msdosfs_vptofh,
|
|
|
|
msdosfs_init
|
|
|
|
};
|
1994-09-21 03:47:43 +00:00
|
|
|
|
|
|
|
VFS_SET(msdosfs_vfsops, msdos, MOUNT_MSDOS, 0);
|