The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/fs/msdosfs/msdosfs_vfsops.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /* $FreeBSD$ */
    2 /*      $NetBSD: msdosfs_vfsops.c,v 1.51 1997/11/17 15:36:58 ws Exp $   */
    3 
    4 /*-
    5  * SPDX-License-Identifier: BSD-4-Clause
    6  *
    7  * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
    8  * Copyright (C) 1994, 1995, 1997 TooLs GmbH.
    9  * All rights reserved.
   10  * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. All advertising materials mentioning features or use of this software
   21  *    must display the following acknowledgement:
   22  *      This product includes software developed by TooLs GmbH.
   23  * 4. The name of TooLs GmbH may not be used to endorse or promote products
   24  *    derived from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
   27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   29  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   36  */
   37 /*-
   38  * Written by Paul Popelka (paulp@uts.amdahl.com)
   39  *
   40  * You can do anything you want with this software, just don't say you wrote
   41  * it, and don't remove this notice.
   42  *
   43  * This software is provided "as is".
   44  *
   45  * The author supplies this software to be publicly redistributed on the
   46  * understanding that the author is not responsible for the correct
   47  * functioning of this software in any circumstances and is not liable for
   48  * any damages caused by this software.
   49  *
   50  * October 1992
   51  */
   52 
   53 #include <sys/param.h>
   54 #include <sys/systm.h>
   55 #include <sys/buf.h>
   56 #include <sys/bufobj.h>
   57 #include <sys/conf.h>
   58 #include <sys/fcntl.h>
   59 #include <sys/iconv.h>
   60 #include <sys/kernel.h>
   61 #include <sys/lock.h>
   62 #include <sys/malloc.h>
   63 #include <sys/mount.h>
   64 #include <sys/mutex.h>
   65 #include <sys/namei.h>
   66 #include <sys/priv.h>
   67 #include <sys/proc.h>
   68 #include <sys/rwlock.h>
   69 #include <sys/stat.h>
   70 #include <sys/taskqueue.h>
   71 #include <sys/vnode.h>
   72 
   73 #include <geom/geom.h>
   74 #include <geom/geom_vfs.h>
   75 
   76 #include <fs/msdosfs/bootsect.h>
   77 #include <fs/msdosfs/bpb.h>
   78 #include <fs/msdosfs/direntry.h>
   79 #include <fs/msdosfs/denode.h>
   80 #include <fs/msdosfs/fat.h>
   81 #include <fs/msdosfs/msdosfsmount.h>
   82 
   83 #ifdef MSDOSFS_DEBUG
   84 #include <sys/rwlock.h>
   85 #endif
   86 
   87 static const char msdosfs_lock_msg[] = "fatlk";
   88 
   89 /* Mount options that we support. */
   90 static const char *msdosfs_opts[] = {
   91         "async", "noatime", "noclusterr", "noclusterw",
   92         "export", "force", "from", "sync",
   93         "cs_dos", "cs_local", "cs_win", "dirmask",
   94         "gid", "kiconv", "longname",
   95         "longnames", "mask", "shortname", "shortnames",
   96         "uid", "win95", "nowin95",
   97         NULL
   98 };
   99 
  100 #if 1 /*def PC98*/
  101 /*
  102  * XXX - The boot signature formatted by NEC PC-98 DOS looks like a
  103  *       garbage or a random value :-{
  104  *       If you want to use that broken-signatured media, define the
  105  *       following symbol even though PC/AT.
  106  *       (ex. mount PC-98 DOS formatted FD on PC/AT)
  107  */
  108 #define MSDOSFS_NOCHECKSIG
  109 #endif
  110 
  111 MALLOC_DEFINE(M_MSDOSFSMNT, "msdosfs_mount", "MSDOSFS mount structure");
  112 static MALLOC_DEFINE(M_MSDOSFSFAT, "msdosfs_fat", "MSDOSFS file allocation table");
  113 
  114 struct iconv_functions *msdosfs_iconv;
  115 
  116 static int      update_mp(struct mount *mp, struct thread *td);
  117 static int      mountmsdosfs(struct vnode *devvp, struct mount *mp);
  118 static void     msdosfs_remount_ro(void *arg, int pending);
  119 static vfs_fhtovp_t     msdosfs_fhtovp;
  120 static vfs_mount_t      msdosfs_mount;
  121 static vfs_root_t       msdosfs_root;
  122 static vfs_statfs_t     msdosfs_statfs;
  123 static vfs_sync_t       msdosfs_sync;
  124 static vfs_unmount_t    msdosfs_unmount;
  125 
  126 /* Maximum length of a character set name (arbitrary). */
  127 #define MAXCSLEN        64
  128 
  129 static int
  130 update_mp(struct mount *mp, struct thread *td)
  131 {
  132         struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
  133         void *dos, *win, *local;
  134         int error, v;
  135 
  136         if (!vfs_getopt(mp->mnt_optnew, "kiconv", NULL, NULL)) {
  137                 if (msdosfs_iconv != NULL) {
  138                         error = vfs_getopt(mp->mnt_optnew,
  139                             "cs_win", &win, NULL);
  140                         if (!error)
  141                                 error = vfs_getopt(mp->mnt_optnew,
  142                                     "cs_local", &local, NULL);
  143                         if (!error)
  144                                 error = vfs_getopt(mp->mnt_optnew,
  145                                     "cs_dos", &dos, NULL);
  146                         if (!error) {
  147                                 msdosfs_iconv->open(win, local, &pmp->pm_u2w);
  148                                 msdosfs_iconv->open(local, win, &pmp->pm_w2u);
  149                                 msdosfs_iconv->open(dos, local, &pmp->pm_u2d);
  150                                 msdosfs_iconv->open(local, dos, &pmp->pm_d2u);
  151                         }
  152                         if (error != 0)
  153                                 return (error);
  154                 } else {
  155                         pmp->pm_w2u = NULL;
  156                         pmp->pm_u2w = NULL;
  157                         pmp->pm_d2u = NULL;
  158                         pmp->pm_u2d = NULL;
  159                 }
  160         }
  161 
  162         if (vfs_scanopt(mp->mnt_optnew, "gid", "%d", &v) == 1)
  163                 pmp->pm_gid = v;
  164         if (vfs_scanopt(mp->mnt_optnew, "uid", "%d", &v) == 1)
  165                 pmp->pm_uid = v;
  166         if (vfs_scanopt(mp->mnt_optnew, "mask", "%d", &v) == 1)
  167                 pmp->pm_mask = v & ALLPERMS;
  168         if (vfs_scanopt(mp->mnt_optnew, "dirmask", "%d", &v) == 1)
  169                 pmp->pm_dirmask = v & ALLPERMS;
  170         vfs_flagopt(mp->mnt_optnew, "shortname",
  171             &pmp->pm_flags, MSDOSFSMNT_SHORTNAME);
  172         vfs_flagopt(mp->mnt_optnew, "shortnames",
  173             &pmp->pm_flags, MSDOSFSMNT_SHORTNAME);
  174         vfs_flagopt(mp->mnt_optnew, "longname",
  175             &pmp->pm_flags, MSDOSFSMNT_LONGNAME);
  176         vfs_flagopt(mp->mnt_optnew, "longnames",
  177             &pmp->pm_flags, MSDOSFSMNT_LONGNAME);
  178         vfs_flagopt(mp->mnt_optnew, "kiconv",
  179             &pmp->pm_flags, MSDOSFSMNT_KICONV);
  180 
  181         if (vfs_getopt(mp->mnt_optnew, "nowin95", NULL, NULL) == 0)
  182                 pmp->pm_flags |= MSDOSFSMNT_NOWIN95;
  183         else
  184                 pmp->pm_flags &= ~MSDOSFSMNT_NOWIN95;
  185 
  186         if (pmp->pm_flags & MSDOSFSMNT_NOWIN95)
  187                 pmp->pm_flags |= MSDOSFSMNT_SHORTNAME;
  188         else
  189                 pmp->pm_flags |= MSDOSFSMNT_LONGNAME;
  190         return 0;
  191 }
  192 
  193 static int
  194 msdosfs_cmount(struct mntarg *ma, void *data, uint64_t flags)
  195 {
  196         struct msdosfs_args args;
  197         int error;
  198 
  199         if (data == NULL)
  200                 return (EINVAL);
  201         error = copyin(data, &args, sizeof args);
  202         if (error)
  203                 return (error);
  204 
  205         ma = mount_argsu(ma, "from", args.fspec, MAXPATHLEN);
  206         ma = mount_arg(ma, "export", &args.export, sizeof(args.export));
  207         ma = mount_argf(ma, "uid", "%d", args.uid);
  208         ma = mount_argf(ma, "gid", "%d", args.gid);
  209         ma = mount_argf(ma, "mask", "%d", args.mask);
  210         ma = mount_argf(ma, "dirmask", "%d", args.dirmask);
  211 
  212         ma = mount_argb(ma, args.flags & MSDOSFSMNT_SHORTNAME, "noshortname");
  213         ma = mount_argb(ma, args.flags & MSDOSFSMNT_LONGNAME, "nolongname");
  214         ma = mount_argb(ma, !(args.flags & MSDOSFSMNT_NOWIN95), "nowin95");
  215         ma = mount_argb(ma, args.flags & MSDOSFSMNT_KICONV, "nokiconv");
  216 
  217         ma = mount_argsu(ma, "cs_win", args.cs_win, MAXCSLEN);
  218         ma = mount_argsu(ma, "cs_dos", args.cs_dos, MAXCSLEN);
  219         ma = mount_argsu(ma, "cs_local", args.cs_local, MAXCSLEN);
  220 
  221         error = kernel_mount(ma, flags);
  222 
  223         return (error);
  224 }
  225 
  226 /*
  227  * mp - path - addr in user space of mount point (ie /usr or whatever)
  228  * data - addr in user space of mount params including the name of the block
  229  * special file to treat as a filesystem.
  230  */
  231 static int
  232 msdosfs_mount(struct mount *mp)
  233 {
  234         struct vnode *devvp, *odevvp;     /* vnode for blk device to mount */
  235         struct thread *td;
  236         /* msdosfs specific mount control block */
  237         struct msdosfsmount *pmp = NULL;
  238         struct nameidata ndp;
  239         int error, flags;
  240         accmode_t accmode;
  241         char *from;
  242 
  243         td = curthread;
  244         if (vfs_filteropt(mp->mnt_optnew, msdosfs_opts))
  245                 return (EINVAL);
  246 
  247         /*
  248          * If updating, check whether changing from read-only to
  249          * read/write; if there is no device name, that's all we do.
  250          */
  251         if (mp->mnt_flag & MNT_UPDATE) {
  252                 pmp = VFSTOMSDOSFS(mp);
  253                 if (!(pmp->pm_flags & MSDOSFSMNT_RONLY) &&
  254                     vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
  255                         if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
  256                                 return (error);
  257                         error = vfs_write_suspend_umnt(mp);
  258                         if (error != 0)
  259                                 return (error);
  260 
  261                         flags = WRITECLOSE;
  262                         if (mp->mnt_flag & MNT_FORCE)
  263                                 flags |= FORCECLOSE;
  264                         error = vflush(mp, 0, flags, td);
  265                         if (error != 0) {
  266                                 vfs_write_resume(mp, 0);
  267                                 return (error);
  268                         }
  269 
  270                         /*
  271                          * Now the volume is clean.  Mark it so while the
  272                          * device is still rw.
  273                          */
  274                         error = markvoldirty(pmp, 0);
  275                         if (error != 0) {
  276                                 vfs_write_resume(mp, 0);
  277                                 (void)markvoldirty(pmp, 1);
  278                                 return (error);
  279                         }
  280 
  281                         /* Downgrade the device from rw to ro. */
  282                         g_topology_lock();
  283                         error = g_access(pmp->pm_cp, 0, -1, 0);
  284                         g_topology_unlock();
  285                         if (error) {
  286                                 vfs_write_resume(mp, 0);
  287                                 (void)markvoldirty(pmp, 1);
  288                                 return (error);
  289                         }
  290 
  291                         /*
  292                          * Backing out after an error was painful in the
  293                          * above.  Now we are committed to succeeding.
  294                          */
  295                         pmp->pm_fmod = 0;
  296                         pmp->pm_flags |= MSDOSFSMNT_RONLY;
  297                         MNT_ILOCK(mp);
  298                         mp->mnt_flag |= MNT_RDONLY;
  299                         MNT_IUNLOCK(mp);
  300                         vfs_write_resume(mp, 0);
  301                 } else if ((pmp->pm_flags & MSDOSFSMNT_RONLY) &&
  302                     !vfs_flagopt(mp->mnt_optnew, "ro", NULL, 0)) {
  303                         /*
  304                          * If upgrade to read-write by non-root, then verify
  305                          * that user has necessary permissions on the device.
  306                          */
  307                         odevvp = pmp->pm_odevvp;
  308                         vn_lock(odevvp, LK_EXCLUSIVE | LK_RETRY);
  309                         error = VOP_ACCESS(odevvp, VREAD | VWRITE,
  310                             td->td_ucred, td);
  311                         if (error)
  312                                 error = priv_check(td, PRIV_VFS_MOUNT_PERM);
  313                         if (error) {
  314                                 VOP_UNLOCK(odevvp);
  315                                 return (error);
  316                         }
  317                         VOP_UNLOCK(odevvp);
  318                         g_topology_lock();
  319                         error = g_access(pmp->pm_cp, 0, 1, 0);
  320                         g_topology_unlock();
  321                         if (error)
  322                                 return (error);
  323 
  324                         /* Now that the volume is modifiable, mark it dirty. */
  325                         error = markvoldirty_upgrade(pmp, true, true);
  326                         if (error) {
  327                                 /*
  328                                  * If dirtying the superblock failed, drop GEOM
  329                                  * 'w' refs (we're still RO).
  330                                  */
  331                                 g_topology_lock();
  332                                 (void)g_access(pmp->pm_cp, 0, -1, 0);
  333                                 g_topology_unlock();
  334 
  335                                 return (error);
  336                         }
  337 
  338                         pmp->pm_fmod = 1;
  339                         pmp->pm_flags &= ~MSDOSFSMNT_RONLY;
  340                         MNT_ILOCK(mp);
  341                         mp->mnt_flag &= ~MNT_RDONLY;
  342                         MNT_IUNLOCK(mp);
  343                 }
  344 
  345                 /*
  346                  * Avoid namei() below.  The "from" option is not set.
  347                  * Update of the devvp is pointless for this case.
  348                  */
  349                 if ((pmp->pm_flags & MSDOSFS_ERR_RO) != 0)
  350                         return (0);
  351         }
  352         /*
  353          * Not an update, or updating the name: look up the name
  354          * and verify that it refers to a sensible disk device.
  355          */
  356         if (vfs_getopt(mp->mnt_optnew, "from", (void **)&from, NULL))
  357                 return (EINVAL);
  358         NDINIT(&ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, from, td);
  359         error = namei(&ndp);
  360         if (error)
  361                 return (error);
  362         devvp = ndp.ni_vp;
  363         NDFREE(&ndp, NDF_ONLY_PNBUF);
  364 
  365         if (!vn_isdisk_error(devvp, &error)) {
  366                 vput(devvp);
  367                 return (error);
  368         }
  369         /*
  370          * If mount by non-root, then verify that user has necessary
  371          * permissions on the device.
  372          */
  373         accmode = VREAD;
  374         if ((mp->mnt_flag & MNT_RDONLY) == 0)
  375                 accmode |= VWRITE;
  376         error = VOP_ACCESS(devvp, accmode, td->td_ucred, td);
  377         if (error)
  378                 error = priv_check(td, PRIV_VFS_MOUNT_PERM);
  379         if (error) {
  380                 vput(devvp);
  381                 return (error);
  382         }
  383         if ((mp->mnt_flag & MNT_UPDATE) == 0) {
  384                 error = mountmsdosfs(devvp, mp);
  385 #ifdef MSDOSFS_DEBUG            /* only needed for the printf below */
  386                 pmp = VFSTOMSDOSFS(mp);
  387 #endif
  388         } else {
  389                 vput(devvp);
  390                 if (devvp != pmp->pm_odevvp)
  391                         return (EINVAL);        /* XXX needs translation */
  392         }
  393         if (error) {
  394                 vrele(devvp);
  395                 return (error);
  396         }
  397 
  398         error = update_mp(mp, td);
  399         if (error) {
  400                 if ((mp->mnt_flag & MNT_UPDATE) == 0)
  401                         msdosfs_unmount(mp, MNT_FORCE);
  402                 return error;
  403         }
  404 
  405         vfs_mountedfrom(mp, from);
  406 #ifdef MSDOSFS_DEBUG
  407         printf("msdosfs_mount(): mp %p, pmp %p, inusemap %p\n", mp, pmp, pmp->pm_inusemap);
  408 #endif
  409         return (0);
  410 }
  411 
  412 static int
  413 mountmsdosfs(struct vnode *odevvp, struct mount *mp)
  414 {
  415         struct msdosfsmount *pmp;
  416         struct buf *bp;
  417         struct cdev *dev;
  418         struct vnode *devvp;
  419         union bootsector *bsp;
  420         struct byte_bpb33 *b33;
  421         struct byte_bpb50 *b50;
  422         struct byte_bpb710 *b710;
  423         uint8_t SecPerClust;
  424         u_long clusters;
  425         int ronly, error;
  426         struct g_consumer *cp;
  427         struct bufobj *bo;
  428 
  429         bp = NULL;              /* This and pmp both used in error_exit. */
  430         pmp = NULL;
  431         ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
  432 
  433         devvp = mntfs_allocvp(mp, odevvp);
  434         VOP_UNLOCK(odevvp);
  435         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
  436         dev = devvp->v_rdev;
  437         if (atomic_cmpset_acq_ptr((uintptr_t *)&dev->si_mountpt, 0,
  438             (uintptr_t)mp) == 0) {
  439                 mntfs_freevp(devvp);
  440                 return (EBUSY);
  441         }
  442         g_topology_lock();
  443         error = g_vfs_open(devvp, &cp, "msdosfs", ronly ? 0 : 1);
  444         g_topology_unlock();
  445         if (error != 0) {
  446                 atomic_store_rel_ptr((uintptr_t *)&dev->si_mountpt, 0);
  447                 mntfs_freevp(devvp);
  448                 return (error);
  449         }
  450         dev_ref(dev);
  451         bo = &devvp->v_bufobj;
  452         BO_LOCK(&odevvp->v_bufobj);
  453         odevvp->v_bufobj.bo_flag |= BO_NOBUFS;
  454         BO_UNLOCK(&odevvp->v_bufobj);
  455         VOP_UNLOCK(devvp);
  456         if (dev->si_iosize_max != 0)
  457                 mp->mnt_iosize_max = dev->si_iosize_max;
  458         if (mp->mnt_iosize_max > maxphys)
  459                 mp->mnt_iosize_max = maxphys;
  460 
  461         /*
  462          * Read the boot sector of the filesystem, and then check the
  463          * boot signature.  If not a dos boot sector then error out.
  464          *
  465          * NOTE: 8192 is a magic size that works for ffs.
  466          */
  467         error = bread(devvp, 0, 8192, NOCRED, &bp);
  468         if (error)
  469                 goto error_exit;
  470         bp->b_flags |= B_AGE;
  471         bsp = (union bootsector *)bp->b_data;
  472         b33 = (struct byte_bpb33 *)bsp->bs33.bsBPB;
  473         b50 = (struct byte_bpb50 *)bsp->bs50.bsBPB;
  474         b710 = (struct byte_bpb710 *)bsp->bs710.bsBPB;
  475 
  476 #ifndef MSDOSFS_NOCHECKSIG
  477         if (bsp->bs50.bsBootSectSig0 != BOOTSIG0 ||
  478             bsp->bs50.bsBootSectSig1 != BOOTSIG1) {
  479                 error = EINVAL;
  480                 goto error_exit;
  481         }
  482 #endif
  483 
  484         pmp = malloc(sizeof(*pmp), M_MSDOSFSMNT, M_WAITOK | M_ZERO);
  485         pmp->pm_mountp = mp;
  486         pmp->pm_cp = cp;
  487         pmp->pm_bo = bo;
  488 
  489         lockinit(&pmp->pm_fatlock, 0, msdosfs_lock_msg, 0, 0);
  490         lockinit(&pmp->pm_checkpath_lock, 0, "msdoscp", 0, 0);
  491 
  492         TASK_INIT(&pmp->pm_rw2ro_task, 0, msdosfs_remount_ro, pmp);
  493 
  494         /*
  495          * Initialize ownerships and permissions, since nothing else will
  496          * initialize them iff we are mounting root.
  497          */
  498         pmp->pm_uid = UID_ROOT;
  499         pmp->pm_gid = GID_WHEEL;
  500         pmp->pm_mask = pmp->pm_dirmask = S_IXUSR | S_IXGRP | S_IXOTH |
  501             S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR;
  502 
  503         /*
  504          * Compute several useful quantities from the bpb in the
  505          * bootsector.  Copy in the dos 5 variant of the bpb then fix up
  506          * the fields that are different between dos 5 and dos 3.3.
  507          */
  508         SecPerClust = b50->bpbSecPerClust;
  509         pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec);
  510         if (pmp->pm_BytesPerSec < DEV_BSIZE) {
  511                 error = EINVAL;
  512                 goto error_exit;
  513         }
  514         pmp->pm_ResSectors = getushort(b50->bpbResSectors);
  515         pmp->pm_FATs = b50->bpbFATs;
  516         pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts);
  517         pmp->pm_Sectors = getushort(b50->bpbSectors);
  518         pmp->pm_FATsecs = getushort(b50->bpbFATsecs);
  519         pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack);
  520         pmp->pm_Heads = getushort(b50->bpbHeads);
  521         pmp->pm_Media = b50->bpbMedia;
  522 
  523         /* calculate the ratio of sector size to DEV_BSIZE */
  524         pmp->pm_BlkPerSec = pmp->pm_BytesPerSec / DEV_BSIZE;
  525 
  526         /*
  527          * We don't check pm_Heads nor pm_SecPerTrack, because
  528          * these may not be set for EFI file systems. We don't
  529          * use these anyway, so we're unaffected if they are
  530          * invalid.
  531          */
  532         if (pmp->pm_BytesPerSec == 0 || SecPerClust == 0) {
  533                 error = EINVAL;
  534                 goto error_exit;
  535         }
  536 
  537         if (pmp->pm_Sectors == 0) {
  538                 pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs);
  539                 pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors);
  540         } else {
  541                 pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs);
  542                 pmp->pm_HugeSectors = pmp->pm_Sectors;
  543         }
  544 
  545         if (pmp->pm_RootDirEnts == 0) {
  546                 if (pmp->pm_FATsecs != 0 || getushort(b710->bpbFSVers) != 0) {
  547                         error = EINVAL;
  548 #ifdef MSDOSFS_DEBUG
  549                         printf("mountmsdosfs(): bad FAT32 filesystem\n");
  550 #endif
  551                         goto error_exit;
  552                 }
  553                 pmp->pm_fatmask = FAT32_MASK;
  554                 pmp->pm_fatmult = 4;
  555                 pmp->pm_fatdiv = 1;
  556                 pmp->pm_FATsecs = getulong(b710->bpbBigFATsecs);
  557                 if ((getushort(b710->bpbExtFlags) & FATMIRROR) != 0)
  558                         pmp->pm_curfat = getushort(b710->bpbExtFlags) & FATNUM;
  559                 else
  560                         pmp->pm_flags |= MSDOSFS_FATMIRROR;
  561         } else
  562                 pmp->pm_flags |= MSDOSFS_FATMIRROR;
  563 
  564         /*
  565          * Check a few values (could do some more):
  566          * - logical sector size: power of 2, >= block size
  567          * - sectors per cluster: power of 2, >= 1
  568          * - number of sectors:   >= 1, <= size of partition
  569          * - number of FAT sectors: >= 1
  570          */
  571         if (SecPerClust == 0 || (SecPerClust & (SecPerClust - 1)) != 0 ||
  572             pmp->pm_BytesPerSec < DEV_BSIZE ||
  573             (pmp->pm_BytesPerSec & (pmp->pm_BytesPerSec - 1)) != 0 ||
  574             pmp->pm_HugeSectors == 0 || pmp->pm_FATsecs == 0 ||
  575             SecPerClust * pmp->pm_BlkPerSec > MAXBSIZE / DEV_BSIZE) {
  576                 error = EINVAL;
  577                 goto error_exit;
  578         }
  579 
  580         if ((off_t)pmp->pm_HugeSectors * pmp->pm_BytesPerSec <
  581             pmp->pm_HugeSectors /* overflow */ ||
  582             (off_t)pmp->pm_HugeSectors * pmp->pm_BytesPerSec >
  583             cp->provider->mediasize /* past end of vol */) {
  584                 error = EINVAL;
  585                 goto error_exit;
  586         }
  587 
  588         pmp->pm_HugeSectors *= pmp->pm_BlkPerSec;
  589         pmp->pm_HiddenSects *= pmp->pm_BlkPerSec;       /* XXX not used? */
  590         pmp->pm_FATsecs     *= pmp->pm_BlkPerSec;
  591         SecPerClust         *= pmp->pm_BlkPerSec;
  592 
  593         pmp->pm_fatblk = pmp->pm_ResSectors * pmp->pm_BlkPerSec;
  594 
  595         if (FAT32(pmp)) {
  596                 pmp->pm_rootdirblk = getulong(b710->bpbRootClust);
  597                 pmp->pm_firstcluster = pmp->pm_fatblk +
  598                     pmp->pm_FATs * pmp->pm_FATsecs;
  599                 pmp->pm_fsinfo = getushort(b710->bpbFSInfo) * pmp->pm_BlkPerSec;
  600         } else {
  601                 pmp->pm_rootdirblk = pmp->pm_fatblk +
  602                     pmp->pm_FATs * pmp->pm_FATsecs;
  603                 pmp->pm_rootdirsize = howmany(pmp->pm_RootDirEnts *
  604                     sizeof(struct direntry), DEV_BSIZE); /* in blocks */
  605                 pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize;
  606         }
  607 
  608         if (pmp->pm_HugeSectors <= pmp->pm_firstcluster) {
  609                 error = EINVAL;
  610                 goto error_exit;
  611         }
  612         pmp->pm_maxcluster = (pmp->pm_HugeSectors - pmp->pm_firstcluster) /
  613             SecPerClust + 1;
  614         pmp->pm_fatsize = pmp->pm_FATsecs * DEV_BSIZE;  /* XXX not used? */
  615 
  616         if (pmp->pm_fatmask == 0) {
  617                 if (pmp->pm_maxcluster <= ((CLUST_RSRVD - CLUST_FIRST) &
  618                     FAT12_MASK)) {
  619                         /*
  620                          * This will usually be a floppy disk. This size makes
  621                          * sure that one FAT entry will not be split across
  622                          * multiple blocks.
  623                          */
  624                         pmp->pm_fatmask = FAT12_MASK;
  625                         pmp->pm_fatmult = 3;
  626                         pmp->pm_fatdiv = 2;
  627                 } else {
  628                         pmp->pm_fatmask = FAT16_MASK;
  629                         pmp->pm_fatmult = 2;
  630                         pmp->pm_fatdiv = 1;
  631                 }
  632         }
  633 
  634         clusters = (pmp->pm_fatsize / pmp->pm_fatmult) * pmp->pm_fatdiv;
  635         if (pmp->pm_maxcluster >= clusters) {
  636 #ifdef MSDOSFS_DEBUG
  637                 printf("Warning: number of clusters (%ld) exceeds FAT "
  638                     "capacity (%ld)\n", pmp->pm_maxcluster + 1, clusters);
  639 #endif
  640                 pmp->pm_maxcluster = clusters - 1;
  641         }
  642 
  643         if (FAT12(pmp))
  644                 pmp->pm_fatblocksize = 3 * 512;
  645         else
  646                 pmp->pm_fatblocksize = PAGE_SIZE;
  647         pmp->pm_fatblocksize = roundup(pmp->pm_fatblocksize,
  648             pmp->pm_BytesPerSec);
  649         pmp->pm_fatblocksec = pmp->pm_fatblocksize / DEV_BSIZE;
  650         pmp->pm_bnshift = ffs(DEV_BSIZE) - 1;
  651 
  652         /*
  653          * Compute mask and shift value for isolating cluster relative byte
  654          * offsets and cluster numbers from a file offset.
  655          */
  656         pmp->pm_bpcluster = SecPerClust * DEV_BSIZE;
  657         pmp->pm_crbomask = pmp->pm_bpcluster - 1;
  658         pmp->pm_cnshift = ffs(pmp->pm_bpcluster) - 1;
  659 
  660         /*
  661          * Check for valid cluster size
  662          * must be a power of 2
  663          */
  664         if ((pmp->pm_bpcluster ^ (1 << pmp->pm_cnshift)) != 0) {
  665                 error = EINVAL;
  666                 goto error_exit;
  667         }
  668 
  669         /*
  670          * Release the bootsector buffer.
  671          */
  672         brelse(bp);
  673         bp = NULL;
  674 
  675         /*
  676          * Check the fsinfo sector if we have one.  Silently fix up our
  677          * in-core copy of fp->fsinxtfree if it is unknown (0xffffffff)
  678          * or too large.  Ignore fp->fsinfree for now, since we need to
  679          * read the entire FAT anyway to fill the inuse map.
  680          */
  681         if (pmp->pm_fsinfo) {
  682                 struct fsinfo *fp;
  683 
  684                 if ((error = bread(devvp, pmp->pm_fsinfo, pmp->pm_BytesPerSec,
  685                     NOCRED, &bp)) != 0)
  686                         goto error_exit;
  687                 fp = (struct fsinfo *)bp->b_data;
  688                 if (!bcmp(fp->fsisig1, "RRaA", 4) &&
  689                     !bcmp(fp->fsisig2, "rrAa", 4) &&
  690                     !bcmp(fp->fsisig3, "\0\0\125\252", 4)) {
  691                         pmp->pm_nxtfree = getulong(fp->fsinxtfree);
  692                         if (pmp->pm_nxtfree > pmp->pm_maxcluster)
  693                                 pmp->pm_nxtfree = CLUST_FIRST;
  694                 } else
  695                         pmp->pm_fsinfo = 0;
  696                 brelse(bp);
  697                 bp = NULL;
  698         }
  699 
  700         /*
  701          * Finish initializing pmp->pm_nxtfree (just in case the first few
  702          * sectors aren't properly reserved in the FAT).  This completes
  703          * the fixup for fp->fsinxtfree, and fixes up the zero-initialized
  704          * value if there is no fsinfo.  We will use pmp->pm_nxtfree
  705          * internally even if there is no fsinfo.
  706          */
  707         if (pmp->pm_nxtfree < CLUST_FIRST)
  708                 pmp->pm_nxtfree = CLUST_FIRST;
  709 
  710         /*
  711          * Allocate memory for the bitmap of allocated clusters, and then
  712          * fill it in.
  713          */
  714         pmp->pm_inusemap = malloc(howmany(pmp->pm_maxcluster + 1,
  715             N_INUSEBITS) * sizeof(*pmp->pm_inusemap), M_MSDOSFSFAT, M_WAITOK);
  716 
  717         /*
  718          * fillinusemap() needs pm_devvp.
  719          */
  720         pmp->pm_devvp = devvp;
  721         pmp->pm_odevvp = odevvp;
  722         pmp->pm_dev = dev;
  723 
  724         /*
  725          * Have the inuse map filled in.
  726          */
  727         MSDOSFS_LOCK_MP(pmp);
  728         error = fillinusemap(pmp);
  729         MSDOSFS_UNLOCK_MP(pmp);
  730         if (error != 0)
  731                 goto error_exit;
  732 
  733         /*
  734          * If they want FAT updates to be synchronous then let them suffer
  735          * the performance degradation in exchange for the on disk copy of
  736          * the FAT being correct just about all the time.  I suppose this
  737          * would be a good thing to turn on if the kernel is still flakey.
  738          */
  739         if (mp->mnt_flag & MNT_SYNCHRONOUS)
  740                 pmp->pm_flags |= MSDOSFSMNT_WAITONFAT;
  741 
  742         /*
  743          * Finish up.
  744          */
  745         if (ronly)
  746                 pmp->pm_flags |= MSDOSFSMNT_RONLY;
  747         else {
  748                 if ((error = markvoldirty(pmp, 1)) != 0)
  749                         goto error_exit;
  750                 pmp->pm_fmod = 1;
  751         }
  752         mp->mnt_data =  pmp;
  753         mp->mnt_stat.f_fsid.val[0] = dev2udev(dev);
  754         mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
  755         MNT_ILOCK(mp);
  756         mp->mnt_flag |= MNT_LOCAL;
  757         mp->mnt_kern_flag |= MNTK_USES_BCACHE | MNTK_NO_IOPF;
  758         MNT_IUNLOCK(mp);
  759 
  760         return (0);
  761 
  762 error_exit:
  763         if (bp != NULL)
  764                 brelse(bp);
  765         if (cp != NULL) {
  766                 g_topology_lock();
  767                 g_vfs_close(cp);
  768                 g_topology_unlock();
  769         }
  770         if (pmp != NULL) {
  771                 lockdestroy(&pmp->pm_fatlock);
  772                 lockdestroy(&pmp->pm_checkpath_lock);
  773                 free(pmp->pm_inusemap, M_MSDOSFSFAT);
  774                 free(pmp, M_MSDOSFSMNT);
  775                 mp->mnt_data = NULL;
  776         }
  777         BO_LOCK(&odevvp->v_bufobj);
  778         odevvp->v_bufobj.bo_flag &= ~BO_NOBUFS;
  779         BO_UNLOCK(&odevvp->v_bufobj);
  780         atomic_store_rel_ptr((uintptr_t *)&dev->si_mountpt, 0);
  781         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
  782         mntfs_freevp(devvp);
  783         dev_rel(dev);
  784         return (error);
  785 }
  786 
  787 /*
  788  * Unmount the filesystem described by mp.
  789  */
  790 static int
  791 msdosfs_unmount(struct mount *mp, int mntflags)
  792 {
  793         struct msdosfsmount *pmp;
  794         int error, flags;
  795         bool susp;
  796 
  797         error = flags = 0;
  798         pmp = VFSTOMSDOSFS(mp);
  799         susp = (pmp->pm_flags & MSDOSFSMNT_RONLY) == 0;
  800 
  801         if (susp) {
  802                 error = vfs_write_suspend_umnt(mp);
  803                 if (error != 0)
  804                         return (error);
  805         }
  806 
  807         if ((mntflags & MNT_FORCE) != 0)
  808                 flags |= FORCECLOSE;
  809         error = vflush(mp, 0, flags, curthread);
  810         if (error != 0 && error != ENXIO) {
  811                 if (susp)
  812                         vfs_write_resume(mp, VR_START_WRITE);
  813                 return (error);
  814         }
  815         if (susp) {
  816                 error = markvoldirty(pmp, 0);
  817                 if (error != 0 && error != ENXIO) {
  818                         if (susp)
  819                                 vfs_write_resume(mp, VR_START_WRITE);
  820                         (void)markvoldirty(pmp, 1);
  821                         return (error);
  822                 }
  823         }
  824         if (pmp->pm_flags & MSDOSFSMNT_KICONV && msdosfs_iconv) {
  825                 if (pmp->pm_w2u)
  826                         msdosfs_iconv->close(pmp->pm_w2u);
  827                 if (pmp->pm_u2w)
  828                         msdosfs_iconv->close(pmp->pm_u2w);
  829                 if (pmp->pm_d2u)
  830                         msdosfs_iconv->close(pmp->pm_d2u);
  831                 if (pmp->pm_u2d)
  832                         msdosfs_iconv->close(pmp->pm_u2d);
  833         }
  834 
  835 #ifdef MSDOSFS_DEBUG
  836         {
  837                 struct vnode *vp = pmp->pm_devvp;
  838                 struct bufobj *bo;
  839 
  840                 bo = &vp->v_bufobj;
  841                 BO_LOCK(bo);
  842                 VI_LOCK(vp);
  843                 vn_printf(vp,
  844                     "msdosfs_umount(): just before calling VOP_CLOSE()\n");
  845                 printf("freef %p, freeb %p, mount %p\n",
  846                     TAILQ_NEXT(vp, v_vnodelist), vp->v_vnodelist.tqe_prev,
  847                     vp->v_mount);
  848                 printf("cleanblkhd %p, dirtyblkhd %p, numoutput %d, type %d\n",
  849                     TAILQ_FIRST(&vp->v_bufobj.bo_clean.bv_hd),
  850                     TAILQ_FIRST(&vp->v_bufobj.bo_dirty.bv_hd),
  851                     vp->v_bufobj.bo_numoutput, vp->v_type);
  852                 VI_UNLOCK(vp);
  853                 BO_UNLOCK(bo);
  854         }
  855 #endif
  856         if (susp)
  857                 vfs_write_resume(mp, VR_START_WRITE);
  858 
  859         vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY);
  860         g_topology_lock();
  861         g_vfs_close(pmp->pm_cp);
  862         g_topology_unlock();
  863         BO_LOCK(&pmp->pm_odevvp->v_bufobj);
  864         pmp->pm_odevvp->v_bufobj.bo_flag &= ~BO_NOBUFS;
  865         BO_UNLOCK(&pmp->pm_odevvp->v_bufobj);
  866         atomic_store_rel_ptr((uintptr_t *)&pmp->pm_dev->si_mountpt, 0);
  867         mntfs_freevp(pmp->pm_devvp);
  868         vrele(pmp->pm_odevvp);
  869         dev_rel(pmp->pm_dev);
  870         free(pmp->pm_inusemap, M_MSDOSFSFAT);
  871         lockdestroy(&pmp->pm_fatlock);
  872         lockdestroy(&pmp->pm_checkpath_lock);
  873         free(pmp, M_MSDOSFSMNT);
  874         mp->mnt_data = NULL;
  875         return (error);
  876 }
  877 
  878 static void
  879 msdosfs_remount_ro(void *arg, int pending)
  880 {
  881         struct msdosfsmount *pmp;
  882         int error;
  883 
  884         pmp = arg;
  885 
  886         MSDOSFS_LOCK_MP(pmp);
  887         if ((pmp->pm_flags & MSDOSFS_ERR_RO) != 0) {
  888                 while ((pmp->pm_flags & MSDOSFS_ERR_RO) != 0)
  889                         msleep(&pmp->pm_flags, &pmp->pm_fatlock, PVFS,
  890                             "msdoserrro", hz);
  891         } else if ((pmp->pm_mountp->mnt_flag & MNT_RDONLY) == 0) {
  892                 pmp->pm_flags |= MSDOSFS_ERR_RO;
  893                 MSDOSFS_UNLOCK_MP(pmp);
  894                 printf("%s: remounting read-only due to corruption\n",
  895                     pmp->pm_mountp->mnt_stat.f_mntfromname);
  896                 error = vfs_remount_ro(pmp->pm_mountp);
  897                 if (error != 0)
  898                         printf("%s: remounting read-only failed: error %d\n",
  899                             pmp->pm_mountp->mnt_stat.f_mntfromname, error);
  900                 else
  901                         printf("remounted %s read-only\n",
  902                             pmp->pm_mountp->mnt_stat.f_mntfromname);
  903                 MSDOSFS_LOCK_MP(pmp);
  904                 pmp->pm_flags &= ~MSDOSFS_ERR_RO;
  905                 wakeup(&pmp->pm_flags);
  906         }
  907         MSDOSFS_UNLOCK_MP(pmp);
  908 
  909         vfs_unbusy(pmp->pm_mountp);
  910 }
  911 
  912 void
  913 msdosfs_integrity_error(struct msdosfsmount *pmp)
  914 {
  915         int error;
  916 
  917         error = vfs_busy(pmp->pm_mountp, MBF_NOWAIT);
  918         if (error == 0)
  919                 taskqueue_enqueue(taskqueue_thread, &pmp->pm_rw2ro_task);
  920         else
  921                 printf("%s: integrity error busying failed, error %d\n",
  922                     pmp->pm_mountp->mnt_stat.f_mntfromname, error);
  923 }
  924 
  925 static int
  926 msdosfs_root(struct mount *mp, int flags, struct vnode **vpp)
  927 {
  928         struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
  929         struct denode *ndep;
  930         int error;
  931 
  932 #ifdef MSDOSFS_DEBUG
  933         printf("msdosfs_root(); mp %p, pmp %p\n", mp, pmp);
  934 #endif
  935         error = deget(pmp, MSDOSFSROOT, MSDOSFSROOT_OFS, LK_EXCLUSIVE, &ndep);
  936         if (error)
  937                 return (error);
  938         *vpp = DETOV(ndep);
  939         return (0);
  940 }
  941 
  942 static int
  943 msdosfs_statfs(struct mount *mp, struct statfs *sbp)
  944 {
  945         struct msdosfsmount *pmp;
  946 
  947         pmp = VFSTOMSDOSFS(mp);
  948         sbp->f_bsize = pmp->pm_bpcluster;
  949         sbp->f_iosize = pmp->pm_bpcluster;
  950         sbp->f_blocks = pmp->pm_maxcluster + 1;
  951         sbp->f_bfree = pmp->pm_freeclustercount;
  952         sbp->f_bavail = pmp->pm_freeclustercount;
  953         sbp->f_files = pmp->pm_RootDirEnts;     /* XXX */
  954         sbp->f_ffree = 0;       /* what to put in here? */
  955         return (0);
  956 }
  957 
  958 /*
  959  * If we have an FSInfo block, update it.
  960  */
  961 static int
  962 msdosfs_fsiflush(struct msdosfsmount *pmp, int waitfor)
  963 {
  964         struct fsinfo *fp;
  965         struct buf *bp;
  966         int error;
  967 
  968         MSDOSFS_LOCK_MP(pmp);
  969         if (pmp->pm_fsinfo == 0 || (pmp->pm_flags & MSDOSFS_FSIMOD) == 0) {
  970                 error = 0;
  971                 goto unlock;
  972         }
  973         error = bread(pmp->pm_devvp, pmp->pm_fsinfo, pmp->pm_BytesPerSec,
  974             NOCRED, &bp);
  975         if (error != 0) {
  976                 goto unlock;
  977         }
  978         fp = (struct fsinfo *)bp->b_data;
  979         putulong(fp->fsinfree, pmp->pm_freeclustercount);
  980         putulong(fp->fsinxtfree, pmp->pm_nxtfree);
  981         pmp->pm_flags &= ~MSDOSFS_FSIMOD;
  982         if (waitfor == MNT_WAIT)
  983                 error = bwrite(bp);
  984         else
  985                 bawrite(bp);
  986 unlock:
  987         MSDOSFS_UNLOCK_MP(pmp);
  988         return (error);
  989 }
  990 
  991 static int
  992 msdosfs_sync(struct mount *mp, int waitfor)
  993 {
  994         struct vnode *vp, *nvp;
  995         struct thread *td;
  996         struct denode *dep;
  997         struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
  998         int error, allerror = 0;
  999 
 1000         td = curthread;
 1001 
 1002         /*
 1003          * If we ever switch to not updating all of the FATs all the time,
 1004          * this would be the place to update them from the first one.
 1005          */
 1006         if (pmp->pm_fmod != 0) {
 1007                 if (pmp->pm_flags & MSDOSFSMNT_RONLY)
 1008                         panic("msdosfs_sync: rofs mod");
 1009                 else {
 1010                         /* update FATs here */
 1011                 }
 1012         }
 1013         /*
 1014          * Write back each (modified) denode.
 1015          */
 1016 loop:
 1017         MNT_VNODE_FOREACH_ALL(vp, mp, nvp) {
 1018                 if (vp->v_type == VNON) {
 1019                         VI_UNLOCK(vp);
 1020                         continue;
 1021                 }
 1022                 dep = VTODE(vp);
 1023                 if ((dep->de_flag &
 1024                     (DE_ACCESS | DE_CREATE | DE_UPDATE | DE_MODIFIED)) == 0 &&
 1025                     (vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
 1026                     waitfor == MNT_LAZY)) {
 1027                         VI_UNLOCK(vp);
 1028                         continue;
 1029                 }
 1030                 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
 1031                 if (error) {
 1032                         if (error == ENOENT) {
 1033                                 MNT_VNODE_FOREACH_ALL_ABORT(mp, nvp);
 1034                                 goto loop;
 1035                         }
 1036                         continue;
 1037                 }
 1038                 error = VOP_FSYNC(vp, waitfor, td);
 1039                 if (error)
 1040                         allerror = error;
 1041                 VOP_UNLOCK(vp);
 1042                 vrele(vp);
 1043         }
 1044 
 1045         /*
 1046          * Flush filesystem control info.
 1047          */
 1048         if (waitfor != MNT_LAZY) {
 1049                 vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY);
 1050                 error = VOP_FSYNC(pmp->pm_devvp, waitfor, td);
 1051                 if (error)
 1052                         allerror = error;
 1053                 VOP_UNLOCK(pmp->pm_devvp);
 1054         }
 1055 
 1056         error = msdosfs_fsiflush(pmp, waitfor);
 1057         if (error != 0)
 1058                 allerror = error;
 1059 
 1060         if (allerror == 0 && waitfor == MNT_SUSPEND) {
 1061                 MNT_ILOCK(mp);
 1062                 mp->mnt_kern_flag |= MNTK_SUSPEND2 | MNTK_SUSPENDED;
 1063                 MNT_IUNLOCK(mp);
 1064         }
 1065         return (allerror);
 1066 }
 1067 
 1068 static int
 1069 msdosfs_fhtovp(struct mount *mp, struct fid *fhp, int flags, struct vnode **vpp)
 1070 {
 1071         struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
 1072         struct defid *defhp = (struct defid *) fhp;
 1073         struct denode *dep;
 1074         int error;
 1075 
 1076         error = deget(pmp, defhp->defid_dirclust, defhp->defid_dirofs,
 1077             LK_EXCLUSIVE, &dep);
 1078         if (error) {
 1079                 *vpp = NULLVP;
 1080                 return (error);
 1081         }
 1082         *vpp = DETOV(dep);
 1083         vnode_create_vobject(*vpp, dep->de_FileSize, curthread);
 1084         return (0);
 1085 }
 1086 
 1087 static struct vfsops msdosfs_vfsops = {
 1088         .vfs_fhtovp =           msdosfs_fhtovp,
 1089         .vfs_mount =            msdosfs_mount,
 1090         .vfs_cmount =           msdosfs_cmount,
 1091         .vfs_root =             msdosfs_root,
 1092         .vfs_statfs =           msdosfs_statfs,
 1093         .vfs_sync =             msdosfs_sync,
 1094         .vfs_unmount =          msdosfs_unmount,
 1095 };
 1096 
 1097 VFS_SET(msdosfs_vfsops, msdosfs, 0);
 1098 MODULE_VERSION(msdosfs, 1);

Cache object: dec4671955c26f21f46efcb8c686fe09


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.