diff options
31 files changed, 12659 insertions, 9 deletions
diff --git a/sys/conf/files b/sys/conf/files index f314a1b..a3d4978 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -22,6 +22,12 @@ isofs/cd9660/cd9660_rrip.c optional cd9660 isofs/cd9660/cd9660_util.c optional cd9660 isofs/cd9660/cd9660_vfsops.c optional cd9660 isofs/cd9660/cd9660_vnops.c optional cd9660 +msdosfs/msdosfs_conv.c optional msdosfs +msdosfs/msdosfs_denode.c optional msdosfs +msdosfs/msdosfs_fat.c optional msdosfs +msdosfs/msdosfs_lookup.c optional msdosfs +msdosfs/msdosfs_vfsops.c optional msdosfs +msdosfs/msdosfs_vnops.c optional msdosfs kdb/kdb_access.c optional kadb kdb/kdb_command.c optional kadb kdb/kdb_ctype.c optional kadb diff --git a/sys/fs/msdosfs/bootsect.h b/sys/fs/msdosfs/bootsect.h new file mode 100644 index 0000000..099b15f --- /dev/null +++ b/sys/fs/msdosfs/bootsect.h @@ -0,0 +1,70 @@ +/* $Id$ */ +/* $NetBSD: bootsect.h,v 1.4 1994/06/29 06:35:28 cgd Exp $ */ + +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Format of a boot sector. This is the first sector on a DOS floppy disk + * or the fist sector of a partition on a hard disk. But, it is not the + * first sector of a partitioned hard disk. + */ +struct bootsector33 { + u_char bsJump[3]; /* jump instruction E9xxxx or EBxx90 */ + char bsOemName[8]; /* OEM name and version */ + char bsBPB[19]; /* BIOS parameter block */ + char bsDriveNumber; /* drive number (0x80) */ + char bsBootCode[474]; /* pad so structure is 512 bytes long */ + u_short bsBootSectSig; +#define BOOTSIG 0xaa55 +}; + +struct bootsector50 { + u_char bsJump[3]; /* jump instruction E9xxxx or EBxx90 */ + char bsOemName[8]; /* OEM name and version */ + char bsBPB[25]; /* BIOS parameter block */ + char bsDriveNumber; /* drive number (0x80) */ + char bsReserved1; /* reserved */ + char bsBootSignature; /* extended boot signature (0x29) */ +#define EXBOOTSIG 0x29 + char bsVolumeID[4]; /* volume ID number */ + char bsVolumeLabel[11]; /* volume label */ + char bsFileSysType[8]; /* file system type (FAT12 or FAT16) */ + char bsBootCode[448]; /* pad so structure is 512 bytes long */ + u_short bsBootSectSig; +#define BOOTSIG 0xaa55 +}; + +union bootsector { + struct bootsector33 bs33; + struct bootsector50 bs50; +}; + +/* + * Shorthand for fields in the bpb. + */ +#define bsBytesPerSec bsBPB.bpbBytesPerSec +#define bsSectPerClust bsBPB.bpbSectPerClust +#define bsResSectors bsBPB.bpbResSectors +#define bsFATS bsBPB.bpbFATS +#define bsRootDirEnts bsBPB.bpbRootDirEnts +#define bsSectors bsBPB.bpbSectors +#define bsMedia bsBPB.bpbMedia +#define bsFATsecs bsBPB.bpbFATsecs +#define bsSectPerTrack bsBPB.bpbSectPerTrack +#define bsHeads bsBPB.bpbHeads +#define bsHiddenSecs bsBPB.bpbHiddenSecs +#define bsHugeSectors bsBPB.bpbHugeSectors diff --git a/sys/fs/msdosfs/bpb.h b/sys/fs/msdosfs/bpb.h new file mode 100644 index 0000000..70e4de2 --- /dev/null +++ b/sys/fs/msdosfs/bpb.h @@ -0,0 +1,120 @@ +/* $Id$ */ +/* $NetBSD: bpb.h,v 1.3 1994/06/29 06:35:29 cgd Exp $ */ + +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * BIOS Parameter Block (BPB) for DOS 3.3 + */ +struct bpb33 { + u_short bpbBytesPerSec; /* bytes per sector */ + u_char bpbSecPerClust; /* sectors per cluster */ + u_short bpbResSectors; /* number of reserved sectors */ + u_char bpbFATs; /* number of FATs */ + u_short bpbRootDirEnts; /* number of root directory entries */ + u_short bpbSectors; /* total number of sectors */ + u_char bpbMedia; /* media descriptor */ + u_short bpbFATsecs; /* number of sectors per FAT */ + u_short bpbSecPerTrack; /* sectors per track */ + u_short bpbHeads; /* number of heads */ + u_short bpbHiddenSecs; /* number of hidden sectors */ +}; + +/* + * BPB for DOS 5.0 The difference is bpbHiddenSecs is a short for DOS 3.3, + * and bpbHugeSectors is not in the 3.3 bpb. + */ +struct bpb50 { + u_short bpbBytesPerSec; /* bytes per sector */ + u_char bpbSecPerClust; /* sectors per cluster */ + u_short bpbResSectors; /* number of reserved sectors */ + u_char bpbFATs; /* number of FATs */ + u_short bpbRootDirEnts; /* number of root directory entries */ + u_short bpbSectors; /* total number of sectors */ + u_char bpbMedia; /* media descriptor */ + u_short bpbFATsecs; /* number of sectors per FAT */ + u_short bpbSecPerTrack; /* sectors per track */ + u_short bpbHeads; /* number of heads */ + u_long bpbHiddenSecs; /* number of hidden sectors */ + u_long bpbHugeSectors; /* number of sectrs if bpbSectors == 0 */ +}; + +/* + * The following structures represent how the bpb's look on disk. shorts + * and longs are just character arrays of the appropriate length. This is + * because the compiler forces shorts and longs to align on word or + * halfword boundaries. + * + * XXX The little-endian code here assumes that the processor can access + * 16-bit and 32-bit quantities on byte boundaries. If this is not true, + * use the macros for the big-endian case. + */ +#include <machine/endian.h> +#if BYTE_ORDER == LITTLE_ENDIAN /* && can do unaligned accesses */ +#define getushort(x) *((u_short *)(x)) +#define getulong(x) *((u_long *)(x)) +#define putushort(p, v) (*((u_short *)(p)) = (v)) +#define putulong(p, v) (*((u_long *)(p)) = (v)) + +#else +#define getushort(x) (((u_char *)(x))[0] + (((u_char *)(x))[1] << 8)) +#define getulong(x) (((u_char *)(x))[0] + (((u_char *)(x))[1] << 8) \ + + (((u_char *)(x))[2] << 16) \ + + (((u_char *)(x))[3] << 24)) +#define putushort(p, v) (((u_char *)(p))[0] = (v), \ + ((u_char *)(p))[1] = (v) >> 8) +#define putulong(p, v) (((u_char *)(p))[0] = (v), \ + ((u_char *)(p))[1] = (v) >> 8, \ + ((u_char *)(p))[2] = (v) >> 16,\ + ((u_char *)(p))[3] = (v) >> 24) +#endif + +/* + * BIOS Parameter Block (BPB) for DOS 3.3 + */ +struct byte_bpb33 { + char bpbBytesPerSec[2]; /* bytes per sector */ + char bpbSecPerClust; /* sectors per cluster */ + char bpbResSectors[2]; /* number of reserved sectors */ + char bpbFATs; /* number of FATs */ + char bpbRootDirEnts[2]; /* number of root directory entries */ + char bpbSectors[2]; /* total number of sectors */ + char bpbMedia; /* media descriptor */ + char bpbFATsecs[2]; /* number of sectors per FAT */ + char bpbSecPerTrack[2]; /* sectors per track */ + char bpbHeads[2]; /* number of heads */ + char bpbHiddenSecs[2]; /* number of hidden sectors */ +}; + +/* + * BPB for DOS 5.0 The difference is bpbHiddenSecs is a short for DOS 3.3, + * and bpbHugeSectors is not in the 3.3 bpb. + */ +struct byte_bpb50 { + char bpbBytesPerSec[2]; /* bytes per sector */ + char bpbSecPerClust; /* sectors per cluster */ + char bpbResSectors[2]; /* number of reserved sectors */ + char bpbFATs; /* number of FATs */ + char bpbRootDirEnts[2]; /* number of root directory entries */ + char bpbSectors[2]; /* total number of sectors */ + char bpbMedia; /* media descriptor */ + char bpbFATsecs[2]; /* number of sectors per FAT */ + char bpbSecPerTrack[2]; /* sectors per track */ + char bpbHeads[2]; /* number of heads */ + char bpbHiddenSecs[4]; /* number of hidden sectors */ + char bpbHugeSectors[4]; /* number of sectrs if bpbSectors == 0 */ +}; diff --git a/sys/fs/msdosfs/denode.h b/sys/fs/msdosfs/denode.h new file mode 100644 index 0000000..8df3e4c --- /dev/null +++ b/sys/fs/msdosfs/denode.h @@ -0,0 +1,267 @@ +/* $Id$ */ +/* $NetBSD: denode.h,v 1.8 1994/08/21 18:43:49 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * This is the pc filesystem specific portion of the vnode structure. + * + * To describe a file uniquely the de_dirclust, de_diroffset, and + * de_StartCluster fields are used. + * + * de_dirclust contains the cluster number of the directory cluster + * containing the entry for a file or directory. + * de_diroffset is the index into the cluster for the entry describing + * a file or directory. + * de_StartCluster is the number of the first cluster of the file or directory. + * + * Now to describe the quirks of the pc filesystem. + * - Clusters 0 and 1 are reserved. + * - The first allocatable cluster is 2. + * - The root directory is of fixed size and all blocks that make it up + * are contiguous. + * - Cluster 0 refers to the root directory when it is found in the + * startcluster field of a directory entry that points to another directory. + * - Cluster 0 implies a 0 length file when found in the start cluster field + * of a directory entry that points to a file. + * - You can't use the cluster number 0 to derive the address of the root + * directory. + * - Multiple directory entries can point to a directory. The entry in the + * parent directory points to a child directory. Any directories in the + * child directory contain a ".." entry that points back to the parent. + * The child directory itself contains a "." entry that points to itself. + * - The root directory does not contain a "." or ".." entry. + * - Directory entries for directories are never changed once they are created + * (except when removed). The size stays 0, and the last modification time + * is never changed. This is because so many directory entries can point to + * the physical clusters that make up a directory. It would lead to an + * update nightmare. + * - The length field in a directory entry pointing to a directory contains 0 + * (always). The only way to find the end of a directory is to follow the + * cluster chain until the "last cluster" marker is found. + * + * My extensions to make this house of cards work. These apply only to the in + * memory copy of the directory entry. + * - A reference count for each denode will be kept since dos doesn't keep such + * things. + */ + +/* + * Internal pseudo-offset for (nonexistent) directory entry for the root + * dir in the root dir + */ +#define MSDOSFSROOT_OFS 0x1fffffff + +/* + * The fat cache structure. fc_fsrcn is the filesystem relative cluster + * number that corresponds to the file relative cluster number in this + * structure (fc_frcn). + */ +struct fatcache { + u_short fc_frcn; /* file relative cluster number */ + u_short fc_fsrcn; /* filesystem relative cluster number */ +}; + +/* + * The fat entry cache as it stands helps make extending files a "quick" + * operation by avoiding having to scan the fat to discover the last + * cluster of the file. The cache also helps sequential reads by + * remembering the last cluster read from the file. This also prevents us + * from having to rescan the fat to find the next cluster to read. This + * cache is probably pretty worthless if a file is opened by multiple + * processes. + */ +#define FC_SIZE 2 /* number of entries in the cache */ +#define FC_LASTMAP 0 /* entry the last call to pcbmap() resolved + * to */ +#define FC_LASTFC 1 /* entry for the last cluster in the file */ + +#define FCE_EMPTY 0xffff /* doesn't represent an actual cluster # */ + +/* + * Set a slot in the fat cache. + */ +#define fc_setcache(dep, slot, frcn, fsrcn) \ + (dep)->de_fc[slot].fc_frcn = frcn; \ + (dep)->de_fc[slot].fc_fsrcn = fsrcn; + +/* + * This is the in memory variant of a dos directory entry. It is usually + * contained within a vnode. + */ +struct denode { + struct denode *de_next; /* Hash chain forward */ + struct denode **de_prev; /* Hash chain back */ + struct vnode *de_vnode; /* addr of vnode we are part of */ + struct vnode *de_devvp; /* vnode of blk dev we live on */ + u_long de_flag; /* flag bits */ + dev_t de_dev; /* device where direntry lives */ + u_long de_dirclust; /* cluster of the directory file containing this entry */ + u_long de_diroffset; /* ordinal of this entry in the directory */ + u_long de_fndclust; /* cluster of found dir entry */ + u_long de_fndoffset; /* offset of found dir entry */ + long de_refcnt; /* reference count */ + struct msdosfsmount *de_pmp; /* addr of our mount struct */ + struct lockf *de_lockf; /* byte level lock list */ + pid_t de_lockholder; /* current lock holder */ + pid_t de_lockwaiter; /* lock wanter */ + /* the next two fields must be contiguous in memory... */ + u_char de_Name[8]; /* name, from directory entry */ + u_char de_Extension[3]; /* extension, from directory entry */ + u_char de_Attributes; /* attributes, from directory entry */ + u_short de_Time; /* creation time */ + u_short de_Date; /* creation date */ + u_short de_StartCluster; /* starting cluster of file */ + u_long de_FileSize; /* size of file in bytes */ + struct fatcache de_fc[FC_SIZE]; /* fat cache */ +}; + +/* + * Values for the de_flag field of the denode. + */ +#define DE_LOCKED 0x0001 /* directory entry is locked */ +#define DE_WANTED 0x0002 /* someone wants this de */ +#define DE_UPDATE 0x0004 /* file has been modified */ +#define DE_MODIFIED 0x0080 /* denode wants to be written back to disk */ + +/* + * Transfer directory entries between internal and external form. + * dep is a struct denode * (internal form), + * dp is a struct direntry * (external form). + */ +#define DE_INTERNALIZE(dep, dp) \ + (bcopy((dp)->deName, (dep)->de_Name, 11), \ + (dep)->de_Attributes = (dp)->deAttributes, \ + (dep)->de_Time = getushort((dp)->deTime), \ + (dep)->de_Date = getushort((dp)->deDate), \ + (dep)->de_StartCluster = getushort((dp)->deStartCluster), \ + (dep)->de_FileSize = getulong((dp)->deFileSize)) + +#define DE_EXTERNALIZE(dp, dep) \ + (bcopy((dep)->de_Name, (dp)->deName, 11), \ + (dp)->deAttributes = (dep)->de_Attributes, \ + putushort((dp)->deTime, (dep)->de_Time), \ + putushort((dp)->deDate, (dep)->de_Date), \ + putushort((dp)->deStartCluster, (dep)->de_StartCluster), \ + putulong((dp)->deFileSize, (dep)->de_FileSize)) + +#define de_forw de_chain[0] +#define de_back de_chain[1] + +#ifdef KERNEL + +#define VTODE(vp) ((struct denode *)(vp)->v_data) +#define DETOV(de) ((de)->de_vnode) + +#define DE_UPDAT(dep, t, waitfor) \ + if (dep->de_flag & DE_UPDATE) \ + (void) deupdat(dep, t, waitfor); + +#define DE_TIMES(dep, t) \ + if (dep->de_flag & DE_UPDATE) { \ + (dep)->de_flag |= DE_MODIFIED; \ + unix2dostime(t, &dep->de_Date, &dep->de_Time); \ + (dep)->de_flag &= ~DE_UPDATE; \ + } + +/* + * This overlays the fid sturcture (see mount.h) + */ +struct defid { + u_short defid_len; /* length of structure */ + u_short defid_pad; /* force long alignment */ + + u_long defid_dirclust; /* cluster this dir entry came from */ + u_long defid_dirofs; /* index of entry within the cluster */ + + /* u_long defid_gen; generation number */ +}; + +/* + * Prototypes for MSDOSFS vnode operations + */ +int msdosfs_lookup __P((struct vop_lookup_args *)); +int msdosfs_create __P((struct vop_create_args *)); +int msdosfs_mknod __P((struct vop_mknod_args *)); +int msdosfs_open __P((struct vop_open_args *)); +int msdosfs_close __P((struct vop_close_args *)); +int msdosfs_access __P((struct vop_access_args *)); +int msdosfs_getattr __P((struct vop_getattr_args *)); +int msdosfs_setattr __P((struct vop_setattr_args *)); +int msdosfs_read __P((struct vop_read_args *)); +int msdosfs_write __P((struct vop_write_args *)); +int msdosfs_ioctl __P((struct vop_ioctl_args *)); +int msdosfs_select __P((struct vop_select_args *)); +int msdosfs_mmap __P((struct vop_mmap_args *)); +int msdosfs_fsync __P((struct vop_fsync_args *)); +int msdosfs_seek __P((struct vop_seek_args *)); +int msdosfs_remove __P((struct vop_remove_args *)); +int msdosfs_link __P((struct vop_link_args *)); +int msdosfs_rename __P((struct vop_rename_args *)); +int msdosfs_mkdir __P((struct vop_mkdir_args *)); +int msdosfs_rmdir __P((struct vop_rmdir_args *)); +int msdosfs_symlink __P((struct vop_symlink_args *)); +int msdosfs_readdir __P((struct vop_readdir_args *)); +int msdosfs_readlink __P((struct vop_readlink_args *)); +int msdosfs_abortop __P((struct vop_abortop_args *)); +int msdosfs_inactive __P((struct vop_inactive_args *)); +int msdosfs_reclaim __P((struct vop_reclaim_args *)); +int msdosfs_lock __P((struct vop_lock_args *)); +int msdosfs_unlock __P((struct vop_unlock_args *)); +int msdosfs_bmap __P((struct vop_bmap_args *)); +int msdosfs_strategy __P((struct vop_strategy_args *)); +int msdosfs_print __P((struct vop_print_args *)); +int msdosfs_islocked __P((struct vop_islocked_args *)); +int msdosfs_advlock __P((struct vop_advlock_args *)); +int msdosfs_reallocblks __P((struct vop_reallocblks_args *)); + +/* + * Internal service routine prototypes. + */ +int deget __P((struct msdosfsmount * pmp, u_long dirclust, u_long diroffset, struct direntry * direntptr, struct denode ** depp)); +#endif /* KERNEL */ diff --git a/sys/fs/msdosfs/direntry.h b/sys/fs/msdosfs/direntry.h new file mode 100644 index 0000000..d2ec019 --- /dev/null +++ b/sys/fs/msdosfs/direntry.h @@ -0,0 +1,104 @@ +/* $Id$ */ +/* $NetBSD: direntry.h,v 1.7 1994/08/21 18:43:54 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Structure of a dos directory entry. + */ +struct direntry { + u_char deName[8]; /* filename, blank filled */ +#define SLOT_EMPTY 0x00 /* slot has never been used */ +#define SLOT_E5 0x05 /* the real value is 0xe5 */ +#define SLOT_DELETED 0xe5 /* file in this slot deleted */ + u_char deExtension[3]; /* extension, blank filled */ + u_char deAttributes; /* file attributes */ +#define ATTR_NORMAL 0x00 /* normal file */ +#define ATTR_READONLY 0x01 /* file is readonly */ +#define ATTR_HIDDEN 0x02 /* file is hidden */ +#define ATTR_SYSTEM 0x04 /* file is a system file */ +#define ATTR_VOLUME 0x08 /* entry is a volume label */ +#define ATTR_DIRECTORY 0x10 /* entry is a directory name */ +#define ATTR_ARCHIVE 0x20 /* file is new or modified */ + u_char deReserved[10]; /* reserved */ + u_char deTime[2]; /* create/last update time */ + u_char deDate[2]; /* create/last update date */ + u_char deStartCluster[2]; /* starting cluster of file */ + u_char deFileSize[4]; /* size of file in bytes */ +}; + +/* + * This is the format of the contents of the deTime field in the direntry + * structure. + * We don't use bitfields because we don't know how compilers for + * arbitrary machines will lay them out. + */ +#define DT_2SECONDS_MASK 0x1F /* seconds divided by 2 */ +#define DT_2SECONDS_SHIFT 0 +#define DT_MINUTES_MASK 0x7E0 /* minutes */ +#define DT_MINUTES_SHIFT 5 +#define DT_HOURS_MASK 0xF800 /* hours */ +#define DT_HOURS_SHIFT 11 + +/* + * This is the format of the contents of the deDate field in the direntry + * structure. + */ +#define DD_DAY_MASK 0x1F /* day of month */ +#define DD_DAY_SHIFT 0 +#define DD_MONTH_MASK 0x1E0 /* month */ +#define DD_MONTH_SHIFT 5 +#define DD_YEAR_MASK 0xFE00 /* year - 1980 */ +#define DD_YEAR_SHIFT 9 + +#ifdef KERNEL +void unix2dostime __P((struct timespec * tsp, u_short * ddp, u_short * dtp)); +void dos2unixtime __P((u_short dd, u_short dt, struct timespec * tsp)); +int dos2unixfn __P((u_char dn[11], u_char * un)); +void unix2dosfn __P((u_char * un, u_char dn[11], int unlen)); +#endif /* KERNEL */ diff --git a/sys/fs/msdosfs/fat.h b/sys/fs/msdosfs/fat.h new file mode 100644 index 0000000..3867c87 --- /dev/null +++ b/sys/fs/msdosfs/fat.h @@ -0,0 +1,97 @@ +/* $Id$ */ +/* $NetBSD: fat.h,v 1.4 1994/08/21 18:43:57 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Some useful cluster numbers. + */ +#define MSDOSFSROOT 0 /* cluster 0 means the root dir */ +#define CLUST_FREE 0 /* cluster 0 also means a free cluster */ +#define MSDOSFSFREE CLUST_FREE +#define CLUST_FIRST 2 /* first legal cluster number */ +#define CLUST_RSRVS 0xfff0 /* start of reserved cluster range */ +#define CLUST_RSRVE 0xfff6 /* end of reserved cluster range */ +#define CLUST_BAD 0xfff7 /* a cluster with a defect */ +#define CLUST_EOFS 0xfff8 /* start of eof cluster range */ +#define CLUST_EOFE 0xffff /* end of eof cluster range */ + +#define FAT12_MASK 0x0fff /* mask for 12 bit cluster numbers */ +#define FAT16_MASK 0xffff /* mask for 16 bit cluster numbers */ + +/* + * Return true if filesystem uses 12 bit fats. Microsoft Programmer's + * Reference says if the maximum cluster number in a filesystem is greater + * than 4086 then we've got a 16 bit fat filesystem. + */ +#define FAT12(pmp) (pmp->pm_maxcluster <= 4086) +#define FAT16(pmp) (pmp->pm_maxcluster > 4086) + +#define MSDOSFSEOF(cn) (((cn) & 0xfff8) == 0xfff8) + +#ifdef KERNEL +/* + * These are the values for the function argument to the function + * fatentry(). + */ +#define FAT_GET 0x0001 /* get a fat entry */ +#define FAT_SET 0x0002 /* set a fat entry */ +#define FAT_GET_AND_SET (FAT_GET | FAT_SET) + +/* + * Flags to extendfile: + */ +#define DE_CLEAR 1 /* Zero out the blocks allocated */ + +int pcbmap __P((struct denode *dep, u_long findcn, daddr_t *bnp, u_long *cnp)); +int clusterfree __P((struct msdosfsmount *pmp, u_long cn, u_long *oldcnp)); +int clusteralloc __P((struct msdosfsmount *pmp, u_long start, u_long count, u_long fillwith, u_long *retcluster, u_long *got)); +int fatentry __P((int function, struct msdosfsmount *pmp, u_long cluster, u_long *oldcontents, u_long newcontents)); +int freeclusterchain __P((struct msdosfsmount *pmp, u_long startchain)); +int extendfile __P((struct denode *dep, u_long count, struct buf **bpp, u_long *ncp, int flags)); +#endif /* KERNEL */ diff --git a/sys/fs/msdosfs/msdosfs_conv.c b/sys/fs/msdosfs/msdosfs_conv.c new file mode 100644 index 0000000..da8ce97 --- /dev/null +++ b/sys/fs/msdosfs/msdosfs_conv.c @@ -0,0 +1,358 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_conv.c,v 1.6.2.1 1994/08/30 02:27:57 cgd Exp $ */ + +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * System include files. + */ +#include <sys/param.h> +#include <sys/time.h> +#include <sys/kernel.h> /* defines tz */ + +/* + * MSDOSFS include files. + */ +#include <msdosfs/direntry.h> + +/* + * Days in each month in a regular year. + */ +u_short regyear[] = { + 31, 28, 31, 30, 31, 30, + 31, 31, 30, 31, 30, 31 +}; + +/* + * Days in each month in a leap year. + */ +u_short leapyear[] = { + 31, 29, 31, 30, 31, 30, + 31, 31, 30, 31, 30, 31 +}; + +/* + * Variables used to remember parts of the last time conversion. Maybe we + * can avoid a full conversion. + */ +u_long lasttime; +u_long lastday; +u_short lastddate; +u_short lastdtime; + +/* + * Convert the unix version of time to dos's idea of time to be used in + * file timestamps. The passed in unix time is assumed to be in GMT. + */ +void +unix2dostime(tsp, ddp, dtp) + struct timespec *tsp; + u_short *ddp; + u_short *dtp; +{ + u_long t; + u_long days; + u_long inc; + u_long year; + u_long month; + u_short *months; + + /* + * If the time from the last conversion is the same as now, then + * skip the computations and use the saved result. + */ + t = tsp->ts_sec - (tz.tz_minuteswest * 60) + /* +- daylight savings time correction */ ; + if (lasttime != t) { + lasttime = t; + lastdtime = (((t % 60) >> 1) << DT_2SECONDS_SHIFT) + + (((t / 60) % 60) << DT_MINUTES_SHIFT) + + (((t / 3600) % 24) << DT_HOURS_SHIFT); + + /* + * If the number of days since 1970 is the same as the last + * time we did the computation then skip all this leap year + * and month stuff. + */ + days = t / (24 * 60 * 60); + if (days != lastday) { + lastday = days; + for (year = 1970;; year++) { + inc = year & 0x03 ? 365 : 366; + if (days < inc) + break; + days -= inc; + } + months = year & 0x03 ? regyear : leapyear; + for (month = 0; month < 12; month++) { + if (days < months[month]) + break; + days -= months[month]; + } + lastddate = ((days + 1) << DD_DAY_SHIFT) + + ((month + 1) << DD_MONTH_SHIFT); + /* + * Remember dos's idea of time is relative to 1980. + * unix's is relative to 1970. If somehow we get a + * time before 1980 then don't give totally crazy + * results. + */ + if (year > 1980) + lastddate += (year - 1980) << DD_YEAR_SHIFT; + } + } + *dtp = lastdtime; + *ddp = lastddate; +} + +/* + * The number of seconds between Jan 1, 1970 and Jan 1, 1980. In that + * interval there were 8 regular years and 2 leap years. + */ +#define SECONDSTO1980 (((8 * 365) + (2 * 366)) * (24 * 60 * 60)) + +u_short lastdosdate; +u_long lastseconds; + +/* + * Convert from dos' idea of time to unix'. This will probably only be + * called from the stat(), and fstat() system calls and so probably need + * not be too efficient. + */ +void +dos2unixtime(dd, dt, tsp) + u_short dd; + u_short dt; + struct timespec *tsp; +{ + u_long seconds; + u_long m, month; + u_long y, year; + u_long days; + u_short *months; + + seconds = ((dt & DT_2SECONDS_MASK) >> DT_2SECONDS_SHIFT) + + ((dt & DT_MINUTES_MASK) >> DT_MINUTES_SHIFT) * 60 + + ((dt & DT_HOURS_MASK) >> DT_HOURS_SHIFT) * 3600; + /* + * If the year, month, and day from the last conversion are the + * same then use the saved value. + */ + if (lastdosdate != dd) { + lastdosdate = dd; + days = 0; + year = (dd & DD_YEAR_MASK) >> DD_YEAR_SHIFT; + for (y = 0; y < year; y++) { + days += y & 0x03 ? 365 : 366; + } + months = year & 0x03 ? regyear : leapyear; + /* + * Prevent going from 0 to 0xffffffff in the following + * loop. + */ + month = (dd & DD_MONTH_MASK) >> DD_MONTH_SHIFT; + if (month == 0) { + printf("dos2unixtime(): month value out of range (%d)\n", + month); + month = 1; + } + for (m = 0; m < month - 1; m++) { + days += months[m]; + } + days += ((dd & DD_DAY_MASK) >> DD_DAY_SHIFT) - 1; + lastseconds = (days * 24 * 60 * 60) + SECONDSTO1980; + } + tsp->ts_sec = seconds + lastseconds + (tz.tz_minuteswest * 60) + /* -+ daylight savings time correction */ ; + tsp->ts_nsec = 0; +} + +/* + * Cheezy macros to do case detection and conversion for the ascii + * character set. DOESN'T work for ebcdic. + */ +#define isupper(c) (c >= 'A' && c <= 'Z') +#define islower(c) (c >= 'a' && c <= 'z') +#define toupper(c) (c & ~' ') +#define tolower(c) (c | ' ') + +/* + * DOS filenames are made of 2 parts, the name part and the extension part. + * The name part is 8 characters long and the extension part is 3 + * characters long. They may contain trailing blanks if the name or + * extension are not long enough to fill their respective fields. + */ + +/* + * Convert a DOS filename to a unix filename. And, return the number of + * characters in the resulting unix filename excluding the terminating + * null. + */ +int +dos2unixfn(dn, un) + u_char dn[11]; + u_char *un; +{ + int i; + int ni; + int ei; + int thislong = 0; + u_char c; + u_char *origun = un; + + /* + * Find the last character in the name portion of the dos filename. + */ + for (ni = 7; ni >= 0; ni--) + if (dn[ni] != ' ') + break; + + /* + * Find the last character in the extension portion of the + * filename. + */ + for (ei = 10; ei >= 8; ei--) + if (dn[ei] != ' ') + break; + + /* + * Copy the name portion into the unix filename string. NOTE: DOS + * filenames are usually kept in upper case. To make it more unixy + * we convert all DOS filenames to lower case. Some may like this, + * some may not. + */ + for (i = 0; i <= ni; i++) { + c = dn[i]; + *un++ = isupper(c) ? tolower(c) : c; + thislong++; + } + + /* + * Now, if there is an extension then put in a period and copy in + * the extension. + */ + if (ei >= 8) { + *un++ = '.'; + thislong++; + for (i = 8; i <= ei; i++) { + c = dn[i]; + *un++ = isupper(c) ? tolower(c) : c; + thislong++; + } + } + *un++ = 0; + + /* + * If first char of the filename is SLOT_E5 (0x05), then the real + * first char of the filename should be 0xe5. But, they couldn't + * just have a 0xe5 mean 0xe5 because that is used to mean a freed + * directory slot. Another dos quirk. + */ + if (*origun == SLOT_E5) + *origun = 0xe5; + + return thislong; +} + +/* + * Convert a unix filename to a DOS filename. This function does not ensure + * that valid characters for a dos filename are supplied. + */ +void +unix2dosfn(un, dn, unlen) + u_char *un; + u_char dn[11]; + int unlen; +{ + int i; + u_char c; + + /* + * Fill the dos filename string with blanks. These are DOS's pad + * characters. + */ + for (i = 0; i <= 10; i++) + dn[i] = ' '; + + /* + * The filenames "." and ".." are handled specially, since they + * don't follow dos filename rules. + */ + if (un[0] == '.' && unlen == 1) { + dn[0] = '.'; + return; + } + if (un[0] == '.' && un[1] == '.' && unlen == 2) { + dn[0] = '.'; + dn[1] = '.'; + return; + } + + /* + * Copy the unix filename into the dos filename string upto the end + * of string, a '.', or 8 characters. Whichever happens first stops + * us. This forms the name portion of the dos filename. Fold to + * upper case. + */ + for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) { + dn[i] = islower(c) ? toupper(c) : c; + un++; + unlen--; + } + + /* + * If the first char of the filename is 0xe5, then translate it to + * 0x05. This is because 0xe5 is the marker for a deleted + * directory slot. I guess this means you can't have filenames + * that start with 0x05. I suppose we should check for this and + * doing something about it. + */ + if (dn[0] == SLOT_DELETED) + dn[0] = SLOT_E5; + + /* + * Strip any further characters up to a '.' or the end of the + * string. + */ + while (unlen && (c = *un)) { + un++; + unlen--; + /* Make sure we've skipped over the dot before stopping. */ + if (c == '.') + break; + } + + /* + * Copy in the extension part of the name, if any. Force to upper + * case. Note that the extension is allowed to contain '.'s. + * Filenames in this form are probably inaccessable under dos. + */ + for (i = 8; i <= 10 && unlen && (c = *un); i++) { + dn[i] = islower(c) ? toupper(c) : c; + un++; + unlen--; + } +} + +/* + * Get rid of these macros before someone discovers we are using such + * hideous things. + */ +#undef isupper +#undef islower +#undef toupper +#undef tolower diff --git a/sys/fs/msdosfs/msdosfs_denode.c b/sys/fs/msdosfs/msdosfs_denode.c new file mode 100644 index 0000000..6812863 --- /dev/null +++ b/sys/fs/msdosfs/msdosfs_denode.c @@ -0,0 +1,689 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_denode.c,v 1.9 1994/08/21 18:44:00 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/mount.h> +#include <sys/malloc.h> +#include <sys/proc.h> +#include <sys/buf.h> +#include <sys/vnode.h> +#include <sys/kernel.h> /* defines "time" */ + +#include <msdosfs/bpb.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/fat.h> + +struct denode **dehashtbl; +u_long dehash; /* size of hash table - 1 */ +#define DEHASH(dev, deno) (((dev) + (deno)) & dehash) + +int msdosfs_init() +{ + dehashtbl = hashinit(desiredvnodes/2, M_MSDOSFSMNT, &dehash); + return 0; +} + +static struct denode * +msdosfs_hashget(dev, dirclust, diroff) + dev_t dev; + u_long dirclust; + u_long diroff; +{ + struct denode *dep; + + for (;;) + for (dep = dehashtbl[DEHASH(dev, dirclust + diroff)];; + dep = dep->de_next) { + if (dep == NULL) + return NULL; + if (dirclust != dep->de_dirclust + || diroff != dep->de_diroffset + || dev != dep->de_dev + || dep->de_refcnt == 0) + continue; + if (dep->de_flag & DE_LOCKED) { + dep->de_flag |= DE_WANTED; + sleep((caddr_t)dep, PINOD); + break; + } + if (!vget(DETOV(dep), 1)) + return dep; + break; + } + /* NOTREACHED */ +} + +static void +msdosfs_hashins(dep) + struct denode *dep; +{ + struct denode **depp, *deq; + + depp = &dehashtbl[DEHASH(dep->de_dev, dep->de_dirclust + dep->de_diroffset)]; + if (deq = *depp) + deq->de_prev = &dep->de_next; + dep->de_next = deq; + dep->de_prev = depp; + *depp = dep; + if (dep->de_flag & DE_LOCKED) + panic("msdosfs_hashins: already locked"); + if (curproc) + dep->de_lockholder = curproc->p_pid; + else + dep->de_lockholder = -1; + dep->de_flag |= DE_LOCKED; +} + +static void +msdosfs_hashrem(dep) + struct denode *dep; +{ + struct denode *deq; + if (deq = dep->de_next) + deq->de_prev = dep->de_prev; + *dep->de_prev = deq; +#ifdef DIAGNOSTIC + dep->de_next = NULL; + dep->de_prev = NULL; +#endif +} + +/* + * If deget() succeeds it returns with the gotten denode locked(). + * + * pmp - address of msdosfsmount structure of the filesystem containing + * the denode of interest. The pm_dev field and the address of + * the msdosfsmount structure are used. + * dirclust - which cluster bp contains, if dirclust is 0 (root directory) + * diroffset is relative to the beginning of the root directory, + * otherwise it is cluster relative. + * diroffset - offset past begin of cluster of denode we want + * direntptr - address of the direntry structure of interest. If direntptr is + * NULL, the block is read if necessary. + * depp - returns the address of the gotten denode. + */ +int +deget(pmp, dirclust, diroffset, direntptr, depp) + struct msdosfsmount *pmp; /* so we know the maj/min number */ + u_long dirclust; /* cluster this dir entry came from */ + u_long diroffset; /* index of entry within the cluster */ + struct direntry *direntptr; + struct denode **depp; /* returns the addr of the gotten denode */ +{ + int error; + dev_t dev = pmp->pm_dev; + struct mount *mntp = pmp->pm_mountp; + extern int (**msdosfs_vnodeop_p)(); + struct denode *ldep; + struct vnode *nvp; + struct buf *bp; + +#ifdef MSDOSFS_DEBUG + printf("deget(pmp %08x, dirclust %d, diroffset %x, direntptr %x, depp %08x)\n", + pmp, dirclust, diroffset, direntptr, depp); +#endif + + /* + * If dir entry is given and refers to a directory, convert to + * canonical form + */ + if (direntptr && (direntptr->deAttributes & ATTR_DIRECTORY)) { + dirclust = getushort(direntptr->deStartCluster); + if (dirclust == MSDOSFSROOT) + diroffset = MSDOSFSROOT_OFS; + else + diroffset = 0; + } + + /* + * See if the denode is in the denode cache. Use the location of + * the directory entry to compute the hash value. For subdir use + * address of "." entry. for root dir use cluster MSDOSFSROOT, + * offset MSDOSFSROOT_OFS + * + * NOTE: The check for de_refcnt > 0 below insures the denode being + * examined does not represent an unlinked but still open file. + * These files are not to be accessible even when the directory + * entry that represented the file happens to be reused while the + * deleted file is still open. + */ + if (ldep = msdosfs_hashget(dev, dirclust, diroffset)) { + *depp = ldep; + return 0; + } + + + /* + * Directory entry was not in cache, have to create a vnode and + * copy it from the passed disk buffer. + */ + /* getnewvnode() does a VREF() on the vnode */ + if (error = getnewvnode(VT_MSDOSFS, mntp, msdosfs_vnodeop_p, &nvp)) { + *depp = 0; + return error; + } + MALLOC(ldep, struct denode *, sizeof(struct denode), M_MSDOSFSNODE, M_WAITOK); + bzero((caddr_t)ldep, sizeof *ldep); + nvp->v_data = ldep; + ldep->de_vnode = nvp; + ldep->de_flag = 0; + ldep->de_devvp = 0; + ldep->de_lockf = 0; + ldep->de_dev = dev; + ldep->de_dirclust = dirclust; + ldep->de_diroffset = diroffset; + fc_purge(ldep, 0); /* init the fat cache for this denode */ + + /* + * Insert the denode into the hash queue and lock the denode so it + * can't be accessed until we've read it in and have done what we + * need to it. + */ + msdosfs_hashins(ldep); + + /* + * Copy the directory entry into the denode area of the vnode. + */ + if (dirclust == MSDOSFSROOT && diroffset == MSDOSFSROOT_OFS) { + /* + * Directory entry for the root directory. There isn't one, + * so we manufacture one. We should probably rummage + * through the root directory and find a label entry (if it + * exists), and then use the time and date from that entry + * as the time and date for the root denode. + */ + ldep->de_Attributes = ATTR_DIRECTORY; + ldep->de_StartCluster = MSDOSFSROOT; + ldep->de_FileSize = pmp->pm_rootdirsize * pmp->pm_BytesPerSec; + /* + * fill in time and date so that dos2unixtime() doesn't + * spit up when called from msdosfs_getattr() with root + * denode + */ + ldep->de_Time = 0x0000; /* 00:00:00 */ + ldep->de_Date = (0 << DD_YEAR_SHIFT) | (1 << DD_MONTH_SHIFT) + | (1 << DD_DAY_SHIFT); + /* Jan 1, 1980 */ + /* leave the other fields as garbage */ + } else { + bp = NULL; + if (!direntptr) { + error = readep(pmp, dirclust, diroffset, &bp, + &direntptr); + if (error) + return error; + } + DE_INTERNALIZE(ldep, direntptr); + if (bp) + brelse(bp); + } + + /* + * Fill in a few fields of the vnode and finish filling in the + * denode. Then return the address of the found denode. + */ + ldep->de_pmp = pmp; + ldep->de_devvp = pmp->pm_devvp; + ldep->de_refcnt = 1; + if (ldep->de_Attributes & ATTR_DIRECTORY) { + /* + * Since DOS directory entries that describe directories + * have 0 in the filesize field, we take this opportunity + * to find out the length of the directory and plug it into + * the denode structure. + */ + u_long size; + + nvp->v_type = VDIR; + if (ldep->de_StartCluster == MSDOSFSROOT) + nvp->v_flag |= VROOT; + else { + error = pcbmap(ldep, 0xffff, 0, &size); + if (error == E2BIG) { + ldep->de_FileSize = size << pmp->pm_cnshift; + error = 0; + } else + printf("deget(): pcbmap returned %d\n", error); + } + } else + nvp->v_type = VREG; + VREF(ldep->de_devvp); + *depp = ldep; + return 0; +} + +int +deupdat(dep, tp, waitfor) + struct denode *dep; + struct timespec *tp; + int waitfor; +{ + int error; + daddr_t bn; + int diro; + struct buf *bp; + struct direntry *dirp; + struct msdosfsmount *pmp = dep->de_pmp; + struct timespec ts; + struct vnode *vp = DETOV(dep); + +#ifdef MSDOSFS_DEBUG + printf("deupdat(): dep %08x\n", dep); +#endif + + /* + * If the update bit is off, or this denode is from a readonly + * filesystem, or this denode is for a directory, or the denode + * represents an open but unlinked file then don't do anything. DOS + * directory entries that describe a directory do not ever get + * updated. This is the way dos treats them. + */ + if ((dep->de_flag & DE_UPDATE) == 0 || + vp->v_mount->mnt_flag & MNT_RDONLY || + dep->de_Attributes & ATTR_DIRECTORY || + dep->de_refcnt <= 0) + return 0; + + /* + * Read in the cluster containing the directory entry we want to + * update. + */ + if (error = readde(dep, &bp, &dirp)) + return error; + + /* + * Put the passed in time into the directory entry. + */ + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &dep->de_Date, &dep->de_Time); + dep->de_flag &= ~DE_UPDATE; + + /* + * Copy the directory entry out of the denode into the cluster it + * came from. + */ + DE_EXTERNALIZE(dirp, dep); + + /* + * Write the cluster back to disk. If they asked for us to wait + * for the write to complete, then use bwrite() otherwise use + * bdwrite(). + */ + error = 0; /* note that error is 0 from above, but ... */ + if (waitfor) + error = bwrite(bp); + else + bdwrite(bp); + return error; +} + +/* + * Truncate the file described by dep to the length specified by length. + */ +int +detrunc(dep, length, flags, cred, p) + struct denode *dep; + u_long length; + int flags; + struct ucred *cred; + struct proc *p; +{ + int error; + int allerror; + int vflags; + u_long eofentry; + u_long chaintofree; + daddr_t bn; + int boff; + int isadir = dep->de_Attributes & ATTR_DIRECTORY; + struct buf *bp; + struct msdosfsmount *pmp = dep->de_pmp; + +#ifdef MSDOSFS_DEBUG + printf("detrunc(): file %s, length %d, flags %d\n", dep->de_Name, length, flags); +#endif + + /* + * Disallow attempts to truncate the root directory since it is of + * fixed size. That's just the way dos filesystems are. We use + * the VROOT bit in the vnode because checking for the directory + * bit and a startcluster of 0 in the denode is not adequate to + * recognize the root directory at this point in a file or + * directory's life. + */ + if (DETOV(dep)->v_flag & VROOT) { + printf("detrunc(): can't truncate root directory, clust %d, offset %d\n", + dep->de_dirclust, dep->de_diroffset); + return EINVAL; + } + + vnode_pager_setsize(DETOV(dep), length); + + if (dep->de_FileSize < length) + return deextend(dep, length, cred); + + /* + * If the desired length is 0 then remember the starting cluster of + * the file and set the StartCluster field in the directory entry + * to 0. If the desired length is not zero, then get the number of + * the last cluster in the shortened file. Then get the number of + * the first cluster in the part of the file that is to be freed. + * Then set the next cluster pointer in the last cluster of the + * file to CLUST_EOFE. + */ + if (length == 0) { + chaintofree = dep->de_StartCluster; + dep->de_StartCluster = 0; + eofentry = ~0; + } else { + if (error = pcbmap(dep, de_clcount(pmp, length) - 1, 0, &eofentry)) { +#ifdef MSDOSFS_DEBUG + printf("detrunc(): pcbmap fails %d\n", error); +#endif + return error; + } + } + + fc_purge(dep, (length + pmp->pm_crbomask) >> pmp->pm_cnshift); + + /* + * If the new length is not a multiple of the cluster size then we + * must zero the tail end of the new last cluster in case it + * becomes part of the file again because of a seek. + */ + if ((boff = length & pmp->pm_crbomask) != 0) { + /* + * should read from file vnode or filesystem vnode + * depending on if file or dir + */ + if (isadir) { + bn = cntobn(pmp, eofentry); + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, + NOCRED, &bp); + } else { + bn = de_blk(pmp, length); + error = bread(DETOV(dep), bn, pmp->pm_bpcluster, + NOCRED, &bp); + } + if (error) { +#ifdef MSDOSFS_DEBUG + printf("detrunc(): bread fails %d\n", error); +#endif + return error; + } + vnode_pager_uncache(DETOV(dep)); /* what's this for? */ + /* + * is this the right place for it? + */ + bzero(bp->b_data + boff, pmp->pm_bpcluster - boff); + if (flags & IO_SYNC) + bwrite(bp); + else + bdwrite(bp); + } + + /* + * Write out the updated directory entry. Even if the update fails + * we free the trailing clusters. + */ + dep->de_FileSize = length; + dep->de_flag |= DE_UPDATE; + vflags = (length > 0 ? V_SAVE : 0) | V_SAVEMETA; + vinvalbuf(DETOV(dep), vflags, cred, p, 0, 0); + allerror = deupdat(dep, &time, 1); +#ifdef MSDOSFS_DEBUG + printf("detrunc(): allerror %d, eofentry %d\n", + allerror, eofentry); +#endif + + /* + * If we need to break the cluster chain for the file then do it + * now. + */ + if (eofentry != ~0) { + error = fatentry(FAT_GET_AND_SET, pmp, eofentry, + &chaintofree, CLUST_EOFE); + if (error) { +#ifdef MSDOSFS_DEBUG + printf("detrunc(): fatentry errors %d\n", error); +#endif + return error; + } + fc_setcache(dep, FC_LASTFC, (length - 1) >> pmp->pm_cnshift, + eofentry); + } + + /* + * Now free the clusters removed from the file because of the + * truncation. + */ + if (chaintofree != 0 && !MSDOSFSEOF(chaintofree)) + freeclusterchain(pmp, chaintofree); + + return allerror; +} + +/* + * Extend the file described by dep to length specified by length. + */ +int +deextend(dep, length, cred) + struct denode *dep; + off_t length; + struct ucred *cred; +{ + struct msdosfsmount *pmp = dep->de_pmp; + u_long count; + int error; + + /* + * The root of a DOS filesystem cannot be extended. + */ + if (DETOV(dep)->v_flag & VROOT) + return EINVAL; + + /* + * Directories can only be extended by the superuser. + * Is this really important? + */ + if (dep->de_Attributes & ATTR_DIRECTORY) { + if (error = suser(cred, NULL)) + return error; + } + + if (length <= dep->de_FileSize) + panic("deextend: file too large"); + + /* + * Compute the number of clusters to allocate. + */ + count = de_clcount(pmp, length) - de_clcount(pmp, dep->de_FileSize); + if (count > 0) { + if (count > pmp->pm_freeclustercount) + return ENOSPC; + if (error = extendfile(dep, count, NULL, NULL, DE_CLEAR)) { + /* truncate the added clusters away again */ + (void) detrunc(dep, dep->de_FileSize, 0, cred, NULL); + return error; + } + } + + dep->de_flag |= DE_UPDATE; + dep->de_FileSize = length; + return deupdat(dep, &time, 1); +} + +/* + * Move a denode to its correct hash queue after the file it represents has + * been moved to a new directory. + */ +int reinsert(dep) + struct denode *dep; +{ + union dehead *deh; + + /* + * Fix up the denode cache. If the denode is for a directory, + * there is nothing to do since the hash is based on the starting + * cluster of the directory file and that hasn't changed. If for a + * file the hash is based on the location of the directory entry, + * so we must remove it from the cache and re-enter it with the + * hash based on the new location of the directory entry. + */ + if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) { + msdosfs_hashrem(dep); + msdosfs_hashins(dep); + } + return 0; +} + +int +msdosfs_reclaim(ap) + struct vop_reclaim_args /* { + struct vnode *a_vp; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + int i; + extern int prtactive; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_reclaim(): dep %08x, file %s, refcnt %d\n", + dep, dep->de_Name, dep->de_refcnt); +#endif + + if (prtactive && vp->v_usecount != 0) + vprint("msdosfs_reclaim(): pushing active", vp); + + /* + * Remove the denode from the denode hash chain we are in. + */ + msdosfs_hashrem(dep); + + cache_purge(vp); + /* + * Indicate that one less file on the filesystem is open. + */ + if (dep->de_devvp) { + vrele(dep->de_devvp); + dep->de_devvp = 0; + } + + dep->de_flag = 0; + + FREE(dep, M_MSDOSFSNODE); + vp->v_data = NULL; + + return 0; +} + +int +msdosfs_inactive(ap) + struct vop_inactive_args /* { + struct vnode *a_vp; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + int error = 0; + extern int prtactive; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_inactive(): dep %08x, de_Name[0] %x\n", dep, dep->de_Name[0]); +#endif + + if (prtactive && vp->v_usecount != 0) + vprint("msdosfs_inactive(): pushing active", vp); + + /* + * Get rid of denodes related to stale file handles. Hmmm, what + * does this really do? + */ + if (dep->de_Name[0] == SLOT_DELETED) { + if ((vp->v_flag & VXLOCK) == 0) + vgone(vp); + return 0; + } + + /* + * If the file has been deleted and it is on a read/write + * filesystem, then truncate the file, and mark the directory slot + * as empty. (This may not be necessary for the dos filesystem.) + */ +#ifdef MSDOSFS_DEBUG + printf("msdosfs_inactive(): dep %08x, refcnt %d, mntflag %x, MNT_RDONLY %x\n", + dep, dep->de_refcnt, vp->v_mount->mnt_flag, MNT_RDONLY); +#endif + VOP_LOCK(vp); + if (dep->de_refcnt <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { + error = detrunc(dep, (u_long) 0, 0, NOCRED, NULL); + dep->de_flag |= DE_UPDATE; + dep->de_Name[0] = SLOT_DELETED; + } + DE_UPDAT(dep, &time, 0); + VOP_UNLOCK(vp); + dep->de_flag = 0; + + /* + * If we are done with the denode, then reclaim it so that it can + * be reused now. + */ +#ifdef MSDOSFS_DEBUG + printf("msdosfs_inactive(): v_usecount %d, de_Name[0] %x\n", vp->v_usecount, + dep->de_Name[0]); +#endif + if (vp->v_usecount == 0 && dep->de_Name[0] == SLOT_DELETED) + vgone(vp); + return error; +} diff --git a/sys/fs/msdosfs/msdosfs_fat.c b/sys/fs/msdosfs/msdosfs_fat.c new file mode 100644 index 0000000..9a2f117 --- /dev/null +++ b/sys/fs/msdosfs/msdosfs_fat.c @@ -0,0 +1,984 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_fat.c,v 1.12 1994/08/21 18:44:04 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * kernel include files. + */ +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/buf.h> +#include <sys/file.h> +#include <sys/namei.h> +#include <sys/mount.h> /* to define statfs structure */ +#include <sys/vnode.h> /* to define vattr structure */ +#include <sys/errno.h> + +/* + * msdosfs include files. + */ +#include <msdosfs/bpb.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/fat.h> + +/* + * Fat cache stats. + */ +int fc_fileextends; /* # of file extends */ +int fc_lfcempty; /* # of time last file cluster cache entry + * was empty */ +int fc_bmapcalls; /* # of times pcbmap was called */ + +#define LMMAX 20 +int fc_lmdistance[LMMAX]; /* counters for how far off the last + * cluster mapped entry was. */ +int fc_largedistance; /* off by more than LMMAX */ + +/* Byte offset in FAT on filesystem pmp, cluster cn */ +#define FATOFS(pmp, cn) (FAT12(pmp) ? (cn) * 3 / 2 : (cn) * 2) + +void fc_lookup(struct denode *dep, u_long findcn, + u_long *frcnp, u_long *fsrcnp); +void fc_purge(struct denode *dep, u_int frcn); + +static void +fatblock(pmp, ofs, bnp, sizep, bop) + struct msdosfsmount *pmp; + u_long ofs; + u_long *bnp; + u_long *sizep; + u_long *bop; +{ + u_long bn, size; + + bn = ofs / pmp->pm_fatblocksize * pmp->pm_fatblocksec; + size = min(pmp->pm_fatblocksec, pmp->pm_FATsecs - bn) + * pmp->pm_BytesPerSec; + bn += pmp->pm_fatblk; + if (bnp) + *bnp = bn; + if (sizep) + *sizep = size; + if (bop) + *bop = ofs % pmp->pm_fatblocksize; +} + +/* + * Map the logical cluster number of a file into a physical disk sector + * that is filesystem relative. + * + * dep - address of denode representing the file of interest + * findcn - file relative cluster whose filesystem relative cluster number + * and/or block number are/is to be found + * bnp - address of where to place the file system relative block number. + * If this pointer is null then don't return this quantity. + * cnp - address of where to place the file system relative cluster number. + * If this pointer is null then don't return this quantity. + * + * NOTE: Either bnp or cnp must be non-null. + * This function has one side effect. If the requested file relative cluster + * is beyond the end of file, then the actual number of clusters in the file + * is returned in *cnp. This is useful for determining how long a directory is. + * If cnp is null, nothing is returned. + */ +int +pcbmap(dep, findcn, bnp, cnp) + struct denode *dep; + u_long findcn; /* file relative cluster to get */ + daddr_t *bnp; /* returned filesys relative blk number */ + u_long *cnp; /* returned cluster number */ +{ + int error; + u_long i; + u_long cn; + u_long prevcn; + u_long byteoffset; + u_long bn; + u_long bo; + struct buf *bp = NULL; + u_long bp_bn = -1; + struct msdosfsmount *pmp = dep->de_pmp; + u_long bsize; + int fat12 = FAT12(pmp); /* 12 bit fat */ + + fc_bmapcalls++; + + /* + * If they don't give us someplace to return a value then don't + * bother doing anything. + */ + if (bnp == NULL && cnp == NULL) + return 0; + + cn = dep->de_StartCluster; + /* + * The "file" that makes up the root directory is contiguous, + * permanently allocated, of fixed size, and is not made up of + * clusters. If the cluster number is beyond the end of the root + * directory, then return the number of clusters in the file. + */ + if (cn == MSDOSFSROOT) { + if (dep->de_Attributes & ATTR_DIRECTORY) { + if (findcn * pmp->pm_SectPerClust > pmp->pm_rootdirsize) { + if (cnp) + *cnp = pmp->pm_rootdirsize / pmp->pm_SectPerClust; + return E2BIG; + } + if (bnp) + *bnp = pmp->pm_rootdirblk + (findcn * pmp->pm_SectPerClust); + if (cnp) + *cnp = MSDOSFSROOT; + return 0; + } else { /* just an empty file */ + if (cnp) + *cnp = 0; + return E2BIG; + } + } + + /* + * Rummage around in the fat cache, maybe we can avoid tromping + * thru every fat entry for the file. And, keep track of how far + * off the cache was from where we wanted to be. + */ + i = 0; + fc_lookup(dep, findcn, &i, &cn); + if ((bn = findcn - i) >= LMMAX) + fc_largedistance++; + else + fc_lmdistance[bn]++; + + /* + * Handle all other files or directories the normal way. + */ + prevcn = 0; + for (; i < findcn; i++) { + if (MSDOSFSEOF(cn)) + goto hiteof; + byteoffset = FATOFS(pmp, cn); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (bn != bp_bn) { + if (bp) + brelse(bp); + error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp); + if (error) + return error; + bp_bn = bn; + } + prevcn = cn; + cn = getushort(&bp->b_data[bo]); + if (fat12) { + if (prevcn & 1) + cn >>= 4; + cn &= 0x0fff; + /* + * Force the special cluster numbers in the range + * 0x0ff0-0x0fff to be the same as for 16 bit + * cluster numbers to let the rest of msdosfs think + * it is always dealing with 16 bit fats. + */ + if ((cn & 0x0ff0) == 0x0ff0) + cn |= 0xf000; + } + } + + if (!MSDOSFSEOF(cn)) { + if (bp) + brelse(bp); + if (bnp) + *bnp = cntobn(pmp, cn); + if (cnp) + *cnp = cn; + fc_setcache(dep, FC_LASTMAP, i, cn); + return 0; + } + +hiteof:; + if (cnp) + *cnp = i; + if (bp) + brelse(bp); + /* update last file cluster entry in the fat cache */ + fc_setcache(dep, FC_LASTFC, i - 1, prevcn); + return E2BIG; +} + +/* + * Find the closest entry in the fat cache to the cluster we are looking + * for. + */ +void fc_lookup(dep, findcn, frcnp, fsrcnp) + struct denode *dep; + u_long findcn; + u_long *frcnp; + u_long *fsrcnp; +{ + int i; + u_long cn; + struct fatcache *closest = 0; + + for (i = 0; i < FC_SIZE; i++) { + cn = dep->de_fc[i].fc_frcn; + if (cn != FCE_EMPTY && cn <= findcn) { + if (closest == 0 || cn > closest->fc_frcn) + closest = &dep->de_fc[i]; + } + } + if (closest) { + *frcnp = closest->fc_frcn; + *fsrcnp = closest->fc_fsrcn; + } +} + +/* + * Purge the fat cache in denode dep of all entries relating to file + * relative cluster frcn and beyond. + */ +void fc_purge(dep, frcn) + struct denode *dep; + u_int frcn; +{ + int i; + struct fatcache *fcp; + + fcp = dep->de_fc; + for (i = 0; i < FC_SIZE; i++, fcp++) { + if (fcp->fc_frcn >= frcn) + fcp->fc_frcn = FCE_EMPTY; + } +} + +/* + * Update all copies of the fat. The first copy is updated last. + * + * pmp - msdosfsmount structure for filesystem to update + * bp - addr of modified fat block + * fatbn - block number relative to begin of filesystem of the modified fat block. + */ +void +updatefats(pmp, bp, fatbn) + struct msdosfsmount *pmp; + struct buf *bp; + u_long fatbn; +{ + int i; + struct buf *bpn; + +#ifdef MSDOSFS_DEBUG + printf("updatefats(pmp %08x, bp %08x, fatbn %d)\n", + pmp, bp, fatbn); +#endif + + /* + * Now copy the block(s) of the modified fat to the other copies of + * the fat and write them out. This is faster than reading in the + * other fats and then writing them back out. This could tie up + * the fat for quite a while. Preventing others from accessing it. + * To prevent us from going after the fat quite so much we use + * delayed writes, unless they specfied "synchronous" when the + * filesystem was mounted. If synch is asked for then use + * bwrite()'s and really slow things down. + */ + for (i = 1; i < pmp->pm_FATs; i++) { + fatbn += pmp->pm_FATsecs; + /* getblk() never fails */ + bpn = getblk(pmp->pm_devvp, fatbn, bp->b_bcount, 0, 0); + bcopy(bp->b_data, bpn->b_data, bp->b_bcount); + if (pmp->pm_waitonfat) + bwrite(bpn); + else + bdwrite(bpn); + } + /* + * Write out the first fat last. + */ + if (pmp->pm_waitonfat) + bwrite(bp); + else + bdwrite(bp); +} + +/* + * Updating entries in 12 bit fats is a pain in the butt. + * + * The following picture shows where nibbles go when moving from a 12 bit + * cluster number into the appropriate bytes in the FAT. + * + * byte m byte m+1 byte m+2 + * +----+----+ +----+----+ +----+----+ + * | 0 1 | | 2 3 | | 4 5 | FAT bytes + * +----+----+ +----+----+ +----+----+ + * + * +----+----+----+ +----+----+----+ + * | 3 0 1 | | 4 5 2 | + * +----+----+----+ +----+----+----+ + * cluster n cluster n+1 + * + * Where n is even. m = n + (n >> 2) + * + */ +extern __inline void +usemap_alloc(pmp, cn) + struct msdosfsmount *pmp; + u_long cn; +{ + pmp->pm_inusemap[cn / N_INUSEBITS] + |= 1 << (cn % N_INUSEBITS); + pmp->pm_freeclustercount--; +} + +extern __inline void +usemap_free(pmp, cn) + struct msdosfsmount *pmp; + u_long cn; +{ + pmp->pm_freeclustercount++; + pmp->pm_inusemap[cn / N_INUSEBITS] &= ~(1 << (cn % N_INUSEBITS)); +} + +int +clusterfree(pmp, cluster, oldcnp) + struct msdosfsmount *pmp; + u_long cluster; + u_long *oldcnp; +{ + int error; + u_long oldcn; + + error = fatentry(FAT_GET_AND_SET, pmp, cluster, &oldcn, MSDOSFSFREE); + if (error == 0) { + /* + * If the cluster was successfully marked free, then update + * the count of free clusters, and turn off the "allocated" + * bit in the "in use" cluster bit map. + */ + usemap_free(pmp, cluster); + if (oldcnp) + *oldcnp = oldcn; + } + return error; +} + +/* + * Get or Set or 'Get and Set' the cluster'th entry in the fat. + * + * function - whether to get or set a fat entry + * pmp - address of the msdosfsmount structure for the filesystem + * whose fat is to be manipulated. + * cn - which cluster is of interest + * oldcontents - address of a word that is to receive the contents of the + * cluster'th entry if this is a get function + * newcontents - the new value to be written into the cluster'th element of + * the fat if this is a set function. + * + * This function can also be used to free a cluster by setting the fat entry + * for a cluster to 0. + * + * All copies of the fat are updated if this is a set function. NOTE: If + * fatentry() marks a cluster as free it does not update the inusemap in + * the msdosfsmount structure. This is left to the caller. + */ +int +fatentry(function, pmp, cn, oldcontents, newcontents) + int function; + struct msdosfsmount *pmp; + u_long cn; + u_long *oldcontents; + u_long newcontents; +{ + int error; + u_long readcn; + u_long bn, bo, bsize, byteoffset; + struct buf *bp; + + /* + * printf("fatentry(func %d, pmp %08x, clust %d, oldcon %08x, newcon %d)\n", + * function, pmp, cluster, oldcontents, newcontents); + */ + +#ifdef DIAGNOSTIC + /* + * Be sure they asked us to do something. + */ + if ((function & (FAT_SET | FAT_GET)) == 0) { + printf("fatentry(): function code doesn't specify get or set\n"); + return EINVAL; + } + + /* + * If they asked us to return a cluster number but didn't tell us + * where to put it, give them an error. + */ + if ((function & FAT_GET) && oldcontents == NULL) { + printf("fatentry(): get function with no place to put result\n"); + return EINVAL; + } +#endif + + /* + * Be sure the requested cluster is in the filesystem. + */ + if (cn < CLUST_FIRST || cn > pmp->pm_maxcluster) + return EINVAL; + + byteoffset = FATOFS(pmp, cn); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp)) + return error; + + if (function & FAT_GET) { + readcn = getushort(&bp->b_data[bo]); + if (FAT12(pmp)) { + if (cn & 1) + readcn >>= 4; + readcn &= 0x0fff; + /* map certain 12 bit fat entries to 16 bit */ + if ((readcn & 0x0ff0) == 0x0ff0) + readcn |= 0xf000; + } + *oldcontents = readcn; + } + if (function & FAT_SET) { + if (FAT12(pmp)) { + readcn = getushort(&bp->b_data[bo]); + if (cn & 1) { + readcn &= 0x000f; + readcn |= newcontents << 4; + } else { + readcn &= 0xf000; + readcn |= newcontents & 0xfff; + } + putushort(&bp->b_data[bo], readcn); + } else + putushort(&bp->b_data[bo], newcontents); + updatefats(pmp, bp, bn); + bp = NULL; + pmp->pm_fmod = 1; + } + if (bp) + brelse(bp); + return 0; +} + +/* + * Update a contiguous cluster chain + * + * pmp - mount point + * start - first cluster of chain + * count - number of clusters in chain + * fillwith - what to write into fat entry of last cluster + */ +static int +fatchain(pmp, start, count, fillwith) + struct msdosfsmount *pmp; + u_long start; + u_long count; + u_long fillwith; +{ + int error; + u_long bn, bo, bsize, byteoffset, readcn, newc; + struct buf *bp; + +#ifdef MSDOSFS_DEBUG + printf("fatchain(pmp %08x, start %d, count %d, fillwith %d)\n", + pmp, start, count, fillwith); +#endif + /* + * Be sure the clusters are in the filesystem. + */ + if (start < CLUST_FIRST || start + count - 1 > pmp->pm_maxcluster) + return EINVAL; + + while (count > 0) { + byteoffset = FATOFS(pmp, start); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp)) + return error; + while (count > 0) { + start++; + newc = --count > 0 ? start : fillwith; + if (FAT12(pmp)) { + readcn = getushort(&bp->b_data[bo]); + if (start & 1) { + readcn &= 0xf000; + readcn |= newc & 0xfff; + } else { + readcn &= 0x000f; + readcn |= newc << 4; + } + putushort(&bp->b_data[bo], readcn); + bo++; + if (!(start & 1)) + bo++; + } else { + putushort(&bp->b_data[bo], newc); + bo += 2; + } + if (bo >= bsize) + break; + } + updatefats(pmp, bp, bn); + } + pmp->pm_fmod = 1; + return 0; +} + +/* + * Check the length of a free cluster chain starting at start. + * + * pmp - mount point + * start - start of chain + * count - maximum interesting length + */ +int +chainlength(pmp, start, count) + struct msdosfsmount *pmp; + u_long start; + u_long count; +{ + u_long idx, max_idx; + u_int map; + u_long len; + + max_idx = pmp->pm_maxcluster / N_INUSEBITS; + idx = start / N_INUSEBITS; + start %= N_INUSEBITS; + map = pmp->pm_inusemap[idx]; + map &= ~((1 << start) - 1); + if (map) { + len = ffs(map) - 1 - start; + return len > count ? count : len; + } + len = N_INUSEBITS - start; + if (len >= count) + return count; + while (++idx <= max_idx) { + if (len >= count) + break; + if (map = pmp->pm_inusemap[idx]) { + len += ffs(map) - 1; + break; + } + len += N_INUSEBITS; + } + return len > count ? count : len; +} + +/* + * Allocate contigous free clusters. + * + * pmp - mount point. + * start - start of cluster chain. + * count - number of clusters to allocate. + * fillwith - put this value into the fat entry for the + * last allocated cluster. + * retcluster - put the first allocated cluster's number here. + * got - how many clusters were actually allocated. + */ +int +chainalloc(pmp, start, count, fillwith, retcluster, got) + struct msdosfsmount *pmp; + u_long start; + u_long count; + u_long fillwith; + u_long *retcluster; + u_long *got; +{ + int error; + + error = fatchain(pmp, start, count, fillwith); + if (error == 0) { +#ifdef MSDOSFS_DEBUG + printf("clusteralloc(): allocated cluster chain at %d (%d clusters)\n", + start, count); +#endif + if (retcluster) + *retcluster = start; + if (got) + *got = count; + while (count-- > 0) + usemap_alloc(pmp, start++); + } + return error; +} + +/* + * Allocate contiguous free clusters. + * + * pmp - mount point. + * start - preferred start of cluster chain. + * count - number of clusters requested. + * fillwith - put this value into the fat entry for the + * last allocated cluster. + * retcluster - put the first allocated cluster's number here. + * got - how many clusters were actually allocated. + */ +int +clusteralloc(pmp, start, count, fillwith, retcluster, got) + struct msdosfsmount *pmp; + u_long start; + u_long count; + u_long fillwith; + u_long *retcluster; + u_long *got; +{ + int error; + u_long idx; + u_long len, newst, foundcn, foundl, cn, l; + u_int map; + +#ifdef MSDOSFS_DEBUG + printf("clusteralloc(): find %d clusters\n",count); +#endif + if (start) { + if ((len = chainlength(pmp, start, count)) >= count) + return chainalloc(pmp, start, count, fillwith, retcluster, got); + } else { + /* + * This is a new file, initialize start + */ + struct timeval tv; + + microtime(&tv); + start = (tv.tv_usec >> 10)|tv.tv_usec; + len = 0; + } + + /* + * Start at a (pseudo) random place to maximize cluster runs + * under multiple writers. + */ + foundcn = newst = (start * 1103515245 + 12345) % (pmp->pm_maxcluster + 1); + foundl = 0; + + for (cn = newst; cn <= pmp->pm_maxcluster;) { + idx = cn / N_INUSEBITS; + map = pmp->pm_inusemap[idx]; + map |= (1 << (cn % N_INUSEBITS)) - 1; + if (map != (u_int)-1) { + cn = idx * N_INUSEBITS + ffs(map^(u_int)-1) - 1; + if ((l = chainlength(pmp, cn, count)) >= count) + return chainalloc(pmp, cn, count, fillwith, retcluster, got); + if (l > foundl) { + foundcn = cn; + foundl = l; + } + cn += l + 1; + continue; + } + cn += N_INUSEBITS - cn % N_INUSEBITS; + } + for (cn = 0; cn < newst;) { + idx = cn / N_INUSEBITS; + map = pmp->pm_inusemap[idx]; + map |= (1 << (cn % N_INUSEBITS)) - 1; + if (map != (u_int)-1) { + cn = idx * N_INUSEBITS + ffs(map^(u_int)-1) - 1; + if ((l = chainlength(pmp, cn, count)) >= count) + return chainalloc(pmp, cn, count, fillwith, retcluster, got); + if (l > foundl) { + foundcn = cn; + foundl = l; + } + cn += l + 1; + continue; + } + cn += N_INUSEBITS - cn % N_INUSEBITS; + } + + if (!foundl) + return ENOSPC; + + if (len) + return chainalloc(pmp, start, len, fillwith, retcluster, got); + else + return chainalloc(pmp, foundcn, foundl, fillwith, retcluster, got); +} + + +/* + * Free a chain of clusters. + * + * pmp - address of the msdosfs mount structure for the filesystem + * containing the cluster chain to be freed. + * startcluster - number of the 1st cluster in the chain of clusters to be + * freed. + */ +int +freeclusterchain(pmp, cluster) + struct msdosfsmount *pmp; + u_long cluster; +{ + int error = 0; + struct buf *bp = NULL; + u_long bn, bo, bsize, byteoffset; + u_long readcn, lbn = -1; + + while (cluster >= CLUST_FIRST && cluster <= pmp->pm_maxcluster) { + byteoffset = FATOFS(pmp, cluster); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (lbn != bn) { + if (bp) + updatefats(pmp, bp, bn); + if (error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp)) + return error; + lbn = bn; + } + usemap_free(pmp, cluster); + readcn = getushort(&bp->b_data[bo]); + if (FAT12(pmp)) { + if (cluster & 1) { + cluster = readcn >> 4; + readcn &= 0x000f; + readcn |= MSDOSFSFREE << 4; + } else { + cluster = readcn; + readcn &= 0xf000; + readcn |= MSDOSFSFREE & 0xfff; + } + putushort(&bp->b_data[bo], readcn); + cluster &= 0x0fff; + if ((cluster&0x0ff0) == 0x0ff0) + cluster |= 0xf000; + } else { + cluster = readcn; + putushort(&bp->b_data[bo], MSDOSFSFREE); + } + } + if (bp) + updatefats(pmp, bp, bn); + return error; +} + +/* + * Read in fat blocks looking for free clusters. For every free cluster + * found turn off its corresponding bit in the pm_inusemap. + */ +int +fillinusemap(pmp) + struct msdosfsmount *pmp; +{ + struct buf *bp = NULL; + u_long cn, readcn; + int error; + int fat12 = FAT12(pmp); + u_long bn, bo, bsize, byteoffset; + + /* + * Mark all clusters in use, we mark the free ones in the fat scan + * loop further down. + */ + for (cn = 0; cn < (pmp->pm_maxcluster + N_INUSEBITS) / N_INUSEBITS; cn++) + pmp->pm_inusemap[cn] = (u_int)-1; + + /* + * Figure how many free clusters are in the filesystem by ripping + * through the fat counting the number of entries whose content is + * zero. These represent free clusters. + */ + pmp->pm_freeclustercount = 0; + for (cn = CLUST_FIRST; cn <= pmp->pm_maxcluster; cn++) { + byteoffset = FATOFS(pmp, cn); + bo = byteoffset % pmp->pm_fatblocksize; + if (!bo || !bp) { + /* Read new FAT block */ + if (bp) + brelse(bp); + fatblock(pmp, byteoffset, &bn, &bsize, NULL); + error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp); + if (error) + return error; + } + readcn = getushort(&bp->b_data[bo]); + if (fat12) { + if (cn & 1) + readcn >>= 4; + readcn &= 0x0fff; + } + + if (readcn == 0) + usemap_free(pmp, cn); + } + brelse(bp); + return 0; +} + +/* + * Allocate a new cluster and chain it onto the end of the file. + * + * dep - the file to extend + * count - number of clusters to allocate + * bpp - where to return the address of the buf header for the first new + * file block + * ncp - where to put cluster number of the first newly allocated cluster + * If this pointer is 0, do not return the cluster number. + * flags - see fat.h + * + * NOTE: This function is not responsible for turning on the DE_UPDATE bit of + * the de_flag field of the denode and it does not change the de_FileSize + * field. This is left for the caller to do. + */ +int +extendfile(dep, count, bpp, ncp, flags) + struct denode *dep; + u_long count; + struct buf **bpp; + u_long *ncp; + int flags; +{ + int error = 0; + u_long frcn; + u_long cn, got; + struct msdosfsmount *pmp = dep->de_pmp; + struct buf *bp; + + /* + * Don't try to extend the root directory + */ + if (DETOV(dep)->v_flag & VROOT) { + printf("extendfile(): attempt to extend root directory\n"); + return ENOSPC; + } + + /* + * If the "file's last cluster" cache entry is empty, and the file + * is not empty, then fill the cache entry by calling pcbmap(). + */ + fc_fileextends++; + if (dep->de_fc[FC_LASTFC].fc_frcn == FCE_EMPTY && + dep->de_StartCluster != 0) { + fc_lfcempty++; + error = pcbmap(dep, 0xffff, 0, &cn); + /* we expect it to return E2BIG */ + if (error != E2BIG) + return error; + error = 0; + } + + while (count > 0) { + /* + * Allocate a new cluster chain and cat onto the end of the file. + * If the file is empty we make de_StartCluster point to the new + * block. Note that de_StartCluster being 0 is sufficient to be + * sure the file is empty since we exclude attempts to extend the + * root directory above, and the root dir is the only file with a + * startcluster of 0 that has blocks allocated (sort of). + */ + if (dep->de_StartCluster == 0) + cn = 0; + else + cn = dep->de_fc[FC_LASTFC].fc_fsrcn + 1; + if (error = clusteralloc(pmp, cn, count, CLUST_EOFE, &cn, &got)) + return error; + + count -= got; + + /* + * Give them the filesystem relative cluster number if they want + * it. + */ + if (ncp) { + *ncp = cn; + ncp = NULL; + } + + if (dep->de_StartCluster == 0) { + dep->de_StartCluster = cn; + frcn = 0; + } else { + error = fatentry(FAT_SET, pmp, dep->de_fc[FC_LASTFC].fc_fsrcn, + 0, cn); + if (error) { + clusterfree(pmp, cn, NULL); + return error; + } + + frcn = dep->de_fc[FC_LASTFC].fc_frcn + 1; + } + + /* + * Update the "last cluster of the file" entry in the denode's fat + * cache. + */ + fc_setcache(dep, FC_LASTFC, frcn + got - 1, cn + got - 1); + + if (flags & DE_CLEAR) { + while (got-- > 0) { + /* + * Get the buf header for the new block of the file. + */ + if (dep->de_Attributes & ATTR_DIRECTORY) + bp = getblk(pmp->pm_devvp, cntobn(pmp, cn++), + pmp->pm_bpcluster, 0, 0); + else { + bp = getblk(DETOV(dep), frcn++, pmp->pm_bpcluster, 0, 0); + /* + * Do the bmap now, as in msdosfs_write + */ + if (pcbmap(dep, bp->b_lblkno, &bp->b_blkno, 0)) + bp->b_blkno = -1; + if (bp->b_blkno == -1) + panic("extendfile: pcbmap"); + } + clrbuf(bp); + if (bpp) { + *bpp = bp; + bpp = NULL; + } else { + bp->b_flags |= B_AGE; + bawrite(bp); + } + } + } + } + + return 0; +} diff --git a/sys/fs/msdosfs/msdosfs_lookup.c b/sys/fs/msdosfs/msdosfs_lookup.c new file mode 100644 index 0000000..c67f888 --- /dev/null +++ b/sys/fs/msdosfs/msdosfs_lookup.c @@ -0,0 +1,763 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_lookup.c,v 1.14 1994/08/21 18:44:07 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/namei.h> +#include <sys/buf.h> +#include <sys/vnode.h> +#include <sys/mount.h> + +#include <msdosfs/bpb.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/fat.h> + +/* + * When we search a directory the blocks containing directory entries are + * read and examined. The directory entries contain information that would + * normally be in the inode of a unix filesystem. This means that some of + * a directory's contents may also be in memory resident denodes (sort of + * an inode). This can cause problems if we are searching while some other + * process is modifying a directory. To prevent one process from accessing + * incompletely modified directory information we depend upon being the + * soul owner of a directory block. bread/brelse provide this service. + * This being the case, when a process modifies a directory it must first + * acquire the disk block that contains the directory entry to be modified. + * Then update the disk block and the denode, and then write the disk block + * out to disk. This way disk blocks containing directory entries and in + * memory denode's will be in synch. + */ +int +msdosfs_lookup(ap) + struct vop_lookup_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + } */ *ap; +{ + struct vnode *vdp = ap->a_dvp; + struct vnode **vpp = ap->a_vpp; + struct componentname *cnp = ap->a_cnp; + daddr_t bn; + int error; + int lockparent; + int wantparent; + int slotstatus; + +#define NONE 0 +#define FOUND 1 + int slotoffset = -1; + int slotcluster = -1; + int frcn; + u_long cluster; + int rootreloff; + int diroff; + int isadir; /* ~0 if found direntry is a directory */ + u_long scn; /* starting cluster number */ + struct vnode *pdp; + struct denode *dp; + struct denode *tdp; + struct msdosfsmount *pmp; + struct buf *bp = 0; + struct direntry *dep = NULL; + u_char dosfilename[12]; + int flags = cnp->cn_flags; + int nameiop = cnp->cn_nameiop; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): looking for %s\n", cnp->cn_nameptr); +#endif + dp = VTODE(vdp); + pmp = dp->de_pmp; + *vpp = NULL; + lockparent = flags & LOCKPARENT; + wantparent = flags & (LOCKPARENT | WANTPARENT); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): vdp %08x, dp %08x, Attr %02x\n", + vdp, dp, dp->de_Attributes); +#endif + + /* + * Be sure vdp is a directory. Since dos filesystems don't have + * the concept of execute permission anybody can search a + * directory. + */ + if ((dp->de_Attributes & ATTR_DIRECTORY) == 0) + return ENOTDIR; + + /* + * See if the component of the pathname we are looking for is in + * the directory cache. If so then do a few things and return. + */ + if (error = cache_lookup(vdp, vpp, cnp)) { + int vpid; + + if (error == ENOENT) + return error; + pdp = vdp; + vdp = *vpp; + dp = VTODE(vdp); + vpid = vdp->v_id; + if (pdp == vdp) { + VREF(vdp); + error = 0; + } else if (flags & ISDOTDOT) { + VOP_UNLOCK(pdp); + error = vget(vdp, 1); + if (!error && lockparent && (flags & ISLASTCN)) + error = VOP_LOCK(pdp); + } else { + error = vget(vdp, 1); + if (!lockparent || error || !(flags & ISLASTCN)) + VOP_UNLOCK(pdp); + } + + if (!error) { + if (vpid == vdp->v_id) { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): cache hit, vnode %08x, file %s\n", + vdp, dp->de_Name); +#endif + return 0; + } + vput(vdp); + if (lockparent && pdp != vdp && (flags & ISLASTCN)) + VOP_UNLOCK(pdp); + } + if (error = VOP_LOCK(pdp)) + return error; + vdp = pdp; + dp = VTODE(vdp); + *vpp = NULL; + } + + /* + * If they are going after the . or .. entry in the root directory, + * they won't find it. DOS filesystems don't have them in the root + * directory. So, we fake it. deget() is in on this scam too. + */ + if ((vdp->v_flag & VROOT) && cnp->cn_nameptr[0] == '.' && + (cnp->cn_namelen == 1 || + (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.'))) { + isadir = ATTR_DIRECTORY; + scn = MSDOSFSROOT; +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): looking for . or .. in root directory\n"); +#endif + cluster = MSDOSFSROOT; + diroff = MSDOSFSROOT_OFS; + goto foundroot; + } + + /* + * Don't search for free slots unless we are creating a filename + * and we are at the end of the pathname. + */ + slotstatus = FOUND; + if ((nameiop == CREATE || nameiop == RENAME) && (flags & ISLASTCN)) { + slotstatus = NONE; + slotoffset = -1; + } + + unix2dosfn((u_char *) cnp->cn_nameptr, dosfilename, cnp->cn_namelen); + dosfilename[11] = 0; +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): dos version of filename %s, length %d\n", + dosfilename, cnp->cn_namelen); +#endif + /* + * Search the directory pointed at by vdp for the name pointed at + * by cnp->cn_nameptr. + */ + tdp = NULL; + /* + * The outer loop ranges over the clusters that make up the + * directory. Note that the root directory is different from all + * other directories. It has a fixed number of blocks that are not + * part of the pool of allocatable clusters. So, we treat it a + * little differently. The root directory starts at "cluster" 0. + */ + rootreloff = 0; + for (frcn = 0;; frcn++) { + if (error = pcbmap(dp, frcn, &bn, &cluster)) { + if (error == E2BIG) + break; + return error; + } + if (error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, &bp)) + return error; + for (diroff = 0; diroff < pmp->pm_depclust; diroff++) { + dep = (struct direntry *) bp->b_data + diroff; + + /* + * If the slot is empty and we are still looking + * for an empty then remember this one. If the + * slot is not empty then check to see if it + * matches what we are looking for. If the slot + * has never been filled with anything, then the + * remainder of the directory has never been used, + * so there is no point in searching it. + */ + if (dep->deName[0] == SLOT_EMPTY || + dep->deName[0] == SLOT_DELETED) { + if (slotstatus != FOUND) { + slotstatus = FOUND; + if (cluster == MSDOSFSROOT) + slotoffset = rootreloff; + else + slotoffset = diroff; + slotcluster = cluster; + } + if (dep->deName[0] == SLOT_EMPTY) { + brelse(bp); + goto notfound; + } + } else { + /* + * Ignore volume labels (anywhere, not just + * the root directory). + */ + if ((dep->deAttributes & ATTR_VOLUME) == 0 && + bcmp(dosfilename, dep->deName, 11) == 0) { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): match diroff %d, rootreloff %d\n", + diroff, rootreloff); +#endif + /* + * Remember where this directory + * entry came from for whoever did + * this lookup. If this is the root + * directory we are interested in + * the offset relative to the + * beginning of the directory (not + * the beginning of the cluster). + */ + if (cluster == MSDOSFSROOT) + diroff = rootreloff; + dp->de_fndoffset = diroff; + dp->de_fndclust = cluster; + goto found; + } + } + rootreloff++; + } /* for (diroff = 0; .... */ + /* + * Release the buffer holding the directory cluster just + * searched. + */ + brelse(bp); + } /* for (frcn = 0; ; frcn++) */ +notfound:; + /* + * We hold no disk buffers at this point. + */ + + /* + * If we get here we didn't find the entry we were looking for. But + * that's ok if we are creating or renaming and are at the end of + * the pathname and the directory hasn't been removed. + */ +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): op %d, refcnt %d, slotstatus %d\n", + nameiop, dp->de_refcnt, slotstatus); + printf(" slotoffset %d, slotcluster %d\n", + slotoffset, slotcluster); +#endif + if ((nameiop == CREATE || nameiop == RENAME) && + (flags & ISLASTCN) && dp->de_refcnt != 0) { + if (slotstatus == NONE) { + dp->de_fndoffset = (u_long)-1; + dp->de_fndclust = (u_long)-1; + } else { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): saving empty slot location\n"); +#endif + dp->de_fndoffset = slotoffset; + dp->de_fndclust = slotcluster; + } + /* dp->de_flag |= DE_UPDATE; never update dos directories */ + cnp->cn_flags |= SAVENAME; + if (!lockparent)/* leave searched dir locked? */ + VOP_UNLOCK(vdp); + return EJUSTRETURN; + } + /* + * Insert name in cache as non-existant if not trying to create it. + */ + if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE) + cache_enter(vdp, *vpp, cnp); + return ENOENT; + +found: ; + /* + * NOTE: We still have the buffer with matched directory entry at + * this point. + */ + isadir = dep->deAttributes & ATTR_DIRECTORY; + scn = getushort(dep->deStartCluster); + +foundroot:; + /* + * If we entered at foundroot, then we are looking for the . or .. + * entry of the filesystems root directory. isadir and scn were + * setup before jumping here. And, bp is null. There is no buf + * header. + */ + + /* + * If deleting and at the end of the path, then if we matched on + * "." then don't deget() we would probably panic(). Otherwise + * deget() the directory entry. + */ + if (nameiop == DELETE && (flags & ISLASTCN)) { + if (dp->de_StartCluster == scn && isadir) { /* "." */ + VREF(vdp); + *vpp = vdp; + if (bp) + brelse(bp); + return 0; + } + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + if (bp) + brelse(bp); + return error; + } + *vpp = DETOV(tdp); + if (!lockparent) + VOP_UNLOCK(vdp); + if (bp) + brelse(bp); + return 0; + } + + /* + * If renaming. + */ + if (nameiop == RENAME && wantparent && (flags & ISLASTCN)) { + if (dp->de_StartCluster == scn && isadir) { + if (bp) + brelse(bp); + return EISDIR; + } + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + if (bp) + brelse(bp); + return error; + } + *vpp = DETOV(tdp); + cnp->cn_flags |= SAVENAME; + if (!lockparent) + VOP_UNLOCK(vdp); + if (bp) + brelse(bp); + return 0; + } + + /* + * ? + */ + pdp = vdp; + if (flags & ISDOTDOT) { + VOP_UNLOCK(pdp); + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + VOP_LOCK(pdp); + if (bp) + brelse(bp); + return error; + } + if (lockparent && (flags & ISLASTCN) + && (error = VOP_LOCK(pdp))) { + vput(DETOV(tdp)); + return error; + } + *vpp = DETOV(tdp); + } else if (dp->de_StartCluster == scn && isadir) { /* "." */ + VREF(vdp); + *vpp = vdp; + } else { + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + if (bp) + brelse(bp); + return error; + } + if (!lockparent || !(flags & ISLASTCN)) + VOP_UNLOCK(pdp); + *vpp = DETOV(tdp); + } + if (bp) + brelse(bp); + + /* + * Insert name in cache if wanted. + */ + if (cnp->cn_flags & MAKEENTRY) + cache_enter(vdp, *vpp, cnp); + return 0; +} + +/* + * dep - directory entry to copy into the directory + * ddep - directory to add to + * depp - return the address of the denode for the created directory entry + * if depp != 0 + */ +int +createde(dep, ddep, depp) + struct denode *dep; + struct denode *ddep; + struct denode **depp; +{ + int bn; + int error; + u_long dirclust, diroffset; + struct direntry *ndep; + struct msdosfsmount *pmp = ddep->de_pmp; + struct buf *bp; + +#ifdef MSDOSFS_DEBUG + printf("createde(dep %08x, ddep %08x, depp %08x)\n", dep, ddep, depp); +#endif + + /* + * If no space left in the directory then allocate another cluster + * and chain it onto the end of the file. There is one exception + * to this. That is, if the root directory has no more space it + * can NOT be expanded. extendfile() checks for and fails attempts + * to extend the root directory. We just return an error in that + * case. + */ + if (ddep->de_fndclust == (u_long)-1) { + if (error = extendfile(ddep, 1, &bp, &dirclust, DE_CLEAR)) + return error; + ndep = (struct direntry *) bp->b_data; + /* + * Let caller know where we put the directory entry. + */ + ddep->de_fndclust = dirclust; + ddep->de_fndoffset = diroffset = 0; + /* + * Update the size of the directory + */ + ddep->de_FileSize += pmp->pm_bpcluster; + } else { + /* + * There is space in the existing directory. So, we just + * read in the cluster with space. Copy the new directory + * entry in. Then write it to disk. NOTE: DOS directories + * do not get smaller as clusters are emptied. + */ + dirclust = ddep->de_fndclust; + diroffset = ddep->de_fndoffset; + + error = readep(pmp, dirclust, diroffset, &bp, &ndep); + if (error) + return error; + } + DE_EXTERNALIZE(ndep, dep); + + /* + * If they want us to return with the denode gotten. + */ + if (depp) { + error = deget(pmp, dirclust, diroffset, ndep, depp); + if (error) + return error; + } + if (error = bwrite(bp)) { + vput(DETOV(*depp)); /* free the vnode we got on error */ + return error; + } + return 0; +} + +/* + * Read in a directory entry and mark it as being deleted. + */ +int +markdeleted(pmp, dirclust, diroffset) + struct msdosfsmount *pmp; + u_long dirclust; + u_long diroffset; +{ + int error; + struct direntry *ep; + struct buf *bp; + + error = readep(pmp, dirclust, diroffset, &bp, &ep); + if (error) + return error; + ep->deName[0] = SLOT_DELETED; + return bwrite(bp); +} + +/* + * Remove a directory entry. At this point the file represented by the + * directory entry to be removed is still full length until no one has it + * open. When the file no longer being used msdosfs_inactive() is called + * and will truncate the file to 0 length. When the vnode containing the + * denode is needed for some other purpose by VFS it will call + * msdosfs_reclaim() which will remove the denode from the denode cache. + */ +int +removede(pdep,dep) + struct denode *pdep; /* directory where the entry is removed */ + struct denode *dep; /* file to be removed */ +{ + struct msdosfsmount *pmp = pdep->de_pmp; + int error; + +#ifdef MSDOSFS_DEBUG + printf("removede(): filename %s\n", dep->de_Name); + printf("removede(): dep %08x, ndpcluster %d, ndpoffset %d\n", + dep, pdep->de_fndclust, pdep->de_fndoffset); +#endif + + /* + * Read the directory block containing the directory entry we are + * to make free. The nameidata structure holds the cluster number + * and directory entry index number of the entry to free. + */ + error = markdeleted(pmp, pdep->de_fndclust, pdep->de_fndoffset); + + if (error == 0) + dep->de_refcnt--; + return error; +} + +/* + * Be sure a directory is empty except for "." and "..". Return 1 if empty, + * return 0 if not empty or error. + */ +int +dosdirempty(dep) + struct denode *dep; +{ + int dei; + int error; + u_long cn; + daddr_t bn; + struct buf *bp; + struct msdosfsmount *pmp = dep->de_pmp; + struct direntry *dentp; + + /* + * Since the filesize field in directory entries for a directory is + * zero, we just have to feel our way through the directory until + * we hit end of file. + */ + for (cn = 0;; cn++) { + error = pcbmap(dep, cn, &bn, 0); + if (error == E2BIG) + return 1; /* it's empty */ + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, + &bp); + if (error) + return error; + dentp = (struct direntry *) bp->b_data; + for (dei = 0; dei < pmp->pm_depclust; dei++) { + if (dentp->deName[0] != SLOT_DELETED) { + /* + * In dos directories an entry whose name + * starts with SLOT_EMPTY (0) starts the + * beginning of the unused part of the + * directory, so we can just return that it + * is empty. + */ + if (dentp->deName[0] == SLOT_EMPTY) { + brelse(bp); + return 1; + } + /* + * Any names other than "." and ".." in a + * directory mean it is not empty. + */ + if (bcmp(dentp->deName, ". ", 11) && + bcmp(dentp->deName, ".. ", 11)) { + brelse(bp); +#ifdef MSDOSFS_DEBUG + printf("dosdirempty(): entry %d found %02x, %02x\n", + dei, dentp->deName[0], dentp->deName[1]); +#endif + return 0; /* not empty */ + } + } + dentp++; + } + brelse(bp); + } + /* NOTREACHED */ +} + +/* + * Check to see if the directory described by target is in some + * subdirectory of source. This prevents something like the following from + * succeeding and leaving a bunch or files and directories orphaned. mv + * /a/b/c /a/b/c/d/e/f Where c and f are directories. + * + * source - the inode for /a/b/c + * target - the inode for /a/b/c/d/e/f + * + * Returns 0 if target is NOT a subdirectory of source. + * Otherwise returns a non-zero error number. + * The target inode is always unlocked on return. + */ +int +doscheckpath(source, target) + struct denode *source; + struct denode *target; +{ + daddr_t scn; + struct denode dummy; + struct msdosfsmount *pmp; + struct direntry *ep; + struct denode *dep; + struct buf *bp = NULL; + int error = 0; + + dep = target; + if ((target->de_Attributes & ATTR_DIRECTORY) == 0 || + (source->de_Attributes & ATTR_DIRECTORY) == 0) { + error = ENOTDIR; + goto out; + } + if (dep->de_StartCluster == source->de_StartCluster) { + error = EEXIST; + goto out; + } + if (dep->de_StartCluster == MSDOSFSROOT) + goto out; + for (;;) { + if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) { + error = ENOTDIR; + goto out; + } + pmp = dep->de_pmp; + scn = dep->de_StartCluster; + error = bread(pmp->pm_devvp, cntobn(pmp, scn), + pmp->pm_bpcluster, NOCRED, &bp); + if (error) { + break; + } + ep = (struct direntry *) bp->b_data + 1; + if ((ep->deAttributes & ATTR_DIRECTORY) == 0 || + bcmp(ep->deName, ".. ", 11) != 0) { + error = ENOTDIR; + break; + } + scn = getushort(ep->deStartCluster); + if (scn == source->de_StartCluster) { + error = EINVAL; + break; + } + if (scn == MSDOSFSROOT) + break; + vput(DETOV(dep)); + /* NOTE: deget() clears dep on error */ + error = deget(pmp, scn, 0, ep, &dep); + brelse(bp); + bp = NULL; + if (error) + break; + } +out: ; + if (bp) + brelse(bp); + if (error == ENOTDIR) + printf("doscheckpath(): .. not a directory?\n"); + if (dep != NULL) + vput(DETOV(dep)); + return error; +} + +/* + * Read in the disk block containing the directory entry (dirclu, dirofs) + * and return the address of the buf header, and the address of the + * directory entry within the block. + */ +int +readep(pmp, dirclu, dirofs, bpp, epp) + struct msdosfsmount *pmp; + u_long dirclu, dirofs; + struct buf **bpp; + struct direntry **epp; +{ + int error; + daddr_t bn; + + bn = detobn(pmp, dirclu, dirofs); + if (error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, bpp)) { + *bpp = NULL; + return error; + } + if (epp) + *epp = bptoep(pmp, *bpp, dirofs); + return 0; +} + + +/* + * Read in the disk block containing the directory entry dep came from and + * return the address of the buf header, and the address of the directory + * entry within the block. + */ +int +readde(dep, bpp, epp) + struct denode *dep; + struct buf **bpp; + struct direntry **epp; +{ + return readep(dep->de_pmp, dep->de_dirclust, dep->de_diroffset, + bpp, epp); +} diff --git a/sys/fs/msdosfs/msdosfs_vfsops.c b/sys/fs/msdosfs/msdosfs_vfsops.c new file mode 100644 index 0000000..ac9c284 --- /dev/null +++ b/sys/fs/msdosfs/msdosfs_vfsops.c @@ -0,0 +1,733 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_vfsops.c,v 1.19 1994/08/21 18:44:10 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/kernel.h> +#include <sys/vnode.h> +#include <miscfs/specfs/specdev.h> /* XXX */ /* defines v_rdev */ +#include <sys/mount.h> +#include <sys/buf.h> +#include <sys/file.h> +#include <sys/malloc.h> + +#include <msdosfs/bpb.h> +#include <msdosfs/bootsect.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/fat.h> + +int msdosfsdoforce = 1; /* 1 = force unmount */ + +/* + * mp - path - addr in user space of mount point (ie /usr or whatever) + * data - addr in user space of mount params including the name of the block + * special file to treat as a filesystem. + */ +int +msdosfs_mount(mp, path, data, ndp, p) + struct mount *mp; + char *path; + caddr_t data; + struct nameidata *ndp; + struct proc *p; +{ + struct vnode *devvp; /* vnode for blk device to mount */ + struct msdosfs_args args; /* will hold data from mount request */ + struct msdosfsmount *pmp; /* msdosfs specific mount control block */ + int error, flags; + u_int size; + struct ucred *cred, *scred; + struct vattr va; + + /* + * Copy in the args for the mount request. + */ + if (error = copyin(data, (caddr_t) & args, sizeof(struct msdosfs_args))) + return error; + + /* + * If they just want to update then be sure we can do what is + * asked. Can't change a filesystem from read/write to read only. + * Why? And if they've supplied a new device file name then we + * continue, otherwise return. + */ + if (mp->mnt_flag & MNT_UPDATE) { + pmp = (struct msdosfsmount *) mp->mnt_data; + error = 0; + if (pmp->pm_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { + flags = WRITECLOSE; + if (mp->mnt_flag & MNT_FORCE) + flags |= FORCECLOSE; + if (vfs_busy(mp)) + return EBUSY; + error = vflush(mp, NULLVP, flags); + vfs_unbusy(mp); + } + if (!error && (mp->mnt_flag & MNT_RELOAD)) + /* not yet implemented */ + error = EINVAL; + if (error) + return error; + if (pmp->pm_ronly && (mp->mnt_flag & MNT_RDONLY) == 0) + pmp->pm_ronly = 0; + if (args.fspec == 0) { + /* + * Process export requests. + */ + return vfs_export(mp, &pmp->pm_export, &args.export); + } + } else + pmp = NULL; + + /* + * check to see that the user in owns the target directory. + * Note the very XXX trick to make sure we're checking as the + * real user -- were mount() executable by anyone, this wouldn't + * be a problem. + * + * XXX there should be one consistent error out. + */ + cred = crdup(p->p_ucred); /* XXX */ + cred->cr_uid = p->p_cred->p_ruid; /* XXX */ + error = VOP_GETATTR(mp->mnt_vnodecovered, &va, cred, p); + if (error) { + crfree(cred); /* XXX */ + return error; + } + if (cred->cr_uid != 0) { + if (va.va_uid != cred->cr_uid) { + error = EACCES; + crfree(cred); /* XXX */ + return error; + } + + /* a user mounted it; we'll verify permissions when unmounting */ + mp->mnt_flag |= MNT_USER; + } + + /* + * Now, lookup the name of the block device this mount or name + * update request is to apply to. + */ + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + scred = p->p_ucred; /* XXX */ + p->p_ucred = cred; /* XXX */ + error = namei(ndp); + p->p_ucred = scred; /* XXX */ + crfree(cred); /* XXX */ + if (error != 0) + return error; + + /* + * Be sure they've given us a block device to treat as a + * filesystem. And, that its major number is within the bdevsw + * table. + */ + devvp = ndp->ni_vp; + if (devvp->v_type != VBLK) { + vrele(devvp); + return ENOTBLK; + } + if (major(devvp->v_rdev) >= nblkdev) { + vrele(devvp); + return ENXIO; + } + + /* + * If this is an update, then make sure the vnode for the block + * special device is the same as the one our filesystem is in. + */ + if (mp->mnt_flag & MNT_UPDATE) { + if (devvp != pmp->pm_devvp) + error = EINVAL; + else + vrele(devvp); + } else { + + /* + * Well, it's not an update, it's a real mount request. + * Time to get dirty. + */ + error = mountmsdosfs(devvp, mp, p); + } + if (error) { + vrele(devvp); + return error; + } + + /* + * Copy in the name of the directory the filesystem is to be + * mounted on. Then copy in the name of the block special file + * representing the filesystem being mounted. And we clear the + * remainder of the character strings to be tidy. Set up the + * user id/group id/mask as specified by the user. Then, we try to + * fill in the filesystem stats structure as best we can with + * whatever applies from a dos file system. + */ + pmp = (struct msdosfsmount *) mp->mnt_data; + copyinstr(path, (caddr_t) mp->mnt_stat.f_mntonname, + sizeof(mp->mnt_stat.f_mntonname) - 1, &size); + bzero(mp->mnt_stat.f_mntonname + size, + sizeof(mp->mnt_stat.f_mntonname) - size); + copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); + bzero(mp->mnt_stat.f_mntfromname + size, + MNAMELEN - size); + pmp->pm_mounter = p->p_cred->p_ruid; + pmp->pm_gid = args.gid; + pmp->pm_uid = args.uid; + pmp->pm_mask = args.mask; + (void) msdosfs_statfs(mp, &mp->mnt_stat, p); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_mount(): mp %x, pmp %x, inusemap %x\n", mp, pmp, pmp->pm_inusemap); +#endif + return 0; +} + +int +mountmsdosfs(devvp, mp, p) + struct vnode *devvp; + struct mount *mp; + struct proc *p; +{ + int i; + int bpc; + int bit; + int error; + int needclose; + int ronly = (mp->mnt_flag & MNT_RDONLY) != 0; + dev_t dev = devvp->v_rdev; + union bootsector *bsp; + struct msdosfsmount *pmp = NULL; + struct buf *bp0 = NULL; + struct byte_bpb33 *b33; + struct byte_bpb50 *b50; + + /* + * Multiple mounts of the same block special file aren't allowed. + * Make sure no one else has the special file open. And flush any + * old buffers from this filesystem. Presumably this prevents us + * from running into buffers that are the wrong blocksize. + */ + if (error = vfs_mountedon(devvp)) + return error; + if (vcount(devvp) > 1) + return EBUSY; + if (error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) + return error; + + /* + * Now open the block special file. + */ + if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD | FWRITE, FSCRED, p)) + return error; + needclose = 1; +#ifdef HDSUPPORT + /* + * Put this in when we support reading dos filesystems from + * partitioned harddisks. + */ + if (VOP_IOCTL(devvp, DIOCGPART, &msdosfspart, FREAD, NOCRED, p) == 0) { + } +#endif + + /* + * Read the boot sector of the filesystem, and then check the boot + * signature. If not a dos boot sector then error out. We could + * also add some checking on the bsOemName field. So far I've seen + * the following values: "IBM 3.3" "MSDOS3.3" "MSDOS5.0" + */ + if (error = bread(devvp, 0, 512, NOCRED, &bp0)) + goto error_exit; + bp0->b_flags |= B_AGE; + bsp = (union bootsector *) bp0->b_data; + b33 = (struct byte_bpb33 *) bsp->bs33.bsBPB; + b50 = (struct byte_bpb50 *) bsp->bs50.bsBPB; +#ifdef MSDOSFS_CHECKSIG + if (bsp->bs50.bsBootSectSig != BOOTSIG) { + error = EINVAL; + goto error_exit; + } +#endif + if ( bsp->bs50.bsJump[0] != 0xe9 && + (bsp->bs50.bsJump[0] != 0xeb || bsp->bs50.bsJump[2] != 0x90)) { + error = EINVAL; + goto error_exit; + } + + pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK); + bzero((caddr_t)pmp, sizeof *pmp); + pmp->pm_mountp = mp; + + /* + * Compute several useful quantities from the bpb in the + * bootsector. Copy in the dos 5 variant of the bpb then fix up + * the fields that are different between dos 5 and dos 3.3. + */ + pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec); + pmp->pm_SectPerClust = b50->bpbSecPerClust; + pmp->pm_ResSectors = getushort(b50->bpbResSectors); + pmp->pm_FATs = b50->bpbFATs; + pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts); + pmp->pm_Sectors = getushort(b50->bpbSectors); + pmp->pm_Media = b50->bpbMedia; + pmp->pm_FATsecs = getushort(b50->bpbFATsecs); + pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack); + pmp->pm_Heads = getushort(b50->bpbHeads); + + /* XXX - We should probably check more values here */ + if (!pmp->pm_BytesPerSec || !pmp->pm_SectPerClust || + !pmp->pm_Heads || pmp->pm_Heads > 255 || + !pmp->pm_SecPerTrack || pmp->pm_SecPerTrack > 63) { + error = EINVAL; + goto error_exit; + } + + if (pmp->pm_Sectors == 0) { + pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs); + pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors); + } else { + pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs); + pmp->pm_HugeSectors = pmp->pm_Sectors; + } + pmp->pm_fatblk = pmp->pm_ResSectors; + pmp->pm_rootdirblk = pmp->pm_fatblk + + (pmp->pm_FATs * pmp->pm_FATsecs); + pmp->pm_rootdirsize = (pmp->pm_RootDirEnts * sizeof(struct direntry)) + / + pmp->pm_BytesPerSec;/* in sectors */ + pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize; + pmp->pm_nmbrofclusters = (pmp->pm_HugeSectors - pmp->pm_firstcluster) / + pmp->pm_SectPerClust; + pmp->pm_maxcluster = pmp->pm_nmbrofclusters + 1; + pmp->pm_fatsize = pmp->pm_FATsecs * pmp->pm_BytesPerSec; + if (FAT12(pmp)) + /* + * This will usually be a floppy disk. This size makes sure + * that one fat entry will not be split across multiple + * blocks. + */ + pmp->pm_fatblocksize = 3 * pmp->pm_BytesPerSec; + else + /* + * This will usually be a hard disk. Reading or writing one + * block should be quite fast. + */ + pmp->pm_fatblocksize = MAXBSIZE; + pmp->pm_fatblocksec = pmp->pm_fatblocksize / pmp->pm_BytesPerSec; + + + if ((pmp->pm_rootdirsize % pmp->pm_SectPerClust) != 0) + printf("mountmsdosfs(): root directory is not a multiple of the clustersize in length\n"); + + /* + * Compute mask and shift value for isolating cluster relative byte + * offsets and cluster numbers from a file offset. + */ + bpc = pmp->pm_SectPerClust * pmp->pm_BytesPerSec; + pmp->pm_bpcluster = bpc; + pmp->pm_depclust = bpc / sizeof(struct direntry); + pmp->pm_crbomask = bpc - 1; + if (bpc == 0) { + error = EINVAL; + goto error_exit; + } + bit = 1; + for (i = 0; i < 32; i++) { + if (bit & bpc) { + if (bit ^ bpc) { + error = EINVAL; + goto error_exit; + } + pmp->pm_cnshift = i; + break; + } + bit <<= 1; + } + + pmp->pm_brbomask = 0x01ff; /* 512 byte blocks only (so far) */ + pmp->pm_bnshift = 9; /* shift right 9 bits to get bn */ + + /* + * Release the bootsector buffer. + */ + brelse(bp0); + bp0 = NULL; + + /* + * Allocate memory for the bitmap of allocated clusters, and then + * fill it in. + */ + pmp->pm_inusemap = malloc(((pmp->pm_maxcluster + N_INUSEBITS - 1) + / N_INUSEBITS) + * sizeof(*pmp->pm_inusemap), + M_MSDOSFSFAT, M_WAITOK); + + /* + * fillinusemap() needs pm_devvp. + */ + pmp->pm_dev = dev; + pmp->pm_devvp = devvp; + + /* + * Have the inuse map filled in. + */ + error = fillinusemap(pmp); + if (error) + goto error_exit; + + /* + * If they want fat updates to be synchronous then let them suffer + * the performance degradation in exchange for the on disk copy of + * the fat being correct just about all the time. I suppose this + * would be a good thing to turn on if the kernel is still flakey. + */ + pmp->pm_waitonfat = mp->mnt_flag & MNT_SYNCHRONOUS; + + /* + * Finish up. + */ + pmp->pm_ronly = ronly; + if (ronly == 0) + pmp->pm_fmod = 1; + mp->mnt_data = (qaddr_t) pmp; + mp->mnt_stat.f_fsid.val[0] = (long)dev; + mp->mnt_stat.f_fsid.val[1] = MOUNT_MSDOS; + mp->mnt_flag |= MNT_LOCAL; +#ifdef QUOTA + /* + * If we ever do quotas for DOS filesystems this would be a place + * to fill in the info in the msdosfsmount structure. You dolt, + * quotas on dos filesystems make no sense because files have no + * owners on dos filesystems. of course there is some empty space + * in the directory entry where we could put uid's and gid's. + */ +#endif + devvp->v_specflags |= SI_MOUNTEDON; + + return 0; + +error_exit:; + if (bp0) + brelse(bp0); + if (needclose) + (void) VOP_CLOSE(devvp, ronly ? FREAD : FREAD | FWRITE, + NOCRED, p); + if (pmp) { + if (pmp->pm_inusemap) + free((caddr_t) pmp->pm_inusemap, M_MSDOSFSFAT); + free((caddr_t) pmp, M_MSDOSFSMNT); + mp->mnt_data = (qaddr_t) 0; + } + return error; +} + +int +msdosfs_start(mp, flags, p) + struct mount *mp; + int flags; + struct proc *p; +{ + return 0; +} + +/* + * Unmount the filesystem described by mp. + */ +int +msdosfs_unmount(mp, mntflags, p) + struct mount *mp; + int mntflags; + struct proc *p; +{ + int flags = 0; + int error; + struct msdosfsmount *pmp = (struct msdosfsmount *) mp->mnt_data; + struct vnode *vp = pmp->pm_devvp; + + /* only the mounter, or superuser can unmount */ + if ((p->p_cred->p_ruid != pmp->pm_mounter) && + (error = suser(p->p_ucred, &p->p_acflag))) + return error; + + if (mntflags & MNT_FORCE) { + if (!msdosfsdoforce) + return EINVAL; + flags |= FORCECLOSE; + } +#ifdef QUOTA +#endif + if (error = vflush(mp, NULLVP, flags)) + return error; + pmp->pm_devvp->v_specflags &= ~SI_MOUNTEDON; +#ifdef MSDOSFS_DEBUG + printf("msdosfs_umount(): just before calling VOP_CLOSE()\n"); + printf("flag %08x, usecount %d, writecount %d, holdcnt %d\n", + vp->v_flag, vp->v_usecount, vp->v_writecount, vp->v_holdcnt); + printf("lastr %d, id %d, mount %08x, op %08x\n", + vp->v_lastr, vp->v_id, vp->v_mount, vp->v_op); + printf("freef %08x, freeb %08x, mountf %08x, mountb %08x\n", + vp->v_freef, vp->v_freeb, vp->v_mountf, vp->v_mountb); + printf("cleanblkhd %08x, dirtyblkhd %08x, numoutput %d, type %d\n", + vp->v_cleanblkhd, vp->v_dirtyblkhd, vp->v_numoutput, vp->v_type); + printf("union %08x, tag %d, data[0] %08x, data[1] %08x\n", + vp->v_socket, vp->v_tag, vp->v_data[0], vp->v_data[1]); +#endif + error = VOP_CLOSE(pmp->pm_devvp, pmp->pm_ronly ? FREAD : FREAD | FWRITE, + NOCRED, p); + vrele(pmp->pm_devvp); + free((caddr_t) pmp->pm_inusemap, M_MSDOSFSFAT); + free((caddr_t) pmp, M_MSDOSFSMNT); + mp->mnt_data = (qaddr_t) 0; + mp->mnt_flag &= ~MNT_LOCAL; + return error; +} + +int +msdosfs_root(mp, vpp) + struct mount *mp; + struct vnode **vpp; +{ + struct denode *ndep; + struct msdosfsmount *pmp = (struct msdosfsmount *) (mp->mnt_data); + int error; + + error = deget(pmp, MSDOSFSROOT, MSDOSFSROOT_OFS, NULL, &ndep); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_root(); mp %08x, pmp %08x, ndep %08x, vp %08x\n", + mp, pmp, ndep, DETOV(ndep)); +#endif + if (error == 0) + *vpp = DETOV(ndep); + return error; +} + +int +msdosfs_quotactl(mp, cmds, uid, arg, p) + struct mount *mp; + int cmds; + uid_t uid; + caddr_t arg; + struct proc *p; +{ +#ifdef QUOTA +#else + return EOPNOTSUPP; +#endif +} + +int +msdosfs_statfs(mp, sbp, p) + struct mount *mp; + struct statfs *sbp; + struct proc *p; +{ + struct msdosfsmount *pmp = (struct msdosfsmount *) mp->mnt_data; + + /* + * Fill in the stat block. + */ +#ifdef COMPAT_09 + sbp->f_type = 4; +#else + sbp->f_type = 0; +#endif + sbp->f_bsize = pmp->pm_bpcluster; + sbp->f_iosize = pmp->pm_bpcluster; + sbp->f_blocks = pmp->pm_nmbrofclusters; + sbp->f_bfree = pmp->pm_freeclustercount; + sbp->f_bavail = pmp->pm_freeclustercount; + sbp->f_files = pmp->pm_RootDirEnts; /* XXX */ + sbp->f_ffree = 0; /* what to put in here? */ + + /* + * Copy the mounted on and mounted from names into the passed in + * stat block, if it is not the one in the mount structure. + */ + if (sbp != &mp->mnt_stat) { + bcopy((caddr_t) mp->mnt_stat.f_mntonname, + (caddr_t) & sbp->f_mntonname[0], MNAMELEN); + bcopy((caddr_t) mp->mnt_stat.f_mntfromname, + (caddr_t) & sbp->f_mntfromname[0], MNAMELEN); + } +#if 0 + strncpy(&sbp->f_fstypename[0], mp->mnt_op->vfs_name, MFSNAMELEN); + sbp->f_fstypename[MFSNAMELEN] = '\0'; +#endif + return 0; +} + +int +msdosfs_sync(mp, waitfor, cred, p) + struct mount *mp; + int waitfor; + struct ucred *cred; + struct proc *p; +{ + struct vnode *vp; + struct denode *dep; + struct msdosfsmount *pmp; + int error; + int allerror = 0; + + pmp = (struct msdosfsmount *) mp->mnt_data; + + /* + * If we ever switch to not updating all of the fats all the time, + * this would be the place to update them from the first one. + */ + if (pmp->pm_fmod) + if (pmp->pm_ronly) + panic("msdosfs_sync: rofs mod"); + else { + /* update fats here */ + } + + /* + * Go thru in memory denodes and write them out along with + * unwritten file blocks. + */ +loop: + for (vp = mp->mnt_vnodelist.lh_first; vp; + vp = vp->v_mntvnodes.le_next) { + if (vp->v_mount != mp) /* not ours anymore */ + goto loop; + if (VOP_ISLOCKED(vp)) /* file is busy */ + continue; + dep = VTODE(vp); + if ((dep->de_flag & DE_UPDATE) == 0 && + vp->v_dirtyblkhd.lh_first == NULL) + continue; + if (vget(vp, 1)) /* not there anymore? */ + goto loop; + if (error = VOP_FSYNC(vp, cred, waitfor, p)) + allerror = error; + vput(vp); /* done with this one */ + } + + /* + * Flush filesystem control info. + */ + if (error = VOP_FSYNC(pmp->pm_devvp, cred, waitfor, p)) + allerror = error; + return allerror; +} + +int +msdosfs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp) + struct mount *mp; + struct fid *fhp; + struct mbuf *nam; + struct vnode **vpp; + int *exflagsp; + struct ucred **credanonp; +{ + struct msdosfsmount *pmp = (struct msdosfsmount *) mp->mnt_data; + struct defid *defhp = (struct defid *) fhp; + struct denode *dep; + struct netcred *np; + int error; + + np = vfs_export_lookup(mp, &pmp->pm_export, nam); + if (np == NULL) + return EACCES; + error = deget(pmp, defhp->defid_dirclust, defhp->defid_dirofs, + NULL, &dep); + if (error) { + *vpp = NULLVP; + return error; + } + *vpp = DETOV(dep); + *exflagsp = np->netc_exflags; + *credanonp = &np->netc_anon; + return 0; +} + + +int +msdosfs_vptofh(vp, fhp) + struct vnode *vp; + struct fid *fhp; +{ + struct denode *dep = VTODE(vp); + struct defid *defhp = (struct defid *) fhp; + + defhp->defid_len = sizeof(struct defid); + defhp->defid_dirclust = dep->de_dirclust; + defhp->defid_dirofs = dep->de_diroffset; + /* defhp->defid_gen = ip->i_gen; */ + return 0; +} + +int +msdosfs_vget(mp, ino, vpp) + struct mount *mp; + ino_t ino; + struct vnode **vpp; +{ + return EOPNOTSUPP; +} + +struct vfsops msdosfs_vfsops = { + msdosfs_mount, + msdosfs_start, + msdosfs_unmount, + msdosfs_root, + msdosfs_quotactl, + msdosfs_statfs, + msdosfs_sync, + msdosfs_vget, + msdosfs_fhtovp, + msdosfs_vptofh, + msdosfs_init +}; diff --git a/sys/fs/msdosfs/msdosfs_vnops.c b/sys/fs/msdosfs/msdosfs_vnops.c new file mode 100644 index 0000000..4294034 --- /dev/null +++ b/sys/fs/msdosfs/msdosfs_vnops.c @@ -0,0 +1,1933 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_vnops.c,v 1.20 1994/08/21 18:44:13 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/resourcevar.h> /* defines plimit structure in proc struct */ +#include <sys/kernel.h> +#include <sys/file.h> /* define FWRITE ... */ +#include <sys/stat.h> +#include <sys/buf.h> +#include <sys/proc.h> +#include <sys/mount.h> +#include <sys/vnode.h> +#include <miscfs/specfs/specdev.h> /* XXX */ /* defines v_rdev */ +#include <sys/malloc.h> +#include <sys/dir.h> /* defines dirent structure */ + +#include <msdosfs/bpb.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/fat.h> +/* + * Some general notes: + * + * In the ufs filesystem the inodes, superblocks, and indirect blocks are + * read/written using the vnode for the filesystem. Blocks that represent + * the contents of a file are read/written using the vnode for the file + * (including directories when they are read/written as files). This + * presents problems for the dos filesystem because data that should be in + * an inode (if dos had them) resides in the directory itself. Since we + * must update directory entries without the benefit of having the vnode + * for the directory we must use the vnode for the filesystem. This means + * that when a directory is actually read/written (via read, write, or + * readdir, or seek) we must use the vnode for the filesystem instead of + * the vnode for the directory as would happen in ufs. This is to insure we + * retreive the correct block from the buffer cache since the hash value is + * based upon the vnode address and the desired block number. + */ + +/* + * Create a regular file. On entry the directory to contain the file being + * created is locked. We must release before we return. We must also free + * the pathname buffer pointed at by cnp->cn_pnbuf, always on error, or + * only if the SAVESTART bit in cn_flags is clear on success. + */ +int +msdosfs_create(ap) + struct vop_create_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ + struct componentname *cnp = ap->a_cnp; + struct denode ndirent; + struct denode *dep; + struct denode *pdep = VTODE(ap->a_dvp); + struct timespec ts; + int error; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_create(cnp %08x, vap %08x\n", cnp, ap->a_vap); +#endif + + /* + * Create a directory entry for the file, then call createde() to + * have it installed. NOTE: DOS files are always executable. We + * use the absence of the owner write bit to make the file + * readonly. + */ +#ifdef DIAGNOSTIC + if ((cnp->cn_flags & SAVENAME) == 0) + panic("msdosfs_create: no name"); +#endif + bzero(&ndirent, sizeof(ndirent)); + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &ndirent.de_Date, &ndirent.de_Time); + unix2dosfn((u_char *)cnp->cn_nameptr, ndirent.de_Name, cnp->cn_namelen); + ndirent.de_Attributes = (ap->a_vap->va_mode & VWRITE) ? 0 : ATTR_READONLY; + ndirent.de_StartCluster = 0; + ndirent.de_FileSize = 0; + ndirent.de_dev = pdep->de_dev; + ndirent.de_devvp = pdep->de_devvp; + if ((error = createde(&ndirent, pdep, &dep)) == 0) { + *ap->a_vpp = DETOV(dep); + if ((cnp->cn_flags & SAVESTART) == 0) + free(cnp->cn_pnbuf, M_NAMEI); + } else { + free(cnp->cn_pnbuf, M_NAMEI); + } + vput(ap->a_dvp); /* release parent dir */ + return error; +} + +int +msdosfs_mknod(ap) + struct vop_mknod_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ + int error; + struct denode *pdep = VTODE(ap->a_dvp); + + switch (ap->a_vap->va_type) { + case VDIR: + error = msdosfs_mkdir((struct vop_mkdir_args *)ap); + break; + + case VREG: + error = msdosfs_create((struct vop_create_args *)ap); + break; + + default: + error = EINVAL; + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + break; + } + return error; +} + +int +msdosfs_open(ap) + struct vop_open_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return 0; +} + +int +msdosfs_close(ap) + struct vop_close_args /* { + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + struct timespec ts; + + if (vp->v_usecount > 1 && !(dep->de_flag & DE_LOCKED)) { + TIMEVAL_TO_TIMESPEC(&time, &ts); + DE_TIMES(dep, &ts); + } + return 0; +} + +/* + * This routine will go into sys/kern/vfs_subr.c one day! + * + * Do the usual access checking. + * file_node, uid and gid are from the vnode in question, + * while acc_mode and cred are from the VOP_ACCESS parameter list. + */ +static int +vaccess(file_mode, uid, gid, acc_mode, cred) + mode_t file_mode; + uid_t uid; + gid_t gid; + mode_t acc_mode; + struct ucred *cred; +{ + mode_t mask; + int i; + register gid_t *gp; + + /* User id 0 always gets access. */ + if (cred->cr_uid == 0) + return 0; + + mask = 0; + + /* Otherwise, check the owner. */ + if (cred->cr_uid == uid) { + if (acc_mode & VEXEC) + mask |= S_IXUSR; + if (acc_mode & VREAD) + mask |= S_IRUSR; + if (acc_mode & VWRITE) + mask |= S_IWUSR; + return (file_mode & mask) == mask ? 0 : EACCES; + } + + /* Otherwise, check the groups. */ + for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) + if (gid == *gp) { + if (acc_mode & VEXEC) + mask |= S_IXGRP; + if (acc_mode & VREAD) + mask |= S_IRGRP; + if (acc_mode & VWRITE) + mask |= S_IWGRP; + return (file_mode & mask) == mask ? 0 : EACCES; + } + + /* Otherwise, check everyone else. */ + if (acc_mode & VEXEC) + mask |= S_IXOTH; + if (acc_mode & VREAD) + mask |= S_IROTH; + if (acc_mode & VWRITE) + mask |= S_IWOTH; + return (file_mode & mask) == mask ? 0 : EACCES; +} + +int +msdosfs_access(ap) + struct vop_access_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + mode_t dosmode; + struct denode *dep = VTODE(ap->a_vp); + struct msdosfsmount *pmp = dep->de_pmp; + + dosmode = (S_IXUSR|S_IXGRP|S_IXOTH) | (S_IRUSR|S_IRGRP|S_IROTH) | + ((dep->de_Attributes & ATTR_READONLY) ? 0 : (S_IWUSR|S_IWGRP|S_IWOTH)); + dosmode &= pmp->pm_mask; + + return vaccess(dosmode, pmp->pm_uid, pmp->pm_gid, ap->a_mode, ap->a_cred); +} + +int +msdosfs_getattr(ap) + struct vop_getattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + u_int cn; + struct denode *dep = VTODE(ap->a_vp); + struct vattr *vap = ap->a_vap; + struct timespec ts; + + TIMEVAL_TO_TIMESPEC(&time, &ts); + DE_TIMES(dep, &ts); + vap->va_fsid = dep->de_dev; + /* + * The following computation of the fileid must be the same as that + * used in msdosfs_readdir() to compute d_fileno. If not, pwd + * doesn't work. + */ + if (dep->de_Attributes & ATTR_DIRECTORY) { + if ((cn = dep->de_StartCluster) == MSDOSFSROOT) + cn = 1; + } else { + if ((cn = dep->de_dirclust) == MSDOSFSROOT) + cn = 1; + cn = (cn << 16) | (dep->de_diroffset & 0xffff); + } + vap->va_fileid = cn; + vap->va_mode = (S_IXUSR|S_IXGRP|S_IXOTH) | (S_IRUSR|S_IRGRP|S_IROTH) | + ((dep->de_Attributes & ATTR_READONLY) ? 0 : (S_IWUSR|S_IWGRP|S_IWOTH)); + vap->va_mode &= dep->de_pmp->pm_mask; + if (dep->de_Attributes & ATTR_DIRECTORY) + vap->va_mode |= S_IFDIR; + vap->va_nlink = 1; + vap->va_gid = dep->de_pmp->pm_gid; + vap->va_uid = dep->de_pmp->pm_uid; + vap->va_rdev = 0; + vap->va_size = dep->de_FileSize; + dos2unixtime(dep->de_Date, dep->de_Time, &vap->va_atime); + vap->va_mtime = vap->va_atime; +#ifndef MSDOSFS_NODIRMOD + if (vap->va_mode & S_IFDIR) + TIMEVAL_TO_TIMESPEC(&time, &vap->va_mtime); +#endif + vap->va_ctime = vap->va_atime; + vap->va_flags = dep->de_flag; + vap->va_gen = 0; + vap->va_blocksize = dep->de_pmp->pm_bpcluster; + vap->va_bytes = (dep->de_FileSize + dep->de_pmp->pm_crbomask) & + ~(dep->de_pmp->pm_crbomask); + vap->va_type = ap->a_vp->v_type; + return 0; +} + +int +msdosfs_setattr(ap) + struct vop_setattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + int error = 0; + struct denode *dep = VTODE(ap->a_vp); + struct vattr *vap = ap->a_vap; + struct ucred *cred = ap->a_cred; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_setattr(): vp %08x, vap %08x, cred %08x, p %08x\n", + ap->a_vp, vap, cred, ap->a_p); +#endif + if ((vap->va_type != VNON) || + (vap->va_nlink != VNOVAL) || + (vap->va_fsid != VNOVAL) || + (vap->va_fileid != VNOVAL) || + (vap->va_blocksize != VNOVAL) || + (vap->va_rdev != VNOVAL) || + (vap->va_bytes != VNOVAL) || + (vap->va_gen != VNOVAL) || + (vap->va_uid != VNOVAL) || + (vap->va_gid != VNOVAL)) { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_setattr(): returning EINVAL\n"); + printf(" va_type %d, va_nlink %x, va_fsid %x, va_fileid %x\n", + vap->va_type, vap->va_nlink, vap->va_fsid, vap->va_fileid); + printf(" va_blocksize %x, va_rdev %x, va_bytes %x, va_gen %x\n", + vap->va_blocksize, vap->va_rdev, vap->va_bytes, vap->va_gen); + printf(" va_uid %x, va_gid %x\n", + vap->va_uid, vap->va_gid); +#endif + return EINVAL; + } + + if (vap->va_size != VNOVAL) { + if (ap->a_vp->v_type == VDIR) + return EISDIR; + if (error = detrunc(dep, vap->va_size, 0, cred, ap->a_p)) + return error; + } + if (vap->va_mtime.ts_sec != VNOVAL) { + dep->de_flag |= DE_UPDATE; + if (error = deupdat(dep, &vap->va_mtime, 1)) + return error; + } + + /* + * DOS files only have the ability to have thier writability + * attribute set, so we use the owner write bit to set the readonly + * attribute. + */ + if (vap->va_mode != (u_short) VNOVAL) { + /* We ignore the read and execute bits */ + if (vap->va_mode & VWRITE) + dep->de_Attributes &= ~ATTR_READONLY; + else + dep->de_Attributes |= ATTR_READONLY; + dep->de_flag |= DE_UPDATE; + } + + if (vap->va_flags != VNOVAL) { + if (error = suser(cred, &ap->a_p->p_acflag)) + return error; + if (cred->cr_uid == 0) + dep->de_flag = vap->va_flags; + else { + dep->de_flag &= 0xffff0000; + dep->de_flag |= (vap->va_flags & 0xffff); + } + dep->de_flag |= DE_UPDATE; + } + return error; +} + +int +msdosfs_read(ap) + struct vop_read_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; +{ + int error = 0; + int diff; + int isadir; + long n; + long on; + daddr_t bn; + daddr_t lbn; + daddr_t rablock; + int rasize; + struct buf *bp; + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct uio *uio = ap->a_uio; + + /* + * If they didn't ask for any data, then we are done. + */ + if (uio->uio_resid == 0) + return 0; + if (uio->uio_offset < 0) + return EINVAL; + + isadir = dep->de_Attributes & ATTR_DIRECTORY; + do { + lbn = uio->uio_offset >> pmp->pm_cnshift; + on = uio->uio_offset & pmp->pm_crbomask; + n = min((u_long) (pmp->pm_bpcluster - on), uio->uio_resid); + diff = dep->de_FileSize - uio->uio_offset; + if (diff <= 0) + return 0; + /* convert cluster # to block # if a directory */ + if (isadir) { + error = pcbmap(dep, lbn, &lbn, 0); + if (error) + return error; + } + if (diff < n) + n = diff; + /* + * If we are operating on a directory file then be sure to + * do i/o with the vnode for the filesystem instead of the + * vnode for the directory. + */ + if (isadir) { + error = bread(pmp->pm_devvp, lbn, pmp->pm_bpcluster, + NOCRED, &bp); + } else { + rablock = lbn + 1; + if (vp->v_lastr + 1 == lbn && + rablock * pmp->pm_bpcluster < dep->de_FileSize) { + rasize = pmp->pm_bpcluster; + error = breadn(vp, lbn, pmp->pm_bpcluster, + &rablock, &rasize, 1, + NOCRED, &bp); + } else { + error = bread(vp, lbn, pmp->pm_bpcluster, NOCRED, + &bp); + } + vp->v_lastr = lbn; + } + n = min(n, pmp->pm_bpcluster - bp->b_resid); + if (error) { + brelse(bp); + return error; + } + error = uiomove(bp->b_data + on, (int) n, uio); + /* + * If we have read everything from this block or have read + * to end of file then we are done with this block. Mark + * it to say the buffer can be reused if need be. + */ +#if 0 + if (n + on == pmp->pm_bpcluster || + uio->uio_offset == dep->de_FileSize) + bp->b_flags |= B_AGE; +#endif + brelse(bp); + } while (error == 0 && uio->uio_resid > 0 && n != 0); + return error; +} + +/* + * Write data to a file or directory. + */ +int +msdosfs_write(ap) + struct vop_write_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; +{ + int n; + int isadir; + int croffset; + int resid; + int osize; + int error = 0; + u_long count; + daddr_t bn, lastcn; + struct buf *bp; + int ioflag = ap->a_ioflag; + struct uio *uio = ap->a_uio; + struct proc *p = uio->uio_procp; + struct vnode *vp = ap->a_vp; + struct vnode *thisvp; + struct denode *dep = VTODE(vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct ucred *cred = ap->a_cred; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_write(vp %08x, uio %08x, ioflag %08x, cred %08x\n", + vp, uio, ioflag, cred); + printf("msdosfs_write(): diroff %d, dirclust %d, startcluster %d\n", + dep->de_diroffset, dep->de_dirclust, dep->de_StartCluster); +#endif + + switch (vp->v_type) { + case VREG: + if (ioflag & IO_APPEND) + uio->uio_offset = dep->de_FileSize; + isadir = 0; + thisvp = vp; + break; + + case VDIR: + if ((ioflag & IO_SYNC) == 0) + panic("msdosfs_write(): non-sync directory update"); + isadir = 1; + thisvp = pmp->pm_devvp; + break; + + default: + panic("msdosfs_write(): bad file type"); + break; + } + + if (uio->uio_offset < 0) + return EINVAL; + + if (uio->uio_resid == 0) + return 0; + + /* + * If they've exceeded their filesize limit, tell them about it. + */ + if (vp->v_type == VREG && p && + ((uio->uio_offset + uio->uio_resid) > + p->p_rlimit[RLIMIT_FSIZE].rlim_cur)) { + psignal(p, SIGXFSZ); + return EFBIG; + } + + /* + * If attempting to write beyond the end of the root directory we + * stop that here because the root directory can not grow. + */ + if ((dep->de_Attributes & ATTR_DIRECTORY) && + dep->de_StartCluster == MSDOSFSROOT && + (uio->uio_offset + uio->uio_resid) > dep->de_FileSize) + return ENOSPC; + + /* + * If the offset we are starting the write at is beyond the end of + * the file, then they've done a seek. Unix filesystems allow + * files with holes in them, DOS doesn't so we must fill the hole + * with zeroed blocks. + */ + if (uio->uio_offset > dep->de_FileSize) { + error = deextend(dep, uio->uio_offset, cred); + if (error) + return error; + } + + /* + * Remember some values in case the write fails. + */ + resid = uio->uio_resid; + osize = dep->de_FileSize; + + + /* + * If we write beyond the end of the file, extend it to its ultimate + * size ahead of the time to hopefully get a contiguous area. + */ + if (uio->uio_offset + resid > osize) { + count = de_clcount(pmp, uio->uio_offset + resid) - de_clcount(pmp, osize); + if ((error = extendfile(dep, count, NULL, NULL, 0)) + && (error != ENOSPC || (ioflag & IO_UNIT))) + goto errexit; + lastcn = dep->de_fc[FC_LASTFC].fc_frcn; + } else + lastcn = de_clcount(pmp, osize) - 1; + + do { + bn = de_blk(pmp, uio->uio_offset); + if (isadir) { + if (error = pcbmap(dep, bn, &bn, 0)) + break; + } else if (bn > lastcn) { + error = ENOSPC; + break; + } + + if ((uio->uio_offset & pmp->pm_crbomask) == 0 + && (de_blk(pmp, uio->uio_offset + uio->uio_resid) > de_blk(pmp, uio->uio_offset) + || uio->uio_offset + uio->uio_resid >= dep->de_FileSize)) { + /* + * If either the whole cluster gets written, + * or we write the cluster from its start beyond EOF, + * then no need to read data from disk. + */ + bp = getblk(thisvp, bn, pmp->pm_bpcluster, 0, 0); + clrbuf(bp); + /* + * Do the bmap now, since pcbmap needs buffers + * for the fat table. (see msdosfs_strategy) + */ + if (!isadir) { + if (bp->b_blkno == bp->b_lblkno) { + if (error = pcbmap(dep, bp->b_lblkno, + &bp->b_blkno, 0)) + bp->b_blkno = -1; + } + if (bp->b_blkno == -1) { + brelse(bp); + if (!error) + error = EIO; /* XXX */ + break; + } + } + } else { + /* + * The block we need to write into exists, so read it in. + */ + if (error = bread(thisvp, bn, pmp->pm_bpcluster, cred, &bp)) + break; + } + + croffset = uio->uio_offset & pmp->pm_crbomask; + n = min(uio->uio_resid, pmp->pm_bpcluster - croffset); + if (uio->uio_offset + n > dep->de_FileSize) { + dep->de_FileSize = uio->uio_offset + n; + vnode_pager_setsize(vp, dep->de_FileSize); /* why? */ + } + (void) vnode_pager_uncache(vp); /* why not? */ + /* + * Should these vnode_pager_* functions be done on dir + * files? + */ + + /* + * Copy the data from user space into the buf header. + */ + error = uiomove(bp->b_data + croffset, n, uio); + + /* + * If they want this synchronous then write it and wait for + * it. Otherwise, if on a cluster boundary write it + * asynchronously so we can move on to the next block + * without delay. Otherwise do a delayed write because we + * may want to write somemore into the block later. + */ + if (ioflag & IO_SYNC) + (void) bwrite(bp); + else if (n + croffset == pmp->pm_bpcluster) { + bp->b_flags |= B_AGE; + bawrite(bp); + } else + bdwrite(bp); + dep->de_flag |= DE_UPDATE; + } while (error == 0 && uio->uio_resid > 0); + + /* + * If the write failed and they want us to, truncate the file back + * to the size it was before the write was attempted. + */ +errexit: + if (error) { + if (ioflag & IO_UNIT) { + detrunc(dep, osize, ioflag & IO_SYNC, NOCRED, NULL); + uio->uio_offset -= resid - uio->uio_resid; + uio->uio_resid = resid; + } else { + detrunc(dep, dep->de_FileSize, ioflag & IO_SYNC, NOCRED, NULL); + if (uio->uio_resid != resid) + error = 0; + } + } else { + error = deupdat(dep, &time, 1); + } + return error; +} + +int +msdosfs_ioctl(ap) + struct vop_ioctl_args /* { + struct vnode *a_vp; + int a_command; + caddr_t a_data; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return ENOTTY; +} + +int +msdosfs_select(ap) + struct vop_select_args /* { + struct vnode *a_vp; + int a_which; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return 1; /* DOS filesystems never block? */ +} + +int +msdosfs_mmap(ap) + struct vop_mmap_args /* { + struct vnode *a_vp; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return EINVAL; +} + +/* + * Flush the blocks of a file to disk. + * + * This function is worthless for vnodes that represent directories. Maybe we + * could just do a sync if they try an fsync on a directory file. + */ +int +msdosfs_fsync(ap) + struct vop_fsync_args /* { + struct vnode *a_vp; + struct ucred *a_cred; + int a_waitfor; + struct proc *a_p; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + int wait = ap->a_waitfor == MNT_WAIT; + int error; + +#if 0 + /* + * Does this call to vflushbuf() do anything? I can find no code + * anywhere that sets v_dirtyblkhd in the vnode, which vflushbuf() + * seems to depend upon. + */ + vflushbuf(vp, wait ? B_SYNC : 0); +#endif + return deupdat(VTODE(vp), &time, wait); +} + +/* + * Now the whole work of extending a file is done in the write function. + * So nothing to do here. + */ +int +msdosfs_seek(ap) + struct vop_seek_args /* { + struct vnode *a_vp; + off_t a_oldoff; + off_t a_newoff; + struct ucred *a_cred; + } */ *ap; +{ + return 0; +} + +int +msdosfs_remove(ap) + struct vop_remove_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; +{ + int error; + struct denode *dep = VTODE(ap->a_vp); + struct denode *ddep = VTODE(ap->a_dvp); + + error = removede(ddep,dep); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_remove(), dep %08x, v_usecount %d\n", dep, ap->a_vp->v_usecount); +#endif + if (ddep == dep) + vrele(ap->a_vp); + else + vput(ap->a_vp); /* causes msdosfs_inactive() to be called + * via vrele() */ + vput(ap->a_dvp); + return error; +} + +/* + * DOS filesystems don't know what links are. But since we already called + * msdosfs_lookup() with create and lockparent, the parent is locked so we + * have to free it before we return the error. + */ +int +msdosfs_link(ap) + struct vop_link_args /* { + struct vnode *a_vp; + struct vnode *a_tdvp; + struct componentname *a_cnp; + } */ *ap; +{ + return VOP_ABORTOP(ap->a_vp, ap->a_cnp); +} + +/* + * Renames on files require moving the denode to a new hash queue since the + * denode's location is used to compute which hash queue to put the file + * in. Unless it is a rename in place. For example "mv a b". + * + * What follows is the basic algorithm: + * + * if (file move) { + * if (dest file exists) { + * remove dest file + * } + * if (dest and src in same directory) { + * rewrite name in existing directory slot + * } else { + * write new entry in dest directory + * update offset and dirclust in denode + * move denode to new hash chain + * clear old directory entry + * } + * } else { + * directory move + * if (dest directory exists) { + * if (dest is not empty) { + * return ENOTEMPTY + * } + * remove dest directory + * } + * if (dest and src in same directory) { + * rewrite name in existing entry + * } else { + * be sure dest is not a child of src directory + * write entry in dest directory + * update "." and ".." in moved directory + * update offset and dirclust in denode + * move denode to new hash chain + * clear old directory entry for moved directory + * } + * } + * + * On entry: + * source's parent directory is unlocked + * source file or directory is unlocked + * destination's parent directory is locked + * destination file or directory is locked if it exists + * + * On exit: + * all denodes should be released + * + * Notes: + * I'm not sure how the memory containing the pathnames pointed at by the + * componentname structures is freed, there may be some memory bleeding + * for each rename done. + */ +int +msdosfs_rename(ap) + struct vop_rename_args /* { + struct vnode *a_fdvp; + struct vnode *a_fvp; + struct componentname *a_fcnp; + struct vnode *a_tdvp; + struct vnode *a_tvp; + struct componentname *a_tcnp; + } */ *ap; +{ + u_char toname[11]; + int error; + int newparent = 0; + int sourceisadirectory = 0; + u_long to_dirclust; + u_long to_diroffset; + u_long cn; + daddr_t bn; + struct vnode *tvp = ap->a_tvp; + struct denode *fddep; /* from file's parent directory */ + struct denode *fdep; /* from file or directory */ + struct denode *tddep; /* to file's parent directory */ + struct denode *tdep; /* to file or directory */ + struct msdosfsmount *pmp; + struct direntry *dotdotp; + struct direntry *ep; + struct buf *bp; + + fddep = VTODE(ap->a_fdvp); + fdep = VTODE(ap->a_fvp); + tddep = VTODE(ap->a_tdvp); + tdep = tvp ? VTODE(tvp) : NULL; + pmp = fddep->de_pmp; + +#ifdef __NetBSD__ + /* Check for cross-device rename */ + if ((ap->a_fvp->v_mount != ap->a_tdvp->v_mount) || + (tvp && (ap->a_fvp->v_mount != tvp->v_mount))) { + error = EXDEV; + goto bad; + } +#endif + + /* + * Convert the filename in tcnp into a dos filename. We copy this + * into the denode and directory entry for the destination + * file/directory. + */ + unix2dosfn((u_char *) ap->a_tcnp->cn_nameptr, + toname, ap->a_tcnp->cn_namelen); + + /* + * At this point this is the lock state of the denodes: + * fddep referenced + * fdep referenced + * tddep locked + * tdep locked if it exists + */ + + /* + * Be sure we are not renaming ".", "..", or an alias of ".". This + * leads to a crippled directory tree. It's pretty tough to do a + * "ls" or "pwd" with the "." directory entry missing, and "cd .." + * doesn't work if the ".." entry is missing. + */ + if (fdep->de_Attributes & ATTR_DIRECTORY) { + if ((ap->a_fcnp->cn_namelen == 1 + && ap->a_fcnp->cn_nameptr[0] == '.') + || fddep == fdep + || (ap->a_fcnp->cn_flags & ISDOTDOT)) { + VOP_ABORTOP(ap->a_tdvp, ap->a_tcnp); + vput(ap->a_tdvp); + if (tvp) + vput(tvp); + VOP_ABORTOP(ap->a_fdvp, ap->a_fcnp); + vrele(ap->a_fdvp); + vrele(ap->a_fvp); + return EINVAL; + } + sourceisadirectory = 1; + } + + /* + * If we are renaming a directory, and the directory is being moved + * to another directory, then we must be sure the destination + * directory is not in the subtree of the source directory. This + * could orphan everything under the source directory. + * doscheckpath() unlocks the destination's parent directory so we + * must look it up again to relock it. + */ + if (fddep->de_StartCluster != tddep->de_StartCluster) + newparent = 1; + if (sourceisadirectory && newparent) { + if (tdep) { + vput(ap->a_tvp); + tdep = NULL; + } + /* doscheckpath() vput()'s tddep */ + error = doscheckpath(fdep, tddep); + tddep = NULL; + if (error) { + goto bad; + } + if ((ap->a_tcnp->cn_flags & SAVESTART) == 0) + panic("msdosfs_rename(): lost to startdir"); + if (error = relookup(ap->a_tdvp, &tvp, ap->a_tcnp)) { + goto bad; + } + tddep = VTODE(ap->a_tdvp); + tdep = tvp ? VTODE(tvp) : NULL; + } + + /* + * If the destination exists, then be sure its type (file or dir) + * matches that of the source. And, if it is a directory make sure + * it is empty. Then delete the destination. + */ + if (tdep) { + if (tdep->de_Attributes & ATTR_DIRECTORY) { + if (!sourceisadirectory) { + error = ENOTDIR; + goto bad; + } + if (!dosdirempty(tdep)) { + error = ENOTEMPTY; + goto bad; + } + } else { /* destination is file */ + if (sourceisadirectory) { + error = EISDIR; + goto bad; + } + } + to_dirclust = tdep->de_dirclust; + to_diroffset = tdep->de_diroffset; + if (error = removede(tddep,tdep)) { + goto bad; + } + vput(ap->a_tvp); + tdep = NULL; + + /* + * Remember where the slot was for createde(). + */ + tddep->de_fndclust = to_dirclust; + tddep->de_fndoffset = to_diroffset; + } + + /* + * If the source and destination are in the same directory then + * just read in the directory entry, change the name in the + * directory entry and write it back to disk. + */ + if (newparent == 0) { + /* tddep and fddep point to the same denode here */ + VOP_LOCK(ap->a_fvp); /* ap->a_fdvp is already locked */ + if (error = readep(fddep->de_pmp, + fdep->de_dirclust, + fdep->de_diroffset, + &bp, &ep)) { + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + bcopy(toname, ep->deName, 11); + if (error = bwrite(bp)) { + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + bcopy(toname, fdep->de_Name, 11); /* update denode */ + /* + * fdep locked fddep and tddep point to the same denode + * which is locked tdep is NULL + */ + } else { + u_long dirsize = 0L; + + /* + * If the source and destination are in different + * directories, then mark the entry in the source directory + * as deleted and write a new entry in the destination + * directory. Then move the denode to the correct hash + * chain for its new location in the filesystem. And, if + * we moved a directory, then update its .. entry to point + * to the new parent directory. If we moved a directory + * will also insure that the directory entry on disk has a + * filesize of zero. + */ + VOP_LOCK(ap->a_fvp); + bcopy(toname, fdep->de_Name, 11); /* update denode */ + if (fdep->de_Attributes & ATTR_DIRECTORY) { + dirsize = fdep->de_FileSize; + fdep->de_FileSize = 0; + } + error = createde(fdep, tddep, (struct denode **) 0); + if (fdep->de_Attributes & ATTR_DIRECTORY) { + fdep->de_FileSize = dirsize; + } + if (error) { + /* should put back filename */ + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + VOP_LOCK(ap->a_fdvp); + if (error = readep(fddep->de_pmp, + fddep->de_fndclust, + fddep->de_fndoffset, + &bp, &ep)) { + VOP_UNLOCK(ap->a_fvp); + VOP_UNLOCK(ap->a_fdvp); + goto bad; + } + ep->deName[0] = SLOT_DELETED; + if (error = bwrite(bp)) { + VOP_UNLOCK(ap->a_fvp); + VOP_UNLOCK(ap->a_fdvp); + goto bad; + } + fdep->de_dirclust = tddep->de_fndclust; + fdep->de_diroffset = tddep->de_fndoffset; + reinsert(fdep); + VOP_UNLOCK(ap->a_fdvp); + } + /* fdep is still locked here */ + + /* + * If we moved a directory to a new parent directory, then we must + * fixup the ".." entry in the moved directory. + */ + if (sourceisadirectory && newparent) { + cn = fdep->de_StartCluster; + if (cn == MSDOSFSROOT) { + /* this should never happen */ + panic("msdosfs_rename(): updating .. in root directory?\n"); + } else { + bn = cntobn(pmp, cn); + } + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, + NOCRED, &bp); + if (error) { + /* should really panic here, fs is corrupt */ + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + dotdotp = (struct direntry *) bp->b_data + 1; + putushort(dotdotp->deStartCluster, tddep->de_StartCluster); + error = bwrite(bp); + VOP_UNLOCK(ap->a_fvp); + if (error) { + /* should really panic here, fs is corrupt */ + goto bad; + } + } else + VOP_UNLOCK(ap->a_fvp); +bad: ; + vrele(DETOV(fdep)); + vrele(DETOV(fddep)); + if (tdep) + vput(DETOV(tdep)); + if (tddep) + vput(DETOV(tddep)); + return error; +} + +struct { + struct direntry dot; + struct direntry dotdot; +} dosdirtemplate = { + + ". ", " ", /* the . entry */ + ATTR_DIRECTORY, /* file attribute */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* resevered */ + 210, 4, 210, 4, /* time and date */ + 0, 0, /* startcluster */ + 0, 0, 0, 0, /* filesize */ + ".. ", " ", /* the .. entry */ + ATTR_DIRECTORY, /* file attribute */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* resevered */ + 210, 4, 210, 4, /* time and date */ + 0, 0, /* startcluster */ + 0, 0, 0, 0, /* filesize */ +}; + +int +msdosfs_mkdir(ap) + struct vop_mkdir_args /* { + struct vnode *a_dvp; + struvt vnode **a_vpp; + struvt componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ + int bn; + int error; + u_long newcluster; + struct denode *pdep; + struct denode *ndep; + struct direntry *denp; + struct denode ndirent; + struct msdosfsmount *pmp; + struct buf *bp; + struct timespec ts; + u_short dDate, dTime; + + pdep = VTODE(ap->a_dvp); + + /* + * If this is the root directory and there is no space left we + * can't do anything. This is because the root directory can not + * change size. + */ + if (pdep->de_StartCluster == MSDOSFSROOT && pdep->de_fndclust == (u_long)-1) { + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return ENOSPC; + } + + pmp = pdep->de_pmp; + + /* + * Allocate a cluster to hold the about to be created directory. + */ + if (error = clusteralloc(pmp, 0, 1, CLUST_EOFE, &newcluster, NULL)) { + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return error; + } + + /* + * Now fill the cluster with the "." and ".." entries. And write + * the cluster to disk. This way it is there for the parent + * directory to be pointing at if there were a crash. + */ + bn = cntobn(pmp, newcluster); + /* always succeeds */ + bp = getblk(pmp->pm_devvp, bn, pmp->pm_bpcluster, 0, 0); + bzero(bp->b_data, pmp->pm_bpcluster); + bcopy(&dosdirtemplate, bp->b_data, sizeof dosdirtemplate); + denp = (struct direntry *) bp->b_data; + putushort(denp->deStartCluster, newcluster); + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &dDate, &dTime); + putushort(denp->deDate, dDate); + putushort(denp->deTime, dTime); + denp++; + putushort(denp->deStartCluster, pdep->de_StartCluster); + putushort(denp->deDate, dDate); + putushort(denp->deTime, dTime); + if (error = bwrite(bp)) { + clusterfree(pmp, newcluster, NULL); + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return error; + } + + /* + * Now build up a directory entry pointing to the newly allocated + * cluster. This will be written to an empty slot in the parent + * directory. + */ + ndep = &ndirent; + bzero(ndep, sizeof(*ndep)); + unix2dosfn((u_char *)ap->a_cnp->cn_nameptr, + ndep->de_Name, ap->a_cnp->cn_namelen); + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &ndep->de_Date, &ndep->de_Time); + ndep->de_StartCluster = newcluster; + ndep->de_Attributes = ATTR_DIRECTORY; + + error = createde(ndep, pdep, &ndep); + if (error) { + clusterfree(pmp, newcluster, NULL); + } else { + *ap->a_vpp = DETOV(ndep); + } + free(ap->a_cnp->cn_pnbuf, M_NAMEI); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_mkdir(): vput(%08x)\n", ap->a_dvp); +#endif + vput(ap->a_dvp); + return error; +} + +int +msdosfs_rmdir(ap) + struct vop_rmdir_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; +{ + struct denode *ddep; + struct denode *dep; + int error = 0; + + ddep = VTODE(ap->a_dvp); /* parent dir of dir to delete */ + dep = VTODE(ap->a_vp);/* directory to delete */ + + /* + * Don't let "rmdir ." go thru. + */ + if (ddep == dep) { + vrele(ap->a_vp); + vput(ap->a_vp); + return EINVAL; + } + + /* + * Be sure the directory being deleted is empty. + */ + if (dosdirempty(dep) == 0) { + error = ENOTEMPTY; + goto out; + } + + /* + * Delete the entry from the directory. For dos filesystems this + * gets rid of the directory entry on disk, the in memory copy + * still exists but the de_refcnt is <= 0. This prevents it from + * being found by deget(). When the vput() on dep is done we give + * up access and eventually msdosfs_reclaim() will be called which + * will remove it from the denode cache. + */ + if (error = removede(ddep,dep)) + goto out; + + /* + * This is where we decrement the link count in the parent + * directory. Since dos filesystems don't do this we just purge + * the name cache and let go of the parent directory denode. + */ + cache_purge(DETOV(ddep)); + vput(ap->a_dvp); + ap->a_dvp = NULL; + + /* + * Truncate the directory that is being deleted. + */ + error = detrunc(dep, (u_long) 0, IO_SYNC); + cache_purge(DETOV(dep)); + +out: ; + if (ap->a_dvp) + vput(ap->a_dvp); + vput(ap->a_vp); + return error; +} + +/* + * DOS filesystems don't know what symlinks are. + */ +int +msdosfs_symlink(ap) + struct vop_symlink_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + char *a_target; + } */ *ap; +{ + struct denode *pdep = VTODE(ap->a_dvp); + + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return EINVAL; +} + +/* + * Dummy dirents to simulate the "." and ".." entries of the root directory + * in a dos filesystem. Dos doesn't provide these. Note that each entry + * must be the same size as a dos directory entry (32 bytes). + */ +struct dos_dirent { + u_long d_fileno; + u_short d_reclen; + u_char d_type; + u_char d_namlen; + u_char d_name[24]; +} rootdots[2] = { + + { + 1, /* d_fileno */ + sizeof(struct direntry), /* d_reclen */ + DT_DIR, /* d_type */ + 1, /* d_namlen */ + "." /* d_name */ + }, + { + 1, /* d_fileno */ + sizeof(struct direntry), /* d_reclen */ + DT_DIR, /* d_type */ + 2, /* d_namlen */ + ".." /* d_name */ + } +}; + +int +msdosfs_readdir(ap) + struct vop_readdir_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + int *a_eofflag; + u_int *a_cookies; + int a_ncookies; + } */ *ap; +{ + int error = 0; + int diff; + char pushout; + long n; + long on; + long lost; + long count; + u_long cn; + u_long fileno; + long bias = 0; + daddr_t bn; + daddr_t lbn; + struct buf *bp; + struct denode *dep = VTODE(ap->a_vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct direntry *dentp; + struct dirent *prev; + struct dirent *crnt; + u_char dirbuf[512]; /* holds converted dos directories */ + int i = 0; + struct uio *uio = ap->a_uio; + int ncookies = 1; + u_int* cookies = NULL; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_readdir(): vp %08x, uio %08x, cred %08x, eofflagp %08x\n", + ap->a_vp, uio, ap->a_cred, ap->a_eofflag); +#endif + +#if 0 + if (!ap->a_cookies) + ncookies = 1; +#endif + + /* + * msdosfs_readdir() won't operate properly on regular files since + * it does i/o only with the the filesystem vnode, and hence can + * retrieve the wrong block from the buffer cache for a plain file. + * So, fail attempts to readdir() on a plain file. + */ + if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) + return ENOTDIR; + + /* + * If the user buffer is smaller than the size of one dos directory + * entry or the file offset is not a multiple of the size of a + * directory entry, then we fail the read. + */ + count = uio->uio_resid & ~(sizeof(struct direntry) - 1); + lost = uio->uio_resid - count; + if (count < sizeof(struct direntry) || + (uio->uio_offset & (sizeof(struct direntry) - 1))) + return EINVAL; + uio->uio_resid = count; + uio->uio_iov->iov_len = count; + + /* + * If they are reading from the root directory then, we simulate + * the . and .. entries since these don't exist in the root + * directory. We also set the offset bias to make up for having to + * simulate these entries. By this I mean that at file offset 64 we + * read the first entry in the root directory that lives on disk. + */ + if (dep->de_StartCluster == MSDOSFSROOT) { + /* + * printf("msdosfs_readdir(): going after . or .. in root dir, offset %d\n", + * uio->uio_offset); + */ + bias = 2 * sizeof(struct direntry); + if (uio->uio_offset < 2 * sizeof(struct direntry)) { + if (uio->uio_offset + && uio->uio_offset != sizeof(struct direntry)) { + error = EINVAL; + goto out; + } + n = 1; + if (!uio->uio_offset) { + n = 2; + if (cookies) { + *cookies++ = sizeof(struct direntry); + ncookies--; + } + } + if (cookies) { + if (ncookies-- <= 0) + n--; + else + *cookies++ = 2 * sizeof(struct direntry); + } + + error = uiomove((char *) rootdots + uio->uio_offset, + n * sizeof(struct direntry), uio); + } + } + while (!error && uio->uio_resid > 0 && ncookies > 0) { + lbn = (uio->uio_offset - bias) >> pmp->pm_cnshift; + on = (uio->uio_offset - bias) & pmp->pm_crbomask; + n = min((u_long) (pmp->pm_bpcluster - on), uio->uio_resid); + diff = dep->de_FileSize - (uio->uio_offset - bias); + if (diff <= 0) + return 0; + if (diff < n) + n = diff; + error = pcbmap(dep, lbn, &bn, &cn); + if (error) + break; + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, &bp); + n = min(n, pmp->pm_bpcluster - bp->b_resid); + if (error) { + brelse(bp); + return error; + } + + /* + * code to convert from dos directory entries to ufs + * directory entries + */ + pushout = 0; + dentp = (struct direntry *)(bp->b_data + on); + prev = 0; + crnt = (struct dirent *) dirbuf; + while ((char *) dentp < bp->b_data + on + n) { + /* + * printf("rd: dentp %08x prev %08x crnt %08x deName %02x attr %02x\n", + * dentp, prev, crnt, dentp->deName[0], dentp->deAttributes); + */ + /* + * If we have an empty entry or a slot from a + * deleted file, or a volume label entry just + * concatenate its space onto the end of the + * previous entry or, manufacture an empty entry if + * there is no previous entry. + */ + if (dentp->deName[0] == SLOT_EMPTY || + dentp->deName[0] == SLOT_DELETED || + (dentp->deAttributes & ATTR_VOLUME)) { + if (prev) { + prev->d_reclen += sizeof(struct direntry); + if (cookies) { + ncookies++; + cookies--; + } + } else { + prev = crnt; + prev->d_fileno = 0; + prev->d_reclen = sizeof(struct direntry); + prev->d_type = DT_UNKNOWN; + prev->d_namlen = 0; + prev->d_name[0] = 0; + } + } else { + /* + * this computation of d_fileno must match + * the computation of va_fileid in + * msdosfs_getattr + */ + if (dentp->deAttributes & ATTR_DIRECTORY) { + /* if this is the root directory */ + fileno = getushort(dentp->deStartCluster); + if (fileno == MSDOSFSROOT) + fileno = 1; + } else { + /* + * if the file's dirent lives in + * root dir + */ + if ((fileno = cn) == MSDOSFSROOT) + fileno = 1; + fileno = (fileno << 16) | + ((dentp - (struct direntry *) bp->b_data) & 0xffff); + } + crnt->d_fileno = fileno; + crnt->d_reclen = sizeof(struct direntry); + crnt->d_type = (dentp->deAttributes & ATTR_DIRECTORY) + ? DT_DIR : DT_REG; + crnt->d_namlen = dos2unixfn(dentp->deName, + (u_char *)crnt->d_name); + /* + * printf("readdir: file %s, fileno %08x, attr %02x, start %08x\n", + * crnt->d_name, crnt->d_fileno, dentp->deAttributes, + * dentp->deStartCluster); + */ + prev = crnt; + } + dentp++; + if (cookies) { + *cookies++ = (u_int)((char *)dentp - bp->b_data - on) + + uio->uio_offset; + ncookies--; + } + + crnt = (struct dirent *) ((char *) crnt + sizeof(struct direntry)); + pushout = 1; + + /* + * If our intermediate buffer is full then copy its + * contents to user space. I would just use the + * buffer the buf header points to but, I'm afraid + * that when we brelse() it someone else might find + * it in the cache and think its contents are + * valid. Maybe there is a way to invalidate the + * buffer before brelse()'ing it. + */ + if ((u_char *) crnt >= &dirbuf[sizeof dirbuf]) { + pushout = 0; + error = uiomove(dirbuf, sizeof(dirbuf), uio); + if (error) + break; + prev = 0; + crnt = (struct dirent *) dirbuf; + } + if (ncookies <= 0) + break; + } + if (pushout) { + pushout = 0; + error = uiomove(dirbuf, (char *) crnt - (char *) dirbuf, + uio); + } + +#if 0 + /* + * If we have read everything from this block or have read + * to end of file then we are done with this block. Mark + * it to say the buffer can be reused if need be. + */ + if (n + on == pmp->pm_bpcluster || + (uio->uio_offset - bias) == dep->de_FileSize) + bp->b_flags |= B_AGE; +#endif /* if 0 */ + brelse(bp); + if (n == 0) + break; + } +out: ; + uio->uio_resid += lost; + +#if 0 + /* + * I don't know why we bother setting this eofflag, getdirentries() + * in vfs_syscalls.c doesn't bother to look at it when we return. + * (because NFS uses it in nfs_serv.c -- JMP) + */ + if (dep->de_FileSize - uio->uio_offset - bias <= 0) + *ap->a_eofflag = 1; + else + *ap->a_eofflag = 0; +#endif + + return error; +} + +/* + * DOS filesystems don't know what symlinks are. + */ +int +msdosfs_readlink(ap) + struct vop_readlink_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + } */ *ap; +{ + return EINVAL; +} + +int +msdosfs_abortop(ap) + struct vop_abortop_args /* { + struct vnode *a_dvp; + struct componentname *a_cnp; + } */ *ap; +{ + if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) + FREE(ap->a_cnp->cn_pnbuf, M_NAMEI); + return 0; +} + +int +msdosfs_lock(ap) + struct vop_lock_args /* { + struct vnode *a_vp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + + while (dep->de_flag & DE_LOCKED) { + dep->de_flag |= DE_WANTED; + if (dep->de_lockholder == curproc->p_pid) + panic("msdosfs_lock: locking against myself"); + dep->de_lockwaiter = curproc->p_pid; + (void) sleep((caddr_t) dep, PINOD); + } + dep->de_lockwaiter = 0; + dep->de_lockholder = curproc->p_pid; + dep->de_flag |= DE_LOCKED; + return 0; +} + +int +msdosfs_unlock(ap) + struct vop_unlock_args /* { + struct vnode *vp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + + if (!(dep->de_flag & DE_LOCKED)) + panic("msdosfs_unlock: denode not locked"); + dep->de_lockholder = 0; + dep->de_flag &= ~DE_LOCKED; + if (dep->de_flag & DE_WANTED) { + dep->de_flag &= ~DE_WANTED; + wakeup((caddr_t) dep); + } + return 0; +} + +int +msdosfs_islocked(ap) + struct vop_islocked_args /* { + struct vnode *a_vp; + } */ *ap; +{ + return VTODE(ap->a_vp)->de_flag & DE_LOCKED ? 1 : 0; +} + +/* + * vp - address of vnode file the file + * bn - which cluster we are interested in mapping to a filesystem block number. + * vpp - returns the vnode for the block special file holding the filesystem + * containing the file of interest + * bnp - address of where to return the filesystem relative block number + */ +int +msdosfs_bmap(ap) + struct vop_bmap_args /* { + struct vnode *a_vp; + daddr_t a_bn; + struct vnode **a_vpp; + daddr_t *a_bnp; + int *a_runp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + struct msdosfsmount *pmp = dep->de_pmp; + + if (ap->a_vpp != NULL) + *ap->a_vpp = dep->de_devvp; + if (ap->a_bnp == NULL) + return 0; + if (ap->a_runp) { + /* + * Sequential clusters should be counted here. + */ + *ap->a_runp = 0; + } + return pcbmap(dep, ap->a_bn, ap->a_bnp, 0); +} + +int msdosfs_reallocblks(ap) + struct vop_reallocblks_args /* { + struct vnode *a_vp; + struct cluster_save *a_buflist; + } */ *ap; +{ + /* Currently no support for clustering */ /* XXX */ + return ENOSPC; +} + +int +msdosfs_strategy(ap) + struct vop_strategy_args /* { + struct buf *a_bp; + } */ *ap; +{ + struct buf *bp = ap->a_bp; + struct denode *dep = VTODE(bp->b_vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct vnode *vp; + int error = 0; + + if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR) + panic("msdosfs_strategy: spec"); + /* + * If we don't already know the filesystem relative block number + * then get it using pcbmap(). If pcbmap() returns the block + * number as -1 then we've got a hole in the file. DOS filesystems + * don't allow files with holes, so we shouldn't ever see this. + */ + if (bp->b_blkno == bp->b_lblkno) { + if (error = pcbmap(dep, bp->b_lblkno, &bp->b_blkno, 0)) + bp->b_blkno = -1; + if (bp->b_blkno == -1) + clrbuf(bp); + } + if (bp->b_blkno == -1) { + biodone(bp); + return error; + } +#ifdef DIAGNOSTIC +#endif + /* + * Read/write the block from/to the disk that contains the desired + * file block. + */ + vp = dep->de_devvp; + bp->b_dev = vp->v_rdev; + VOCALL(vp->v_op, VOFFSET(vop_strategy), ap); + return 0; +} + +int +msdosfs_print(ap) + struct vop_print_args /* { + struct vnode *vp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + + printf("tag VT_MSDOSFS, startcluster %d, dircluster %d, diroffset %d ", + dep->de_StartCluster, dep->de_dirclust, dep->de_diroffset); + printf(" dev %d, %d, %s\n", + major(dep->de_dev), minor(dep->de_dev), + dep->de_flag & DE_LOCKED ? "(LOCKED)" : ""); + if (dep->de_lockholder) { + printf(" owner pid %d", dep->de_lockholder); + if (dep->de_lockwaiter) + printf(" waiting pid %d", dep->de_lockwaiter); + printf("\n"); + } + return 0; +} + +int +msdosfs_advlock(ap) + struct vop_advlock_args /* { + struct vnode *a_vp; + caddr_t a_id; + int a_op; + struct flock *a_fl; + int a_flags; + } */ *ap; +{ + return EINVAL; /* we don't do locking yet */ +} + +int +msdosfs_pathconf(ap) + struct vop_pathconf_args /* { + struct vnode *a_vp; + int a_name; + int *a_retval; + } */ *ap; +{ + switch (ap->a_name) { + case _PC_LINK_MAX: + *ap->a_retval = 1; + return 0; + case _PC_NAME_MAX: + *ap->a_retval = 12; + return 0; + case _PC_PATH_MAX: + *ap->a_retval = PATH_MAX; /* 255? */ + return 0; + case _PC_CHOWN_RESTRICTED: + *ap->a_retval = 1; + return 0; + case _PC_NO_TRUNC: + *ap->a_retval = 0; + return 0; + default: + return EINVAL; + } +} + +/* Global vfs data structures for msdosfs */ +int (**msdosfs_vnodeop_p)(); +struct vnodeopv_entry_desc msdosfs_vnodeop_entries[] = { + { &vop_default_desc, vn_default_error }, + { &vop_lookup_desc, msdosfs_lookup }, /* lookup */ + { &vop_create_desc, msdosfs_create }, /* create */ + { &vop_mknod_desc, msdosfs_mknod }, /* mknod */ + { &vop_open_desc, msdosfs_open }, /* open */ + { &vop_close_desc, msdosfs_close }, /* close */ + { &vop_access_desc, msdosfs_access }, /* access */ + { &vop_getattr_desc, msdosfs_getattr }, /* getattr */ + { &vop_setattr_desc, msdosfs_setattr }, /* setattr */ + { &vop_read_desc, msdosfs_read }, /* read */ + { &vop_write_desc, msdosfs_write }, /* write */ + { &vop_ioctl_desc, msdosfs_ioctl }, /* ioctl */ + { &vop_select_desc, msdosfs_select }, /* select */ + { &vop_mmap_desc, msdosfs_mmap }, /* mmap */ + { &vop_fsync_desc, msdosfs_fsync }, /* fsync */ + { &vop_seek_desc, msdosfs_seek }, /* seek */ + { &vop_remove_desc, msdosfs_remove }, /* remove */ + { &vop_link_desc, msdosfs_link }, /* link */ + { &vop_rename_desc, msdosfs_rename }, /* rename */ + { &vop_mkdir_desc, msdosfs_mkdir }, /* mkdir */ + { &vop_rmdir_desc, msdosfs_rmdir }, /* rmdir */ + { &vop_symlink_desc, msdosfs_symlink }, /* symlink */ + { &vop_readdir_desc, msdosfs_readdir }, /* readdir */ + { &vop_readlink_desc, msdosfs_readlink }, /* readlink */ + { &vop_abortop_desc, msdosfs_abortop }, /* abortop */ + { &vop_inactive_desc, msdosfs_inactive }, /* inactive */ + { &vop_reclaim_desc, msdosfs_reclaim }, /* reclaim */ + { &vop_lock_desc, msdosfs_lock }, /* lock */ + { &vop_unlock_desc, msdosfs_unlock }, /* unlock */ + { &vop_bmap_desc, msdosfs_bmap }, /* bmap */ + { &vop_strategy_desc, msdosfs_strategy }, /* strategy */ + { &vop_print_desc, msdosfs_print }, /* print */ + { &vop_islocked_desc, msdosfs_islocked }, /* islocked */ + { &vop_pathconf_desc, msdosfs_pathconf }, /* pathconf */ + { &vop_advlock_desc, msdosfs_advlock }, /* advlock */ + { &vop_reallocblks_desc, msdosfs_reallocblks }, /* reallocblks */ + { &vop_bwrite_desc, vn_bwrite }, + { (struct vnodeop_desc *)NULL, (int (*)())NULL } +}; +struct vnodeopv_desc msdosfs_vnodeop_opv_desc = + { &msdosfs_vnodeop_p, msdosfs_vnodeop_entries }; diff --git a/sys/fs/msdosfs/msdosfsmount.h b/sys/fs/msdosfs/msdosfsmount.h new file mode 100644 index 0000000..62853c5 --- /dev/null +++ b/sys/fs/msdosfs/msdosfsmount.h @@ -0,0 +1,183 @@ +/* $Id$ */ +/* $NetBSD: msdosfsmount.h,v 1.7 1994/08/21 18:44:17 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Layout of the mount control block for a msdos file system. + */ +struct msdosfsmount { + struct mount *pm_mountp;/* vfs mount struct for this fs */ + dev_t pm_dev; /* block special device mounted */ + uid_t pm_mounter; /* uid of the user who mounted the FS */ + uid_t pm_uid; /* uid to set as owner of the files */ + gid_t pm_gid; /* gid to set as owner of the files */ + mode_t pm_mask; /* mask to and with file protection bits */ + struct vnode *pm_devvp; /* vnode for block device mntd */ + struct bpb50 pm_bpb; /* BIOS parameter blk for this fs */ + u_long pm_fatblk; /* block # of first FAT */ + u_long pm_rootdirblk; /* block # of root directory */ + u_long pm_rootdirsize; /* size in blocks (not clusters) */ + u_long pm_firstcluster; /* block number of first cluster */ + u_long pm_nmbrofclusters; /* # of clusters in filesystem */ + u_long pm_maxcluster; /* maximum cluster number */ + u_long pm_freeclustercount; /* number of free clusters */ + u_long pm_bnshift; /* shift file offset right this amount to get a block number */ + u_long pm_brbomask; /* and a file offset with this mask to get block rel offset */ + u_long pm_cnshift; /* shift file offset right this amount to get a cluster number */ + u_long pm_crbomask; /* and a file offset with this mask to get cluster rel offset */ + u_long pm_bpcluster; /* bytes per cluster */ + u_long pm_depclust; /* directory entries per cluster */ + u_long pm_fmod; /* ~0 if fs is modified, this can rollover to 0 */ + u_long pm_fatblocksize; /* size of fat blocks in bytes */ + u_long pm_fatblocksec; /* size of fat blocks in sectors */ + u_long pm_fatsize; /* size of fat in bytes */ + u_int *pm_inusemap; /* ptr to bitmap of in-use clusters */ + char pm_ronly; /* read only if non-zero */ + char pm_waitonfat; /* wait for writes of the fat to complt, when 0 use bdwrite, else use bwrite */ + struct netexport pm_export; /* export information */ +}; + +/* Number of bits in one pm_inusemap item: */ +#define N_INUSEBITS (8 * sizeof(u_int)) + +/* + * How to compute pm_cnshift and pm_crbomask. + * + * pm_crbomask = (pm_SectPerClust * pm_BytesPerSect) - 1 + * if (bytesperclust == * 0) + * return EBADBLKSZ; + * bit = 1; + * for (i = 0; i < 32; i++) { + * if (bit & bytesperclust) { + * if (bit ^ bytesperclust) + * return EBADBLKSZ; + * pm_cnshift = * i; + * break; + * } + * bit <<= 1; + * } + */ + +/* + * Shorthand for fields in the bpb contained in the msdosfsmount structure. + */ +#define pm_BytesPerSec pm_bpb.bpbBytesPerSec +#define pm_SectPerClust pm_bpb.bpbSecPerClust +#define pm_ResSectors pm_bpb.bpbResSectors +#define pm_FATs pm_bpb.bpbFATs +#define pm_RootDirEnts pm_bpb.bpbRootDirEnts +#define pm_Sectors pm_bpb.bpbSectors +#define pm_Media pm_bpb.bpbMedia +#define pm_FATsecs pm_bpb.bpbFATsecs +#define pm_SecPerTrack pm_bpb.bpbSecPerTrack +#define pm_Heads pm_bpb.bpbHeads +#define pm_HiddenSects pm_bpb.bpbHiddenSecs +#define pm_HugeSectors pm_bpb.bpbHugeSectors + +/* + * Map a cluster number into a filesystem relative block number. + */ +#define cntobn(pmp, cn) \ + ((((cn)-CLUST_FIRST) * (pmp)->pm_SectPerClust) + (pmp)->pm_firstcluster) + +/* + * Map a filesystem relative block number back into a cluster number. + */ +#define bntocn(pmp, bn) \ + ((((bn) - pmp->pm_firstcluster)/ (pmp)->pm_SectPerClust) + CLUST_FIRST) + +/* + * Calculate block number for directory entry in root dir, offset dirofs + */ +#define roottobn(pmp, dirofs) \ + (((dirofs) / (pmp)->pm_depclust) * (pmp)->pm_SectPerClust \ + + (pmp)->pm_rootdirblk) + +/* + * Calculate block number for directory entry at cluster dirclu, offset + * dirofs + */ +#define detobn(pmp, dirclu, dirofs) \ + ((dirclu) == MSDOSFSROOT \ + ? roottobn((pmp), (dirofs)) \ + : cntobn((pmp), (dirclu))) + +/* + * Convert pointer to buffer -> pointer to direntry + */ +#define bptoep(pmp, bp, dirofs) \ + ((struct direntry *)((bp)->b_data) \ + + (dirofs) % (pmp)->pm_depclust) + + +/* + * Convert filesize to block number + */ +#define de_blk(pmp, off) \ + ((off) >> (pmp)->pm_cnshift) + +/* + * Clusters required to hold size bytes + */ +#define de_clcount(pmp, size) \ + (((size) + (pmp)->pm_bpcluster - 1) >> (pmp)->pm_cnshift) + +/* + * Prototypes for MSDOSFS virtual filesystem operations + */ +int msdosfs_mount __P((struct mount *, char *, caddr_t, struct nameidata *, struct proc *)); +int msdosfs_start __P((struct mount *, int, struct proc *)); +int msdosfs_unmount __P((struct mount *, int, struct proc *)); +int msdosfs_root __P((struct mount *, struct vnode **)); +int msdosfs_quotactl __P((struct mount *, int, uid_t, caddr_t, struct proc *)); +int msdosfs_statfs __P((struct mount *, struct statfs *, struct proc *)); +int msdosfs_sync __P((struct mount *, int, struct ucred *, struct proc *)); +int msdosfs_fhtovp __P((struct mount *, struct fid *, struct mbuf *, struct vnode **, int *, struct ucred **)); +int msdosfs_vptofh __P((struct vnode *, struct fid *)); +int msdosfs_init __P(()); diff --git a/sys/kern/kern_ntptime.c b/sys/kern/kern_ntptime.c index 9d4c1b9..e11628b 100644 --- a/sys/kern/kern_ntptime.c +++ b/sys/kern/kern_ntptime.c @@ -48,6 +48,7 @@ #include <sys/kernel.h> #include <sys/proc.h> #include <sys/timex.h> +#include <vm/vm.h> #include <sys/sysctl.h> /* diff --git a/sys/kern/vfs_conf.c b/sys/kern/vfs_conf.c index 70377ed..3480333 100644 --- a/sys/kern/vfs_conf.c +++ b/sys/kern/vfs_conf.c @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)vfs_conf.c 8.8 (Berkeley) 3/31/94 - * $Id: vfs_conf.c,v 1.2 1994/08/02 07:43:19 davidg Exp $ + * $Id: vfs_conf.c,v 1.3 1994/08/20 16:03:12 davidg Exp $ */ #include <sys/param.h> @@ -138,6 +138,13 @@ extern struct vfsops cd9660_vfsops; #define CD9660_VFSOPS NULL #endif +#ifdef MSDOSFS +extern struct vfsops msdosfs_vfsops; +#define MSDOSFS_VFSOPS &msdosfs_vfsops +#else +#define MSDOSFS_VFSOPS NULL +#endif + #ifdef UNION extern struct vfsops union_vfsops; #define UNION_VFSOPS &union_vfsops @@ -150,7 +157,7 @@ struct vfsops *vfssw[] = { UFS_VFSOPS, /* 1 = MOUNT_UFS */ NFS_VFSOPS, /* 2 = MOUNT_NFS */ MFS_VFSOPS, /* 3 = MOUNT_MFS */ - NULL, /* 4 = MOUNT_PC */ + MSDOSFS_VFSOPS, /* 4 = MOUNT_MSDOS */ LFS_VFSOPS, /* 5 = MOUNT_LFS */ NULL, /* 6 = MOUNT_LOFS */ FDESC_VFSOPS, /* 7 = MOUNT_FDESC */ @@ -195,6 +202,7 @@ extern struct vnodeopv_desc procfs_vnodeop_opv_desc; extern struct vnodeopv_desc cd9660_vnodeop_opv_desc; extern struct vnodeopv_desc cd9660_specop_opv_desc; extern struct vnodeopv_desc cd9660_fifoop_opv_desc; +extern struct vnodeopv_desc msdosfs_vnodeop_opv_desc; extern struct vnodeopv_desc union_vnodeop_opv_desc; struct vnodeopv_desc *vfs_opv_descs[] = { @@ -250,6 +258,9 @@ struct vnodeopv_desc *vfs_opv_descs[] = { &cd9660_fifoop_opv_desc, #endif #endif +#ifdef MSDOSFS + &msdosfs_vnodeop_opv_desc, +#endif #ifdef UNION &union_vnodeop_opv_desc, #endif diff --git a/sys/kern/vfs_mount.c b/sys/kern/vfs_mount.c index 70377ed..3480333 100644 --- a/sys/kern/vfs_mount.c +++ b/sys/kern/vfs_mount.c @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)vfs_conf.c 8.8 (Berkeley) 3/31/94 - * $Id: vfs_conf.c,v 1.2 1994/08/02 07:43:19 davidg Exp $ + * $Id: vfs_conf.c,v 1.3 1994/08/20 16:03:12 davidg Exp $ */ #include <sys/param.h> @@ -138,6 +138,13 @@ extern struct vfsops cd9660_vfsops; #define CD9660_VFSOPS NULL #endif +#ifdef MSDOSFS +extern struct vfsops msdosfs_vfsops; +#define MSDOSFS_VFSOPS &msdosfs_vfsops +#else +#define MSDOSFS_VFSOPS NULL +#endif + #ifdef UNION extern struct vfsops union_vfsops; #define UNION_VFSOPS &union_vfsops @@ -150,7 +157,7 @@ struct vfsops *vfssw[] = { UFS_VFSOPS, /* 1 = MOUNT_UFS */ NFS_VFSOPS, /* 2 = MOUNT_NFS */ MFS_VFSOPS, /* 3 = MOUNT_MFS */ - NULL, /* 4 = MOUNT_PC */ + MSDOSFS_VFSOPS, /* 4 = MOUNT_MSDOS */ LFS_VFSOPS, /* 5 = MOUNT_LFS */ NULL, /* 6 = MOUNT_LOFS */ FDESC_VFSOPS, /* 7 = MOUNT_FDESC */ @@ -195,6 +202,7 @@ extern struct vnodeopv_desc procfs_vnodeop_opv_desc; extern struct vnodeopv_desc cd9660_vnodeop_opv_desc; extern struct vnodeopv_desc cd9660_specop_opv_desc; extern struct vnodeopv_desc cd9660_fifoop_opv_desc; +extern struct vnodeopv_desc msdosfs_vnodeop_opv_desc; extern struct vnodeopv_desc union_vnodeop_opv_desc; struct vnodeopv_desc *vfs_opv_descs[] = { @@ -250,6 +258,9 @@ struct vnodeopv_desc *vfs_opv_descs[] = { &cd9660_fifoop_opv_desc, #endif #endif +#ifdef MSDOSFS + &msdosfs_vnodeop_opv_desc, +#endif #ifdef UNION &union_vnodeop_opv_desc, #endif diff --git a/sys/msdosfs/bootsect.h b/sys/msdosfs/bootsect.h new file mode 100644 index 0000000..099b15f --- /dev/null +++ b/sys/msdosfs/bootsect.h @@ -0,0 +1,70 @@ +/* $Id$ */ +/* $NetBSD: bootsect.h,v 1.4 1994/06/29 06:35:28 cgd Exp $ */ + +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Format of a boot sector. This is the first sector on a DOS floppy disk + * or the fist sector of a partition on a hard disk. But, it is not the + * first sector of a partitioned hard disk. + */ +struct bootsector33 { + u_char bsJump[3]; /* jump instruction E9xxxx or EBxx90 */ + char bsOemName[8]; /* OEM name and version */ + char bsBPB[19]; /* BIOS parameter block */ + char bsDriveNumber; /* drive number (0x80) */ + char bsBootCode[474]; /* pad so structure is 512 bytes long */ + u_short bsBootSectSig; +#define BOOTSIG 0xaa55 +}; + +struct bootsector50 { + u_char bsJump[3]; /* jump instruction E9xxxx or EBxx90 */ + char bsOemName[8]; /* OEM name and version */ + char bsBPB[25]; /* BIOS parameter block */ + char bsDriveNumber; /* drive number (0x80) */ + char bsReserved1; /* reserved */ + char bsBootSignature; /* extended boot signature (0x29) */ +#define EXBOOTSIG 0x29 + char bsVolumeID[4]; /* volume ID number */ + char bsVolumeLabel[11]; /* volume label */ + char bsFileSysType[8]; /* file system type (FAT12 or FAT16) */ + char bsBootCode[448]; /* pad so structure is 512 bytes long */ + u_short bsBootSectSig; +#define BOOTSIG 0xaa55 +}; + +union bootsector { + struct bootsector33 bs33; + struct bootsector50 bs50; +}; + +/* + * Shorthand for fields in the bpb. + */ +#define bsBytesPerSec bsBPB.bpbBytesPerSec +#define bsSectPerClust bsBPB.bpbSectPerClust +#define bsResSectors bsBPB.bpbResSectors +#define bsFATS bsBPB.bpbFATS +#define bsRootDirEnts bsBPB.bpbRootDirEnts +#define bsSectors bsBPB.bpbSectors +#define bsMedia bsBPB.bpbMedia +#define bsFATsecs bsBPB.bpbFATsecs +#define bsSectPerTrack bsBPB.bpbSectPerTrack +#define bsHeads bsBPB.bpbHeads +#define bsHiddenSecs bsBPB.bpbHiddenSecs +#define bsHugeSectors bsBPB.bpbHugeSectors diff --git a/sys/msdosfs/bpb.h b/sys/msdosfs/bpb.h new file mode 100644 index 0000000..70e4de2 --- /dev/null +++ b/sys/msdosfs/bpb.h @@ -0,0 +1,120 @@ +/* $Id$ */ +/* $NetBSD: bpb.h,v 1.3 1994/06/29 06:35:29 cgd Exp $ */ + +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * BIOS Parameter Block (BPB) for DOS 3.3 + */ +struct bpb33 { + u_short bpbBytesPerSec; /* bytes per sector */ + u_char bpbSecPerClust; /* sectors per cluster */ + u_short bpbResSectors; /* number of reserved sectors */ + u_char bpbFATs; /* number of FATs */ + u_short bpbRootDirEnts; /* number of root directory entries */ + u_short bpbSectors; /* total number of sectors */ + u_char bpbMedia; /* media descriptor */ + u_short bpbFATsecs; /* number of sectors per FAT */ + u_short bpbSecPerTrack; /* sectors per track */ + u_short bpbHeads; /* number of heads */ + u_short bpbHiddenSecs; /* number of hidden sectors */ +}; + +/* + * BPB for DOS 5.0 The difference is bpbHiddenSecs is a short for DOS 3.3, + * and bpbHugeSectors is not in the 3.3 bpb. + */ +struct bpb50 { + u_short bpbBytesPerSec; /* bytes per sector */ + u_char bpbSecPerClust; /* sectors per cluster */ + u_short bpbResSectors; /* number of reserved sectors */ + u_char bpbFATs; /* number of FATs */ + u_short bpbRootDirEnts; /* number of root directory entries */ + u_short bpbSectors; /* total number of sectors */ + u_char bpbMedia; /* media descriptor */ + u_short bpbFATsecs; /* number of sectors per FAT */ + u_short bpbSecPerTrack; /* sectors per track */ + u_short bpbHeads; /* number of heads */ + u_long bpbHiddenSecs; /* number of hidden sectors */ + u_long bpbHugeSectors; /* number of sectrs if bpbSectors == 0 */ +}; + +/* + * The following structures represent how the bpb's look on disk. shorts + * and longs are just character arrays of the appropriate length. This is + * because the compiler forces shorts and longs to align on word or + * halfword boundaries. + * + * XXX The little-endian code here assumes that the processor can access + * 16-bit and 32-bit quantities on byte boundaries. If this is not true, + * use the macros for the big-endian case. + */ +#include <machine/endian.h> +#if BYTE_ORDER == LITTLE_ENDIAN /* && can do unaligned accesses */ +#define getushort(x) *((u_short *)(x)) +#define getulong(x) *((u_long *)(x)) +#define putushort(p, v) (*((u_short *)(p)) = (v)) +#define putulong(p, v) (*((u_long *)(p)) = (v)) + +#else +#define getushort(x) (((u_char *)(x))[0] + (((u_char *)(x))[1] << 8)) +#define getulong(x) (((u_char *)(x))[0] + (((u_char *)(x))[1] << 8) \ + + (((u_char *)(x))[2] << 16) \ + + (((u_char *)(x))[3] << 24)) +#define putushort(p, v) (((u_char *)(p))[0] = (v), \ + ((u_char *)(p))[1] = (v) >> 8) +#define putulong(p, v) (((u_char *)(p))[0] = (v), \ + ((u_char *)(p))[1] = (v) >> 8, \ + ((u_char *)(p))[2] = (v) >> 16,\ + ((u_char *)(p))[3] = (v) >> 24) +#endif + +/* + * BIOS Parameter Block (BPB) for DOS 3.3 + */ +struct byte_bpb33 { + char bpbBytesPerSec[2]; /* bytes per sector */ + char bpbSecPerClust; /* sectors per cluster */ + char bpbResSectors[2]; /* number of reserved sectors */ + char bpbFATs; /* number of FATs */ + char bpbRootDirEnts[2]; /* number of root directory entries */ + char bpbSectors[2]; /* total number of sectors */ + char bpbMedia; /* media descriptor */ + char bpbFATsecs[2]; /* number of sectors per FAT */ + char bpbSecPerTrack[2]; /* sectors per track */ + char bpbHeads[2]; /* number of heads */ + char bpbHiddenSecs[2]; /* number of hidden sectors */ +}; + +/* + * BPB for DOS 5.0 The difference is bpbHiddenSecs is a short for DOS 3.3, + * and bpbHugeSectors is not in the 3.3 bpb. + */ +struct byte_bpb50 { + char bpbBytesPerSec[2]; /* bytes per sector */ + char bpbSecPerClust; /* sectors per cluster */ + char bpbResSectors[2]; /* number of reserved sectors */ + char bpbFATs; /* number of FATs */ + char bpbRootDirEnts[2]; /* number of root directory entries */ + char bpbSectors[2]; /* total number of sectors */ + char bpbMedia; /* media descriptor */ + char bpbFATsecs[2]; /* number of sectors per FAT */ + char bpbSecPerTrack[2]; /* sectors per track */ + char bpbHeads[2]; /* number of heads */ + char bpbHiddenSecs[4]; /* number of hidden sectors */ + char bpbHugeSectors[4]; /* number of sectrs if bpbSectors == 0 */ +}; diff --git a/sys/msdosfs/denode.h b/sys/msdosfs/denode.h new file mode 100644 index 0000000..8df3e4c --- /dev/null +++ b/sys/msdosfs/denode.h @@ -0,0 +1,267 @@ +/* $Id$ */ +/* $NetBSD: denode.h,v 1.8 1994/08/21 18:43:49 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * This is the pc filesystem specific portion of the vnode structure. + * + * To describe a file uniquely the de_dirclust, de_diroffset, and + * de_StartCluster fields are used. + * + * de_dirclust contains the cluster number of the directory cluster + * containing the entry for a file or directory. + * de_diroffset is the index into the cluster for the entry describing + * a file or directory. + * de_StartCluster is the number of the first cluster of the file or directory. + * + * Now to describe the quirks of the pc filesystem. + * - Clusters 0 and 1 are reserved. + * - The first allocatable cluster is 2. + * - The root directory is of fixed size and all blocks that make it up + * are contiguous. + * - Cluster 0 refers to the root directory when it is found in the + * startcluster field of a directory entry that points to another directory. + * - Cluster 0 implies a 0 length file when found in the start cluster field + * of a directory entry that points to a file. + * - You can't use the cluster number 0 to derive the address of the root + * directory. + * - Multiple directory entries can point to a directory. The entry in the + * parent directory points to a child directory. Any directories in the + * child directory contain a ".." entry that points back to the parent. + * The child directory itself contains a "." entry that points to itself. + * - The root directory does not contain a "." or ".." entry. + * - Directory entries for directories are never changed once they are created + * (except when removed). The size stays 0, and the last modification time + * is never changed. This is because so many directory entries can point to + * the physical clusters that make up a directory. It would lead to an + * update nightmare. + * - The length field in a directory entry pointing to a directory contains 0 + * (always). The only way to find the end of a directory is to follow the + * cluster chain until the "last cluster" marker is found. + * + * My extensions to make this house of cards work. These apply only to the in + * memory copy of the directory entry. + * - A reference count for each denode will be kept since dos doesn't keep such + * things. + */ + +/* + * Internal pseudo-offset for (nonexistent) directory entry for the root + * dir in the root dir + */ +#define MSDOSFSROOT_OFS 0x1fffffff + +/* + * The fat cache structure. fc_fsrcn is the filesystem relative cluster + * number that corresponds to the file relative cluster number in this + * structure (fc_frcn). + */ +struct fatcache { + u_short fc_frcn; /* file relative cluster number */ + u_short fc_fsrcn; /* filesystem relative cluster number */ +}; + +/* + * The fat entry cache as it stands helps make extending files a "quick" + * operation by avoiding having to scan the fat to discover the last + * cluster of the file. The cache also helps sequential reads by + * remembering the last cluster read from the file. This also prevents us + * from having to rescan the fat to find the next cluster to read. This + * cache is probably pretty worthless if a file is opened by multiple + * processes. + */ +#define FC_SIZE 2 /* number of entries in the cache */ +#define FC_LASTMAP 0 /* entry the last call to pcbmap() resolved + * to */ +#define FC_LASTFC 1 /* entry for the last cluster in the file */ + +#define FCE_EMPTY 0xffff /* doesn't represent an actual cluster # */ + +/* + * Set a slot in the fat cache. + */ +#define fc_setcache(dep, slot, frcn, fsrcn) \ + (dep)->de_fc[slot].fc_frcn = frcn; \ + (dep)->de_fc[slot].fc_fsrcn = fsrcn; + +/* + * This is the in memory variant of a dos directory entry. It is usually + * contained within a vnode. + */ +struct denode { + struct denode *de_next; /* Hash chain forward */ + struct denode **de_prev; /* Hash chain back */ + struct vnode *de_vnode; /* addr of vnode we are part of */ + struct vnode *de_devvp; /* vnode of blk dev we live on */ + u_long de_flag; /* flag bits */ + dev_t de_dev; /* device where direntry lives */ + u_long de_dirclust; /* cluster of the directory file containing this entry */ + u_long de_diroffset; /* ordinal of this entry in the directory */ + u_long de_fndclust; /* cluster of found dir entry */ + u_long de_fndoffset; /* offset of found dir entry */ + long de_refcnt; /* reference count */ + struct msdosfsmount *de_pmp; /* addr of our mount struct */ + struct lockf *de_lockf; /* byte level lock list */ + pid_t de_lockholder; /* current lock holder */ + pid_t de_lockwaiter; /* lock wanter */ + /* the next two fields must be contiguous in memory... */ + u_char de_Name[8]; /* name, from directory entry */ + u_char de_Extension[3]; /* extension, from directory entry */ + u_char de_Attributes; /* attributes, from directory entry */ + u_short de_Time; /* creation time */ + u_short de_Date; /* creation date */ + u_short de_StartCluster; /* starting cluster of file */ + u_long de_FileSize; /* size of file in bytes */ + struct fatcache de_fc[FC_SIZE]; /* fat cache */ +}; + +/* + * Values for the de_flag field of the denode. + */ +#define DE_LOCKED 0x0001 /* directory entry is locked */ +#define DE_WANTED 0x0002 /* someone wants this de */ +#define DE_UPDATE 0x0004 /* file has been modified */ +#define DE_MODIFIED 0x0080 /* denode wants to be written back to disk */ + +/* + * Transfer directory entries between internal and external form. + * dep is a struct denode * (internal form), + * dp is a struct direntry * (external form). + */ +#define DE_INTERNALIZE(dep, dp) \ + (bcopy((dp)->deName, (dep)->de_Name, 11), \ + (dep)->de_Attributes = (dp)->deAttributes, \ + (dep)->de_Time = getushort((dp)->deTime), \ + (dep)->de_Date = getushort((dp)->deDate), \ + (dep)->de_StartCluster = getushort((dp)->deStartCluster), \ + (dep)->de_FileSize = getulong((dp)->deFileSize)) + +#define DE_EXTERNALIZE(dp, dep) \ + (bcopy((dep)->de_Name, (dp)->deName, 11), \ + (dp)->deAttributes = (dep)->de_Attributes, \ + putushort((dp)->deTime, (dep)->de_Time), \ + putushort((dp)->deDate, (dep)->de_Date), \ + putushort((dp)->deStartCluster, (dep)->de_StartCluster), \ + putulong((dp)->deFileSize, (dep)->de_FileSize)) + +#define de_forw de_chain[0] +#define de_back de_chain[1] + +#ifdef KERNEL + +#define VTODE(vp) ((struct denode *)(vp)->v_data) +#define DETOV(de) ((de)->de_vnode) + +#define DE_UPDAT(dep, t, waitfor) \ + if (dep->de_flag & DE_UPDATE) \ + (void) deupdat(dep, t, waitfor); + +#define DE_TIMES(dep, t) \ + if (dep->de_flag & DE_UPDATE) { \ + (dep)->de_flag |= DE_MODIFIED; \ + unix2dostime(t, &dep->de_Date, &dep->de_Time); \ + (dep)->de_flag &= ~DE_UPDATE; \ + } + +/* + * This overlays the fid sturcture (see mount.h) + */ +struct defid { + u_short defid_len; /* length of structure */ + u_short defid_pad; /* force long alignment */ + + u_long defid_dirclust; /* cluster this dir entry came from */ + u_long defid_dirofs; /* index of entry within the cluster */ + + /* u_long defid_gen; generation number */ +}; + +/* + * Prototypes for MSDOSFS vnode operations + */ +int msdosfs_lookup __P((struct vop_lookup_args *)); +int msdosfs_create __P((struct vop_create_args *)); +int msdosfs_mknod __P((struct vop_mknod_args *)); +int msdosfs_open __P((struct vop_open_args *)); +int msdosfs_close __P((struct vop_close_args *)); +int msdosfs_access __P((struct vop_access_args *)); +int msdosfs_getattr __P((struct vop_getattr_args *)); +int msdosfs_setattr __P((struct vop_setattr_args *)); +int msdosfs_read __P((struct vop_read_args *)); +int msdosfs_write __P((struct vop_write_args *)); +int msdosfs_ioctl __P((struct vop_ioctl_args *)); +int msdosfs_select __P((struct vop_select_args *)); +int msdosfs_mmap __P((struct vop_mmap_args *)); +int msdosfs_fsync __P((struct vop_fsync_args *)); +int msdosfs_seek __P((struct vop_seek_args *)); +int msdosfs_remove __P((struct vop_remove_args *)); +int msdosfs_link __P((struct vop_link_args *)); +int msdosfs_rename __P((struct vop_rename_args *)); +int msdosfs_mkdir __P((struct vop_mkdir_args *)); +int msdosfs_rmdir __P((struct vop_rmdir_args *)); +int msdosfs_symlink __P((struct vop_symlink_args *)); +int msdosfs_readdir __P((struct vop_readdir_args *)); +int msdosfs_readlink __P((struct vop_readlink_args *)); +int msdosfs_abortop __P((struct vop_abortop_args *)); +int msdosfs_inactive __P((struct vop_inactive_args *)); +int msdosfs_reclaim __P((struct vop_reclaim_args *)); +int msdosfs_lock __P((struct vop_lock_args *)); +int msdosfs_unlock __P((struct vop_unlock_args *)); +int msdosfs_bmap __P((struct vop_bmap_args *)); +int msdosfs_strategy __P((struct vop_strategy_args *)); +int msdosfs_print __P((struct vop_print_args *)); +int msdosfs_islocked __P((struct vop_islocked_args *)); +int msdosfs_advlock __P((struct vop_advlock_args *)); +int msdosfs_reallocblks __P((struct vop_reallocblks_args *)); + +/* + * Internal service routine prototypes. + */ +int deget __P((struct msdosfsmount * pmp, u_long dirclust, u_long diroffset, struct direntry * direntptr, struct denode ** depp)); +#endif /* KERNEL */ diff --git a/sys/msdosfs/direntry.h b/sys/msdosfs/direntry.h new file mode 100644 index 0000000..d2ec019 --- /dev/null +++ b/sys/msdosfs/direntry.h @@ -0,0 +1,104 @@ +/* $Id$ */ +/* $NetBSD: direntry.h,v 1.7 1994/08/21 18:43:54 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Structure of a dos directory entry. + */ +struct direntry { + u_char deName[8]; /* filename, blank filled */ +#define SLOT_EMPTY 0x00 /* slot has never been used */ +#define SLOT_E5 0x05 /* the real value is 0xe5 */ +#define SLOT_DELETED 0xe5 /* file in this slot deleted */ + u_char deExtension[3]; /* extension, blank filled */ + u_char deAttributes; /* file attributes */ +#define ATTR_NORMAL 0x00 /* normal file */ +#define ATTR_READONLY 0x01 /* file is readonly */ +#define ATTR_HIDDEN 0x02 /* file is hidden */ +#define ATTR_SYSTEM 0x04 /* file is a system file */ +#define ATTR_VOLUME 0x08 /* entry is a volume label */ +#define ATTR_DIRECTORY 0x10 /* entry is a directory name */ +#define ATTR_ARCHIVE 0x20 /* file is new or modified */ + u_char deReserved[10]; /* reserved */ + u_char deTime[2]; /* create/last update time */ + u_char deDate[2]; /* create/last update date */ + u_char deStartCluster[2]; /* starting cluster of file */ + u_char deFileSize[4]; /* size of file in bytes */ +}; + +/* + * This is the format of the contents of the deTime field in the direntry + * structure. + * We don't use bitfields because we don't know how compilers for + * arbitrary machines will lay them out. + */ +#define DT_2SECONDS_MASK 0x1F /* seconds divided by 2 */ +#define DT_2SECONDS_SHIFT 0 +#define DT_MINUTES_MASK 0x7E0 /* minutes */ +#define DT_MINUTES_SHIFT 5 +#define DT_HOURS_MASK 0xF800 /* hours */ +#define DT_HOURS_SHIFT 11 + +/* + * This is the format of the contents of the deDate field in the direntry + * structure. + */ +#define DD_DAY_MASK 0x1F /* day of month */ +#define DD_DAY_SHIFT 0 +#define DD_MONTH_MASK 0x1E0 /* month */ +#define DD_MONTH_SHIFT 5 +#define DD_YEAR_MASK 0xFE00 /* year - 1980 */ +#define DD_YEAR_SHIFT 9 + +#ifdef KERNEL +void unix2dostime __P((struct timespec * tsp, u_short * ddp, u_short * dtp)); +void dos2unixtime __P((u_short dd, u_short dt, struct timespec * tsp)); +int dos2unixfn __P((u_char dn[11], u_char * un)); +void unix2dosfn __P((u_char * un, u_char dn[11], int unlen)); +#endif /* KERNEL */ diff --git a/sys/msdosfs/fat.h b/sys/msdosfs/fat.h new file mode 100644 index 0000000..3867c87 --- /dev/null +++ b/sys/msdosfs/fat.h @@ -0,0 +1,97 @@ +/* $Id$ */ +/* $NetBSD: fat.h,v 1.4 1994/08/21 18:43:57 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Some useful cluster numbers. + */ +#define MSDOSFSROOT 0 /* cluster 0 means the root dir */ +#define CLUST_FREE 0 /* cluster 0 also means a free cluster */ +#define MSDOSFSFREE CLUST_FREE +#define CLUST_FIRST 2 /* first legal cluster number */ +#define CLUST_RSRVS 0xfff0 /* start of reserved cluster range */ +#define CLUST_RSRVE 0xfff6 /* end of reserved cluster range */ +#define CLUST_BAD 0xfff7 /* a cluster with a defect */ +#define CLUST_EOFS 0xfff8 /* start of eof cluster range */ +#define CLUST_EOFE 0xffff /* end of eof cluster range */ + +#define FAT12_MASK 0x0fff /* mask for 12 bit cluster numbers */ +#define FAT16_MASK 0xffff /* mask for 16 bit cluster numbers */ + +/* + * Return true if filesystem uses 12 bit fats. Microsoft Programmer's + * Reference says if the maximum cluster number in a filesystem is greater + * than 4086 then we've got a 16 bit fat filesystem. + */ +#define FAT12(pmp) (pmp->pm_maxcluster <= 4086) +#define FAT16(pmp) (pmp->pm_maxcluster > 4086) + +#define MSDOSFSEOF(cn) (((cn) & 0xfff8) == 0xfff8) + +#ifdef KERNEL +/* + * These are the values for the function argument to the function + * fatentry(). + */ +#define FAT_GET 0x0001 /* get a fat entry */ +#define FAT_SET 0x0002 /* set a fat entry */ +#define FAT_GET_AND_SET (FAT_GET | FAT_SET) + +/* + * Flags to extendfile: + */ +#define DE_CLEAR 1 /* Zero out the blocks allocated */ + +int pcbmap __P((struct denode *dep, u_long findcn, daddr_t *bnp, u_long *cnp)); +int clusterfree __P((struct msdosfsmount *pmp, u_long cn, u_long *oldcnp)); +int clusteralloc __P((struct msdosfsmount *pmp, u_long start, u_long count, u_long fillwith, u_long *retcluster, u_long *got)); +int fatentry __P((int function, struct msdosfsmount *pmp, u_long cluster, u_long *oldcontents, u_long newcontents)); +int freeclusterchain __P((struct msdosfsmount *pmp, u_long startchain)); +int extendfile __P((struct denode *dep, u_long count, struct buf **bpp, u_long *ncp, int flags)); +#endif /* KERNEL */ diff --git a/sys/msdosfs/msdosfs_conv.c b/sys/msdosfs/msdosfs_conv.c new file mode 100644 index 0000000..da8ce97 --- /dev/null +++ b/sys/msdosfs/msdosfs_conv.c @@ -0,0 +1,358 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_conv.c,v 1.6.2.1 1994/08/30 02:27:57 cgd Exp $ */ + +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * System include files. + */ +#include <sys/param.h> +#include <sys/time.h> +#include <sys/kernel.h> /* defines tz */ + +/* + * MSDOSFS include files. + */ +#include <msdosfs/direntry.h> + +/* + * Days in each month in a regular year. + */ +u_short regyear[] = { + 31, 28, 31, 30, 31, 30, + 31, 31, 30, 31, 30, 31 +}; + +/* + * Days in each month in a leap year. + */ +u_short leapyear[] = { + 31, 29, 31, 30, 31, 30, + 31, 31, 30, 31, 30, 31 +}; + +/* + * Variables used to remember parts of the last time conversion. Maybe we + * can avoid a full conversion. + */ +u_long lasttime; +u_long lastday; +u_short lastddate; +u_short lastdtime; + +/* + * Convert the unix version of time to dos's idea of time to be used in + * file timestamps. The passed in unix time is assumed to be in GMT. + */ +void +unix2dostime(tsp, ddp, dtp) + struct timespec *tsp; + u_short *ddp; + u_short *dtp; +{ + u_long t; + u_long days; + u_long inc; + u_long year; + u_long month; + u_short *months; + + /* + * If the time from the last conversion is the same as now, then + * skip the computations and use the saved result. + */ + t = tsp->ts_sec - (tz.tz_minuteswest * 60) + /* +- daylight savings time correction */ ; + if (lasttime != t) { + lasttime = t; + lastdtime = (((t % 60) >> 1) << DT_2SECONDS_SHIFT) + + (((t / 60) % 60) << DT_MINUTES_SHIFT) + + (((t / 3600) % 24) << DT_HOURS_SHIFT); + + /* + * If the number of days since 1970 is the same as the last + * time we did the computation then skip all this leap year + * and month stuff. + */ + days = t / (24 * 60 * 60); + if (days != lastday) { + lastday = days; + for (year = 1970;; year++) { + inc = year & 0x03 ? 365 : 366; + if (days < inc) + break; + days -= inc; + } + months = year & 0x03 ? regyear : leapyear; + for (month = 0; month < 12; month++) { + if (days < months[month]) + break; + days -= months[month]; + } + lastddate = ((days + 1) << DD_DAY_SHIFT) + + ((month + 1) << DD_MONTH_SHIFT); + /* + * Remember dos's idea of time is relative to 1980. + * unix's is relative to 1970. If somehow we get a + * time before 1980 then don't give totally crazy + * results. + */ + if (year > 1980) + lastddate += (year - 1980) << DD_YEAR_SHIFT; + } + } + *dtp = lastdtime; + *ddp = lastddate; +} + +/* + * The number of seconds between Jan 1, 1970 and Jan 1, 1980. In that + * interval there were 8 regular years and 2 leap years. + */ +#define SECONDSTO1980 (((8 * 365) + (2 * 366)) * (24 * 60 * 60)) + +u_short lastdosdate; +u_long lastseconds; + +/* + * Convert from dos' idea of time to unix'. This will probably only be + * called from the stat(), and fstat() system calls and so probably need + * not be too efficient. + */ +void +dos2unixtime(dd, dt, tsp) + u_short dd; + u_short dt; + struct timespec *tsp; +{ + u_long seconds; + u_long m, month; + u_long y, year; + u_long days; + u_short *months; + + seconds = ((dt & DT_2SECONDS_MASK) >> DT_2SECONDS_SHIFT) + + ((dt & DT_MINUTES_MASK) >> DT_MINUTES_SHIFT) * 60 + + ((dt & DT_HOURS_MASK) >> DT_HOURS_SHIFT) * 3600; + /* + * If the year, month, and day from the last conversion are the + * same then use the saved value. + */ + if (lastdosdate != dd) { + lastdosdate = dd; + days = 0; + year = (dd & DD_YEAR_MASK) >> DD_YEAR_SHIFT; + for (y = 0; y < year; y++) { + days += y & 0x03 ? 365 : 366; + } + months = year & 0x03 ? regyear : leapyear; + /* + * Prevent going from 0 to 0xffffffff in the following + * loop. + */ + month = (dd & DD_MONTH_MASK) >> DD_MONTH_SHIFT; + if (month == 0) { + printf("dos2unixtime(): month value out of range (%d)\n", + month); + month = 1; + } + for (m = 0; m < month - 1; m++) { + days += months[m]; + } + days += ((dd & DD_DAY_MASK) >> DD_DAY_SHIFT) - 1; + lastseconds = (days * 24 * 60 * 60) + SECONDSTO1980; + } + tsp->ts_sec = seconds + lastseconds + (tz.tz_minuteswest * 60) + /* -+ daylight savings time correction */ ; + tsp->ts_nsec = 0; +} + +/* + * Cheezy macros to do case detection and conversion for the ascii + * character set. DOESN'T work for ebcdic. + */ +#define isupper(c) (c >= 'A' && c <= 'Z') +#define islower(c) (c >= 'a' && c <= 'z') +#define toupper(c) (c & ~' ') +#define tolower(c) (c | ' ') + +/* + * DOS filenames are made of 2 parts, the name part and the extension part. + * The name part is 8 characters long and the extension part is 3 + * characters long. They may contain trailing blanks if the name or + * extension are not long enough to fill their respective fields. + */ + +/* + * Convert a DOS filename to a unix filename. And, return the number of + * characters in the resulting unix filename excluding the terminating + * null. + */ +int +dos2unixfn(dn, un) + u_char dn[11]; + u_char *un; +{ + int i; + int ni; + int ei; + int thislong = 0; + u_char c; + u_char *origun = un; + + /* + * Find the last character in the name portion of the dos filename. + */ + for (ni = 7; ni >= 0; ni--) + if (dn[ni] != ' ') + break; + + /* + * Find the last character in the extension portion of the + * filename. + */ + for (ei = 10; ei >= 8; ei--) + if (dn[ei] != ' ') + break; + + /* + * Copy the name portion into the unix filename string. NOTE: DOS + * filenames are usually kept in upper case. To make it more unixy + * we convert all DOS filenames to lower case. Some may like this, + * some may not. + */ + for (i = 0; i <= ni; i++) { + c = dn[i]; + *un++ = isupper(c) ? tolower(c) : c; + thislong++; + } + + /* + * Now, if there is an extension then put in a period and copy in + * the extension. + */ + if (ei >= 8) { + *un++ = '.'; + thislong++; + for (i = 8; i <= ei; i++) { + c = dn[i]; + *un++ = isupper(c) ? tolower(c) : c; + thislong++; + } + } + *un++ = 0; + + /* + * If first char of the filename is SLOT_E5 (0x05), then the real + * first char of the filename should be 0xe5. But, they couldn't + * just have a 0xe5 mean 0xe5 because that is used to mean a freed + * directory slot. Another dos quirk. + */ + if (*origun == SLOT_E5) + *origun = 0xe5; + + return thislong; +} + +/* + * Convert a unix filename to a DOS filename. This function does not ensure + * that valid characters for a dos filename are supplied. + */ +void +unix2dosfn(un, dn, unlen) + u_char *un; + u_char dn[11]; + int unlen; +{ + int i; + u_char c; + + /* + * Fill the dos filename string with blanks. These are DOS's pad + * characters. + */ + for (i = 0; i <= 10; i++) + dn[i] = ' '; + + /* + * The filenames "." and ".." are handled specially, since they + * don't follow dos filename rules. + */ + if (un[0] == '.' && unlen == 1) { + dn[0] = '.'; + return; + } + if (un[0] == '.' && un[1] == '.' && unlen == 2) { + dn[0] = '.'; + dn[1] = '.'; + return; + } + + /* + * Copy the unix filename into the dos filename string upto the end + * of string, a '.', or 8 characters. Whichever happens first stops + * us. This forms the name portion of the dos filename. Fold to + * upper case. + */ + for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) { + dn[i] = islower(c) ? toupper(c) : c; + un++; + unlen--; + } + + /* + * If the first char of the filename is 0xe5, then translate it to + * 0x05. This is because 0xe5 is the marker for a deleted + * directory slot. I guess this means you can't have filenames + * that start with 0x05. I suppose we should check for this and + * doing something about it. + */ + if (dn[0] == SLOT_DELETED) + dn[0] = SLOT_E5; + + /* + * Strip any further characters up to a '.' or the end of the + * string. + */ + while (unlen && (c = *un)) { + un++; + unlen--; + /* Make sure we've skipped over the dot before stopping. */ + if (c == '.') + break; + } + + /* + * Copy in the extension part of the name, if any. Force to upper + * case. Note that the extension is allowed to contain '.'s. + * Filenames in this form are probably inaccessable under dos. + */ + for (i = 8; i <= 10 && unlen && (c = *un); i++) { + dn[i] = islower(c) ? toupper(c) : c; + un++; + unlen--; + } +} + +/* + * Get rid of these macros before someone discovers we are using such + * hideous things. + */ +#undef isupper +#undef islower +#undef toupper +#undef tolower diff --git a/sys/msdosfs/msdosfs_denode.c b/sys/msdosfs/msdosfs_denode.c new file mode 100644 index 0000000..6812863 --- /dev/null +++ b/sys/msdosfs/msdosfs_denode.c @@ -0,0 +1,689 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_denode.c,v 1.9 1994/08/21 18:44:00 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/mount.h> +#include <sys/malloc.h> +#include <sys/proc.h> +#include <sys/buf.h> +#include <sys/vnode.h> +#include <sys/kernel.h> /* defines "time" */ + +#include <msdosfs/bpb.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/fat.h> + +struct denode **dehashtbl; +u_long dehash; /* size of hash table - 1 */ +#define DEHASH(dev, deno) (((dev) + (deno)) & dehash) + +int msdosfs_init() +{ + dehashtbl = hashinit(desiredvnodes/2, M_MSDOSFSMNT, &dehash); + return 0; +} + +static struct denode * +msdosfs_hashget(dev, dirclust, diroff) + dev_t dev; + u_long dirclust; + u_long diroff; +{ + struct denode *dep; + + for (;;) + for (dep = dehashtbl[DEHASH(dev, dirclust + diroff)];; + dep = dep->de_next) { + if (dep == NULL) + return NULL; + if (dirclust != dep->de_dirclust + || diroff != dep->de_diroffset + || dev != dep->de_dev + || dep->de_refcnt == 0) + continue; + if (dep->de_flag & DE_LOCKED) { + dep->de_flag |= DE_WANTED; + sleep((caddr_t)dep, PINOD); + break; + } + if (!vget(DETOV(dep), 1)) + return dep; + break; + } + /* NOTREACHED */ +} + +static void +msdosfs_hashins(dep) + struct denode *dep; +{ + struct denode **depp, *deq; + + depp = &dehashtbl[DEHASH(dep->de_dev, dep->de_dirclust + dep->de_diroffset)]; + if (deq = *depp) + deq->de_prev = &dep->de_next; + dep->de_next = deq; + dep->de_prev = depp; + *depp = dep; + if (dep->de_flag & DE_LOCKED) + panic("msdosfs_hashins: already locked"); + if (curproc) + dep->de_lockholder = curproc->p_pid; + else + dep->de_lockholder = -1; + dep->de_flag |= DE_LOCKED; +} + +static void +msdosfs_hashrem(dep) + struct denode *dep; +{ + struct denode *deq; + if (deq = dep->de_next) + deq->de_prev = dep->de_prev; + *dep->de_prev = deq; +#ifdef DIAGNOSTIC + dep->de_next = NULL; + dep->de_prev = NULL; +#endif +} + +/* + * If deget() succeeds it returns with the gotten denode locked(). + * + * pmp - address of msdosfsmount structure of the filesystem containing + * the denode of interest. The pm_dev field and the address of + * the msdosfsmount structure are used. + * dirclust - which cluster bp contains, if dirclust is 0 (root directory) + * diroffset is relative to the beginning of the root directory, + * otherwise it is cluster relative. + * diroffset - offset past begin of cluster of denode we want + * direntptr - address of the direntry structure of interest. If direntptr is + * NULL, the block is read if necessary. + * depp - returns the address of the gotten denode. + */ +int +deget(pmp, dirclust, diroffset, direntptr, depp) + struct msdosfsmount *pmp; /* so we know the maj/min number */ + u_long dirclust; /* cluster this dir entry came from */ + u_long diroffset; /* index of entry within the cluster */ + struct direntry *direntptr; + struct denode **depp; /* returns the addr of the gotten denode */ +{ + int error; + dev_t dev = pmp->pm_dev; + struct mount *mntp = pmp->pm_mountp; + extern int (**msdosfs_vnodeop_p)(); + struct denode *ldep; + struct vnode *nvp; + struct buf *bp; + +#ifdef MSDOSFS_DEBUG + printf("deget(pmp %08x, dirclust %d, diroffset %x, direntptr %x, depp %08x)\n", + pmp, dirclust, diroffset, direntptr, depp); +#endif + + /* + * If dir entry is given and refers to a directory, convert to + * canonical form + */ + if (direntptr && (direntptr->deAttributes & ATTR_DIRECTORY)) { + dirclust = getushort(direntptr->deStartCluster); + if (dirclust == MSDOSFSROOT) + diroffset = MSDOSFSROOT_OFS; + else + diroffset = 0; + } + + /* + * See if the denode is in the denode cache. Use the location of + * the directory entry to compute the hash value. For subdir use + * address of "." entry. for root dir use cluster MSDOSFSROOT, + * offset MSDOSFSROOT_OFS + * + * NOTE: The check for de_refcnt > 0 below insures the denode being + * examined does not represent an unlinked but still open file. + * These files are not to be accessible even when the directory + * entry that represented the file happens to be reused while the + * deleted file is still open. + */ + if (ldep = msdosfs_hashget(dev, dirclust, diroffset)) { + *depp = ldep; + return 0; + } + + + /* + * Directory entry was not in cache, have to create a vnode and + * copy it from the passed disk buffer. + */ + /* getnewvnode() does a VREF() on the vnode */ + if (error = getnewvnode(VT_MSDOSFS, mntp, msdosfs_vnodeop_p, &nvp)) { + *depp = 0; + return error; + } + MALLOC(ldep, struct denode *, sizeof(struct denode), M_MSDOSFSNODE, M_WAITOK); + bzero((caddr_t)ldep, sizeof *ldep); + nvp->v_data = ldep; + ldep->de_vnode = nvp; + ldep->de_flag = 0; + ldep->de_devvp = 0; + ldep->de_lockf = 0; + ldep->de_dev = dev; + ldep->de_dirclust = dirclust; + ldep->de_diroffset = diroffset; + fc_purge(ldep, 0); /* init the fat cache for this denode */ + + /* + * Insert the denode into the hash queue and lock the denode so it + * can't be accessed until we've read it in and have done what we + * need to it. + */ + msdosfs_hashins(ldep); + + /* + * Copy the directory entry into the denode area of the vnode. + */ + if (dirclust == MSDOSFSROOT && diroffset == MSDOSFSROOT_OFS) { + /* + * Directory entry for the root directory. There isn't one, + * so we manufacture one. We should probably rummage + * through the root directory and find a label entry (if it + * exists), and then use the time and date from that entry + * as the time and date for the root denode. + */ + ldep->de_Attributes = ATTR_DIRECTORY; + ldep->de_StartCluster = MSDOSFSROOT; + ldep->de_FileSize = pmp->pm_rootdirsize * pmp->pm_BytesPerSec; + /* + * fill in time and date so that dos2unixtime() doesn't + * spit up when called from msdosfs_getattr() with root + * denode + */ + ldep->de_Time = 0x0000; /* 00:00:00 */ + ldep->de_Date = (0 << DD_YEAR_SHIFT) | (1 << DD_MONTH_SHIFT) + | (1 << DD_DAY_SHIFT); + /* Jan 1, 1980 */ + /* leave the other fields as garbage */ + } else { + bp = NULL; + if (!direntptr) { + error = readep(pmp, dirclust, diroffset, &bp, + &direntptr); + if (error) + return error; + } + DE_INTERNALIZE(ldep, direntptr); + if (bp) + brelse(bp); + } + + /* + * Fill in a few fields of the vnode and finish filling in the + * denode. Then return the address of the found denode. + */ + ldep->de_pmp = pmp; + ldep->de_devvp = pmp->pm_devvp; + ldep->de_refcnt = 1; + if (ldep->de_Attributes & ATTR_DIRECTORY) { + /* + * Since DOS directory entries that describe directories + * have 0 in the filesize field, we take this opportunity + * to find out the length of the directory and plug it into + * the denode structure. + */ + u_long size; + + nvp->v_type = VDIR; + if (ldep->de_StartCluster == MSDOSFSROOT) + nvp->v_flag |= VROOT; + else { + error = pcbmap(ldep, 0xffff, 0, &size); + if (error == E2BIG) { + ldep->de_FileSize = size << pmp->pm_cnshift; + error = 0; + } else + printf("deget(): pcbmap returned %d\n", error); + } + } else + nvp->v_type = VREG; + VREF(ldep->de_devvp); + *depp = ldep; + return 0; +} + +int +deupdat(dep, tp, waitfor) + struct denode *dep; + struct timespec *tp; + int waitfor; +{ + int error; + daddr_t bn; + int diro; + struct buf *bp; + struct direntry *dirp; + struct msdosfsmount *pmp = dep->de_pmp; + struct timespec ts; + struct vnode *vp = DETOV(dep); + +#ifdef MSDOSFS_DEBUG + printf("deupdat(): dep %08x\n", dep); +#endif + + /* + * If the update bit is off, or this denode is from a readonly + * filesystem, or this denode is for a directory, or the denode + * represents an open but unlinked file then don't do anything. DOS + * directory entries that describe a directory do not ever get + * updated. This is the way dos treats them. + */ + if ((dep->de_flag & DE_UPDATE) == 0 || + vp->v_mount->mnt_flag & MNT_RDONLY || + dep->de_Attributes & ATTR_DIRECTORY || + dep->de_refcnt <= 0) + return 0; + + /* + * Read in the cluster containing the directory entry we want to + * update. + */ + if (error = readde(dep, &bp, &dirp)) + return error; + + /* + * Put the passed in time into the directory entry. + */ + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &dep->de_Date, &dep->de_Time); + dep->de_flag &= ~DE_UPDATE; + + /* + * Copy the directory entry out of the denode into the cluster it + * came from. + */ + DE_EXTERNALIZE(dirp, dep); + + /* + * Write the cluster back to disk. If they asked for us to wait + * for the write to complete, then use bwrite() otherwise use + * bdwrite(). + */ + error = 0; /* note that error is 0 from above, but ... */ + if (waitfor) + error = bwrite(bp); + else + bdwrite(bp); + return error; +} + +/* + * Truncate the file described by dep to the length specified by length. + */ +int +detrunc(dep, length, flags, cred, p) + struct denode *dep; + u_long length; + int flags; + struct ucred *cred; + struct proc *p; +{ + int error; + int allerror; + int vflags; + u_long eofentry; + u_long chaintofree; + daddr_t bn; + int boff; + int isadir = dep->de_Attributes & ATTR_DIRECTORY; + struct buf *bp; + struct msdosfsmount *pmp = dep->de_pmp; + +#ifdef MSDOSFS_DEBUG + printf("detrunc(): file %s, length %d, flags %d\n", dep->de_Name, length, flags); +#endif + + /* + * Disallow attempts to truncate the root directory since it is of + * fixed size. That's just the way dos filesystems are. We use + * the VROOT bit in the vnode because checking for the directory + * bit and a startcluster of 0 in the denode is not adequate to + * recognize the root directory at this point in a file or + * directory's life. + */ + if (DETOV(dep)->v_flag & VROOT) { + printf("detrunc(): can't truncate root directory, clust %d, offset %d\n", + dep->de_dirclust, dep->de_diroffset); + return EINVAL; + } + + vnode_pager_setsize(DETOV(dep), length); + + if (dep->de_FileSize < length) + return deextend(dep, length, cred); + + /* + * If the desired length is 0 then remember the starting cluster of + * the file and set the StartCluster field in the directory entry + * to 0. If the desired length is not zero, then get the number of + * the last cluster in the shortened file. Then get the number of + * the first cluster in the part of the file that is to be freed. + * Then set the next cluster pointer in the last cluster of the + * file to CLUST_EOFE. + */ + if (length == 0) { + chaintofree = dep->de_StartCluster; + dep->de_StartCluster = 0; + eofentry = ~0; + } else { + if (error = pcbmap(dep, de_clcount(pmp, length) - 1, 0, &eofentry)) { +#ifdef MSDOSFS_DEBUG + printf("detrunc(): pcbmap fails %d\n", error); +#endif + return error; + } + } + + fc_purge(dep, (length + pmp->pm_crbomask) >> pmp->pm_cnshift); + + /* + * If the new length is not a multiple of the cluster size then we + * must zero the tail end of the new last cluster in case it + * becomes part of the file again because of a seek. + */ + if ((boff = length & pmp->pm_crbomask) != 0) { + /* + * should read from file vnode or filesystem vnode + * depending on if file or dir + */ + if (isadir) { + bn = cntobn(pmp, eofentry); + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, + NOCRED, &bp); + } else { + bn = de_blk(pmp, length); + error = bread(DETOV(dep), bn, pmp->pm_bpcluster, + NOCRED, &bp); + } + if (error) { +#ifdef MSDOSFS_DEBUG + printf("detrunc(): bread fails %d\n", error); +#endif + return error; + } + vnode_pager_uncache(DETOV(dep)); /* what's this for? */ + /* + * is this the right place for it? + */ + bzero(bp->b_data + boff, pmp->pm_bpcluster - boff); + if (flags & IO_SYNC) + bwrite(bp); + else + bdwrite(bp); + } + + /* + * Write out the updated directory entry. Even if the update fails + * we free the trailing clusters. + */ + dep->de_FileSize = length; + dep->de_flag |= DE_UPDATE; + vflags = (length > 0 ? V_SAVE : 0) | V_SAVEMETA; + vinvalbuf(DETOV(dep), vflags, cred, p, 0, 0); + allerror = deupdat(dep, &time, 1); +#ifdef MSDOSFS_DEBUG + printf("detrunc(): allerror %d, eofentry %d\n", + allerror, eofentry); +#endif + + /* + * If we need to break the cluster chain for the file then do it + * now. + */ + if (eofentry != ~0) { + error = fatentry(FAT_GET_AND_SET, pmp, eofentry, + &chaintofree, CLUST_EOFE); + if (error) { +#ifdef MSDOSFS_DEBUG + printf("detrunc(): fatentry errors %d\n", error); +#endif + return error; + } + fc_setcache(dep, FC_LASTFC, (length - 1) >> pmp->pm_cnshift, + eofentry); + } + + /* + * Now free the clusters removed from the file because of the + * truncation. + */ + if (chaintofree != 0 && !MSDOSFSEOF(chaintofree)) + freeclusterchain(pmp, chaintofree); + + return allerror; +} + +/* + * Extend the file described by dep to length specified by length. + */ +int +deextend(dep, length, cred) + struct denode *dep; + off_t length; + struct ucred *cred; +{ + struct msdosfsmount *pmp = dep->de_pmp; + u_long count; + int error; + + /* + * The root of a DOS filesystem cannot be extended. + */ + if (DETOV(dep)->v_flag & VROOT) + return EINVAL; + + /* + * Directories can only be extended by the superuser. + * Is this really important? + */ + if (dep->de_Attributes & ATTR_DIRECTORY) { + if (error = suser(cred, NULL)) + return error; + } + + if (length <= dep->de_FileSize) + panic("deextend: file too large"); + + /* + * Compute the number of clusters to allocate. + */ + count = de_clcount(pmp, length) - de_clcount(pmp, dep->de_FileSize); + if (count > 0) { + if (count > pmp->pm_freeclustercount) + return ENOSPC; + if (error = extendfile(dep, count, NULL, NULL, DE_CLEAR)) { + /* truncate the added clusters away again */ + (void) detrunc(dep, dep->de_FileSize, 0, cred, NULL); + return error; + } + } + + dep->de_flag |= DE_UPDATE; + dep->de_FileSize = length; + return deupdat(dep, &time, 1); +} + +/* + * Move a denode to its correct hash queue after the file it represents has + * been moved to a new directory. + */ +int reinsert(dep) + struct denode *dep; +{ + union dehead *deh; + + /* + * Fix up the denode cache. If the denode is for a directory, + * there is nothing to do since the hash is based on the starting + * cluster of the directory file and that hasn't changed. If for a + * file the hash is based on the location of the directory entry, + * so we must remove it from the cache and re-enter it with the + * hash based on the new location of the directory entry. + */ + if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) { + msdosfs_hashrem(dep); + msdosfs_hashins(dep); + } + return 0; +} + +int +msdosfs_reclaim(ap) + struct vop_reclaim_args /* { + struct vnode *a_vp; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + int i; + extern int prtactive; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_reclaim(): dep %08x, file %s, refcnt %d\n", + dep, dep->de_Name, dep->de_refcnt); +#endif + + if (prtactive && vp->v_usecount != 0) + vprint("msdosfs_reclaim(): pushing active", vp); + + /* + * Remove the denode from the denode hash chain we are in. + */ + msdosfs_hashrem(dep); + + cache_purge(vp); + /* + * Indicate that one less file on the filesystem is open. + */ + if (dep->de_devvp) { + vrele(dep->de_devvp); + dep->de_devvp = 0; + } + + dep->de_flag = 0; + + FREE(dep, M_MSDOSFSNODE); + vp->v_data = NULL; + + return 0; +} + +int +msdosfs_inactive(ap) + struct vop_inactive_args /* { + struct vnode *a_vp; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + int error = 0; + extern int prtactive; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_inactive(): dep %08x, de_Name[0] %x\n", dep, dep->de_Name[0]); +#endif + + if (prtactive && vp->v_usecount != 0) + vprint("msdosfs_inactive(): pushing active", vp); + + /* + * Get rid of denodes related to stale file handles. Hmmm, what + * does this really do? + */ + if (dep->de_Name[0] == SLOT_DELETED) { + if ((vp->v_flag & VXLOCK) == 0) + vgone(vp); + return 0; + } + + /* + * If the file has been deleted and it is on a read/write + * filesystem, then truncate the file, and mark the directory slot + * as empty. (This may not be necessary for the dos filesystem.) + */ +#ifdef MSDOSFS_DEBUG + printf("msdosfs_inactive(): dep %08x, refcnt %d, mntflag %x, MNT_RDONLY %x\n", + dep, dep->de_refcnt, vp->v_mount->mnt_flag, MNT_RDONLY); +#endif + VOP_LOCK(vp); + if (dep->de_refcnt <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { + error = detrunc(dep, (u_long) 0, 0, NOCRED, NULL); + dep->de_flag |= DE_UPDATE; + dep->de_Name[0] = SLOT_DELETED; + } + DE_UPDAT(dep, &time, 0); + VOP_UNLOCK(vp); + dep->de_flag = 0; + + /* + * If we are done with the denode, then reclaim it so that it can + * be reused now. + */ +#ifdef MSDOSFS_DEBUG + printf("msdosfs_inactive(): v_usecount %d, de_Name[0] %x\n", vp->v_usecount, + dep->de_Name[0]); +#endif + if (vp->v_usecount == 0 && dep->de_Name[0] == SLOT_DELETED) + vgone(vp); + return error; +} diff --git a/sys/msdosfs/msdosfs_fat.c b/sys/msdosfs/msdosfs_fat.c new file mode 100644 index 0000000..9a2f117 --- /dev/null +++ b/sys/msdosfs/msdosfs_fat.c @@ -0,0 +1,984 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_fat.c,v 1.12 1994/08/21 18:44:04 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * kernel include files. + */ +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/buf.h> +#include <sys/file.h> +#include <sys/namei.h> +#include <sys/mount.h> /* to define statfs structure */ +#include <sys/vnode.h> /* to define vattr structure */ +#include <sys/errno.h> + +/* + * msdosfs include files. + */ +#include <msdosfs/bpb.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/fat.h> + +/* + * Fat cache stats. + */ +int fc_fileextends; /* # of file extends */ +int fc_lfcempty; /* # of time last file cluster cache entry + * was empty */ +int fc_bmapcalls; /* # of times pcbmap was called */ + +#define LMMAX 20 +int fc_lmdistance[LMMAX]; /* counters for how far off the last + * cluster mapped entry was. */ +int fc_largedistance; /* off by more than LMMAX */ + +/* Byte offset in FAT on filesystem pmp, cluster cn */ +#define FATOFS(pmp, cn) (FAT12(pmp) ? (cn) * 3 / 2 : (cn) * 2) + +void fc_lookup(struct denode *dep, u_long findcn, + u_long *frcnp, u_long *fsrcnp); +void fc_purge(struct denode *dep, u_int frcn); + +static void +fatblock(pmp, ofs, bnp, sizep, bop) + struct msdosfsmount *pmp; + u_long ofs; + u_long *bnp; + u_long *sizep; + u_long *bop; +{ + u_long bn, size; + + bn = ofs / pmp->pm_fatblocksize * pmp->pm_fatblocksec; + size = min(pmp->pm_fatblocksec, pmp->pm_FATsecs - bn) + * pmp->pm_BytesPerSec; + bn += pmp->pm_fatblk; + if (bnp) + *bnp = bn; + if (sizep) + *sizep = size; + if (bop) + *bop = ofs % pmp->pm_fatblocksize; +} + +/* + * Map the logical cluster number of a file into a physical disk sector + * that is filesystem relative. + * + * dep - address of denode representing the file of interest + * findcn - file relative cluster whose filesystem relative cluster number + * and/or block number are/is to be found + * bnp - address of where to place the file system relative block number. + * If this pointer is null then don't return this quantity. + * cnp - address of where to place the file system relative cluster number. + * If this pointer is null then don't return this quantity. + * + * NOTE: Either bnp or cnp must be non-null. + * This function has one side effect. If the requested file relative cluster + * is beyond the end of file, then the actual number of clusters in the file + * is returned in *cnp. This is useful for determining how long a directory is. + * If cnp is null, nothing is returned. + */ +int +pcbmap(dep, findcn, bnp, cnp) + struct denode *dep; + u_long findcn; /* file relative cluster to get */ + daddr_t *bnp; /* returned filesys relative blk number */ + u_long *cnp; /* returned cluster number */ +{ + int error; + u_long i; + u_long cn; + u_long prevcn; + u_long byteoffset; + u_long bn; + u_long bo; + struct buf *bp = NULL; + u_long bp_bn = -1; + struct msdosfsmount *pmp = dep->de_pmp; + u_long bsize; + int fat12 = FAT12(pmp); /* 12 bit fat */ + + fc_bmapcalls++; + + /* + * If they don't give us someplace to return a value then don't + * bother doing anything. + */ + if (bnp == NULL && cnp == NULL) + return 0; + + cn = dep->de_StartCluster; + /* + * The "file" that makes up the root directory is contiguous, + * permanently allocated, of fixed size, and is not made up of + * clusters. If the cluster number is beyond the end of the root + * directory, then return the number of clusters in the file. + */ + if (cn == MSDOSFSROOT) { + if (dep->de_Attributes & ATTR_DIRECTORY) { + if (findcn * pmp->pm_SectPerClust > pmp->pm_rootdirsize) { + if (cnp) + *cnp = pmp->pm_rootdirsize / pmp->pm_SectPerClust; + return E2BIG; + } + if (bnp) + *bnp = pmp->pm_rootdirblk + (findcn * pmp->pm_SectPerClust); + if (cnp) + *cnp = MSDOSFSROOT; + return 0; + } else { /* just an empty file */ + if (cnp) + *cnp = 0; + return E2BIG; + } + } + + /* + * Rummage around in the fat cache, maybe we can avoid tromping + * thru every fat entry for the file. And, keep track of how far + * off the cache was from where we wanted to be. + */ + i = 0; + fc_lookup(dep, findcn, &i, &cn); + if ((bn = findcn - i) >= LMMAX) + fc_largedistance++; + else + fc_lmdistance[bn]++; + + /* + * Handle all other files or directories the normal way. + */ + prevcn = 0; + for (; i < findcn; i++) { + if (MSDOSFSEOF(cn)) + goto hiteof; + byteoffset = FATOFS(pmp, cn); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (bn != bp_bn) { + if (bp) + brelse(bp); + error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp); + if (error) + return error; + bp_bn = bn; + } + prevcn = cn; + cn = getushort(&bp->b_data[bo]); + if (fat12) { + if (prevcn & 1) + cn >>= 4; + cn &= 0x0fff; + /* + * Force the special cluster numbers in the range + * 0x0ff0-0x0fff to be the same as for 16 bit + * cluster numbers to let the rest of msdosfs think + * it is always dealing with 16 bit fats. + */ + if ((cn & 0x0ff0) == 0x0ff0) + cn |= 0xf000; + } + } + + if (!MSDOSFSEOF(cn)) { + if (bp) + brelse(bp); + if (bnp) + *bnp = cntobn(pmp, cn); + if (cnp) + *cnp = cn; + fc_setcache(dep, FC_LASTMAP, i, cn); + return 0; + } + +hiteof:; + if (cnp) + *cnp = i; + if (bp) + brelse(bp); + /* update last file cluster entry in the fat cache */ + fc_setcache(dep, FC_LASTFC, i - 1, prevcn); + return E2BIG; +} + +/* + * Find the closest entry in the fat cache to the cluster we are looking + * for. + */ +void fc_lookup(dep, findcn, frcnp, fsrcnp) + struct denode *dep; + u_long findcn; + u_long *frcnp; + u_long *fsrcnp; +{ + int i; + u_long cn; + struct fatcache *closest = 0; + + for (i = 0; i < FC_SIZE; i++) { + cn = dep->de_fc[i].fc_frcn; + if (cn != FCE_EMPTY && cn <= findcn) { + if (closest == 0 || cn > closest->fc_frcn) + closest = &dep->de_fc[i]; + } + } + if (closest) { + *frcnp = closest->fc_frcn; + *fsrcnp = closest->fc_fsrcn; + } +} + +/* + * Purge the fat cache in denode dep of all entries relating to file + * relative cluster frcn and beyond. + */ +void fc_purge(dep, frcn) + struct denode *dep; + u_int frcn; +{ + int i; + struct fatcache *fcp; + + fcp = dep->de_fc; + for (i = 0; i < FC_SIZE; i++, fcp++) { + if (fcp->fc_frcn >= frcn) + fcp->fc_frcn = FCE_EMPTY; + } +} + +/* + * Update all copies of the fat. The first copy is updated last. + * + * pmp - msdosfsmount structure for filesystem to update + * bp - addr of modified fat block + * fatbn - block number relative to begin of filesystem of the modified fat block. + */ +void +updatefats(pmp, bp, fatbn) + struct msdosfsmount *pmp; + struct buf *bp; + u_long fatbn; +{ + int i; + struct buf *bpn; + +#ifdef MSDOSFS_DEBUG + printf("updatefats(pmp %08x, bp %08x, fatbn %d)\n", + pmp, bp, fatbn); +#endif + + /* + * Now copy the block(s) of the modified fat to the other copies of + * the fat and write them out. This is faster than reading in the + * other fats and then writing them back out. This could tie up + * the fat for quite a while. Preventing others from accessing it. + * To prevent us from going after the fat quite so much we use + * delayed writes, unless they specfied "synchronous" when the + * filesystem was mounted. If synch is asked for then use + * bwrite()'s and really slow things down. + */ + for (i = 1; i < pmp->pm_FATs; i++) { + fatbn += pmp->pm_FATsecs; + /* getblk() never fails */ + bpn = getblk(pmp->pm_devvp, fatbn, bp->b_bcount, 0, 0); + bcopy(bp->b_data, bpn->b_data, bp->b_bcount); + if (pmp->pm_waitonfat) + bwrite(bpn); + else + bdwrite(bpn); + } + /* + * Write out the first fat last. + */ + if (pmp->pm_waitonfat) + bwrite(bp); + else + bdwrite(bp); +} + +/* + * Updating entries in 12 bit fats is a pain in the butt. + * + * The following picture shows where nibbles go when moving from a 12 bit + * cluster number into the appropriate bytes in the FAT. + * + * byte m byte m+1 byte m+2 + * +----+----+ +----+----+ +----+----+ + * | 0 1 | | 2 3 | | 4 5 | FAT bytes + * +----+----+ +----+----+ +----+----+ + * + * +----+----+----+ +----+----+----+ + * | 3 0 1 | | 4 5 2 | + * +----+----+----+ +----+----+----+ + * cluster n cluster n+1 + * + * Where n is even. m = n + (n >> 2) + * + */ +extern __inline void +usemap_alloc(pmp, cn) + struct msdosfsmount *pmp; + u_long cn; +{ + pmp->pm_inusemap[cn / N_INUSEBITS] + |= 1 << (cn % N_INUSEBITS); + pmp->pm_freeclustercount--; +} + +extern __inline void +usemap_free(pmp, cn) + struct msdosfsmount *pmp; + u_long cn; +{ + pmp->pm_freeclustercount++; + pmp->pm_inusemap[cn / N_INUSEBITS] &= ~(1 << (cn % N_INUSEBITS)); +} + +int +clusterfree(pmp, cluster, oldcnp) + struct msdosfsmount *pmp; + u_long cluster; + u_long *oldcnp; +{ + int error; + u_long oldcn; + + error = fatentry(FAT_GET_AND_SET, pmp, cluster, &oldcn, MSDOSFSFREE); + if (error == 0) { + /* + * If the cluster was successfully marked free, then update + * the count of free clusters, and turn off the "allocated" + * bit in the "in use" cluster bit map. + */ + usemap_free(pmp, cluster); + if (oldcnp) + *oldcnp = oldcn; + } + return error; +} + +/* + * Get or Set or 'Get and Set' the cluster'th entry in the fat. + * + * function - whether to get or set a fat entry + * pmp - address of the msdosfsmount structure for the filesystem + * whose fat is to be manipulated. + * cn - which cluster is of interest + * oldcontents - address of a word that is to receive the contents of the + * cluster'th entry if this is a get function + * newcontents - the new value to be written into the cluster'th element of + * the fat if this is a set function. + * + * This function can also be used to free a cluster by setting the fat entry + * for a cluster to 0. + * + * All copies of the fat are updated if this is a set function. NOTE: If + * fatentry() marks a cluster as free it does not update the inusemap in + * the msdosfsmount structure. This is left to the caller. + */ +int +fatentry(function, pmp, cn, oldcontents, newcontents) + int function; + struct msdosfsmount *pmp; + u_long cn; + u_long *oldcontents; + u_long newcontents; +{ + int error; + u_long readcn; + u_long bn, bo, bsize, byteoffset; + struct buf *bp; + + /* + * printf("fatentry(func %d, pmp %08x, clust %d, oldcon %08x, newcon %d)\n", + * function, pmp, cluster, oldcontents, newcontents); + */ + +#ifdef DIAGNOSTIC + /* + * Be sure they asked us to do something. + */ + if ((function & (FAT_SET | FAT_GET)) == 0) { + printf("fatentry(): function code doesn't specify get or set\n"); + return EINVAL; + } + + /* + * If they asked us to return a cluster number but didn't tell us + * where to put it, give them an error. + */ + if ((function & FAT_GET) && oldcontents == NULL) { + printf("fatentry(): get function with no place to put result\n"); + return EINVAL; + } +#endif + + /* + * Be sure the requested cluster is in the filesystem. + */ + if (cn < CLUST_FIRST || cn > pmp->pm_maxcluster) + return EINVAL; + + byteoffset = FATOFS(pmp, cn); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp)) + return error; + + if (function & FAT_GET) { + readcn = getushort(&bp->b_data[bo]); + if (FAT12(pmp)) { + if (cn & 1) + readcn >>= 4; + readcn &= 0x0fff; + /* map certain 12 bit fat entries to 16 bit */ + if ((readcn & 0x0ff0) == 0x0ff0) + readcn |= 0xf000; + } + *oldcontents = readcn; + } + if (function & FAT_SET) { + if (FAT12(pmp)) { + readcn = getushort(&bp->b_data[bo]); + if (cn & 1) { + readcn &= 0x000f; + readcn |= newcontents << 4; + } else { + readcn &= 0xf000; + readcn |= newcontents & 0xfff; + } + putushort(&bp->b_data[bo], readcn); + } else + putushort(&bp->b_data[bo], newcontents); + updatefats(pmp, bp, bn); + bp = NULL; + pmp->pm_fmod = 1; + } + if (bp) + brelse(bp); + return 0; +} + +/* + * Update a contiguous cluster chain + * + * pmp - mount point + * start - first cluster of chain + * count - number of clusters in chain + * fillwith - what to write into fat entry of last cluster + */ +static int +fatchain(pmp, start, count, fillwith) + struct msdosfsmount *pmp; + u_long start; + u_long count; + u_long fillwith; +{ + int error; + u_long bn, bo, bsize, byteoffset, readcn, newc; + struct buf *bp; + +#ifdef MSDOSFS_DEBUG + printf("fatchain(pmp %08x, start %d, count %d, fillwith %d)\n", + pmp, start, count, fillwith); +#endif + /* + * Be sure the clusters are in the filesystem. + */ + if (start < CLUST_FIRST || start + count - 1 > pmp->pm_maxcluster) + return EINVAL; + + while (count > 0) { + byteoffset = FATOFS(pmp, start); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp)) + return error; + while (count > 0) { + start++; + newc = --count > 0 ? start : fillwith; + if (FAT12(pmp)) { + readcn = getushort(&bp->b_data[bo]); + if (start & 1) { + readcn &= 0xf000; + readcn |= newc & 0xfff; + } else { + readcn &= 0x000f; + readcn |= newc << 4; + } + putushort(&bp->b_data[bo], readcn); + bo++; + if (!(start & 1)) + bo++; + } else { + putushort(&bp->b_data[bo], newc); + bo += 2; + } + if (bo >= bsize) + break; + } + updatefats(pmp, bp, bn); + } + pmp->pm_fmod = 1; + return 0; +} + +/* + * Check the length of a free cluster chain starting at start. + * + * pmp - mount point + * start - start of chain + * count - maximum interesting length + */ +int +chainlength(pmp, start, count) + struct msdosfsmount *pmp; + u_long start; + u_long count; +{ + u_long idx, max_idx; + u_int map; + u_long len; + + max_idx = pmp->pm_maxcluster / N_INUSEBITS; + idx = start / N_INUSEBITS; + start %= N_INUSEBITS; + map = pmp->pm_inusemap[idx]; + map &= ~((1 << start) - 1); + if (map) { + len = ffs(map) - 1 - start; + return len > count ? count : len; + } + len = N_INUSEBITS - start; + if (len >= count) + return count; + while (++idx <= max_idx) { + if (len >= count) + break; + if (map = pmp->pm_inusemap[idx]) { + len += ffs(map) - 1; + break; + } + len += N_INUSEBITS; + } + return len > count ? count : len; +} + +/* + * Allocate contigous free clusters. + * + * pmp - mount point. + * start - start of cluster chain. + * count - number of clusters to allocate. + * fillwith - put this value into the fat entry for the + * last allocated cluster. + * retcluster - put the first allocated cluster's number here. + * got - how many clusters were actually allocated. + */ +int +chainalloc(pmp, start, count, fillwith, retcluster, got) + struct msdosfsmount *pmp; + u_long start; + u_long count; + u_long fillwith; + u_long *retcluster; + u_long *got; +{ + int error; + + error = fatchain(pmp, start, count, fillwith); + if (error == 0) { +#ifdef MSDOSFS_DEBUG + printf("clusteralloc(): allocated cluster chain at %d (%d clusters)\n", + start, count); +#endif + if (retcluster) + *retcluster = start; + if (got) + *got = count; + while (count-- > 0) + usemap_alloc(pmp, start++); + } + return error; +} + +/* + * Allocate contiguous free clusters. + * + * pmp - mount point. + * start - preferred start of cluster chain. + * count - number of clusters requested. + * fillwith - put this value into the fat entry for the + * last allocated cluster. + * retcluster - put the first allocated cluster's number here. + * got - how many clusters were actually allocated. + */ +int +clusteralloc(pmp, start, count, fillwith, retcluster, got) + struct msdosfsmount *pmp; + u_long start; + u_long count; + u_long fillwith; + u_long *retcluster; + u_long *got; +{ + int error; + u_long idx; + u_long len, newst, foundcn, foundl, cn, l; + u_int map; + +#ifdef MSDOSFS_DEBUG + printf("clusteralloc(): find %d clusters\n",count); +#endif + if (start) { + if ((len = chainlength(pmp, start, count)) >= count) + return chainalloc(pmp, start, count, fillwith, retcluster, got); + } else { + /* + * This is a new file, initialize start + */ + struct timeval tv; + + microtime(&tv); + start = (tv.tv_usec >> 10)|tv.tv_usec; + len = 0; + } + + /* + * Start at a (pseudo) random place to maximize cluster runs + * under multiple writers. + */ + foundcn = newst = (start * 1103515245 + 12345) % (pmp->pm_maxcluster + 1); + foundl = 0; + + for (cn = newst; cn <= pmp->pm_maxcluster;) { + idx = cn / N_INUSEBITS; + map = pmp->pm_inusemap[idx]; + map |= (1 << (cn % N_INUSEBITS)) - 1; + if (map != (u_int)-1) { + cn = idx * N_INUSEBITS + ffs(map^(u_int)-1) - 1; + if ((l = chainlength(pmp, cn, count)) >= count) + return chainalloc(pmp, cn, count, fillwith, retcluster, got); + if (l > foundl) { + foundcn = cn; + foundl = l; + } + cn += l + 1; + continue; + } + cn += N_INUSEBITS - cn % N_INUSEBITS; + } + for (cn = 0; cn < newst;) { + idx = cn / N_INUSEBITS; + map = pmp->pm_inusemap[idx]; + map |= (1 << (cn % N_INUSEBITS)) - 1; + if (map != (u_int)-1) { + cn = idx * N_INUSEBITS + ffs(map^(u_int)-1) - 1; + if ((l = chainlength(pmp, cn, count)) >= count) + return chainalloc(pmp, cn, count, fillwith, retcluster, got); + if (l > foundl) { + foundcn = cn; + foundl = l; + } + cn += l + 1; + continue; + } + cn += N_INUSEBITS - cn % N_INUSEBITS; + } + + if (!foundl) + return ENOSPC; + + if (len) + return chainalloc(pmp, start, len, fillwith, retcluster, got); + else + return chainalloc(pmp, foundcn, foundl, fillwith, retcluster, got); +} + + +/* + * Free a chain of clusters. + * + * pmp - address of the msdosfs mount structure for the filesystem + * containing the cluster chain to be freed. + * startcluster - number of the 1st cluster in the chain of clusters to be + * freed. + */ +int +freeclusterchain(pmp, cluster) + struct msdosfsmount *pmp; + u_long cluster; +{ + int error = 0; + struct buf *bp = NULL; + u_long bn, bo, bsize, byteoffset; + u_long readcn, lbn = -1; + + while (cluster >= CLUST_FIRST && cluster <= pmp->pm_maxcluster) { + byteoffset = FATOFS(pmp, cluster); + fatblock(pmp, byteoffset, &bn, &bsize, &bo); + if (lbn != bn) { + if (bp) + updatefats(pmp, bp, bn); + if (error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp)) + return error; + lbn = bn; + } + usemap_free(pmp, cluster); + readcn = getushort(&bp->b_data[bo]); + if (FAT12(pmp)) { + if (cluster & 1) { + cluster = readcn >> 4; + readcn &= 0x000f; + readcn |= MSDOSFSFREE << 4; + } else { + cluster = readcn; + readcn &= 0xf000; + readcn |= MSDOSFSFREE & 0xfff; + } + putushort(&bp->b_data[bo], readcn); + cluster &= 0x0fff; + if ((cluster&0x0ff0) == 0x0ff0) + cluster |= 0xf000; + } else { + cluster = readcn; + putushort(&bp->b_data[bo], MSDOSFSFREE); + } + } + if (bp) + updatefats(pmp, bp, bn); + return error; +} + +/* + * Read in fat blocks looking for free clusters. For every free cluster + * found turn off its corresponding bit in the pm_inusemap. + */ +int +fillinusemap(pmp) + struct msdosfsmount *pmp; +{ + struct buf *bp = NULL; + u_long cn, readcn; + int error; + int fat12 = FAT12(pmp); + u_long bn, bo, bsize, byteoffset; + + /* + * Mark all clusters in use, we mark the free ones in the fat scan + * loop further down. + */ + for (cn = 0; cn < (pmp->pm_maxcluster + N_INUSEBITS) / N_INUSEBITS; cn++) + pmp->pm_inusemap[cn] = (u_int)-1; + + /* + * Figure how many free clusters are in the filesystem by ripping + * through the fat counting the number of entries whose content is + * zero. These represent free clusters. + */ + pmp->pm_freeclustercount = 0; + for (cn = CLUST_FIRST; cn <= pmp->pm_maxcluster; cn++) { + byteoffset = FATOFS(pmp, cn); + bo = byteoffset % pmp->pm_fatblocksize; + if (!bo || !bp) { + /* Read new FAT block */ + if (bp) + brelse(bp); + fatblock(pmp, byteoffset, &bn, &bsize, NULL); + error = bread(pmp->pm_devvp, bn, bsize, NOCRED, &bp); + if (error) + return error; + } + readcn = getushort(&bp->b_data[bo]); + if (fat12) { + if (cn & 1) + readcn >>= 4; + readcn &= 0x0fff; + } + + if (readcn == 0) + usemap_free(pmp, cn); + } + brelse(bp); + return 0; +} + +/* + * Allocate a new cluster and chain it onto the end of the file. + * + * dep - the file to extend + * count - number of clusters to allocate + * bpp - where to return the address of the buf header for the first new + * file block + * ncp - where to put cluster number of the first newly allocated cluster + * If this pointer is 0, do not return the cluster number. + * flags - see fat.h + * + * NOTE: This function is not responsible for turning on the DE_UPDATE bit of + * the de_flag field of the denode and it does not change the de_FileSize + * field. This is left for the caller to do. + */ +int +extendfile(dep, count, bpp, ncp, flags) + struct denode *dep; + u_long count; + struct buf **bpp; + u_long *ncp; + int flags; +{ + int error = 0; + u_long frcn; + u_long cn, got; + struct msdosfsmount *pmp = dep->de_pmp; + struct buf *bp; + + /* + * Don't try to extend the root directory + */ + if (DETOV(dep)->v_flag & VROOT) { + printf("extendfile(): attempt to extend root directory\n"); + return ENOSPC; + } + + /* + * If the "file's last cluster" cache entry is empty, and the file + * is not empty, then fill the cache entry by calling pcbmap(). + */ + fc_fileextends++; + if (dep->de_fc[FC_LASTFC].fc_frcn == FCE_EMPTY && + dep->de_StartCluster != 0) { + fc_lfcempty++; + error = pcbmap(dep, 0xffff, 0, &cn); + /* we expect it to return E2BIG */ + if (error != E2BIG) + return error; + error = 0; + } + + while (count > 0) { + /* + * Allocate a new cluster chain and cat onto the end of the file. + * If the file is empty we make de_StartCluster point to the new + * block. Note that de_StartCluster being 0 is sufficient to be + * sure the file is empty since we exclude attempts to extend the + * root directory above, and the root dir is the only file with a + * startcluster of 0 that has blocks allocated (sort of). + */ + if (dep->de_StartCluster == 0) + cn = 0; + else + cn = dep->de_fc[FC_LASTFC].fc_fsrcn + 1; + if (error = clusteralloc(pmp, cn, count, CLUST_EOFE, &cn, &got)) + return error; + + count -= got; + + /* + * Give them the filesystem relative cluster number if they want + * it. + */ + if (ncp) { + *ncp = cn; + ncp = NULL; + } + + if (dep->de_StartCluster == 0) { + dep->de_StartCluster = cn; + frcn = 0; + } else { + error = fatentry(FAT_SET, pmp, dep->de_fc[FC_LASTFC].fc_fsrcn, + 0, cn); + if (error) { + clusterfree(pmp, cn, NULL); + return error; + } + + frcn = dep->de_fc[FC_LASTFC].fc_frcn + 1; + } + + /* + * Update the "last cluster of the file" entry in the denode's fat + * cache. + */ + fc_setcache(dep, FC_LASTFC, frcn + got - 1, cn + got - 1); + + if (flags & DE_CLEAR) { + while (got-- > 0) { + /* + * Get the buf header for the new block of the file. + */ + if (dep->de_Attributes & ATTR_DIRECTORY) + bp = getblk(pmp->pm_devvp, cntobn(pmp, cn++), + pmp->pm_bpcluster, 0, 0); + else { + bp = getblk(DETOV(dep), frcn++, pmp->pm_bpcluster, 0, 0); + /* + * Do the bmap now, as in msdosfs_write + */ + if (pcbmap(dep, bp->b_lblkno, &bp->b_blkno, 0)) + bp->b_blkno = -1; + if (bp->b_blkno == -1) + panic("extendfile: pcbmap"); + } + clrbuf(bp); + if (bpp) { + *bpp = bp; + bpp = NULL; + } else { + bp->b_flags |= B_AGE; + bawrite(bp); + } + } + } + } + + return 0; +} diff --git a/sys/msdosfs/msdosfs_lookup.c b/sys/msdosfs/msdosfs_lookup.c new file mode 100644 index 0000000..c67f888 --- /dev/null +++ b/sys/msdosfs/msdosfs_lookup.c @@ -0,0 +1,763 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_lookup.c,v 1.14 1994/08/21 18:44:07 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/namei.h> +#include <sys/buf.h> +#include <sys/vnode.h> +#include <sys/mount.h> + +#include <msdosfs/bpb.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/fat.h> + +/* + * When we search a directory the blocks containing directory entries are + * read and examined. The directory entries contain information that would + * normally be in the inode of a unix filesystem. This means that some of + * a directory's contents may also be in memory resident denodes (sort of + * an inode). This can cause problems if we are searching while some other + * process is modifying a directory. To prevent one process from accessing + * incompletely modified directory information we depend upon being the + * soul owner of a directory block. bread/brelse provide this service. + * This being the case, when a process modifies a directory it must first + * acquire the disk block that contains the directory entry to be modified. + * Then update the disk block and the denode, and then write the disk block + * out to disk. This way disk blocks containing directory entries and in + * memory denode's will be in synch. + */ +int +msdosfs_lookup(ap) + struct vop_lookup_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + } */ *ap; +{ + struct vnode *vdp = ap->a_dvp; + struct vnode **vpp = ap->a_vpp; + struct componentname *cnp = ap->a_cnp; + daddr_t bn; + int error; + int lockparent; + int wantparent; + int slotstatus; + +#define NONE 0 +#define FOUND 1 + int slotoffset = -1; + int slotcluster = -1; + int frcn; + u_long cluster; + int rootreloff; + int diroff; + int isadir; /* ~0 if found direntry is a directory */ + u_long scn; /* starting cluster number */ + struct vnode *pdp; + struct denode *dp; + struct denode *tdp; + struct msdosfsmount *pmp; + struct buf *bp = 0; + struct direntry *dep = NULL; + u_char dosfilename[12]; + int flags = cnp->cn_flags; + int nameiop = cnp->cn_nameiop; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): looking for %s\n", cnp->cn_nameptr); +#endif + dp = VTODE(vdp); + pmp = dp->de_pmp; + *vpp = NULL; + lockparent = flags & LOCKPARENT; + wantparent = flags & (LOCKPARENT | WANTPARENT); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): vdp %08x, dp %08x, Attr %02x\n", + vdp, dp, dp->de_Attributes); +#endif + + /* + * Be sure vdp is a directory. Since dos filesystems don't have + * the concept of execute permission anybody can search a + * directory. + */ + if ((dp->de_Attributes & ATTR_DIRECTORY) == 0) + return ENOTDIR; + + /* + * See if the component of the pathname we are looking for is in + * the directory cache. If so then do a few things and return. + */ + if (error = cache_lookup(vdp, vpp, cnp)) { + int vpid; + + if (error == ENOENT) + return error; + pdp = vdp; + vdp = *vpp; + dp = VTODE(vdp); + vpid = vdp->v_id; + if (pdp == vdp) { + VREF(vdp); + error = 0; + } else if (flags & ISDOTDOT) { + VOP_UNLOCK(pdp); + error = vget(vdp, 1); + if (!error && lockparent && (flags & ISLASTCN)) + error = VOP_LOCK(pdp); + } else { + error = vget(vdp, 1); + if (!lockparent || error || !(flags & ISLASTCN)) + VOP_UNLOCK(pdp); + } + + if (!error) { + if (vpid == vdp->v_id) { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): cache hit, vnode %08x, file %s\n", + vdp, dp->de_Name); +#endif + return 0; + } + vput(vdp); + if (lockparent && pdp != vdp && (flags & ISLASTCN)) + VOP_UNLOCK(pdp); + } + if (error = VOP_LOCK(pdp)) + return error; + vdp = pdp; + dp = VTODE(vdp); + *vpp = NULL; + } + + /* + * If they are going after the . or .. entry in the root directory, + * they won't find it. DOS filesystems don't have them in the root + * directory. So, we fake it. deget() is in on this scam too. + */ + if ((vdp->v_flag & VROOT) && cnp->cn_nameptr[0] == '.' && + (cnp->cn_namelen == 1 || + (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.'))) { + isadir = ATTR_DIRECTORY; + scn = MSDOSFSROOT; +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): looking for . or .. in root directory\n"); +#endif + cluster = MSDOSFSROOT; + diroff = MSDOSFSROOT_OFS; + goto foundroot; + } + + /* + * Don't search for free slots unless we are creating a filename + * and we are at the end of the pathname. + */ + slotstatus = FOUND; + if ((nameiop == CREATE || nameiop == RENAME) && (flags & ISLASTCN)) { + slotstatus = NONE; + slotoffset = -1; + } + + unix2dosfn((u_char *) cnp->cn_nameptr, dosfilename, cnp->cn_namelen); + dosfilename[11] = 0; +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): dos version of filename %s, length %d\n", + dosfilename, cnp->cn_namelen); +#endif + /* + * Search the directory pointed at by vdp for the name pointed at + * by cnp->cn_nameptr. + */ + tdp = NULL; + /* + * The outer loop ranges over the clusters that make up the + * directory. Note that the root directory is different from all + * other directories. It has a fixed number of blocks that are not + * part of the pool of allocatable clusters. So, we treat it a + * little differently. The root directory starts at "cluster" 0. + */ + rootreloff = 0; + for (frcn = 0;; frcn++) { + if (error = pcbmap(dp, frcn, &bn, &cluster)) { + if (error == E2BIG) + break; + return error; + } + if (error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, &bp)) + return error; + for (diroff = 0; diroff < pmp->pm_depclust; diroff++) { + dep = (struct direntry *) bp->b_data + diroff; + + /* + * If the slot is empty and we are still looking + * for an empty then remember this one. If the + * slot is not empty then check to see if it + * matches what we are looking for. If the slot + * has never been filled with anything, then the + * remainder of the directory has never been used, + * so there is no point in searching it. + */ + if (dep->deName[0] == SLOT_EMPTY || + dep->deName[0] == SLOT_DELETED) { + if (slotstatus != FOUND) { + slotstatus = FOUND; + if (cluster == MSDOSFSROOT) + slotoffset = rootreloff; + else + slotoffset = diroff; + slotcluster = cluster; + } + if (dep->deName[0] == SLOT_EMPTY) { + brelse(bp); + goto notfound; + } + } else { + /* + * Ignore volume labels (anywhere, not just + * the root directory). + */ + if ((dep->deAttributes & ATTR_VOLUME) == 0 && + bcmp(dosfilename, dep->deName, 11) == 0) { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): match diroff %d, rootreloff %d\n", + diroff, rootreloff); +#endif + /* + * Remember where this directory + * entry came from for whoever did + * this lookup. If this is the root + * directory we are interested in + * the offset relative to the + * beginning of the directory (not + * the beginning of the cluster). + */ + if (cluster == MSDOSFSROOT) + diroff = rootreloff; + dp->de_fndoffset = diroff; + dp->de_fndclust = cluster; + goto found; + } + } + rootreloff++; + } /* for (diroff = 0; .... */ + /* + * Release the buffer holding the directory cluster just + * searched. + */ + brelse(bp); + } /* for (frcn = 0; ; frcn++) */ +notfound:; + /* + * We hold no disk buffers at this point. + */ + + /* + * If we get here we didn't find the entry we were looking for. But + * that's ok if we are creating or renaming and are at the end of + * the pathname and the directory hasn't been removed. + */ +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): op %d, refcnt %d, slotstatus %d\n", + nameiop, dp->de_refcnt, slotstatus); + printf(" slotoffset %d, slotcluster %d\n", + slotoffset, slotcluster); +#endif + if ((nameiop == CREATE || nameiop == RENAME) && + (flags & ISLASTCN) && dp->de_refcnt != 0) { + if (slotstatus == NONE) { + dp->de_fndoffset = (u_long)-1; + dp->de_fndclust = (u_long)-1; + } else { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_lookup(): saving empty slot location\n"); +#endif + dp->de_fndoffset = slotoffset; + dp->de_fndclust = slotcluster; + } + /* dp->de_flag |= DE_UPDATE; never update dos directories */ + cnp->cn_flags |= SAVENAME; + if (!lockparent)/* leave searched dir locked? */ + VOP_UNLOCK(vdp); + return EJUSTRETURN; + } + /* + * Insert name in cache as non-existant if not trying to create it. + */ + if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE) + cache_enter(vdp, *vpp, cnp); + return ENOENT; + +found: ; + /* + * NOTE: We still have the buffer with matched directory entry at + * this point. + */ + isadir = dep->deAttributes & ATTR_DIRECTORY; + scn = getushort(dep->deStartCluster); + +foundroot:; + /* + * If we entered at foundroot, then we are looking for the . or .. + * entry of the filesystems root directory. isadir and scn were + * setup before jumping here. And, bp is null. There is no buf + * header. + */ + + /* + * If deleting and at the end of the path, then if we matched on + * "." then don't deget() we would probably panic(). Otherwise + * deget() the directory entry. + */ + if (nameiop == DELETE && (flags & ISLASTCN)) { + if (dp->de_StartCluster == scn && isadir) { /* "." */ + VREF(vdp); + *vpp = vdp; + if (bp) + brelse(bp); + return 0; + } + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + if (bp) + brelse(bp); + return error; + } + *vpp = DETOV(tdp); + if (!lockparent) + VOP_UNLOCK(vdp); + if (bp) + brelse(bp); + return 0; + } + + /* + * If renaming. + */ + if (nameiop == RENAME && wantparent && (flags & ISLASTCN)) { + if (dp->de_StartCluster == scn && isadir) { + if (bp) + brelse(bp); + return EISDIR; + } + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + if (bp) + brelse(bp); + return error; + } + *vpp = DETOV(tdp); + cnp->cn_flags |= SAVENAME; + if (!lockparent) + VOP_UNLOCK(vdp); + if (bp) + brelse(bp); + return 0; + } + + /* + * ? + */ + pdp = vdp; + if (flags & ISDOTDOT) { + VOP_UNLOCK(pdp); + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + VOP_LOCK(pdp); + if (bp) + brelse(bp); + return error; + } + if (lockparent && (flags & ISLASTCN) + && (error = VOP_LOCK(pdp))) { + vput(DETOV(tdp)); + return error; + } + *vpp = DETOV(tdp); + } else if (dp->de_StartCluster == scn && isadir) { /* "." */ + VREF(vdp); + *vpp = vdp; + } else { + error = deget(pmp, cluster, diroff, dep, &tdp); + if (error) { + if (bp) + brelse(bp); + return error; + } + if (!lockparent || !(flags & ISLASTCN)) + VOP_UNLOCK(pdp); + *vpp = DETOV(tdp); + } + if (bp) + brelse(bp); + + /* + * Insert name in cache if wanted. + */ + if (cnp->cn_flags & MAKEENTRY) + cache_enter(vdp, *vpp, cnp); + return 0; +} + +/* + * dep - directory entry to copy into the directory + * ddep - directory to add to + * depp - return the address of the denode for the created directory entry + * if depp != 0 + */ +int +createde(dep, ddep, depp) + struct denode *dep; + struct denode *ddep; + struct denode **depp; +{ + int bn; + int error; + u_long dirclust, diroffset; + struct direntry *ndep; + struct msdosfsmount *pmp = ddep->de_pmp; + struct buf *bp; + +#ifdef MSDOSFS_DEBUG + printf("createde(dep %08x, ddep %08x, depp %08x)\n", dep, ddep, depp); +#endif + + /* + * If no space left in the directory then allocate another cluster + * and chain it onto the end of the file. There is one exception + * to this. That is, if the root directory has no more space it + * can NOT be expanded. extendfile() checks for and fails attempts + * to extend the root directory. We just return an error in that + * case. + */ + if (ddep->de_fndclust == (u_long)-1) { + if (error = extendfile(ddep, 1, &bp, &dirclust, DE_CLEAR)) + return error; + ndep = (struct direntry *) bp->b_data; + /* + * Let caller know where we put the directory entry. + */ + ddep->de_fndclust = dirclust; + ddep->de_fndoffset = diroffset = 0; + /* + * Update the size of the directory + */ + ddep->de_FileSize += pmp->pm_bpcluster; + } else { + /* + * There is space in the existing directory. So, we just + * read in the cluster with space. Copy the new directory + * entry in. Then write it to disk. NOTE: DOS directories + * do not get smaller as clusters are emptied. + */ + dirclust = ddep->de_fndclust; + diroffset = ddep->de_fndoffset; + + error = readep(pmp, dirclust, diroffset, &bp, &ndep); + if (error) + return error; + } + DE_EXTERNALIZE(ndep, dep); + + /* + * If they want us to return with the denode gotten. + */ + if (depp) { + error = deget(pmp, dirclust, diroffset, ndep, depp); + if (error) + return error; + } + if (error = bwrite(bp)) { + vput(DETOV(*depp)); /* free the vnode we got on error */ + return error; + } + return 0; +} + +/* + * Read in a directory entry and mark it as being deleted. + */ +int +markdeleted(pmp, dirclust, diroffset) + struct msdosfsmount *pmp; + u_long dirclust; + u_long diroffset; +{ + int error; + struct direntry *ep; + struct buf *bp; + + error = readep(pmp, dirclust, diroffset, &bp, &ep); + if (error) + return error; + ep->deName[0] = SLOT_DELETED; + return bwrite(bp); +} + +/* + * Remove a directory entry. At this point the file represented by the + * directory entry to be removed is still full length until no one has it + * open. When the file no longer being used msdosfs_inactive() is called + * and will truncate the file to 0 length. When the vnode containing the + * denode is needed for some other purpose by VFS it will call + * msdosfs_reclaim() which will remove the denode from the denode cache. + */ +int +removede(pdep,dep) + struct denode *pdep; /* directory where the entry is removed */ + struct denode *dep; /* file to be removed */ +{ + struct msdosfsmount *pmp = pdep->de_pmp; + int error; + +#ifdef MSDOSFS_DEBUG + printf("removede(): filename %s\n", dep->de_Name); + printf("removede(): dep %08x, ndpcluster %d, ndpoffset %d\n", + dep, pdep->de_fndclust, pdep->de_fndoffset); +#endif + + /* + * Read the directory block containing the directory entry we are + * to make free. The nameidata structure holds the cluster number + * and directory entry index number of the entry to free. + */ + error = markdeleted(pmp, pdep->de_fndclust, pdep->de_fndoffset); + + if (error == 0) + dep->de_refcnt--; + return error; +} + +/* + * Be sure a directory is empty except for "." and "..". Return 1 if empty, + * return 0 if not empty or error. + */ +int +dosdirempty(dep) + struct denode *dep; +{ + int dei; + int error; + u_long cn; + daddr_t bn; + struct buf *bp; + struct msdosfsmount *pmp = dep->de_pmp; + struct direntry *dentp; + + /* + * Since the filesize field in directory entries for a directory is + * zero, we just have to feel our way through the directory until + * we hit end of file. + */ + for (cn = 0;; cn++) { + error = pcbmap(dep, cn, &bn, 0); + if (error == E2BIG) + return 1; /* it's empty */ + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, + &bp); + if (error) + return error; + dentp = (struct direntry *) bp->b_data; + for (dei = 0; dei < pmp->pm_depclust; dei++) { + if (dentp->deName[0] != SLOT_DELETED) { + /* + * In dos directories an entry whose name + * starts with SLOT_EMPTY (0) starts the + * beginning of the unused part of the + * directory, so we can just return that it + * is empty. + */ + if (dentp->deName[0] == SLOT_EMPTY) { + brelse(bp); + return 1; + } + /* + * Any names other than "." and ".." in a + * directory mean it is not empty. + */ + if (bcmp(dentp->deName, ". ", 11) && + bcmp(dentp->deName, ".. ", 11)) { + brelse(bp); +#ifdef MSDOSFS_DEBUG + printf("dosdirempty(): entry %d found %02x, %02x\n", + dei, dentp->deName[0], dentp->deName[1]); +#endif + return 0; /* not empty */ + } + } + dentp++; + } + brelse(bp); + } + /* NOTREACHED */ +} + +/* + * Check to see if the directory described by target is in some + * subdirectory of source. This prevents something like the following from + * succeeding and leaving a bunch or files and directories orphaned. mv + * /a/b/c /a/b/c/d/e/f Where c and f are directories. + * + * source - the inode for /a/b/c + * target - the inode for /a/b/c/d/e/f + * + * Returns 0 if target is NOT a subdirectory of source. + * Otherwise returns a non-zero error number. + * The target inode is always unlocked on return. + */ +int +doscheckpath(source, target) + struct denode *source; + struct denode *target; +{ + daddr_t scn; + struct denode dummy; + struct msdosfsmount *pmp; + struct direntry *ep; + struct denode *dep; + struct buf *bp = NULL; + int error = 0; + + dep = target; + if ((target->de_Attributes & ATTR_DIRECTORY) == 0 || + (source->de_Attributes & ATTR_DIRECTORY) == 0) { + error = ENOTDIR; + goto out; + } + if (dep->de_StartCluster == source->de_StartCluster) { + error = EEXIST; + goto out; + } + if (dep->de_StartCluster == MSDOSFSROOT) + goto out; + for (;;) { + if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) { + error = ENOTDIR; + goto out; + } + pmp = dep->de_pmp; + scn = dep->de_StartCluster; + error = bread(pmp->pm_devvp, cntobn(pmp, scn), + pmp->pm_bpcluster, NOCRED, &bp); + if (error) { + break; + } + ep = (struct direntry *) bp->b_data + 1; + if ((ep->deAttributes & ATTR_DIRECTORY) == 0 || + bcmp(ep->deName, ".. ", 11) != 0) { + error = ENOTDIR; + break; + } + scn = getushort(ep->deStartCluster); + if (scn == source->de_StartCluster) { + error = EINVAL; + break; + } + if (scn == MSDOSFSROOT) + break; + vput(DETOV(dep)); + /* NOTE: deget() clears dep on error */ + error = deget(pmp, scn, 0, ep, &dep); + brelse(bp); + bp = NULL; + if (error) + break; + } +out: ; + if (bp) + brelse(bp); + if (error == ENOTDIR) + printf("doscheckpath(): .. not a directory?\n"); + if (dep != NULL) + vput(DETOV(dep)); + return error; +} + +/* + * Read in the disk block containing the directory entry (dirclu, dirofs) + * and return the address of the buf header, and the address of the + * directory entry within the block. + */ +int +readep(pmp, dirclu, dirofs, bpp, epp) + struct msdosfsmount *pmp; + u_long dirclu, dirofs; + struct buf **bpp; + struct direntry **epp; +{ + int error; + daddr_t bn; + + bn = detobn(pmp, dirclu, dirofs); + if (error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, bpp)) { + *bpp = NULL; + return error; + } + if (epp) + *epp = bptoep(pmp, *bpp, dirofs); + return 0; +} + + +/* + * Read in the disk block containing the directory entry dep came from and + * return the address of the buf header, and the address of the directory + * entry within the block. + */ +int +readde(dep, bpp, epp) + struct denode *dep; + struct buf **bpp; + struct direntry **epp; +{ + return readep(dep->de_pmp, dep->de_dirclust, dep->de_diroffset, + bpp, epp); +} diff --git a/sys/msdosfs/msdosfs_vfsops.c b/sys/msdosfs/msdosfs_vfsops.c new file mode 100644 index 0000000..ac9c284 --- /dev/null +++ b/sys/msdosfs/msdosfs_vfsops.c @@ -0,0 +1,733 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_vfsops.c,v 1.19 1994/08/21 18:44:10 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/proc.h> +#include <sys/kernel.h> +#include <sys/vnode.h> +#include <miscfs/specfs/specdev.h> /* XXX */ /* defines v_rdev */ +#include <sys/mount.h> +#include <sys/buf.h> +#include <sys/file.h> +#include <sys/malloc.h> + +#include <msdosfs/bpb.h> +#include <msdosfs/bootsect.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/fat.h> + +int msdosfsdoforce = 1; /* 1 = force unmount */ + +/* + * mp - path - addr in user space of mount point (ie /usr or whatever) + * data - addr in user space of mount params including the name of the block + * special file to treat as a filesystem. + */ +int +msdosfs_mount(mp, path, data, ndp, p) + struct mount *mp; + char *path; + caddr_t data; + struct nameidata *ndp; + struct proc *p; +{ + struct vnode *devvp; /* vnode for blk device to mount */ + struct msdosfs_args args; /* will hold data from mount request */ + struct msdosfsmount *pmp; /* msdosfs specific mount control block */ + int error, flags; + u_int size; + struct ucred *cred, *scred; + struct vattr va; + + /* + * Copy in the args for the mount request. + */ + if (error = copyin(data, (caddr_t) & args, sizeof(struct msdosfs_args))) + return error; + + /* + * If they just want to update then be sure we can do what is + * asked. Can't change a filesystem from read/write to read only. + * Why? And if they've supplied a new device file name then we + * continue, otherwise return. + */ + if (mp->mnt_flag & MNT_UPDATE) { + pmp = (struct msdosfsmount *) mp->mnt_data; + error = 0; + if (pmp->pm_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) { + flags = WRITECLOSE; + if (mp->mnt_flag & MNT_FORCE) + flags |= FORCECLOSE; + if (vfs_busy(mp)) + return EBUSY; + error = vflush(mp, NULLVP, flags); + vfs_unbusy(mp); + } + if (!error && (mp->mnt_flag & MNT_RELOAD)) + /* not yet implemented */ + error = EINVAL; + if (error) + return error; + if (pmp->pm_ronly && (mp->mnt_flag & MNT_RDONLY) == 0) + pmp->pm_ronly = 0; + if (args.fspec == 0) { + /* + * Process export requests. + */ + return vfs_export(mp, &pmp->pm_export, &args.export); + } + } else + pmp = NULL; + + /* + * check to see that the user in owns the target directory. + * Note the very XXX trick to make sure we're checking as the + * real user -- were mount() executable by anyone, this wouldn't + * be a problem. + * + * XXX there should be one consistent error out. + */ + cred = crdup(p->p_ucred); /* XXX */ + cred->cr_uid = p->p_cred->p_ruid; /* XXX */ + error = VOP_GETATTR(mp->mnt_vnodecovered, &va, cred, p); + if (error) { + crfree(cred); /* XXX */ + return error; + } + if (cred->cr_uid != 0) { + if (va.va_uid != cred->cr_uid) { + error = EACCES; + crfree(cred); /* XXX */ + return error; + } + + /* a user mounted it; we'll verify permissions when unmounting */ + mp->mnt_flag |= MNT_USER; + } + + /* + * Now, lookup the name of the block device this mount or name + * update request is to apply to. + */ + NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); + scred = p->p_ucred; /* XXX */ + p->p_ucred = cred; /* XXX */ + error = namei(ndp); + p->p_ucred = scred; /* XXX */ + crfree(cred); /* XXX */ + if (error != 0) + return error; + + /* + * Be sure they've given us a block device to treat as a + * filesystem. And, that its major number is within the bdevsw + * table. + */ + devvp = ndp->ni_vp; + if (devvp->v_type != VBLK) { + vrele(devvp); + return ENOTBLK; + } + if (major(devvp->v_rdev) >= nblkdev) { + vrele(devvp); + return ENXIO; + } + + /* + * If this is an update, then make sure the vnode for the block + * special device is the same as the one our filesystem is in. + */ + if (mp->mnt_flag & MNT_UPDATE) { + if (devvp != pmp->pm_devvp) + error = EINVAL; + else + vrele(devvp); + } else { + + /* + * Well, it's not an update, it's a real mount request. + * Time to get dirty. + */ + error = mountmsdosfs(devvp, mp, p); + } + if (error) { + vrele(devvp); + return error; + } + + /* + * Copy in the name of the directory the filesystem is to be + * mounted on. Then copy in the name of the block special file + * representing the filesystem being mounted. And we clear the + * remainder of the character strings to be tidy. Set up the + * user id/group id/mask as specified by the user. Then, we try to + * fill in the filesystem stats structure as best we can with + * whatever applies from a dos file system. + */ + pmp = (struct msdosfsmount *) mp->mnt_data; + copyinstr(path, (caddr_t) mp->mnt_stat.f_mntonname, + sizeof(mp->mnt_stat.f_mntonname) - 1, &size); + bzero(mp->mnt_stat.f_mntonname + size, + sizeof(mp->mnt_stat.f_mntonname) - size); + copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size); + bzero(mp->mnt_stat.f_mntfromname + size, + MNAMELEN - size); + pmp->pm_mounter = p->p_cred->p_ruid; + pmp->pm_gid = args.gid; + pmp->pm_uid = args.uid; + pmp->pm_mask = args.mask; + (void) msdosfs_statfs(mp, &mp->mnt_stat, p); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_mount(): mp %x, pmp %x, inusemap %x\n", mp, pmp, pmp->pm_inusemap); +#endif + return 0; +} + +int +mountmsdosfs(devvp, mp, p) + struct vnode *devvp; + struct mount *mp; + struct proc *p; +{ + int i; + int bpc; + int bit; + int error; + int needclose; + int ronly = (mp->mnt_flag & MNT_RDONLY) != 0; + dev_t dev = devvp->v_rdev; + union bootsector *bsp; + struct msdosfsmount *pmp = NULL; + struct buf *bp0 = NULL; + struct byte_bpb33 *b33; + struct byte_bpb50 *b50; + + /* + * Multiple mounts of the same block special file aren't allowed. + * Make sure no one else has the special file open. And flush any + * old buffers from this filesystem. Presumably this prevents us + * from running into buffers that are the wrong blocksize. + */ + if (error = vfs_mountedon(devvp)) + return error; + if (vcount(devvp) > 1) + return EBUSY; + if (error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) + return error; + + /* + * Now open the block special file. + */ + if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD | FWRITE, FSCRED, p)) + return error; + needclose = 1; +#ifdef HDSUPPORT + /* + * Put this in when we support reading dos filesystems from + * partitioned harddisks. + */ + if (VOP_IOCTL(devvp, DIOCGPART, &msdosfspart, FREAD, NOCRED, p) == 0) { + } +#endif + + /* + * Read the boot sector of the filesystem, and then check the boot + * signature. If not a dos boot sector then error out. We could + * also add some checking on the bsOemName field. So far I've seen + * the following values: "IBM 3.3" "MSDOS3.3" "MSDOS5.0" + */ + if (error = bread(devvp, 0, 512, NOCRED, &bp0)) + goto error_exit; + bp0->b_flags |= B_AGE; + bsp = (union bootsector *) bp0->b_data; + b33 = (struct byte_bpb33 *) bsp->bs33.bsBPB; + b50 = (struct byte_bpb50 *) bsp->bs50.bsBPB; +#ifdef MSDOSFS_CHECKSIG + if (bsp->bs50.bsBootSectSig != BOOTSIG) { + error = EINVAL; + goto error_exit; + } +#endif + if ( bsp->bs50.bsJump[0] != 0xe9 && + (bsp->bs50.bsJump[0] != 0xeb || bsp->bs50.bsJump[2] != 0x90)) { + error = EINVAL; + goto error_exit; + } + + pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK); + bzero((caddr_t)pmp, sizeof *pmp); + pmp->pm_mountp = mp; + + /* + * Compute several useful quantities from the bpb in the + * bootsector. Copy in the dos 5 variant of the bpb then fix up + * the fields that are different between dos 5 and dos 3.3. + */ + pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec); + pmp->pm_SectPerClust = b50->bpbSecPerClust; + pmp->pm_ResSectors = getushort(b50->bpbResSectors); + pmp->pm_FATs = b50->bpbFATs; + pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts); + pmp->pm_Sectors = getushort(b50->bpbSectors); + pmp->pm_Media = b50->bpbMedia; + pmp->pm_FATsecs = getushort(b50->bpbFATsecs); + pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack); + pmp->pm_Heads = getushort(b50->bpbHeads); + + /* XXX - We should probably check more values here */ + if (!pmp->pm_BytesPerSec || !pmp->pm_SectPerClust || + !pmp->pm_Heads || pmp->pm_Heads > 255 || + !pmp->pm_SecPerTrack || pmp->pm_SecPerTrack > 63) { + error = EINVAL; + goto error_exit; + } + + if (pmp->pm_Sectors == 0) { + pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs); + pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors); + } else { + pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs); + pmp->pm_HugeSectors = pmp->pm_Sectors; + } + pmp->pm_fatblk = pmp->pm_ResSectors; + pmp->pm_rootdirblk = pmp->pm_fatblk + + (pmp->pm_FATs * pmp->pm_FATsecs); + pmp->pm_rootdirsize = (pmp->pm_RootDirEnts * sizeof(struct direntry)) + / + pmp->pm_BytesPerSec;/* in sectors */ + pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize; + pmp->pm_nmbrofclusters = (pmp->pm_HugeSectors - pmp->pm_firstcluster) / + pmp->pm_SectPerClust; + pmp->pm_maxcluster = pmp->pm_nmbrofclusters + 1; + pmp->pm_fatsize = pmp->pm_FATsecs * pmp->pm_BytesPerSec; + if (FAT12(pmp)) + /* + * This will usually be a floppy disk. This size makes sure + * that one fat entry will not be split across multiple + * blocks. + */ + pmp->pm_fatblocksize = 3 * pmp->pm_BytesPerSec; + else + /* + * This will usually be a hard disk. Reading or writing one + * block should be quite fast. + */ + pmp->pm_fatblocksize = MAXBSIZE; + pmp->pm_fatblocksec = pmp->pm_fatblocksize / pmp->pm_BytesPerSec; + + + if ((pmp->pm_rootdirsize % pmp->pm_SectPerClust) != 0) + printf("mountmsdosfs(): root directory is not a multiple of the clustersize in length\n"); + + /* + * Compute mask and shift value for isolating cluster relative byte + * offsets and cluster numbers from a file offset. + */ + bpc = pmp->pm_SectPerClust * pmp->pm_BytesPerSec; + pmp->pm_bpcluster = bpc; + pmp->pm_depclust = bpc / sizeof(struct direntry); + pmp->pm_crbomask = bpc - 1; + if (bpc == 0) { + error = EINVAL; + goto error_exit; + } + bit = 1; + for (i = 0; i < 32; i++) { + if (bit & bpc) { + if (bit ^ bpc) { + error = EINVAL; + goto error_exit; + } + pmp->pm_cnshift = i; + break; + } + bit <<= 1; + } + + pmp->pm_brbomask = 0x01ff; /* 512 byte blocks only (so far) */ + pmp->pm_bnshift = 9; /* shift right 9 bits to get bn */ + + /* + * Release the bootsector buffer. + */ + brelse(bp0); + bp0 = NULL; + + /* + * Allocate memory for the bitmap of allocated clusters, and then + * fill it in. + */ + pmp->pm_inusemap = malloc(((pmp->pm_maxcluster + N_INUSEBITS - 1) + / N_INUSEBITS) + * sizeof(*pmp->pm_inusemap), + M_MSDOSFSFAT, M_WAITOK); + + /* + * fillinusemap() needs pm_devvp. + */ + pmp->pm_dev = dev; + pmp->pm_devvp = devvp; + + /* + * Have the inuse map filled in. + */ + error = fillinusemap(pmp); + if (error) + goto error_exit; + + /* + * If they want fat updates to be synchronous then let them suffer + * the performance degradation in exchange for the on disk copy of + * the fat being correct just about all the time. I suppose this + * would be a good thing to turn on if the kernel is still flakey. + */ + pmp->pm_waitonfat = mp->mnt_flag & MNT_SYNCHRONOUS; + + /* + * Finish up. + */ + pmp->pm_ronly = ronly; + if (ronly == 0) + pmp->pm_fmod = 1; + mp->mnt_data = (qaddr_t) pmp; + mp->mnt_stat.f_fsid.val[0] = (long)dev; + mp->mnt_stat.f_fsid.val[1] = MOUNT_MSDOS; + mp->mnt_flag |= MNT_LOCAL; +#ifdef QUOTA + /* + * If we ever do quotas for DOS filesystems this would be a place + * to fill in the info in the msdosfsmount structure. You dolt, + * quotas on dos filesystems make no sense because files have no + * owners on dos filesystems. of course there is some empty space + * in the directory entry where we could put uid's and gid's. + */ +#endif + devvp->v_specflags |= SI_MOUNTEDON; + + return 0; + +error_exit:; + if (bp0) + brelse(bp0); + if (needclose) + (void) VOP_CLOSE(devvp, ronly ? FREAD : FREAD | FWRITE, + NOCRED, p); + if (pmp) { + if (pmp->pm_inusemap) + free((caddr_t) pmp->pm_inusemap, M_MSDOSFSFAT); + free((caddr_t) pmp, M_MSDOSFSMNT); + mp->mnt_data = (qaddr_t) 0; + } + return error; +} + +int +msdosfs_start(mp, flags, p) + struct mount *mp; + int flags; + struct proc *p; +{ + return 0; +} + +/* + * Unmount the filesystem described by mp. + */ +int +msdosfs_unmount(mp, mntflags, p) + struct mount *mp; + int mntflags; + struct proc *p; +{ + int flags = 0; + int error; + struct msdosfsmount *pmp = (struct msdosfsmount *) mp->mnt_data; + struct vnode *vp = pmp->pm_devvp; + + /* only the mounter, or superuser can unmount */ + if ((p->p_cred->p_ruid != pmp->pm_mounter) && + (error = suser(p->p_ucred, &p->p_acflag))) + return error; + + if (mntflags & MNT_FORCE) { + if (!msdosfsdoforce) + return EINVAL; + flags |= FORCECLOSE; + } +#ifdef QUOTA +#endif + if (error = vflush(mp, NULLVP, flags)) + return error; + pmp->pm_devvp->v_specflags &= ~SI_MOUNTEDON; +#ifdef MSDOSFS_DEBUG + printf("msdosfs_umount(): just before calling VOP_CLOSE()\n"); + printf("flag %08x, usecount %d, writecount %d, holdcnt %d\n", + vp->v_flag, vp->v_usecount, vp->v_writecount, vp->v_holdcnt); + printf("lastr %d, id %d, mount %08x, op %08x\n", + vp->v_lastr, vp->v_id, vp->v_mount, vp->v_op); + printf("freef %08x, freeb %08x, mountf %08x, mountb %08x\n", + vp->v_freef, vp->v_freeb, vp->v_mountf, vp->v_mountb); + printf("cleanblkhd %08x, dirtyblkhd %08x, numoutput %d, type %d\n", + vp->v_cleanblkhd, vp->v_dirtyblkhd, vp->v_numoutput, vp->v_type); + printf("union %08x, tag %d, data[0] %08x, data[1] %08x\n", + vp->v_socket, vp->v_tag, vp->v_data[0], vp->v_data[1]); +#endif + error = VOP_CLOSE(pmp->pm_devvp, pmp->pm_ronly ? FREAD : FREAD | FWRITE, + NOCRED, p); + vrele(pmp->pm_devvp); + free((caddr_t) pmp->pm_inusemap, M_MSDOSFSFAT); + free((caddr_t) pmp, M_MSDOSFSMNT); + mp->mnt_data = (qaddr_t) 0; + mp->mnt_flag &= ~MNT_LOCAL; + return error; +} + +int +msdosfs_root(mp, vpp) + struct mount *mp; + struct vnode **vpp; +{ + struct denode *ndep; + struct msdosfsmount *pmp = (struct msdosfsmount *) (mp->mnt_data); + int error; + + error = deget(pmp, MSDOSFSROOT, MSDOSFSROOT_OFS, NULL, &ndep); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_root(); mp %08x, pmp %08x, ndep %08x, vp %08x\n", + mp, pmp, ndep, DETOV(ndep)); +#endif + if (error == 0) + *vpp = DETOV(ndep); + return error; +} + +int +msdosfs_quotactl(mp, cmds, uid, arg, p) + struct mount *mp; + int cmds; + uid_t uid; + caddr_t arg; + struct proc *p; +{ +#ifdef QUOTA +#else + return EOPNOTSUPP; +#endif +} + +int +msdosfs_statfs(mp, sbp, p) + struct mount *mp; + struct statfs *sbp; + struct proc *p; +{ + struct msdosfsmount *pmp = (struct msdosfsmount *) mp->mnt_data; + + /* + * Fill in the stat block. + */ +#ifdef COMPAT_09 + sbp->f_type = 4; +#else + sbp->f_type = 0; +#endif + sbp->f_bsize = pmp->pm_bpcluster; + sbp->f_iosize = pmp->pm_bpcluster; + sbp->f_blocks = pmp->pm_nmbrofclusters; + sbp->f_bfree = pmp->pm_freeclustercount; + sbp->f_bavail = pmp->pm_freeclustercount; + sbp->f_files = pmp->pm_RootDirEnts; /* XXX */ + sbp->f_ffree = 0; /* what to put in here? */ + + /* + * Copy the mounted on and mounted from names into the passed in + * stat block, if it is not the one in the mount structure. + */ + if (sbp != &mp->mnt_stat) { + bcopy((caddr_t) mp->mnt_stat.f_mntonname, + (caddr_t) & sbp->f_mntonname[0], MNAMELEN); + bcopy((caddr_t) mp->mnt_stat.f_mntfromname, + (caddr_t) & sbp->f_mntfromname[0], MNAMELEN); + } +#if 0 + strncpy(&sbp->f_fstypename[0], mp->mnt_op->vfs_name, MFSNAMELEN); + sbp->f_fstypename[MFSNAMELEN] = '\0'; +#endif + return 0; +} + +int +msdosfs_sync(mp, waitfor, cred, p) + struct mount *mp; + int waitfor; + struct ucred *cred; + struct proc *p; +{ + struct vnode *vp; + struct denode *dep; + struct msdosfsmount *pmp; + int error; + int allerror = 0; + + pmp = (struct msdosfsmount *) mp->mnt_data; + + /* + * If we ever switch to not updating all of the fats all the time, + * this would be the place to update them from the first one. + */ + if (pmp->pm_fmod) + if (pmp->pm_ronly) + panic("msdosfs_sync: rofs mod"); + else { + /* update fats here */ + } + + /* + * Go thru in memory denodes and write them out along with + * unwritten file blocks. + */ +loop: + for (vp = mp->mnt_vnodelist.lh_first; vp; + vp = vp->v_mntvnodes.le_next) { + if (vp->v_mount != mp) /* not ours anymore */ + goto loop; + if (VOP_ISLOCKED(vp)) /* file is busy */ + continue; + dep = VTODE(vp); + if ((dep->de_flag & DE_UPDATE) == 0 && + vp->v_dirtyblkhd.lh_first == NULL) + continue; + if (vget(vp, 1)) /* not there anymore? */ + goto loop; + if (error = VOP_FSYNC(vp, cred, waitfor, p)) + allerror = error; + vput(vp); /* done with this one */ + } + + /* + * Flush filesystem control info. + */ + if (error = VOP_FSYNC(pmp->pm_devvp, cred, waitfor, p)) + allerror = error; + return allerror; +} + +int +msdosfs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp) + struct mount *mp; + struct fid *fhp; + struct mbuf *nam; + struct vnode **vpp; + int *exflagsp; + struct ucred **credanonp; +{ + struct msdosfsmount *pmp = (struct msdosfsmount *) mp->mnt_data; + struct defid *defhp = (struct defid *) fhp; + struct denode *dep; + struct netcred *np; + int error; + + np = vfs_export_lookup(mp, &pmp->pm_export, nam); + if (np == NULL) + return EACCES; + error = deget(pmp, defhp->defid_dirclust, defhp->defid_dirofs, + NULL, &dep); + if (error) { + *vpp = NULLVP; + return error; + } + *vpp = DETOV(dep); + *exflagsp = np->netc_exflags; + *credanonp = &np->netc_anon; + return 0; +} + + +int +msdosfs_vptofh(vp, fhp) + struct vnode *vp; + struct fid *fhp; +{ + struct denode *dep = VTODE(vp); + struct defid *defhp = (struct defid *) fhp; + + defhp->defid_len = sizeof(struct defid); + defhp->defid_dirclust = dep->de_dirclust; + defhp->defid_dirofs = dep->de_diroffset; + /* defhp->defid_gen = ip->i_gen; */ + return 0; +} + +int +msdosfs_vget(mp, ino, vpp) + struct mount *mp; + ino_t ino; + struct vnode **vpp; +{ + return EOPNOTSUPP; +} + +struct vfsops msdosfs_vfsops = { + msdosfs_mount, + msdosfs_start, + msdosfs_unmount, + msdosfs_root, + msdosfs_quotactl, + msdosfs_statfs, + msdosfs_sync, + msdosfs_vget, + msdosfs_fhtovp, + msdosfs_vptofh, + msdosfs_init +}; diff --git a/sys/msdosfs/msdosfs_vnops.c b/sys/msdosfs/msdosfs_vnops.c new file mode 100644 index 0000000..4294034 --- /dev/null +++ b/sys/msdosfs/msdosfs_vnops.c @@ -0,0 +1,1933 @@ +/* $Id$ */ +/* $NetBSD: msdosfs_vnops.c,v 1.20 1994/08/21 18:44:13 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/namei.h> +#include <sys/resourcevar.h> /* defines plimit structure in proc struct */ +#include <sys/kernel.h> +#include <sys/file.h> /* define FWRITE ... */ +#include <sys/stat.h> +#include <sys/buf.h> +#include <sys/proc.h> +#include <sys/mount.h> +#include <sys/vnode.h> +#include <miscfs/specfs/specdev.h> /* XXX */ /* defines v_rdev */ +#include <sys/malloc.h> +#include <sys/dir.h> /* defines dirent structure */ + +#include <msdosfs/bpb.h> +#include <msdosfs/direntry.h> +#include <msdosfs/denode.h> +#include <msdosfs/msdosfsmount.h> +#include <msdosfs/fat.h> +/* + * Some general notes: + * + * In the ufs filesystem the inodes, superblocks, and indirect blocks are + * read/written using the vnode for the filesystem. Blocks that represent + * the contents of a file are read/written using the vnode for the file + * (including directories when they are read/written as files). This + * presents problems for the dos filesystem because data that should be in + * an inode (if dos had them) resides in the directory itself. Since we + * must update directory entries without the benefit of having the vnode + * for the directory we must use the vnode for the filesystem. This means + * that when a directory is actually read/written (via read, write, or + * readdir, or seek) we must use the vnode for the filesystem instead of + * the vnode for the directory as would happen in ufs. This is to insure we + * retreive the correct block from the buffer cache since the hash value is + * based upon the vnode address and the desired block number. + */ + +/* + * Create a regular file. On entry the directory to contain the file being + * created is locked. We must release before we return. We must also free + * the pathname buffer pointed at by cnp->cn_pnbuf, always on error, or + * only if the SAVESTART bit in cn_flags is clear on success. + */ +int +msdosfs_create(ap) + struct vop_create_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ + struct componentname *cnp = ap->a_cnp; + struct denode ndirent; + struct denode *dep; + struct denode *pdep = VTODE(ap->a_dvp); + struct timespec ts; + int error; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_create(cnp %08x, vap %08x\n", cnp, ap->a_vap); +#endif + + /* + * Create a directory entry for the file, then call createde() to + * have it installed. NOTE: DOS files are always executable. We + * use the absence of the owner write bit to make the file + * readonly. + */ +#ifdef DIAGNOSTIC + if ((cnp->cn_flags & SAVENAME) == 0) + panic("msdosfs_create: no name"); +#endif + bzero(&ndirent, sizeof(ndirent)); + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &ndirent.de_Date, &ndirent.de_Time); + unix2dosfn((u_char *)cnp->cn_nameptr, ndirent.de_Name, cnp->cn_namelen); + ndirent.de_Attributes = (ap->a_vap->va_mode & VWRITE) ? 0 : ATTR_READONLY; + ndirent.de_StartCluster = 0; + ndirent.de_FileSize = 0; + ndirent.de_dev = pdep->de_dev; + ndirent.de_devvp = pdep->de_devvp; + if ((error = createde(&ndirent, pdep, &dep)) == 0) { + *ap->a_vpp = DETOV(dep); + if ((cnp->cn_flags & SAVESTART) == 0) + free(cnp->cn_pnbuf, M_NAMEI); + } else { + free(cnp->cn_pnbuf, M_NAMEI); + } + vput(ap->a_dvp); /* release parent dir */ + return error; +} + +int +msdosfs_mknod(ap) + struct vop_mknod_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ + int error; + struct denode *pdep = VTODE(ap->a_dvp); + + switch (ap->a_vap->va_type) { + case VDIR: + error = msdosfs_mkdir((struct vop_mkdir_args *)ap); + break; + + case VREG: + error = msdosfs_create((struct vop_create_args *)ap); + break; + + default: + error = EINVAL; + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + break; + } + return error; +} + +int +msdosfs_open(ap) + struct vop_open_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return 0; +} + +int +msdosfs_close(ap) + struct vop_close_args /* { + struct vnode *a_vp; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + struct timespec ts; + + if (vp->v_usecount > 1 && !(dep->de_flag & DE_LOCKED)) { + TIMEVAL_TO_TIMESPEC(&time, &ts); + DE_TIMES(dep, &ts); + } + return 0; +} + +/* + * This routine will go into sys/kern/vfs_subr.c one day! + * + * Do the usual access checking. + * file_node, uid and gid are from the vnode in question, + * while acc_mode and cred are from the VOP_ACCESS parameter list. + */ +static int +vaccess(file_mode, uid, gid, acc_mode, cred) + mode_t file_mode; + uid_t uid; + gid_t gid; + mode_t acc_mode; + struct ucred *cred; +{ + mode_t mask; + int i; + register gid_t *gp; + + /* User id 0 always gets access. */ + if (cred->cr_uid == 0) + return 0; + + mask = 0; + + /* Otherwise, check the owner. */ + if (cred->cr_uid == uid) { + if (acc_mode & VEXEC) + mask |= S_IXUSR; + if (acc_mode & VREAD) + mask |= S_IRUSR; + if (acc_mode & VWRITE) + mask |= S_IWUSR; + return (file_mode & mask) == mask ? 0 : EACCES; + } + + /* Otherwise, check the groups. */ + for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) + if (gid == *gp) { + if (acc_mode & VEXEC) + mask |= S_IXGRP; + if (acc_mode & VREAD) + mask |= S_IRGRP; + if (acc_mode & VWRITE) + mask |= S_IWGRP; + return (file_mode & mask) == mask ? 0 : EACCES; + } + + /* Otherwise, check everyone else. */ + if (acc_mode & VEXEC) + mask |= S_IXOTH; + if (acc_mode & VREAD) + mask |= S_IROTH; + if (acc_mode & VWRITE) + mask |= S_IWOTH; + return (file_mode & mask) == mask ? 0 : EACCES; +} + +int +msdosfs_access(ap) + struct vop_access_args /* { + struct vnode *a_vp; + int a_mode; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + mode_t dosmode; + struct denode *dep = VTODE(ap->a_vp); + struct msdosfsmount *pmp = dep->de_pmp; + + dosmode = (S_IXUSR|S_IXGRP|S_IXOTH) | (S_IRUSR|S_IRGRP|S_IROTH) | + ((dep->de_Attributes & ATTR_READONLY) ? 0 : (S_IWUSR|S_IWGRP|S_IWOTH)); + dosmode &= pmp->pm_mask; + + return vaccess(dosmode, pmp->pm_uid, pmp->pm_gid, ap->a_mode, ap->a_cred); +} + +int +msdosfs_getattr(ap) + struct vop_getattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + u_int cn; + struct denode *dep = VTODE(ap->a_vp); + struct vattr *vap = ap->a_vap; + struct timespec ts; + + TIMEVAL_TO_TIMESPEC(&time, &ts); + DE_TIMES(dep, &ts); + vap->va_fsid = dep->de_dev; + /* + * The following computation of the fileid must be the same as that + * used in msdosfs_readdir() to compute d_fileno. If not, pwd + * doesn't work. + */ + if (dep->de_Attributes & ATTR_DIRECTORY) { + if ((cn = dep->de_StartCluster) == MSDOSFSROOT) + cn = 1; + } else { + if ((cn = dep->de_dirclust) == MSDOSFSROOT) + cn = 1; + cn = (cn << 16) | (dep->de_diroffset & 0xffff); + } + vap->va_fileid = cn; + vap->va_mode = (S_IXUSR|S_IXGRP|S_IXOTH) | (S_IRUSR|S_IRGRP|S_IROTH) | + ((dep->de_Attributes & ATTR_READONLY) ? 0 : (S_IWUSR|S_IWGRP|S_IWOTH)); + vap->va_mode &= dep->de_pmp->pm_mask; + if (dep->de_Attributes & ATTR_DIRECTORY) + vap->va_mode |= S_IFDIR; + vap->va_nlink = 1; + vap->va_gid = dep->de_pmp->pm_gid; + vap->va_uid = dep->de_pmp->pm_uid; + vap->va_rdev = 0; + vap->va_size = dep->de_FileSize; + dos2unixtime(dep->de_Date, dep->de_Time, &vap->va_atime); + vap->va_mtime = vap->va_atime; +#ifndef MSDOSFS_NODIRMOD + if (vap->va_mode & S_IFDIR) + TIMEVAL_TO_TIMESPEC(&time, &vap->va_mtime); +#endif + vap->va_ctime = vap->va_atime; + vap->va_flags = dep->de_flag; + vap->va_gen = 0; + vap->va_blocksize = dep->de_pmp->pm_bpcluster; + vap->va_bytes = (dep->de_FileSize + dep->de_pmp->pm_crbomask) & + ~(dep->de_pmp->pm_crbomask); + vap->va_type = ap->a_vp->v_type; + return 0; +} + +int +msdosfs_setattr(ap) + struct vop_setattr_args /* { + struct vnode *a_vp; + struct vattr *a_vap; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + int error = 0; + struct denode *dep = VTODE(ap->a_vp); + struct vattr *vap = ap->a_vap; + struct ucred *cred = ap->a_cred; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_setattr(): vp %08x, vap %08x, cred %08x, p %08x\n", + ap->a_vp, vap, cred, ap->a_p); +#endif + if ((vap->va_type != VNON) || + (vap->va_nlink != VNOVAL) || + (vap->va_fsid != VNOVAL) || + (vap->va_fileid != VNOVAL) || + (vap->va_blocksize != VNOVAL) || + (vap->va_rdev != VNOVAL) || + (vap->va_bytes != VNOVAL) || + (vap->va_gen != VNOVAL) || + (vap->va_uid != VNOVAL) || + (vap->va_gid != VNOVAL)) { +#ifdef MSDOSFS_DEBUG + printf("msdosfs_setattr(): returning EINVAL\n"); + printf(" va_type %d, va_nlink %x, va_fsid %x, va_fileid %x\n", + vap->va_type, vap->va_nlink, vap->va_fsid, vap->va_fileid); + printf(" va_blocksize %x, va_rdev %x, va_bytes %x, va_gen %x\n", + vap->va_blocksize, vap->va_rdev, vap->va_bytes, vap->va_gen); + printf(" va_uid %x, va_gid %x\n", + vap->va_uid, vap->va_gid); +#endif + return EINVAL; + } + + if (vap->va_size != VNOVAL) { + if (ap->a_vp->v_type == VDIR) + return EISDIR; + if (error = detrunc(dep, vap->va_size, 0, cred, ap->a_p)) + return error; + } + if (vap->va_mtime.ts_sec != VNOVAL) { + dep->de_flag |= DE_UPDATE; + if (error = deupdat(dep, &vap->va_mtime, 1)) + return error; + } + + /* + * DOS files only have the ability to have thier writability + * attribute set, so we use the owner write bit to set the readonly + * attribute. + */ + if (vap->va_mode != (u_short) VNOVAL) { + /* We ignore the read and execute bits */ + if (vap->va_mode & VWRITE) + dep->de_Attributes &= ~ATTR_READONLY; + else + dep->de_Attributes |= ATTR_READONLY; + dep->de_flag |= DE_UPDATE; + } + + if (vap->va_flags != VNOVAL) { + if (error = suser(cred, &ap->a_p->p_acflag)) + return error; + if (cred->cr_uid == 0) + dep->de_flag = vap->va_flags; + else { + dep->de_flag &= 0xffff0000; + dep->de_flag |= (vap->va_flags & 0xffff); + } + dep->de_flag |= DE_UPDATE; + } + return error; +} + +int +msdosfs_read(ap) + struct vop_read_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; +{ + int error = 0; + int diff; + int isadir; + long n; + long on; + daddr_t bn; + daddr_t lbn; + daddr_t rablock; + int rasize; + struct buf *bp; + struct vnode *vp = ap->a_vp; + struct denode *dep = VTODE(vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct uio *uio = ap->a_uio; + + /* + * If they didn't ask for any data, then we are done. + */ + if (uio->uio_resid == 0) + return 0; + if (uio->uio_offset < 0) + return EINVAL; + + isadir = dep->de_Attributes & ATTR_DIRECTORY; + do { + lbn = uio->uio_offset >> pmp->pm_cnshift; + on = uio->uio_offset & pmp->pm_crbomask; + n = min((u_long) (pmp->pm_bpcluster - on), uio->uio_resid); + diff = dep->de_FileSize - uio->uio_offset; + if (diff <= 0) + return 0; + /* convert cluster # to block # if a directory */ + if (isadir) { + error = pcbmap(dep, lbn, &lbn, 0); + if (error) + return error; + } + if (diff < n) + n = diff; + /* + * If we are operating on a directory file then be sure to + * do i/o with the vnode for the filesystem instead of the + * vnode for the directory. + */ + if (isadir) { + error = bread(pmp->pm_devvp, lbn, pmp->pm_bpcluster, + NOCRED, &bp); + } else { + rablock = lbn + 1; + if (vp->v_lastr + 1 == lbn && + rablock * pmp->pm_bpcluster < dep->de_FileSize) { + rasize = pmp->pm_bpcluster; + error = breadn(vp, lbn, pmp->pm_bpcluster, + &rablock, &rasize, 1, + NOCRED, &bp); + } else { + error = bread(vp, lbn, pmp->pm_bpcluster, NOCRED, + &bp); + } + vp->v_lastr = lbn; + } + n = min(n, pmp->pm_bpcluster - bp->b_resid); + if (error) { + brelse(bp); + return error; + } + error = uiomove(bp->b_data + on, (int) n, uio); + /* + * If we have read everything from this block or have read + * to end of file then we are done with this block. Mark + * it to say the buffer can be reused if need be. + */ +#if 0 + if (n + on == pmp->pm_bpcluster || + uio->uio_offset == dep->de_FileSize) + bp->b_flags |= B_AGE; +#endif + brelse(bp); + } while (error == 0 && uio->uio_resid > 0 && n != 0); + return error; +} + +/* + * Write data to a file or directory. + */ +int +msdosfs_write(ap) + struct vop_write_args /* { + struct vnode *a_vp; + struct uio *a_uio; + int a_ioflag; + struct ucred *a_cred; + } */ *ap; +{ + int n; + int isadir; + int croffset; + int resid; + int osize; + int error = 0; + u_long count; + daddr_t bn, lastcn; + struct buf *bp; + int ioflag = ap->a_ioflag; + struct uio *uio = ap->a_uio; + struct proc *p = uio->uio_procp; + struct vnode *vp = ap->a_vp; + struct vnode *thisvp; + struct denode *dep = VTODE(vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct ucred *cred = ap->a_cred; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_write(vp %08x, uio %08x, ioflag %08x, cred %08x\n", + vp, uio, ioflag, cred); + printf("msdosfs_write(): diroff %d, dirclust %d, startcluster %d\n", + dep->de_diroffset, dep->de_dirclust, dep->de_StartCluster); +#endif + + switch (vp->v_type) { + case VREG: + if (ioflag & IO_APPEND) + uio->uio_offset = dep->de_FileSize; + isadir = 0; + thisvp = vp; + break; + + case VDIR: + if ((ioflag & IO_SYNC) == 0) + panic("msdosfs_write(): non-sync directory update"); + isadir = 1; + thisvp = pmp->pm_devvp; + break; + + default: + panic("msdosfs_write(): bad file type"); + break; + } + + if (uio->uio_offset < 0) + return EINVAL; + + if (uio->uio_resid == 0) + return 0; + + /* + * If they've exceeded their filesize limit, tell them about it. + */ + if (vp->v_type == VREG && p && + ((uio->uio_offset + uio->uio_resid) > + p->p_rlimit[RLIMIT_FSIZE].rlim_cur)) { + psignal(p, SIGXFSZ); + return EFBIG; + } + + /* + * If attempting to write beyond the end of the root directory we + * stop that here because the root directory can not grow. + */ + if ((dep->de_Attributes & ATTR_DIRECTORY) && + dep->de_StartCluster == MSDOSFSROOT && + (uio->uio_offset + uio->uio_resid) > dep->de_FileSize) + return ENOSPC; + + /* + * If the offset we are starting the write at is beyond the end of + * the file, then they've done a seek. Unix filesystems allow + * files with holes in them, DOS doesn't so we must fill the hole + * with zeroed blocks. + */ + if (uio->uio_offset > dep->de_FileSize) { + error = deextend(dep, uio->uio_offset, cred); + if (error) + return error; + } + + /* + * Remember some values in case the write fails. + */ + resid = uio->uio_resid; + osize = dep->de_FileSize; + + + /* + * If we write beyond the end of the file, extend it to its ultimate + * size ahead of the time to hopefully get a contiguous area. + */ + if (uio->uio_offset + resid > osize) { + count = de_clcount(pmp, uio->uio_offset + resid) - de_clcount(pmp, osize); + if ((error = extendfile(dep, count, NULL, NULL, 0)) + && (error != ENOSPC || (ioflag & IO_UNIT))) + goto errexit; + lastcn = dep->de_fc[FC_LASTFC].fc_frcn; + } else + lastcn = de_clcount(pmp, osize) - 1; + + do { + bn = de_blk(pmp, uio->uio_offset); + if (isadir) { + if (error = pcbmap(dep, bn, &bn, 0)) + break; + } else if (bn > lastcn) { + error = ENOSPC; + break; + } + + if ((uio->uio_offset & pmp->pm_crbomask) == 0 + && (de_blk(pmp, uio->uio_offset + uio->uio_resid) > de_blk(pmp, uio->uio_offset) + || uio->uio_offset + uio->uio_resid >= dep->de_FileSize)) { + /* + * If either the whole cluster gets written, + * or we write the cluster from its start beyond EOF, + * then no need to read data from disk. + */ + bp = getblk(thisvp, bn, pmp->pm_bpcluster, 0, 0); + clrbuf(bp); + /* + * Do the bmap now, since pcbmap needs buffers + * for the fat table. (see msdosfs_strategy) + */ + if (!isadir) { + if (bp->b_blkno == bp->b_lblkno) { + if (error = pcbmap(dep, bp->b_lblkno, + &bp->b_blkno, 0)) + bp->b_blkno = -1; + } + if (bp->b_blkno == -1) { + brelse(bp); + if (!error) + error = EIO; /* XXX */ + break; + } + } + } else { + /* + * The block we need to write into exists, so read it in. + */ + if (error = bread(thisvp, bn, pmp->pm_bpcluster, cred, &bp)) + break; + } + + croffset = uio->uio_offset & pmp->pm_crbomask; + n = min(uio->uio_resid, pmp->pm_bpcluster - croffset); + if (uio->uio_offset + n > dep->de_FileSize) { + dep->de_FileSize = uio->uio_offset + n; + vnode_pager_setsize(vp, dep->de_FileSize); /* why? */ + } + (void) vnode_pager_uncache(vp); /* why not? */ + /* + * Should these vnode_pager_* functions be done on dir + * files? + */ + + /* + * Copy the data from user space into the buf header. + */ + error = uiomove(bp->b_data + croffset, n, uio); + + /* + * If they want this synchronous then write it and wait for + * it. Otherwise, if on a cluster boundary write it + * asynchronously so we can move on to the next block + * without delay. Otherwise do a delayed write because we + * may want to write somemore into the block later. + */ + if (ioflag & IO_SYNC) + (void) bwrite(bp); + else if (n + croffset == pmp->pm_bpcluster) { + bp->b_flags |= B_AGE; + bawrite(bp); + } else + bdwrite(bp); + dep->de_flag |= DE_UPDATE; + } while (error == 0 && uio->uio_resid > 0); + + /* + * If the write failed and they want us to, truncate the file back + * to the size it was before the write was attempted. + */ +errexit: + if (error) { + if (ioflag & IO_UNIT) { + detrunc(dep, osize, ioflag & IO_SYNC, NOCRED, NULL); + uio->uio_offset -= resid - uio->uio_resid; + uio->uio_resid = resid; + } else { + detrunc(dep, dep->de_FileSize, ioflag & IO_SYNC, NOCRED, NULL); + if (uio->uio_resid != resid) + error = 0; + } + } else { + error = deupdat(dep, &time, 1); + } + return error; +} + +int +msdosfs_ioctl(ap) + struct vop_ioctl_args /* { + struct vnode *a_vp; + int a_command; + caddr_t a_data; + int a_fflag; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return ENOTTY; +} + +int +msdosfs_select(ap) + struct vop_select_args /* { + struct vnode *a_vp; + int a_which; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return 1; /* DOS filesystems never block? */ +} + +int +msdosfs_mmap(ap) + struct vop_mmap_args /* { + struct vnode *a_vp; + int a_fflags; + struct ucred *a_cred; + struct proc *a_p; + } */ *ap; +{ + return EINVAL; +} + +/* + * Flush the blocks of a file to disk. + * + * This function is worthless for vnodes that represent directories. Maybe we + * could just do a sync if they try an fsync on a directory file. + */ +int +msdosfs_fsync(ap) + struct vop_fsync_args /* { + struct vnode *a_vp; + struct ucred *a_cred; + int a_waitfor; + struct proc *a_p; + } */ *ap; +{ + struct vnode *vp = ap->a_vp; + int wait = ap->a_waitfor == MNT_WAIT; + int error; + +#if 0 + /* + * Does this call to vflushbuf() do anything? I can find no code + * anywhere that sets v_dirtyblkhd in the vnode, which vflushbuf() + * seems to depend upon. + */ + vflushbuf(vp, wait ? B_SYNC : 0); +#endif + return deupdat(VTODE(vp), &time, wait); +} + +/* + * Now the whole work of extending a file is done in the write function. + * So nothing to do here. + */ +int +msdosfs_seek(ap) + struct vop_seek_args /* { + struct vnode *a_vp; + off_t a_oldoff; + off_t a_newoff; + struct ucred *a_cred; + } */ *ap; +{ + return 0; +} + +int +msdosfs_remove(ap) + struct vop_remove_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; +{ + int error; + struct denode *dep = VTODE(ap->a_vp); + struct denode *ddep = VTODE(ap->a_dvp); + + error = removede(ddep,dep); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_remove(), dep %08x, v_usecount %d\n", dep, ap->a_vp->v_usecount); +#endif + if (ddep == dep) + vrele(ap->a_vp); + else + vput(ap->a_vp); /* causes msdosfs_inactive() to be called + * via vrele() */ + vput(ap->a_dvp); + return error; +} + +/* + * DOS filesystems don't know what links are. But since we already called + * msdosfs_lookup() with create and lockparent, the parent is locked so we + * have to free it before we return the error. + */ +int +msdosfs_link(ap) + struct vop_link_args /* { + struct vnode *a_vp; + struct vnode *a_tdvp; + struct componentname *a_cnp; + } */ *ap; +{ + return VOP_ABORTOP(ap->a_vp, ap->a_cnp); +} + +/* + * Renames on files require moving the denode to a new hash queue since the + * denode's location is used to compute which hash queue to put the file + * in. Unless it is a rename in place. For example "mv a b". + * + * What follows is the basic algorithm: + * + * if (file move) { + * if (dest file exists) { + * remove dest file + * } + * if (dest and src in same directory) { + * rewrite name in existing directory slot + * } else { + * write new entry in dest directory + * update offset and dirclust in denode + * move denode to new hash chain + * clear old directory entry + * } + * } else { + * directory move + * if (dest directory exists) { + * if (dest is not empty) { + * return ENOTEMPTY + * } + * remove dest directory + * } + * if (dest and src in same directory) { + * rewrite name in existing entry + * } else { + * be sure dest is not a child of src directory + * write entry in dest directory + * update "." and ".." in moved directory + * update offset and dirclust in denode + * move denode to new hash chain + * clear old directory entry for moved directory + * } + * } + * + * On entry: + * source's parent directory is unlocked + * source file or directory is unlocked + * destination's parent directory is locked + * destination file or directory is locked if it exists + * + * On exit: + * all denodes should be released + * + * Notes: + * I'm not sure how the memory containing the pathnames pointed at by the + * componentname structures is freed, there may be some memory bleeding + * for each rename done. + */ +int +msdosfs_rename(ap) + struct vop_rename_args /* { + struct vnode *a_fdvp; + struct vnode *a_fvp; + struct componentname *a_fcnp; + struct vnode *a_tdvp; + struct vnode *a_tvp; + struct componentname *a_tcnp; + } */ *ap; +{ + u_char toname[11]; + int error; + int newparent = 0; + int sourceisadirectory = 0; + u_long to_dirclust; + u_long to_diroffset; + u_long cn; + daddr_t bn; + struct vnode *tvp = ap->a_tvp; + struct denode *fddep; /* from file's parent directory */ + struct denode *fdep; /* from file or directory */ + struct denode *tddep; /* to file's parent directory */ + struct denode *tdep; /* to file or directory */ + struct msdosfsmount *pmp; + struct direntry *dotdotp; + struct direntry *ep; + struct buf *bp; + + fddep = VTODE(ap->a_fdvp); + fdep = VTODE(ap->a_fvp); + tddep = VTODE(ap->a_tdvp); + tdep = tvp ? VTODE(tvp) : NULL; + pmp = fddep->de_pmp; + +#ifdef __NetBSD__ + /* Check for cross-device rename */ + if ((ap->a_fvp->v_mount != ap->a_tdvp->v_mount) || + (tvp && (ap->a_fvp->v_mount != tvp->v_mount))) { + error = EXDEV; + goto bad; + } +#endif + + /* + * Convert the filename in tcnp into a dos filename. We copy this + * into the denode and directory entry for the destination + * file/directory. + */ + unix2dosfn((u_char *) ap->a_tcnp->cn_nameptr, + toname, ap->a_tcnp->cn_namelen); + + /* + * At this point this is the lock state of the denodes: + * fddep referenced + * fdep referenced + * tddep locked + * tdep locked if it exists + */ + + /* + * Be sure we are not renaming ".", "..", or an alias of ".". This + * leads to a crippled directory tree. It's pretty tough to do a + * "ls" or "pwd" with the "." directory entry missing, and "cd .." + * doesn't work if the ".." entry is missing. + */ + if (fdep->de_Attributes & ATTR_DIRECTORY) { + if ((ap->a_fcnp->cn_namelen == 1 + && ap->a_fcnp->cn_nameptr[0] == '.') + || fddep == fdep + || (ap->a_fcnp->cn_flags & ISDOTDOT)) { + VOP_ABORTOP(ap->a_tdvp, ap->a_tcnp); + vput(ap->a_tdvp); + if (tvp) + vput(tvp); + VOP_ABORTOP(ap->a_fdvp, ap->a_fcnp); + vrele(ap->a_fdvp); + vrele(ap->a_fvp); + return EINVAL; + } + sourceisadirectory = 1; + } + + /* + * If we are renaming a directory, and the directory is being moved + * to another directory, then we must be sure the destination + * directory is not in the subtree of the source directory. This + * could orphan everything under the source directory. + * doscheckpath() unlocks the destination's parent directory so we + * must look it up again to relock it. + */ + if (fddep->de_StartCluster != tddep->de_StartCluster) + newparent = 1; + if (sourceisadirectory && newparent) { + if (tdep) { + vput(ap->a_tvp); + tdep = NULL; + } + /* doscheckpath() vput()'s tddep */ + error = doscheckpath(fdep, tddep); + tddep = NULL; + if (error) { + goto bad; + } + if ((ap->a_tcnp->cn_flags & SAVESTART) == 0) + panic("msdosfs_rename(): lost to startdir"); + if (error = relookup(ap->a_tdvp, &tvp, ap->a_tcnp)) { + goto bad; + } + tddep = VTODE(ap->a_tdvp); + tdep = tvp ? VTODE(tvp) : NULL; + } + + /* + * If the destination exists, then be sure its type (file or dir) + * matches that of the source. And, if it is a directory make sure + * it is empty. Then delete the destination. + */ + if (tdep) { + if (tdep->de_Attributes & ATTR_DIRECTORY) { + if (!sourceisadirectory) { + error = ENOTDIR; + goto bad; + } + if (!dosdirempty(tdep)) { + error = ENOTEMPTY; + goto bad; + } + } else { /* destination is file */ + if (sourceisadirectory) { + error = EISDIR; + goto bad; + } + } + to_dirclust = tdep->de_dirclust; + to_diroffset = tdep->de_diroffset; + if (error = removede(tddep,tdep)) { + goto bad; + } + vput(ap->a_tvp); + tdep = NULL; + + /* + * Remember where the slot was for createde(). + */ + tddep->de_fndclust = to_dirclust; + tddep->de_fndoffset = to_diroffset; + } + + /* + * If the source and destination are in the same directory then + * just read in the directory entry, change the name in the + * directory entry and write it back to disk. + */ + if (newparent == 0) { + /* tddep and fddep point to the same denode here */ + VOP_LOCK(ap->a_fvp); /* ap->a_fdvp is already locked */ + if (error = readep(fddep->de_pmp, + fdep->de_dirclust, + fdep->de_diroffset, + &bp, &ep)) { + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + bcopy(toname, ep->deName, 11); + if (error = bwrite(bp)) { + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + bcopy(toname, fdep->de_Name, 11); /* update denode */ + /* + * fdep locked fddep and tddep point to the same denode + * which is locked tdep is NULL + */ + } else { + u_long dirsize = 0L; + + /* + * If the source and destination are in different + * directories, then mark the entry in the source directory + * as deleted and write a new entry in the destination + * directory. Then move the denode to the correct hash + * chain for its new location in the filesystem. And, if + * we moved a directory, then update its .. entry to point + * to the new parent directory. If we moved a directory + * will also insure that the directory entry on disk has a + * filesize of zero. + */ + VOP_LOCK(ap->a_fvp); + bcopy(toname, fdep->de_Name, 11); /* update denode */ + if (fdep->de_Attributes & ATTR_DIRECTORY) { + dirsize = fdep->de_FileSize; + fdep->de_FileSize = 0; + } + error = createde(fdep, tddep, (struct denode **) 0); + if (fdep->de_Attributes & ATTR_DIRECTORY) { + fdep->de_FileSize = dirsize; + } + if (error) { + /* should put back filename */ + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + VOP_LOCK(ap->a_fdvp); + if (error = readep(fddep->de_pmp, + fddep->de_fndclust, + fddep->de_fndoffset, + &bp, &ep)) { + VOP_UNLOCK(ap->a_fvp); + VOP_UNLOCK(ap->a_fdvp); + goto bad; + } + ep->deName[0] = SLOT_DELETED; + if (error = bwrite(bp)) { + VOP_UNLOCK(ap->a_fvp); + VOP_UNLOCK(ap->a_fdvp); + goto bad; + } + fdep->de_dirclust = tddep->de_fndclust; + fdep->de_diroffset = tddep->de_fndoffset; + reinsert(fdep); + VOP_UNLOCK(ap->a_fdvp); + } + /* fdep is still locked here */ + + /* + * If we moved a directory to a new parent directory, then we must + * fixup the ".." entry in the moved directory. + */ + if (sourceisadirectory && newparent) { + cn = fdep->de_StartCluster; + if (cn == MSDOSFSROOT) { + /* this should never happen */ + panic("msdosfs_rename(): updating .. in root directory?\n"); + } else { + bn = cntobn(pmp, cn); + } + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, + NOCRED, &bp); + if (error) { + /* should really panic here, fs is corrupt */ + VOP_UNLOCK(ap->a_fvp); + goto bad; + } + dotdotp = (struct direntry *) bp->b_data + 1; + putushort(dotdotp->deStartCluster, tddep->de_StartCluster); + error = bwrite(bp); + VOP_UNLOCK(ap->a_fvp); + if (error) { + /* should really panic here, fs is corrupt */ + goto bad; + } + } else + VOP_UNLOCK(ap->a_fvp); +bad: ; + vrele(DETOV(fdep)); + vrele(DETOV(fddep)); + if (tdep) + vput(DETOV(tdep)); + if (tddep) + vput(DETOV(tddep)); + return error; +} + +struct { + struct direntry dot; + struct direntry dotdot; +} dosdirtemplate = { + + ". ", " ", /* the . entry */ + ATTR_DIRECTORY, /* file attribute */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* resevered */ + 210, 4, 210, 4, /* time and date */ + 0, 0, /* startcluster */ + 0, 0, 0, 0, /* filesize */ + ".. ", " ", /* the .. entry */ + ATTR_DIRECTORY, /* file attribute */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* resevered */ + 210, 4, 210, 4, /* time and date */ + 0, 0, /* startcluster */ + 0, 0, 0, 0, /* filesize */ +}; + +int +msdosfs_mkdir(ap) + struct vop_mkdir_args /* { + struct vnode *a_dvp; + struvt vnode **a_vpp; + struvt componentname *a_cnp; + struct vattr *a_vap; + } */ *ap; +{ + int bn; + int error; + u_long newcluster; + struct denode *pdep; + struct denode *ndep; + struct direntry *denp; + struct denode ndirent; + struct msdosfsmount *pmp; + struct buf *bp; + struct timespec ts; + u_short dDate, dTime; + + pdep = VTODE(ap->a_dvp); + + /* + * If this is the root directory and there is no space left we + * can't do anything. This is because the root directory can not + * change size. + */ + if (pdep->de_StartCluster == MSDOSFSROOT && pdep->de_fndclust == (u_long)-1) { + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return ENOSPC; + } + + pmp = pdep->de_pmp; + + /* + * Allocate a cluster to hold the about to be created directory. + */ + if (error = clusteralloc(pmp, 0, 1, CLUST_EOFE, &newcluster, NULL)) { + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return error; + } + + /* + * Now fill the cluster with the "." and ".." entries. And write + * the cluster to disk. This way it is there for the parent + * directory to be pointing at if there were a crash. + */ + bn = cntobn(pmp, newcluster); + /* always succeeds */ + bp = getblk(pmp->pm_devvp, bn, pmp->pm_bpcluster, 0, 0); + bzero(bp->b_data, pmp->pm_bpcluster); + bcopy(&dosdirtemplate, bp->b_data, sizeof dosdirtemplate); + denp = (struct direntry *) bp->b_data; + putushort(denp->deStartCluster, newcluster); + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &dDate, &dTime); + putushort(denp->deDate, dDate); + putushort(denp->deTime, dTime); + denp++; + putushort(denp->deStartCluster, pdep->de_StartCluster); + putushort(denp->deDate, dDate); + putushort(denp->deTime, dTime); + if (error = bwrite(bp)) { + clusterfree(pmp, newcluster, NULL); + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return error; + } + + /* + * Now build up a directory entry pointing to the newly allocated + * cluster. This will be written to an empty slot in the parent + * directory. + */ + ndep = &ndirent; + bzero(ndep, sizeof(*ndep)); + unix2dosfn((u_char *)ap->a_cnp->cn_nameptr, + ndep->de_Name, ap->a_cnp->cn_namelen); + TIMEVAL_TO_TIMESPEC(&time, &ts); + unix2dostime(&ts, &ndep->de_Date, &ndep->de_Time); + ndep->de_StartCluster = newcluster; + ndep->de_Attributes = ATTR_DIRECTORY; + + error = createde(ndep, pdep, &ndep); + if (error) { + clusterfree(pmp, newcluster, NULL); + } else { + *ap->a_vpp = DETOV(ndep); + } + free(ap->a_cnp->cn_pnbuf, M_NAMEI); +#ifdef MSDOSFS_DEBUG + printf("msdosfs_mkdir(): vput(%08x)\n", ap->a_dvp); +#endif + vput(ap->a_dvp); + return error; +} + +int +msdosfs_rmdir(ap) + struct vop_rmdir_args /* { + struct vnode *a_dvp; + struct vnode *a_vp; + struct componentname *a_cnp; + } */ *ap; +{ + struct denode *ddep; + struct denode *dep; + int error = 0; + + ddep = VTODE(ap->a_dvp); /* parent dir of dir to delete */ + dep = VTODE(ap->a_vp);/* directory to delete */ + + /* + * Don't let "rmdir ." go thru. + */ + if (ddep == dep) { + vrele(ap->a_vp); + vput(ap->a_vp); + return EINVAL; + } + + /* + * Be sure the directory being deleted is empty. + */ + if (dosdirempty(dep) == 0) { + error = ENOTEMPTY; + goto out; + } + + /* + * Delete the entry from the directory. For dos filesystems this + * gets rid of the directory entry on disk, the in memory copy + * still exists but the de_refcnt is <= 0. This prevents it from + * being found by deget(). When the vput() on dep is done we give + * up access and eventually msdosfs_reclaim() will be called which + * will remove it from the denode cache. + */ + if (error = removede(ddep,dep)) + goto out; + + /* + * This is where we decrement the link count in the parent + * directory. Since dos filesystems don't do this we just purge + * the name cache and let go of the parent directory denode. + */ + cache_purge(DETOV(ddep)); + vput(ap->a_dvp); + ap->a_dvp = NULL; + + /* + * Truncate the directory that is being deleted. + */ + error = detrunc(dep, (u_long) 0, IO_SYNC); + cache_purge(DETOV(dep)); + +out: ; + if (ap->a_dvp) + vput(ap->a_dvp); + vput(ap->a_vp); + return error; +} + +/* + * DOS filesystems don't know what symlinks are. + */ +int +msdosfs_symlink(ap) + struct vop_symlink_args /* { + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + struct vattr *a_vap; + char *a_target; + } */ *ap; +{ + struct denode *pdep = VTODE(ap->a_dvp); + + free(ap->a_cnp->cn_pnbuf, M_NAMEI); + vput(ap->a_dvp); + return EINVAL; +} + +/* + * Dummy dirents to simulate the "." and ".." entries of the root directory + * in a dos filesystem. Dos doesn't provide these. Note that each entry + * must be the same size as a dos directory entry (32 bytes). + */ +struct dos_dirent { + u_long d_fileno; + u_short d_reclen; + u_char d_type; + u_char d_namlen; + u_char d_name[24]; +} rootdots[2] = { + + { + 1, /* d_fileno */ + sizeof(struct direntry), /* d_reclen */ + DT_DIR, /* d_type */ + 1, /* d_namlen */ + "." /* d_name */ + }, + { + 1, /* d_fileno */ + sizeof(struct direntry), /* d_reclen */ + DT_DIR, /* d_type */ + 2, /* d_namlen */ + ".." /* d_name */ + } +}; + +int +msdosfs_readdir(ap) + struct vop_readdir_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + int *a_eofflag; + u_int *a_cookies; + int a_ncookies; + } */ *ap; +{ + int error = 0; + int diff; + char pushout; + long n; + long on; + long lost; + long count; + u_long cn; + u_long fileno; + long bias = 0; + daddr_t bn; + daddr_t lbn; + struct buf *bp; + struct denode *dep = VTODE(ap->a_vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct direntry *dentp; + struct dirent *prev; + struct dirent *crnt; + u_char dirbuf[512]; /* holds converted dos directories */ + int i = 0; + struct uio *uio = ap->a_uio; + int ncookies = 1; + u_int* cookies = NULL; + +#ifdef MSDOSFS_DEBUG + printf("msdosfs_readdir(): vp %08x, uio %08x, cred %08x, eofflagp %08x\n", + ap->a_vp, uio, ap->a_cred, ap->a_eofflag); +#endif + +#if 0 + if (!ap->a_cookies) + ncookies = 1; +#endif + + /* + * msdosfs_readdir() won't operate properly on regular files since + * it does i/o only with the the filesystem vnode, and hence can + * retrieve the wrong block from the buffer cache for a plain file. + * So, fail attempts to readdir() on a plain file. + */ + if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) + return ENOTDIR; + + /* + * If the user buffer is smaller than the size of one dos directory + * entry or the file offset is not a multiple of the size of a + * directory entry, then we fail the read. + */ + count = uio->uio_resid & ~(sizeof(struct direntry) - 1); + lost = uio->uio_resid - count; + if (count < sizeof(struct direntry) || + (uio->uio_offset & (sizeof(struct direntry) - 1))) + return EINVAL; + uio->uio_resid = count; + uio->uio_iov->iov_len = count; + + /* + * If they are reading from the root directory then, we simulate + * the . and .. entries since these don't exist in the root + * directory. We also set the offset bias to make up for having to + * simulate these entries. By this I mean that at file offset 64 we + * read the first entry in the root directory that lives on disk. + */ + if (dep->de_StartCluster == MSDOSFSROOT) { + /* + * printf("msdosfs_readdir(): going after . or .. in root dir, offset %d\n", + * uio->uio_offset); + */ + bias = 2 * sizeof(struct direntry); + if (uio->uio_offset < 2 * sizeof(struct direntry)) { + if (uio->uio_offset + && uio->uio_offset != sizeof(struct direntry)) { + error = EINVAL; + goto out; + } + n = 1; + if (!uio->uio_offset) { + n = 2; + if (cookies) { + *cookies++ = sizeof(struct direntry); + ncookies--; + } + } + if (cookies) { + if (ncookies-- <= 0) + n--; + else + *cookies++ = 2 * sizeof(struct direntry); + } + + error = uiomove((char *) rootdots + uio->uio_offset, + n * sizeof(struct direntry), uio); + } + } + while (!error && uio->uio_resid > 0 && ncookies > 0) { + lbn = (uio->uio_offset - bias) >> pmp->pm_cnshift; + on = (uio->uio_offset - bias) & pmp->pm_crbomask; + n = min((u_long) (pmp->pm_bpcluster - on), uio->uio_resid); + diff = dep->de_FileSize - (uio->uio_offset - bias); + if (diff <= 0) + return 0; + if (diff < n) + n = diff; + error = pcbmap(dep, lbn, &bn, &cn); + if (error) + break; + error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster, NOCRED, &bp); + n = min(n, pmp->pm_bpcluster - bp->b_resid); + if (error) { + brelse(bp); + return error; + } + + /* + * code to convert from dos directory entries to ufs + * directory entries + */ + pushout = 0; + dentp = (struct direntry *)(bp->b_data + on); + prev = 0; + crnt = (struct dirent *) dirbuf; + while ((char *) dentp < bp->b_data + on + n) { + /* + * printf("rd: dentp %08x prev %08x crnt %08x deName %02x attr %02x\n", + * dentp, prev, crnt, dentp->deName[0], dentp->deAttributes); + */ + /* + * If we have an empty entry or a slot from a + * deleted file, or a volume label entry just + * concatenate its space onto the end of the + * previous entry or, manufacture an empty entry if + * there is no previous entry. + */ + if (dentp->deName[0] == SLOT_EMPTY || + dentp->deName[0] == SLOT_DELETED || + (dentp->deAttributes & ATTR_VOLUME)) { + if (prev) { + prev->d_reclen += sizeof(struct direntry); + if (cookies) { + ncookies++; + cookies--; + } + } else { + prev = crnt; + prev->d_fileno = 0; + prev->d_reclen = sizeof(struct direntry); + prev->d_type = DT_UNKNOWN; + prev->d_namlen = 0; + prev->d_name[0] = 0; + } + } else { + /* + * this computation of d_fileno must match + * the computation of va_fileid in + * msdosfs_getattr + */ + if (dentp->deAttributes & ATTR_DIRECTORY) { + /* if this is the root directory */ + fileno = getushort(dentp->deStartCluster); + if (fileno == MSDOSFSROOT) + fileno = 1; + } else { + /* + * if the file's dirent lives in + * root dir + */ + if ((fileno = cn) == MSDOSFSROOT) + fileno = 1; + fileno = (fileno << 16) | + ((dentp - (struct direntry *) bp->b_data) & 0xffff); + } + crnt->d_fileno = fileno; + crnt->d_reclen = sizeof(struct direntry); + crnt->d_type = (dentp->deAttributes & ATTR_DIRECTORY) + ? DT_DIR : DT_REG; + crnt->d_namlen = dos2unixfn(dentp->deName, + (u_char *)crnt->d_name); + /* + * printf("readdir: file %s, fileno %08x, attr %02x, start %08x\n", + * crnt->d_name, crnt->d_fileno, dentp->deAttributes, + * dentp->deStartCluster); + */ + prev = crnt; + } + dentp++; + if (cookies) { + *cookies++ = (u_int)((char *)dentp - bp->b_data - on) + + uio->uio_offset; + ncookies--; + } + + crnt = (struct dirent *) ((char *) crnt + sizeof(struct direntry)); + pushout = 1; + + /* + * If our intermediate buffer is full then copy its + * contents to user space. I would just use the + * buffer the buf header points to but, I'm afraid + * that when we brelse() it someone else might find + * it in the cache and think its contents are + * valid. Maybe there is a way to invalidate the + * buffer before brelse()'ing it. + */ + if ((u_char *) crnt >= &dirbuf[sizeof dirbuf]) { + pushout = 0; + error = uiomove(dirbuf, sizeof(dirbuf), uio); + if (error) + break; + prev = 0; + crnt = (struct dirent *) dirbuf; + } + if (ncookies <= 0) + break; + } + if (pushout) { + pushout = 0; + error = uiomove(dirbuf, (char *) crnt - (char *) dirbuf, + uio); + } + +#if 0 + /* + * If we have read everything from this block or have read + * to end of file then we are done with this block. Mark + * it to say the buffer can be reused if need be. + */ + if (n + on == pmp->pm_bpcluster || + (uio->uio_offset - bias) == dep->de_FileSize) + bp->b_flags |= B_AGE; +#endif /* if 0 */ + brelse(bp); + if (n == 0) + break; + } +out: ; + uio->uio_resid += lost; + +#if 0 + /* + * I don't know why we bother setting this eofflag, getdirentries() + * in vfs_syscalls.c doesn't bother to look at it when we return. + * (because NFS uses it in nfs_serv.c -- JMP) + */ + if (dep->de_FileSize - uio->uio_offset - bias <= 0) + *ap->a_eofflag = 1; + else + *ap->a_eofflag = 0; +#endif + + return error; +} + +/* + * DOS filesystems don't know what symlinks are. + */ +int +msdosfs_readlink(ap) + struct vop_readlink_args /* { + struct vnode *a_vp; + struct uio *a_uio; + struct ucred *a_cred; + } */ *ap; +{ + return EINVAL; +} + +int +msdosfs_abortop(ap) + struct vop_abortop_args /* { + struct vnode *a_dvp; + struct componentname *a_cnp; + } */ *ap; +{ + if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF) + FREE(ap->a_cnp->cn_pnbuf, M_NAMEI); + return 0; +} + +int +msdosfs_lock(ap) + struct vop_lock_args /* { + struct vnode *a_vp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + + while (dep->de_flag & DE_LOCKED) { + dep->de_flag |= DE_WANTED; + if (dep->de_lockholder == curproc->p_pid) + panic("msdosfs_lock: locking against myself"); + dep->de_lockwaiter = curproc->p_pid; + (void) sleep((caddr_t) dep, PINOD); + } + dep->de_lockwaiter = 0; + dep->de_lockholder = curproc->p_pid; + dep->de_flag |= DE_LOCKED; + return 0; +} + +int +msdosfs_unlock(ap) + struct vop_unlock_args /* { + struct vnode *vp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + + if (!(dep->de_flag & DE_LOCKED)) + panic("msdosfs_unlock: denode not locked"); + dep->de_lockholder = 0; + dep->de_flag &= ~DE_LOCKED; + if (dep->de_flag & DE_WANTED) { + dep->de_flag &= ~DE_WANTED; + wakeup((caddr_t) dep); + } + return 0; +} + +int +msdosfs_islocked(ap) + struct vop_islocked_args /* { + struct vnode *a_vp; + } */ *ap; +{ + return VTODE(ap->a_vp)->de_flag & DE_LOCKED ? 1 : 0; +} + +/* + * vp - address of vnode file the file + * bn - which cluster we are interested in mapping to a filesystem block number. + * vpp - returns the vnode for the block special file holding the filesystem + * containing the file of interest + * bnp - address of where to return the filesystem relative block number + */ +int +msdosfs_bmap(ap) + struct vop_bmap_args /* { + struct vnode *a_vp; + daddr_t a_bn; + struct vnode **a_vpp; + daddr_t *a_bnp; + int *a_runp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + struct msdosfsmount *pmp = dep->de_pmp; + + if (ap->a_vpp != NULL) + *ap->a_vpp = dep->de_devvp; + if (ap->a_bnp == NULL) + return 0; + if (ap->a_runp) { + /* + * Sequential clusters should be counted here. + */ + *ap->a_runp = 0; + } + return pcbmap(dep, ap->a_bn, ap->a_bnp, 0); +} + +int msdosfs_reallocblks(ap) + struct vop_reallocblks_args /* { + struct vnode *a_vp; + struct cluster_save *a_buflist; + } */ *ap; +{ + /* Currently no support for clustering */ /* XXX */ + return ENOSPC; +} + +int +msdosfs_strategy(ap) + struct vop_strategy_args /* { + struct buf *a_bp; + } */ *ap; +{ + struct buf *bp = ap->a_bp; + struct denode *dep = VTODE(bp->b_vp); + struct msdosfsmount *pmp = dep->de_pmp; + struct vnode *vp; + int error = 0; + + if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR) + panic("msdosfs_strategy: spec"); + /* + * If we don't already know the filesystem relative block number + * then get it using pcbmap(). If pcbmap() returns the block + * number as -1 then we've got a hole in the file. DOS filesystems + * don't allow files with holes, so we shouldn't ever see this. + */ + if (bp->b_blkno == bp->b_lblkno) { + if (error = pcbmap(dep, bp->b_lblkno, &bp->b_blkno, 0)) + bp->b_blkno = -1; + if (bp->b_blkno == -1) + clrbuf(bp); + } + if (bp->b_blkno == -1) { + biodone(bp); + return error; + } +#ifdef DIAGNOSTIC +#endif + /* + * Read/write the block from/to the disk that contains the desired + * file block. + */ + vp = dep->de_devvp; + bp->b_dev = vp->v_rdev; + VOCALL(vp->v_op, VOFFSET(vop_strategy), ap); + return 0; +} + +int +msdosfs_print(ap) + struct vop_print_args /* { + struct vnode *vp; + } */ *ap; +{ + struct denode *dep = VTODE(ap->a_vp); + + printf("tag VT_MSDOSFS, startcluster %d, dircluster %d, diroffset %d ", + dep->de_StartCluster, dep->de_dirclust, dep->de_diroffset); + printf(" dev %d, %d, %s\n", + major(dep->de_dev), minor(dep->de_dev), + dep->de_flag & DE_LOCKED ? "(LOCKED)" : ""); + if (dep->de_lockholder) { + printf(" owner pid %d", dep->de_lockholder); + if (dep->de_lockwaiter) + printf(" waiting pid %d", dep->de_lockwaiter); + printf("\n"); + } + return 0; +} + +int +msdosfs_advlock(ap) + struct vop_advlock_args /* { + struct vnode *a_vp; + caddr_t a_id; + int a_op; + struct flock *a_fl; + int a_flags; + } */ *ap; +{ + return EINVAL; /* we don't do locking yet */ +} + +int +msdosfs_pathconf(ap) + struct vop_pathconf_args /* { + struct vnode *a_vp; + int a_name; + int *a_retval; + } */ *ap; +{ + switch (ap->a_name) { + case _PC_LINK_MAX: + *ap->a_retval = 1; + return 0; + case _PC_NAME_MAX: + *ap->a_retval = 12; + return 0; + case _PC_PATH_MAX: + *ap->a_retval = PATH_MAX; /* 255? */ + return 0; + case _PC_CHOWN_RESTRICTED: + *ap->a_retval = 1; + return 0; + case _PC_NO_TRUNC: + *ap->a_retval = 0; + return 0; + default: + return EINVAL; + } +} + +/* Global vfs data structures for msdosfs */ +int (**msdosfs_vnodeop_p)(); +struct vnodeopv_entry_desc msdosfs_vnodeop_entries[] = { + { &vop_default_desc, vn_default_error }, + { &vop_lookup_desc, msdosfs_lookup }, /* lookup */ + { &vop_create_desc, msdosfs_create }, /* create */ + { &vop_mknod_desc, msdosfs_mknod }, /* mknod */ + { &vop_open_desc, msdosfs_open }, /* open */ + { &vop_close_desc, msdosfs_close }, /* close */ + { &vop_access_desc, msdosfs_access }, /* access */ + { &vop_getattr_desc, msdosfs_getattr }, /* getattr */ + { &vop_setattr_desc, msdosfs_setattr }, /* setattr */ + { &vop_read_desc, msdosfs_read }, /* read */ + { &vop_write_desc, msdosfs_write }, /* write */ + { &vop_ioctl_desc, msdosfs_ioctl }, /* ioctl */ + { &vop_select_desc, msdosfs_select }, /* select */ + { &vop_mmap_desc, msdosfs_mmap }, /* mmap */ + { &vop_fsync_desc, msdosfs_fsync }, /* fsync */ + { &vop_seek_desc, msdosfs_seek }, /* seek */ + { &vop_remove_desc, msdosfs_remove }, /* remove */ + { &vop_link_desc, msdosfs_link }, /* link */ + { &vop_rename_desc, msdosfs_rename }, /* rename */ + { &vop_mkdir_desc, msdosfs_mkdir }, /* mkdir */ + { &vop_rmdir_desc, msdosfs_rmdir }, /* rmdir */ + { &vop_symlink_desc, msdosfs_symlink }, /* symlink */ + { &vop_readdir_desc, msdosfs_readdir }, /* readdir */ + { &vop_readlink_desc, msdosfs_readlink }, /* readlink */ + { &vop_abortop_desc, msdosfs_abortop }, /* abortop */ + { &vop_inactive_desc, msdosfs_inactive }, /* inactive */ + { &vop_reclaim_desc, msdosfs_reclaim }, /* reclaim */ + { &vop_lock_desc, msdosfs_lock }, /* lock */ + { &vop_unlock_desc, msdosfs_unlock }, /* unlock */ + { &vop_bmap_desc, msdosfs_bmap }, /* bmap */ + { &vop_strategy_desc, msdosfs_strategy }, /* strategy */ + { &vop_print_desc, msdosfs_print }, /* print */ + { &vop_islocked_desc, msdosfs_islocked }, /* islocked */ + { &vop_pathconf_desc, msdosfs_pathconf }, /* pathconf */ + { &vop_advlock_desc, msdosfs_advlock }, /* advlock */ + { &vop_reallocblks_desc, msdosfs_reallocblks }, /* reallocblks */ + { &vop_bwrite_desc, vn_bwrite }, + { (struct vnodeop_desc *)NULL, (int (*)())NULL } +}; +struct vnodeopv_desc msdosfs_vnodeop_opv_desc = + { &msdosfs_vnodeop_p, msdosfs_vnodeop_entries }; diff --git a/sys/msdosfs/msdosfsmount.h b/sys/msdosfs/msdosfsmount.h new file mode 100644 index 0000000..62853c5 --- /dev/null +++ b/sys/msdosfs/msdosfsmount.h @@ -0,0 +1,183 @@ +/* $Id$ */ +/* $NetBSD: msdosfsmount.h,v 1.7 1994/08/21 18:44:17 ws Exp $ */ + +/*- + * Copyright (C) 1994 Wolfgang Solfrank. + * Copyright (C) 1994 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Layout of the mount control block for a msdos file system. + */ +struct msdosfsmount { + struct mount *pm_mountp;/* vfs mount struct for this fs */ + dev_t pm_dev; /* block special device mounted */ + uid_t pm_mounter; /* uid of the user who mounted the FS */ + uid_t pm_uid; /* uid to set as owner of the files */ + gid_t pm_gid; /* gid to set as owner of the files */ + mode_t pm_mask; /* mask to and with file protection bits */ + struct vnode *pm_devvp; /* vnode for block device mntd */ + struct bpb50 pm_bpb; /* BIOS parameter blk for this fs */ + u_long pm_fatblk; /* block # of first FAT */ + u_long pm_rootdirblk; /* block # of root directory */ + u_long pm_rootdirsize; /* size in blocks (not clusters) */ + u_long pm_firstcluster; /* block number of first cluster */ + u_long pm_nmbrofclusters; /* # of clusters in filesystem */ + u_long pm_maxcluster; /* maximum cluster number */ + u_long pm_freeclustercount; /* number of free clusters */ + u_long pm_bnshift; /* shift file offset right this amount to get a block number */ + u_long pm_brbomask; /* and a file offset with this mask to get block rel offset */ + u_long pm_cnshift; /* shift file offset right this amount to get a cluster number */ + u_long pm_crbomask; /* and a file offset with this mask to get cluster rel offset */ + u_long pm_bpcluster; /* bytes per cluster */ + u_long pm_depclust; /* directory entries per cluster */ + u_long pm_fmod; /* ~0 if fs is modified, this can rollover to 0 */ + u_long pm_fatblocksize; /* size of fat blocks in bytes */ + u_long pm_fatblocksec; /* size of fat blocks in sectors */ + u_long pm_fatsize; /* size of fat in bytes */ + u_int *pm_inusemap; /* ptr to bitmap of in-use clusters */ + char pm_ronly; /* read only if non-zero */ + char pm_waitonfat; /* wait for writes of the fat to complt, when 0 use bdwrite, else use bwrite */ + struct netexport pm_export; /* export information */ +}; + +/* Number of bits in one pm_inusemap item: */ +#define N_INUSEBITS (8 * sizeof(u_int)) + +/* + * How to compute pm_cnshift and pm_crbomask. + * + * pm_crbomask = (pm_SectPerClust * pm_BytesPerSect) - 1 + * if (bytesperclust == * 0) + * return EBADBLKSZ; + * bit = 1; + * for (i = 0; i < 32; i++) { + * if (bit & bytesperclust) { + * if (bit ^ bytesperclust) + * return EBADBLKSZ; + * pm_cnshift = * i; + * break; + * } + * bit <<= 1; + * } + */ + +/* + * Shorthand for fields in the bpb contained in the msdosfsmount structure. + */ +#define pm_BytesPerSec pm_bpb.bpbBytesPerSec +#define pm_SectPerClust pm_bpb.bpbSecPerClust +#define pm_ResSectors pm_bpb.bpbResSectors +#define pm_FATs pm_bpb.bpbFATs +#define pm_RootDirEnts pm_bpb.bpbRootDirEnts +#define pm_Sectors pm_bpb.bpbSectors +#define pm_Media pm_bpb.bpbMedia +#define pm_FATsecs pm_bpb.bpbFATsecs +#define pm_SecPerTrack pm_bpb.bpbSecPerTrack +#define pm_Heads pm_bpb.bpbHeads +#define pm_HiddenSects pm_bpb.bpbHiddenSecs +#define pm_HugeSectors pm_bpb.bpbHugeSectors + +/* + * Map a cluster number into a filesystem relative block number. + */ +#define cntobn(pmp, cn) \ + ((((cn)-CLUST_FIRST) * (pmp)->pm_SectPerClust) + (pmp)->pm_firstcluster) + +/* + * Map a filesystem relative block number back into a cluster number. + */ +#define bntocn(pmp, bn) \ + ((((bn) - pmp->pm_firstcluster)/ (pmp)->pm_SectPerClust) + CLUST_FIRST) + +/* + * Calculate block number for directory entry in root dir, offset dirofs + */ +#define roottobn(pmp, dirofs) \ + (((dirofs) / (pmp)->pm_depclust) * (pmp)->pm_SectPerClust \ + + (pmp)->pm_rootdirblk) + +/* + * Calculate block number for directory entry at cluster dirclu, offset + * dirofs + */ +#define detobn(pmp, dirclu, dirofs) \ + ((dirclu) == MSDOSFSROOT \ + ? roottobn((pmp), (dirofs)) \ + : cntobn((pmp), (dirclu))) + +/* + * Convert pointer to buffer -> pointer to direntry + */ +#define bptoep(pmp, bp, dirofs) \ + ((struct direntry *)((bp)->b_data) \ + + (dirofs) % (pmp)->pm_depclust) + + +/* + * Convert filesize to block number + */ +#define de_blk(pmp, off) \ + ((off) >> (pmp)->pm_cnshift) + +/* + * Clusters required to hold size bytes + */ +#define de_clcount(pmp, size) \ + (((size) + (pmp)->pm_bpcluster - 1) >> (pmp)->pm_cnshift) + +/* + * Prototypes for MSDOSFS virtual filesystem operations + */ +int msdosfs_mount __P((struct mount *, char *, caddr_t, struct nameidata *, struct proc *)); +int msdosfs_start __P((struct mount *, int, struct proc *)); +int msdosfs_unmount __P((struct mount *, int, struct proc *)); +int msdosfs_root __P((struct mount *, struct vnode **)); +int msdosfs_quotactl __P((struct mount *, int, uid_t, caddr_t, struct proc *)); +int msdosfs_statfs __P((struct mount *, struct statfs *, struct proc *)); +int msdosfs_sync __P((struct mount *, int, struct ucred *, struct proc *)); +int msdosfs_fhtovp __P((struct mount *, struct fid *, struct mbuf *, struct vnode **, int *, struct ucred **)); +int msdosfs_vptofh __P((struct vnode *, struct fid *)); +int msdosfs_init __P(()); diff --git a/sys/sys/malloc.h b/sys/sys/malloc.h index 46c7df7..3d190ed 100644 --- a/sys/sys/malloc.h +++ b/sys/sys/malloc.h @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)malloc.h 8.3 (Berkeley) 1/12/94 - * $Id$ + * $Id: malloc.h,v 1.3 1994/08/02 07:53:10 davidg Exp $ */ #ifndef _SYS_MALLOC_H_ @@ -107,6 +107,9 @@ #define M_MRTABLE 56 /* multicast routing tables */ #define M_ISOFSMNT 57 /* ISOFS mount structure */ #define M_ISOFSNODE 58 /* ISOFS vnode private part */ +#define M_MSDOSFSMNT 59 /* MSDOSFS mount structure */ +#define M_MSDOSFSNODE 60 /* MSDOSFS vnode private part */ +#define M_MSDOSFSFAT 61 /* MSDOSFS file allocation table */ #define M_TEMP 74 /* misc temporary data buffers */ #define M_TTYS 75 /* tty data structures */ #define M_LAST 76 /* Must be last type + 1 */ @@ -171,9 +174,12 @@ "mrt", /* 56 M_MRTABLE */ \ "ISOFS mount", /* 57 M_ISOFSMNT */ \ "ISOFS node", /* 58 M_ISOFSNODE */ \ + "MSDOSFS mount",/* 59 M_MSDOSFSMNT */ \ + "MSDOSFS node", /* 60 M_MSDOSFSNODE */ \ + "MSDOSFS FAT", /* 61 M_MSDOSFSFAR */ \ NULL, NULL, NULL, NULL, NULL, \ NULL, NULL, NULL, NULL, NULL, \ - NULL, NULL, NULL, NULL, NULL, \ + NULL, NULL, \ "temp", /* 74 M_TEMP */ \ "ttys", /* 75 M_TTYS */ \ } diff --git a/sys/sys/mount.h b/sys/sys/mount.h index cae5442..1136343 100644 --- a/sys/sys/mount.h +++ b/sys/sys/mount.h @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)mount.h 8.13 (Berkeley) 3/27/94 - * $Id: mount.h,v 1.5 1994/08/22 14:09:51 bde Exp $ + * $Id: mount.h,v 1.6 1994/09/15 20:24:26 bde Exp $ */ #ifndef _SYS_MOUNT_H_ @@ -308,6 +308,19 @@ struct mfs_args { }; #endif /* MFS */ +#ifdef MSDOSFS +/* + * Arguments to mount MSDOS filesystems. + */ +struct msdosfs_args { + char *fspec; /* blocks special holding the fs to mount */ + struct export_args export; /* network export information */ + uid_t uid; /* uid that owns msdosfs files */ + gid_t gid; /* gid that owns msdosfs files */ + mode_t mask; /* mask to be applied for msdosfs perms */ +}; +#endif + #ifdef CD9660 /* * Arguments to mount ISO 9660 filesystems. diff --git a/sys/sys/vnode.h b/sys/sys/vnode.h index 89c8052..e20b71c 100644 --- a/sys/sys/vnode.h +++ b/sys/sys/vnode.h @@ -31,7 +31,7 @@ * SUCH DAMAGE. * * @(#)vnode.h 8.7 (Berkeley) 2/4/94 - * $Id: vnode.h,v 1.4 1994/08/29 06:09:11 davidg Exp $ + * $Id: vnode.h,v 1.5 1994/09/15 20:24:29 bde Exp $ */ #ifndef _SYS_VNODE_H_ @@ -58,7 +58,7 @@ enum vtype { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD }; enum vtagtype { VT_NON, VT_UFS, VT_NFS, VT_MFS, VT_PC, VT_LFS, VT_LOFS, VT_FDESC, VT_PORTAL, VT_NULL, VT_UMAP, VT_KERNFS, VT_PROCFS, VT_AFS, VT_ISOFS, - VT_UNION + VT_UNION, VT_MSDOSFS }; /* |
