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/conf.h> 56 #include <sys/proc.h> 57 #include <sys/nlookup.h> 58 #include <sys/kernel.h> 59 #include <sys/vnode.h> 60 #include <sys/iconv.h> 61 #include <sys/mount.h> 62 #include <sys/buf.h> 63 #include <sys/fcntl.h> 64 #include <sys/malloc.h> 65 #include <sys/stat.h> 66 #include <vm/vm_zone.h> 67 68 #include <sys/buf2.h> 69 70 #include <vfs/msdosfs/bootsect.h> 71 #include <vfs/msdosfs/bpb.h> 72 #include <vfs/msdosfs/direntry.h> 73 #include <vfs/msdosfs/denode.h> 74 #include <vfs/msdosfs/fat.h> 75 #include <vfs/msdosfs/msdosfsmount.h> 76 77 extern struct vop_ops msdosfs_vnode_vops; 78 struct iconv_functions *msdosfs_iconv; 79 80 #define ENCODING_UNICODE "UTF-16BE" 81 #if 1 /*def PC98*/ 82 /* 83 * XXX - The boot signature formatted by NEC PC-98 DOS looks like a 84 * garbage or a random value :-{ 85 * If you want to use that broken-signatured media, define the 86 * following symbol even though PC/AT. 87 * (ex. mount PC-98 DOS formatted FD on PC/AT) 88 */ 89 #define MSDOSFS_NOCHECKSIG 90 #endif 91 92 MALLOC_DEFINE(M_MSDOSFSMNT, "MSDOSFS mount", "MSDOSFS mount structure"); 93 static MALLOC_DEFINE(M_MSDOSFSFAT, "MSDOSFS FAT", "MSDOSFS file allocation table"); 94 95 static int mountmsdosfs(struct vnode *devvp, struct mount *mp, 96 struct msdosfs_args *argp); 97 static int msdosfs_root(struct mount *, struct vnode **); 98 static int msdosfs_statfs(struct mount *, struct statfs *, struct ucred *); 99 static int msdosfs_unmount(struct mount *, int); 100 101 static int 102 update_mp(struct mount *mp, struct msdosfs_args *argp) 103 { 104 struct msdosfsmount *pmp = VFSTOMSDOSFS(mp); 105 int error; 106 char cs_local[ICONV_CSNMAXLEN]; 107 char cs_dos[ICONV_CSNMAXLEN]; 108 109 pmp->pm_gid = argp->gid; 110 pmp->pm_uid = argp->uid; 111 pmp->pm_mask = argp->mask & ALLPERMS; 112 pmp->pm_dirmask = argp->dirmask & ALLPERMS; 113 pmp->pm_flags |= argp->flags & MSDOSFSMNT_MNTOPT; 114 115 if (pmp->pm_flags & MSDOSFSMNT_KICONV && msdosfs_iconv) { 116 memcpy(cs_local, argp->cs_local, sizeof(cs_local)); 117 memcpy(cs_dos, argp->cs_dos, sizeof(cs_dos)); 118 kprintf("local: %s dos: %s\n",argp->cs_local, argp->cs_dos); 119 error = msdosfs_iconv->open(cs_local, ENCODING_UNICODE, 120 &pmp->pm_w2u); 121 if(error) 122 return error; 123 error = msdosfs_iconv->open(ENCODING_UNICODE, cs_local, 124 &pmp->pm_u2w); 125 if(error) 126 return error; 127 error = msdosfs_iconv->open(cs_dos, cs_local, &pmp->pm_u2d); 128 if(error) 129 return error; 130 error = msdosfs_iconv->open(cs_local, cs_dos, &pmp->pm_d2u); 131 if(error) 132 return error; 133 } 134 135 if (pmp->pm_flags & MSDOSFSMNT_NOWIN95) 136 pmp->pm_flags |= MSDOSFSMNT_SHORTNAME; 137 else 138 pmp->pm_flags |= MSDOSFSMNT_LONGNAME; 139 return 0; 140 } 141 142 /* 143 * mp - path - addr in user space of mount point (ie /usr or whatever) 144 * data - addr in user space of mount params including the name of the block 145 * special file to treat as a filesystem. 146 */ 147 static int 148 msdosfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred) 149 { 150 struct vnode *devvp; /* vnode for blk device to mount */ 151 struct msdosfs_args args; /* will hold data from mount request */ 152 /* msdosfs specific mount control block */ 153 struct msdosfsmount *pmp = NULL; 154 size_t size; 155 int error, flags; 156 mode_t accessmode; 157 struct nlookupdata nd; 158 159 error = copyin(data, (caddr_t)&args, sizeof(struct msdosfs_args)); 160 if (error) 161 return (error); 162 /* 163 * If updating, check whether changing from read-only to 164 * read/write; if there is no device name, that's all we do. 165 */ 166 if (mp->mnt_flag & MNT_UPDATE) { 167 pmp = VFSTOMSDOSFS(mp); 168 error = 0; 169 if (!(pmp->pm_flags & MSDOSFSMNT_RONLY) && 170 (mp->mnt_flag & MNT_RDONLY)) { 171 flags = WRITECLOSE; 172 if (mp->mnt_flag & MNT_FORCE) 173 flags |= FORCECLOSE; 174 error = vflush(mp, 0, flags); 175 if (error == 0) { 176 devvp = pmp->pm_devvp; 177 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 178 VOP_OPEN(devvp, FREAD, FSCRED, NULL); 179 VOP_CLOSE(devvp, FREAD|FWRITE, NULL); 180 vn_unlock(devvp); 181 pmp->pm_flags |= MSDOSFSMNT_RONLY; 182 } 183 } 184 if (!error && (mp->mnt_flag & MNT_RELOAD)) 185 error = EOPNOTSUPP; /* not yet implemented */ 186 if (error) 187 return (error); 188 if ((pmp->pm_flags & MSDOSFSMNT_RONLY) && 189 (mp->mnt_kern_flag & MNTK_WANTRDWR)) { 190 /* 191 * If upgrade to read-write by non-root, then verify 192 * that user has necessary permissions on the device. 193 */ 194 devvp = pmp->pm_devvp; 195 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 196 if (cred->cr_uid != 0) { 197 error = VOP_EACCESS(devvp, VREAD | VWRITE, 198 cred); 199 if (error) { 200 vn_unlock(devvp); 201 return (error); 202 } 203 } 204 VOP_OPEN(devvp, FREAD|FWRITE, FSCRED, NULL); 205 VOP_CLOSE(devvp, FREAD, NULL); 206 vn_unlock(devvp); 207 pmp->pm_flags &= ~MSDOSFSMNT_RONLY; 208 } 209 if (args.fspec == NULL) { 210 #ifdef __notyet__ /* doesn't work correctly with current mountd XXX */ 211 if (args.flags & MSDOSFSMNT_MNTOPT) { 212 pmp->pm_flags &= ~MSDOSFSMNT_MNTOPT; 213 pmp->pm_flags |= args.flags & MSDOSFSMNT_MNTOPT; 214 if (pmp->pm_flags & MSDOSFSMNT_NOWIN95) 215 pmp->pm_flags |= MSDOSFSMNT_SHORTNAME; 216 } 217 #endif 218 /* 219 * Process export requests. 220 */ 221 return (vfs_export(mp, &pmp->pm_export, &args.export)); 222 } 223 } 224 /* 225 * Not an update, or updating the name: look up the name 226 * and verify that it refers to a sensible disk device. 227 */ 228 devvp = NULL; 229 error = nlookup_init(&nd, args.fspec, UIO_USERSPACE, NLC_FOLLOW); 230 if (error == 0) 231 error = nlookup(&nd); 232 if (error == 0) 233 error = cache_vref(&nd.nl_nch, nd.nl_cred, &devvp); 234 nlookup_done(&nd); 235 if (error) 236 return (error); 237 238 if (!vn_isdisk(devvp, &error)) { 239 vrele(devvp); 240 return (error); 241 } 242 /* 243 * If mount by non-root, then verify that user has necessary 244 * permissions on the device. 245 */ 246 if (cred->cr_uid != 0) { 247 accessmode = VREAD; 248 if ((mp->mnt_flag & MNT_RDONLY) == 0) 249 accessmode |= VWRITE; 250 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 251 error = VOP_EACCESS(devvp, accessmode, cred); 252 if (error) { 253 vput(devvp); 254 return (error); 255 } 256 vn_unlock(devvp); 257 } 258 if ((mp->mnt_flag & MNT_UPDATE) == 0) { 259 error = mountmsdosfs(devvp, mp, &args); 260 #ifdef MSDOSFS_DEBUG /* only needed for the kprintf below */ 261 pmp = VFSTOMSDOSFS(mp); 262 #endif 263 } else { 264 if (devvp != pmp->pm_devvp) 265 error = EINVAL; /* XXX needs translation */ 266 else 267 vrele(devvp); 268 } 269 if (error) { 270 vrele(devvp); 271 return (error); 272 } 273 274 error = update_mp(mp, &args); 275 if (error) { 276 msdosfs_unmount(mp, MNT_FORCE); 277 return error; 278 } 279 280 copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); 281 memset(mp->mnt_stat.f_mntfromname + size, 0, MNAMELEN - size); 282 msdosfs_statfs(mp, &mp->mnt_stat, cred); 283 #ifdef MSDOSFS_DEBUG 284 kprintf("msdosfs_mount(): mp %p, pmp %p, inusemap %p\n", 285 mp, pmp, pmp->pm_inusemap); 286 #endif 287 return (0); 288 } 289 290 static int 291 mountmsdosfs(struct vnode *devvp, struct mount *mp, struct msdosfs_args *argp) 292 { 293 struct msdosfsmount *pmp; 294 struct buf *bp; 295 cdev_t dev; 296 union bootsector *bsp; 297 struct byte_bpb33 *b33; 298 struct byte_bpb50 *b50; 299 struct byte_bpb710 *b710; 300 uint8_t SecPerClust; 301 u_long clusters; 302 int ronly, error; 303 304 /* 305 * Disallow multiple mounts of the same device. 306 * Disallow mounting of a device that is currently in use 307 * Flush out any old buffers remaining from a previous use. 308 */ 309 error = vfs_mountedon(devvp); 310 if (error) 311 return (error); 312 if (vcount(devvp) > 0) 313 return (EBUSY); 314 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 315 error = vinvalbuf(devvp, V_SAVE, 0, 0); 316 vn_unlock(devvp); 317 if (error) 318 return (error); 319 320 ronly = (mp->mnt_flag & MNT_RDONLY) != 0; 321 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 322 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, NULL); 323 vn_unlock(devvp); 324 if (error) 325 return (error); 326 dev = devvp->v_rdev; 327 bp = NULL; /* both used in error_exit */ 328 pmp = NULL; 329 330 /* 331 * Read the boot sector of the filesystem, and then check the 332 * boot signature. If not a dos boot sector then error out. 333 * 334 * NOTE: 8192 is a magic size that works for ffs. 335 */ 336 error = bread(devvp, 0, 8192, &bp); 337 if (error) 338 goto error_exit; 339 bp->b_flags |= B_AGE; 340 bsp = (union bootsector *)bp->b_data; 341 b33 = (struct byte_bpb33 *)bsp->bs33.bsBPB; 342 b50 = (struct byte_bpb50 *)bsp->bs50.bsBPB; 343 b710 = (struct byte_bpb710 *)bsp->bs710.bsBPB; 344 345 #ifndef MSDOSFS_NOCHECKSIG 346 if (bsp->bs50.bsBootSectSig0 != BOOTSIG0 347 || bsp->bs50.bsBootSectSig1 != BOOTSIG1) { 348 error = EINVAL; 349 goto error_exit; 350 } 351 #endif 352 353 pmp = kmalloc(sizeof(*pmp), M_MSDOSFSMNT, M_WAITOK | M_ZERO); 354 pmp->pm_mountp = mp; 355 356 /* 357 * Compute several useful quantities from the bpb in the 358 * bootsector. Copy in the dos 5 variant of the bpb then fix up 359 * the fields that are different between dos 5 and dos 3.3. 360 */ 361 SecPerClust = b50->bpbSecPerClust; 362 pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec); 363 if (pmp->pm_BytesPerSec < DEV_BSIZE) { 364 error = EINVAL; 365 goto error_exit; 366 } 367 pmp->pm_ResSectors = getushort(b50->bpbResSectors); 368 pmp->pm_FATs = b50->bpbFATs; 369 pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts); 370 pmp->pm_Sectors = getushort(b50->bpbSectors); 371 pmp->pm_FATsecs = getushort(b50->bpbFATsecs); 372 pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack); 373 pmp->pm_Heads = getushort(b50->bpbHeads); 374 pmp->pm_Media = b50->bpbMedia; 375 376 /* calculate the ratio of sector size to DEV_BSIZE */ 377 pmp->pm_BlkPerSec = pmp->pm_BytesPerSec / DEV_BSIZE; 378 379 /* 380 * We don't check pm_Heads nor pm_SecPerTrack, because 381 * these may not be set for EFI file systems. We don't 382 * use these anyway, so we're unaffected if they are 383 * invalid. 384 */ 385 if (!pmp->pm_BytesPerSec || !SecPerClust) { 386 error = EINVAL; 387 goto error_exit; 388 } 389 390 if (pmp->pm_Sectors == 0) { 391 pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs); 392 pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors); 393 } else { 394 pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs); 395 pmp->pm_HugeSectors = pmp->pm_Sectors; 396 } 397 398 if (pmp->pm_RootDirEnts == 0) { 399 if (pmp->pm_FATsecs 400 || getushort(b710->bpbFSVers)) { 401 error = EINVAL; 402 kprintf("mountmsdosfs(): bad FAT32 filesystem\n"); 403 goto error_exit; 404 } 405 pmp->pm_fatmask = FAT32_MASK; 406 pmp->pm_fatmult = 4; 407 pmp->pm_fatdiv = 1; 408 pmp->pm_FATsecs = getulong(b710->bpbBigFATsecs); 409 if (getushort(b710->bpbExtFlags) & FATMIRROR) 410 pmp->pm_curfat = getushort(b710->bpbExtFlags) & FATNUM; 411 else 412 pmp->pm_flags |= MSDOSFS_FATMIRROR; 413 } else 414 pmp->pm_flags |= MSDOSFS_FATMIRROR; 415 416 /* 417 * Check a few values (could do some more): 418 * - logical sector size: power of 2, >= block size 419 * - sectors per cluster: power of 2, >= 1 420 * - number of sectors: >= 1, <= size of partition 421 * - number of FAT sectors: >= 1 422 */ 423 if ( (SecPerClust == 0) 424 || (SecPerClust & (SecPerClust - 1)) 425 || (pmp->pm_BytesPerSec < DEV_BSIZE) 426 || (pmp->pm_BytesPerSec & (pmp->pm_BytesPerSec - 1)) 427 || (pmp->pm_HugeSectors == 0) 428 || (pmp->pm_FATsecs == 0) 429 || (SecPerClust * pmp->pm_BlkPerSec > MAXBSIZE / DEV_BSIZE)) { 430 error = EINVAL; 431 goto error_exit; 432 } 433 434 pmp->pm_HugeSectors *= pmp->pm_BlkPerSec; 435 pmp->pm_HiddenSects *= pmp->pm_BlkPerSec; /* XXX not used? */ 436 pmp->pm_FATsecs *= pmp->pm_BlkPerSec; 437 SecPerClust *= pmp->pm_BlkPerSec; 438 439 pmp->pm_fatblk = pmp->pm_ResSectors * pmp->pm_BlkPerSec; 440 441 if (FAT32(pmp)) { 442 pmp->pm_rootdirblk = getulong(b710->bpbRootClust); 443 pmp->pm_firstcluster = pmp->pm_fatblk 444 + (pmp->pm_FATs * pmp->pm_FATsecs); 445 pmp->pm_fsinfo = getushort(b710->bpbFSInfo) * pmp->pm_BlkPerSec; 446 } else { 447 pmp->pm_rootdirblk = pmp->pm_fatblk + 448 (pmp->pm_FATs * pmp->pm_FATsecs); 449 pmp->pm_rootdirsize = howmany(pmp->pm_RootDirEnts * 450 sizeof(struct direntry), DEV_BSIZE); /* in blocks */ 451 pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize; 452 } 453 454 pmp->pm_maxcluster = (pmp->pm_HugeSectors - pmp->pm_firstcluster) / 455 SecPerClust + 1; 456 457 if (pmp->pm_fatmask == 0) { 458 if (pmp->pm_maxcluster 459 <= ((CLUST_RSRVD - CLUST_FIRST) & FAT12_MASK)) { 460 /* 461 * This will usually be a floppy disk. This size makes 462 * sure that one FAT entry will not be split across 463 * multiple blocks. 464 */ 465 pmp->pm_fatmask = FAT12_MASK; 466 pmp->pm_fatmult = 3; 467 pmp->pm_fatdiv = 2; 468 } else { 469 pmp->pm_fatmask = FAT16_MASK; 470 pmp->pm_fatmult = 2; 471 pmp->pm_fatdiv = 1; 472 } 473 } 474 475 clusters = ((pmp->pm_FATsecs * DEV_BSIZE) / pmp->pm_fatmult) * 476 pmp->pm_fatdiv; 477 if (pmp->pm_maxcluster >= clusters) { 478 kprintf("Warning: number of clusters (%ld) exceeds FAT " 479 "capacity (%ld)\n", pmp->pm_maxcluster + 1, clusters); 480 pmp->pm_maxcluster = clusters - 1; 481 } 482 483 if (FAT12(pmp)) 484 pmp->pm_fatblocksize = 3 * 512; 485 else 486 pmp->pm_fatblocksize = PAGE_SIZE; 487 pmp->pm_fatblocksize = roundup(pmp->pm_fatblocksize, 488 pmp->pm_BytesPerSec); 489 pmp->pm_fatblocksec = pmp->pm_fatblocksize / DEV_BSIZE; 490 pmp->pm_bnshift = DEV_BSHIFT; 491 492 /* 493 * Compute mask and shift value for isolating cluster relative byte 494 * offsets and cluster numbers from a file offset. 495 */ 496 pmp->pm_bpcluster = SecPerClust * DEV_BSIZE; 497 pmp->pm_crbomask = pmp->pm_bpcluster - 1; 498 pmp->pm_cnshift = ffs(pmp->pm_bpcluster) - 1; 499 500 /* 501 * Check for valid cluster size 502 * must be a power of 2 503 */ 504 if (pmp->pm_bpcluster ^ (1 << pmp->pm_cnshift)) { 505 error = EINVAL; 506 goto error_exit; 507 } 508 509 /* 510 * Release the bootsector buffer. 511 */ 512 bp->b_flags |= B_RELBUF; 513 brelse(bp); 514 bp = NULL; 515 516 /* 517 * Check the fsinfo sector if we have one. Silently fix up our 518 * in-core copy of fp->fsinxtfree if it is unknown (0xffffffff) 519 * or too large. Ignore fp->fsinfree for now, since we need to 520 * read the entire FAT anyway to fill the inuse map. 521 */ 522 if (pmp->pm_fsinfo) { 523 struct fsinfo *fp; 524 525 if ((error = bread(devvp, de_bn2doff(pmp, pmp->pm_fsinfo), 526 pmp->pm_BytesPerSec, &bp)) != 0) 527 goto error_exit; 528 fp = (struct fsinfo *)bp->b_data; 529 if (!memcmp(fp->fsisig1, "RRaA", 4) && 530 !memcmp(fp->fsisig2, "rrAa", 4) && 531 !memcmp(fp->fsisig3, "\0\0\125\252", 4)) { 532 pmp->pm_nxtfree = getulong(fp->fsinxtfree); 533 if (pmp->pm_nxtfree > pmp->pm_maxcluster) 534 pmp->pm_nxtfree = CLUST_FIRST; 535 } else 536 pmp->pm_fsinfo = 0; 537 bp->b_flags |= B_RELBUF; 538 brelse(bp); 539 bp = NULL; 540 } 541 542 /* 543 * Finish initializing pmp->pm_nxtfree (just in case the first few 544 * sectors aren't properly reserved in the FAT). This completes 545 * the fixup for fp->fsinxtfree, and fixes up the zero-initialized 546 * value if there is no fsinfo. We will use pmp->pm_nxtfree 547 * internally even if there is no fsinfo. 548 */ 549 if (pmp->pm_nxtfree < CLUST_FIRST) 550 pmp->pm_nxtfree = CLUST_FIRST; 551 552 /* 553 * Allocate memory for the bitmap of allocated clusters, and then 554 * fill it in. 555 */ 556 pmp->pm_inusemap = kmalloc(howmany(pmp->pm_maxcluster + 1, N_INUSEBITS) 557 * sizeof(*pmp->pm_inusemap), 558 M_MSDOSFSFAT, M_WAITOK); 559 560 /* 561 * fillinusemap() needs pm_devvp. 562 */ 563 pmp->pm_devvp = devvp; 564 pmp->pm_dev = dev; 565 566 /* 567 * Have the inuse map filled in. 568 */ 569 MSDOSFS_LOCK_MP(pmp); 570 error = fillinusemap(pmp); 571 MSDOSFS_UNLOCK_MP(pmp); 572 if (error != 0) 573 goto error_exit; 574 575 /* 576 * If they want FAT updates to be synchronous then let them suffer 577 * the performance degradation in exchange for the on disk copy of 578 * the FAT being correct just about all the time. I suppose this 579 * would be a good thing to turn on if the kernel is still flakey. 580 */ 581 if (mp->mnt_flag & MNT_SYNCHRONOUS) 582 pmp->pm_flags |= MSDOSFSMNT_WAITONFAT; 583 584 /* 585 * Finish up. 586 */ 587 if (ronly) 588 pmp->pm_flags |= MSDOSFSMNT_RONLY; 589 else 590 pmp->pm_fmod = 1; 591 mp->mnt_data = (qaddr_t) pmp; 592 mp->mnt_stat.f_fsid.val[0] = dev2udev(dev); 593 mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum; 594 mp->mnt_flag |= MNT_LOCAL; 595 vfs_add_vnodeops(mp, &msdosfs_vnode_vops, &mp->mnt_vn_norm_ops); 596 dev->si_mountpoint = mp; 597 598 return (0); 599 600 error_exit: 601 if (bp) { 602 bp->b_flags |= B_RELBUF; 603 brelse(bp); 604 } 605 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY); 606 VOP_CLOSE(devvp, ronly ? FREAD : FREAD | FWRITE, NULL); 607 vn_unlock(devvp); 608 if (pmp) { 609 if (pmp->pm_inusemap) 610 kfree(pmp->pm_inusemap, M_MSDOSFSFAT); 611 kfree(pmp, M_MSDOSFSMNT); 612 mp->mnt_data = (qaddr_t)0; 613 } 614 return (error); 615 } 616 617 /* 618 * Unmount the filesystem described by mp. 619 */ 620 static int 621 msdosfs_unmount(struct mount *mp, int mntflags) 622 { 623 struct msdosfsmount *pmp; 624 int error, flags; 625 #ifdef MSDOSFS_DEBUG 626 struct vnode *vp; 627 #endif 628 flags = 0; 629 if (mntflags & MNT_FORCE) 630 flags |= FORCECLOSE; 631 error = vflush(mp, 0, flags); 632 if (error) 633 return error; 634 635 pmp = VFSTOMSDOSFS(mp); 636 pmp->pm_devvp->v_rdev->si_mountpoint = NULL; 637 638 if (pmp->pm_flags & MSDOSFSMNT_KICONV && msdosfs_iconv) { 639 if (pmp->pm_w2u) 640 msdosfs_iconv->close(pmp->pm_w2u); 641 if (pmp->pm_u2w) 642 msdosfs_iconv->close(pmp->pm_u2w); 643 if (pmp->pm_d2u) 644 msdosfs_iconv->close(pmp->pm_d2u); 645 if (pmp->pm_u2d) 646 msdosfs_iconv->close(pmp->pm_u2d); 647 } 648 649 #ifdef MSDOSFS_DEBUG 650 vp = pmp->pm_devvp; 651 kprintf("msdosfs_umount(): just before calling VOP_CLOSE()\n"); 652 kprintf("flag %08x, refcnt 0x%08x, writecount %d, auxrefs 0x%08x\n", 653 vp->v_flag, vp->v_refcnt, vp->v_writecount, vp->v_auxrefs); 654 kprintf("mount %p, op %p\n", vp->v_mount, vp->v_ops); 655 kprintf("mount %p\n", vp->v_mount); 656 kprintf("cleanblkhd %p, dirtyblkhd %p, numoutput %d, type %d\n", 657 RB_ROOT(&vp->v_rbclean_tree), RB_ROOT(&vp->v_rbdirty_tree), 658 bio_track_active(&vp->v_track_write), vp->v_type); 659 kprintf("union %p, tag %d, data[0] %08x, data[1] %08x\n", 660 vp->v_socket, vp->v_tag, ((u_int *)vp->v_data)[0], 661 ((u_int *)vp->v_data)[1]); 662 #endif 663 664 vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY); 665 error = VOP_CLOSE(pmp->pm_devvp, 666 pmp->pm_flags & MSDOSFSMNT_RONLY ? FREAD : FREAD | FWRITE, 667 NULL); 668 vn_unlock(pmp->pm_devvp); 669 vrele(pmp->pm_devvp); 670 kfree(pmp->pm_inusemap, M_MSDOSFSFAT); 671 kfree(pmp, M_MSDOSFSMNT); 672 mp->mnt_data = (qaddr_t)0; 673 mp->mnt_flag &= ~MNT_LOCAL; 674 return (error); 675 } 676 677 static int 678 msdosfs_root(struct mount *mp, struct vnode **vpp) 679 { 680 struct msdosfsmount *pmp = VFSTOMSDOSFS(mp); 681 struct denode *ndep; 682 int error; 683 684 mprintf("msdosfs_root(); mp %p, pmp %p\n", mp, pmp); 685 error = deget(pmp, MSDOSFSROOT, MSDOSFSROOT_OFS, &ndep); 686 if (error) 687 return (error); 688 *vpp = DETOV(ndep); 689 return (0); 690 } 691 692 static int 693 msdosfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred) 694 { 695 struct msdosfsmount *pmp; 696 697 pmp = VFSTOMSDOSFS(mp); 698 sbp->f_bsize = pmp->pm_bpcluster; 699 sbp->f_iosize = pmp->pm_bpcluster; 700 sbp->f_blocks = pmp->pm_maxcluster + 1; 701 sbp->f_bfree = pmp->pm_freeclustercount; 702 sbp->f_bavail = pmp->pm_freeclustercount; 703 sbp->f_files = pmp->pm_RootDirEnts; /* XXX */ 704 sbp->f_ffree = 0; /* what to put in here? */ 705 if (sbp != &mp->mnt_stat) { 706 sbp->f_type = mp->mnt_vfc->vfc_typenum; 707 memcpy(sbp->f_mntfromname, mp->mnt_stat.f_mntfromname, MNAMELEN); 708 } 709 strncpy(sbp->f_fstypename, mp->mnt_vfc->vfc_name, MFSNAMELEN); 710 return (0); 711 } 712 713 struct scaninfo { 714 int rescan; 715 int allerror; 716 int waitfor; 717 }; 718 719 static int msdosfs_sync_scan(struct mount *mp, struct vnode *vp, void *data); 720 721 /* 722 * If we have an FSInfo block, update it. 723 */ 724 static int 725 msdosfs_fsiflush(struct msdosfsmount *pmp, int waitfor) 726 { 727 struct fsinfo *fp; 728 struct buf *bp; 729 int error; 730 731 MSDOSFS_LOCK_MP(pmp); 732 if (pmp->pm_fsinfo == 0 || (pmp->pm_flags & MSDOSFS_FSIMOD) == 0) { 733 error = 0; 734 goto unlock; 735 } 736 error = bread(pmp->pm_devvp, de_bn2doff(pmp, pmp->pm_fsinfo), 737 pmp->pm_BytesPerSec, &bp); 738 if (error != 0) { 739 brelse(bp); 740 goto unlock; 741 } 742 743 fp = (struct fsinfo *)bp->b_data; 744 putulong(fp->fsinfree, pmp->pm_freeclustercount); 745 putulong(fp->fsinxtfree, pmp->pm_nxtfree); 746 pmp->pm_flags &= ~MSDOSFS_FSIMOD; 747 if (waitfor == MNT_WAIT) 748 error = bwrite(bp); 749 else 750 bawrite(bp); 751 unlock: 752 MSDOSFS_UNLOCK_MP(pmp); 753 return (error); 754 } 755 756 static int 757 msdosfs_sync(struct mount *mp, int waitfor) 758 { 759 struct msdosfsmount *pmp = VFSTOMSDOSFS(mp); 760 struct scaninfo scaninfo; 761 int error; 762 763 /* 764 * If we ever switch to not updating all of the FATs all the time, 765 * this would be the place to update them from the first one. 766 */ 767 if (pmp->pm_fmod != 0) { 768 if (pmp->pm_flags & MSDOSFSMNT_RONLY) { 769 panic("msdosfs_sync: rofs mod"); 770 } else { 771 /* update FATs here */ 772 } 773 } 774 /* 775 * Write back each (modified) denode. 776 */ 777 scaninfo.allerror = 0; 778 scaninfo.rescan = 1; 779 while (scaninfo.rescan) { 780 scaninfo.rescan = 0; 781 vmntvnodescan(mp, VMSC_GETVP|VMSC_NOWAIT, NULL, 782 msdosfs_sync_scan, &scaninfo); 783 } 784 785 /* 786 * Flush filesystem control info. 787 */ 788 if ((waitfor & MNT_LAZY) == 0) { 789 vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY); 790 if ((error = VOP_FSYNC(pmp->pm_devvp, waitfor, 0)) != 0) 791 scaninfo.allerror = error; 792 vn_unlock(pmp->pm_devvp); 793 } 794 795 error = msdosfs_fsiflush(pmp, waitfor); 796 if (error != 0) 797 scaninfo.allerror = error; 798 return (scaninfo.allerror); 799 } 800 801 static int 802 msdosfs_sync_scan(struct mount *mp, struct vnode *vp, void *data) 803 { 804 struct scaninfo *info = data; 805 struct denode *dep; 806 int error; 807 808 dep = VTODE(vp); 809 if (vp->v_type == VNON || vp->v_type == VBAD || 810 ((dep->de_flag & 811 (DE_ACCESS | DE_CREATE | DE_UPDATE | DE_MODIFIED)) == 0 && 812 (RB_EMPTY(&vp->v_rbdirty_tree) || (info->waitfor & MNT_LAZY)))) { 813 return(0); 814 } 815 if ((error = VOP_FSYNC(vp, info->waitfor, 0)) != 0) 816 info->allerror = error; 817 return(0); 818 } 819 820 static int 821 msdosfs_fhtovp(struct mount *mp, struct vnode *rootvp, 822 struct fid *fhp, struct vnode **vpp) 823 { 824 struct msdosfsmount *pmp = VFSTOMSDOSFS(mp); 825 struct defid *defhp = (struct defid *) fhp; 826 struct denode *dep; 827 int error; 828 829 error = deget(pmp, defhp->defid_dirclust, defhp->defid_dirofs, &dep); 830 if (error) { 831 *vpp = NULLVP; 832 return (error); 833 } 834 *vpp = DETOV(dep); 835 return (0); 836 } 837 838 static int 839 msdosfs_checkexp(struct mount *mp, struct sockaddr *nam, int *exflagsp, 840 struct ucred **credanonp) 841 { 842 struct msdosfsmount *pmp = VFSTOMSDOSFS(mp); 843 struct netcred *np; 844 845 np = vfs_export_lookup(mp, &pmp->pm_export, nam); 846 if (np == NULL) 847 return (EACCES); 848 *exflagsp = np->netc_exflags; 849 *credanonp = &np->netc_anon; 850 return (0); 851 } 852 853 static int 854 msdosfs_vptofh(struct vnode *vp, struct fid *fhp) 855 { 856 struct denode *dep; 857 struct defid *defhp; 858 859 dep = VTODE(vp); 860 defhp = (struct defid *)fhp; 861 defhp->defid_len = sizeof(struct defid); 862 defhp->defid_dirclust = dep->de_dirclust; 863 defhp->defid_dirofs = dep->de_diroffset; 864 /* defhp->defid_gen = dep->de_gen; */ 865 return (0); 866 } 867 868 static struct vfsops msdosfs_vfsops = { 869 .vfs_mount = msdosfs_mount, 870 .vfs_root = msdosfs_root, 871 .vfs_statfs = msdosfs_statfs, 872 .vfs_sync = msdosfs_sync, 873 .vfs_fhtovp = msdosfs_fhtovp, 874 .vfs_checkexp = msdosfs_checkexp, 875 .vfs_vptofh = msdosfs_vptofh, 876 .vfs_init = msdosfs_init, 877 .vfs_uninit = msdosfs_uninit, 878 .vfs_unmount = msdosfs_unmount, 879 }; 880 881 VFS_SET(msdosfs_vfsops, msdos, 0); 882 MODULE_VERSION(msdos, 1); 883