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

Cache object: 6500431f297afa27be993532b22bce7a


[ 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.