/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #ifndef _SYS_FS_PC_FS_H #define _SYS_FS_PC_FS_H #include #include #include #include #ifdef __cplusplus extern "C" { #endif typedef uint16_t pc_cluster16_t; typedef uint32_t pc_cluster32_t; /* * PC (MSDOS) compatible virtual file system. * * A main goal of the implementation was to maintain statelessness * except while files are open. Thus mounting and unmounting merely * declared the file system name. The user may change disks at almost * any time without concern (just like the PC). It is assumed that when * files are open for writing the disk access light will be on, as a * warning not to change disks. The implementation must, however, detect * disk change and recover gracefully. It does this by comparing the * in core entry for a directory to the on disk entry whenever a directory * is searched. If a discrepancy is found active directories become root and * active files are marked invalid. * * There are only two type of nodes on the PC file system; files and * directories. These are represented by two separate vnode op vectors, * and they are kept in two separate tables. Files are known by the * disk block number and block (cluster) offset of the files directory * entry. Directories are known by the starting cluster number. * * The file system is locked for during each user operation. This is * done to simplify disk verification error conditions. * * Notes on FAT32 support * ---------------------- * The basic difference between FAT32 and FAT16 is that cluster numbers are now * 32-bit instead of 16-bit. The FAT is thus an array of 32-bit cluster numbers, * and because of this the cluster size can be much smaller on a large disk * (4k, say, on a 1 Gig drive instead of 16k). Unfortunately, the FAT is not * the only place cluster numbers are stored - the starting cluster is stored * in the directory entry for a file, and of course it's only 16-bit. Luckily, * there's a 16-bit OS/2 Extended Attribute field that is now used to store the * upper 16-bits of the starting cluster number. * * Most of the FAT32 changes to pcfs are under 'if it's FAT32' to minimize the * effect on non-FAT32 filesystems (and still share the code), except for the * starting cluster changes. It seemed easier to make common functions to * handle that. * * Other changes: * * 1. FAT32 partitions are indicated by partition types 0xB and 0xC. * 2. The boot sector is now 2 sectors, to make room for FAT32 extensions. * 3. The root directory is no longer stored in a fixed location. Its' * starting cluster is stored in the extended boot sector. * 4. "Summary information" is now stored and we need to (at least) maintain * the number of free clusters or scandisk will be upset. Though the * sector this info is in is pointed to by the extensions in the boot * sector, the magic offset of this information is just that so * far - magic. 0x1e0. * 5. FAT32 can use the alternate FAT. But we don't. * * FAT32 also exposed a latent bug: we bread() each copy of the FAT in one * big chunk. This is not good on a large FAT32 drive, such as a 1 Gig * Jaz drive that has 4k clusters, since the FAT becomes 1 Meg in size and * bread blocks forever. So now we read the FAT in chunks. */ /* * The FAT bootsector uses little-endian multibyte values not aligned at * a 'native' wordsize. Instead of defining a strange data structure and * odd accessor methods for some members while using standard C accesses * for others, we don't bother and just define the structure offsets, and * a common set of misaligned-littleendian accessor macros. * * The "bootsec" and "fat32_bootsec" structures are only provided for * compatibility with old code including but not used * by the PCFS kernel driver anymore. */ struct bootsec { uchar_t instr[3]; uchar_t version[8]; uchar_t bps[2]; /* bytes per sector */ uchar_t spcl; /* sectors per allocation unit */ uchar_t res_sec[2]; /* reserved sectors, starting at 0 */ uchar_t nfat; /* number of FATs */ uchar_t rdirents[2]; /* number of root directory entries */ uchar_t numsect[2]; /* old total sectors in logical image */ uchar_t mediadesriptor; /* media descriptor byte */ ushort_t fatsec; /* number of sectors per FAT */ ushort_t spt; /* sectors per track */ ushort_t nhead; /* number of heads */ uint_t hiddensec; /* number of hidden sectors */ uint_t totalsec; /* total sectors in logical image */ }; /* * FAT32 volumes have a bigger boot sector. They include the normal * boot sector. */ struct fat32_bootsec { struct bootsec f_bs; uint32_t f_fatlength; /* size of FAT */ uint16_t f_flags; uint8_t f_major; /* major filesystem version #? */ uint8_t f_minor; /* minor filesystem version #? */ uint32_t f_rootcluster; /* first cluster in root directory */ uint16_t f_infosector; /* where summary info is */ uint16_t f_backupboot; /* backup boot sector */ uint16_t f_reserved2[6]; }; #define OFF_JMPBOOT 0 #define OFF_OEMNAME 3 #define OFF_BYTESPERSEC 11 #define OFF_SECPERCLUS 13 #define OFF_RSVDSECCNT 14 #define OFF_NUMFATS 16 #define OFF_ROOTENTCNT 17 #define OFF_TOTSEC16 19 #define OFF_MEDIA 21 #define OFF_FATSZ16 22 #define OFF_SECPERTRK 24 #define OFF_NUMHEADS 26 #define OFF_HIDDSEC 28 #define OFF_TOTSEC32 32 #define OFF_BPBSIG 510 #define OFF_DRVNUM16 36 #define OFF_BOOTSIG16 38 #define OFF_VOLID16 39 #define OFF_VOLLAB16 43 #define OFF_FILSYSTYP16 54 #define OFF_FATSZ32 36 #define OFF_EXTFLAGS32 40 #define OFF_FSVER32 42 #define OFF_ROOTCLUS32 44 #define OFF_FSINFO32 48 #define OFF_BKBOOTSEC32 50 #define OFF_DRVNUM32 64 #define OFF_BOOTSIG32 66 #define OFF_VOLID32 67 #define OFF_VOLLAB32 71 #define OFF_FILSYSTYP32 82 #define LE_16_NA(addr) \ (((uint16_t)*((uint8_t *)(addr))) + \ ((uint16_t)*((uint8_t *)(addr) + 1) << 8)) #define LE_32_NA(addr) \ (((uint32_t)*((uint8_t *)(addr))) + \ ((uint32_t)*((uint8_t *)(addr) + 1) << 8) + \ ((uint32_t)*((uint8_t *)(addr) + 2) << 16) + \ ((uint32_t)*((uint8_t *)(addr) + 3) << 24)) /* * Generic FAT BPB fields */ #define bpb_jmpBoot(bpb) ((unsigned char *)(bpb)) #define bpb_OEMName(bpb) ((char *)(bpb) + OFF_OEMNAME) #define bpb_get_BytesPerSec(bpb) LE_16_NA((bpb) + OFF_BYTESPERSEC) #define bpb_get_SecPerClus(bpb) (((uint8_t *)(bpb))[OFF_SECPERCLUS]) #define bpb_get_RsvdSecCnt(bpb) LE_16_NA((bpb) + OFF_RSVDSECCNT) #define bpb_get_NumFATs(bpb) (((uint8_t *)(bpb))[OFF_NUMFATS]) #define bpb_get_RootEntCnt(bpb) LE_16_NA((bpb) + OFF_ROOTENTCNT) #define bpb_get_TotSec16(bpb) LE_16_NA((bpb) + OFF_TOTSEC16) #define bpb_get_Media(bpb) (((uint8_t *)(bpb))[OFF_MEDIA]) #define bpb_get_FatSz16(bpb) LE_16_NA((bpb) + OFF_FATSZ16) #define bpb_get_SecPerTrk(bpb) LE_16_NA((bpb) + OFF_SECPERTRK) #define bpb_get_NumHeads(bpb) LE_16_NA((bpb) + OFF_NUMHEADS) #define bpb_get_HiddSec(bpb) LE_32_NA((bpb) + OFF_HIDDSEC) #define bpb_get_TotSec32(bpb) LE_32_NA((bpb) + OFF_TOTSEC32) #define bpb_get_BPBSig(bpb) LE_16_NA((bpb) + OFF_BPBSIG) /* * FAT12/16 extended BPB fields */ #define bpb_get_DrvNum16(bpb) (((uint8_t *)(bpb))[OFF_DRVNUM16]) #define bpb_get_BootSig16(bpb) (((uint8_t *)(bpb))[OFF_BOOTSIG16]) #define bpb_VolLab16(bpb) ((char *)(bpb) + OFF_VOLLAB16) #define bpb_FilSysType16(bpb) ((char *)(bpb) + OFF_FILSYSTYP16) #define bpb_get_VolID16(bpb) LE_32_NA((bpb) + OFF_VOLID16) /* * FAT32 extended BPB fields */ #define bpb_get_FatSz32(bpb) LE_32_NA((bpb) + OFF_FATSZ32) #define bpb_get_ExtFlags32(bpb) LE_16_NA((bpb) + OFF_EXTFLAGS32) #define bpb_get_FSVer32(bpb) LE_16_NA((bpb) + OFF_FSVER32) #define bpb_get_RootClus32(bpb) LE_32_NA((bpb) + OFF_ROOTCLUS32) #define bpb_get_FSInfo32(bpb) LE_16_NA((bpb) + OFF_FSINFO32) #define bpb_get_BkBootSec32(bpb) LE_16_NA((bpb) + OFF_BKBOOTSEC32) #define bpb_get_DrvNum32(bpb) (((uint8_t *)(bpb))[OFF_DRVNUM32]) #define bpb_get_BootSig32(bpb) (((uint8_t *)(bpb))[OFF_BOOTSIG32]) #define bpb_get_VolID32(bpb) LE_32_NA((bpb) + OFF_VOLID32) #define bpb_VolLab32(bpb) ((char *)(bpb) + OFF_VOLLAB32) #define bpb_FilSysType32(bpb) ((char *)(bpb) + OFF_FILSYSTYP32) /* * Validators */ #define VALID_SECSIZE(s) \ (s == 512 || s == 1024 || s == 2048 || s == 4096) #define VALID_SPCL(s) (ISP2((s)) && (unsigned int)(s) <= 128) #define VALID_CLSIZE(s) (ISP2((s)) && (unsigned int)(s) <= (64 * 1024)) #define VALID_NUMFATS(n) ((n) > 0 && (n) < 8) #define VALID_RSVDSEC(s) ((s) > 0) #define VALID_BPBSIG(sig) ((sig) == MBB_MAGIC) #define VALID_BOOTSIG(sig) ((sig) == 0x29) #define VALID_MEDIA(m) ((m) == 0xF0 || ((m) >= 0xF8 && (m) <= 0xFF)) /* * this might require a change for codepage support. In particular, * pc_validchar() cannot be a macro anymore if codepages get involved. */ #define VALID_VOLLAB(l) ( \ pc_validchar((l)[0]) && pc_validchar((l)[1]) && \ pc_validchar((l)[2]) && pc_validchar((l)[3]) && \ pc_validchar((l)[4]) && pc_validchar((l)[5]) && \ pc_validchar((l)[6]) && pc_validchar((l)[7]) && \ pc_validchar((l)[8]) && pc_validchar((l)[9]) && \ pc_validchar((l)[10])) /* * We might actually use the 'validchar' checks as well; it only needs * to be printable. Should this ever caused failed media recognition, * we can change it. Many ISVs put different strings into the "oemname" * field. */ #define VALID_OEMNAME(nm) ( \ bcmp((nm), "MSDOS", 5) == 0 || bcmp((nm), "MSWIN", 5) == 0) #define VALID_FSTYPSTR16(typ) (bcmp((typ), "FAT", 3) == 0) #define VALID_FSTYPSTR32(typ) (bcmp((typ), "FAT32", 5) == 0) #define VALID_JMPBOOT(b) ( \ ((b)[0] == 0xeb && (b)[2] == 0x90) || (b)[0] == 0xe9) #define VALID_FSVER32(v) ((v) == PCFS_SUPPORTED_FSVER) /* * Can we check this properly somehow ? There should be a better way. * The FAT spec doesn't mention reserved bits need to be zero ... */ #define VALID_EXTFLAGS(flags) (((flags) & 0x8f) == (flags)) /* * Validation results */ #define BPB_SECSIZE_OK (1 << 0) /* ok: 512/1024/2048/4096 */ #define BPB_OEMNAME_OK (1 << 1) /* "MSDOS" or "MSWIN" */ #define BPB_JMPBOOT_OK (1 << 2) /* 16bit "jmp" / "call" */ #define BPB_SECPERCLUS_OK (1 << 3) /* power of 2, [1 .. 128] */ #define BPB_RSVDSECCNT_OK (1 << 4) /* cannot be zero */ #define BPB_NUMFAT_OK (1 << 5) /* >= 1, <= 8 */ #define BPB_ROOTENTCNT_OK (1 << 6) /* 0 on FAT32, != 0 else */ #define BPB_TOTSEC_OK (1 << 7) /* smaller than volume */ #define BPB_TOTSEC16_OK (1 << 8) /* 0 on FAT32, != 0 on FAT12 */ #define BPB_TOTSEC32_OK (1 << 9) /* 0 on FAT12, != 0 on FAT32 */ #define BPB_MEDIADESC_OK (1 << 10) /* 0xf0 or 0xf8..0xff */ #define BPB_FATSZ_OK (1 << 11) /* [nclusters], no smaller */ #define BPB_FATSZ16_OK (1 << 12) /* 0 on FAT32, != 0 else */ #define BPB_FATSZ32_OK (1 << 13) /* non-zero on FAT32 */ #define BPB_BPBSIG_OK (1 << 14) /* 0x55, 0xAA */ #define BPB_BOOTSIG16_OK (1 << 15) /* 0x29 - if present */ #define BPB_BOOTSIG32_OK (1 << 16) /* 0x29 - unless SYSLINUX2.x */ #define BPB_FSTYPSTR16_OK (1 << 17) /* At least "FAT" */ #define BPB_FSTYPSTR32_OK (1 << 18) /* "FAT32" */ #define BPB_EXTFLAGS_OK (1 << 19) /* reserved bits should be 0 */ #define BPB_FSVER_OK (1 << 20) /* must be 0 */ #define BPB_ROOTCLUSTER_OK (1 << 21) /* must be != 0 and valid */ #define BPB_FSISEC_OK (1 << 22) /* != 0, <= reserved */ #define BPB_BKBOOTSEC_OK (1 << 23) /* != 0, <= reserved, != fsi */ #define BPB_VOLLAB16_OK (1 << 24) /* passes pc_validchar() */ #define BPB_VOLLAB32_OK (1 << 25) /* passes pc_validchar() */ #define BPB_NCLUSTERS_OK (1 << 26) /* from FAT spec */ #define BPB_CLSIZE_OK (1 << 27) /* cluster size */ #define BPB_MEDIASZ_OK (1 << 28) /* filesystem fits on device */ #define FAT12_VALIDMSK \ (BPB_SECSIZE_OK | BPB_SECPERCLUS_OK | BPB_CLSIZE_OK | \ BPB_RSVDSECCNT_OK | BPB_NUMFAT_OK | BPB_ROOTENTCNT_OK | \ BPB_TOTSEC_OK | BPB_TOTSEC16_OK | \ BPB_FATSZ_OK | BPB_FATSZ16_OK | BPB_BPBSIG_OK) #define FAT16_VALIDMSK \ (BPB_SECSIZE_OK | BPB_SECPERCLUS_OK | BPB_CLSIZE_OK | \ BPB_RSVDSECCNT_OK | BPB_NUMFAT_OK | BPB_ROOTENTCNT_OK | \ BPB_TOTSEC_OK | BPB_TOTSEC16_OK | BPB_TOTSEC32_OK | \ BPB_FATSZ_OK | BPB_FATSZ16_OK | BPB_BPBSIG_OK) /* * A note on FAT32: According to the FAT spec, FAT32 _must_ have a valid * extended BPB and therefore, as a proof of its existance, the FAT32 * boot signature (offset 66) must be valid as well. Why don't we check * for BPB_BOOTSIG32_OK then ? * * We don't test for this here first-pass, because there are media out * there that are valid FAT32 structurally but don't have a valid sig. * This happens if older versions of the SYSLINUX bootloader (below 3.x) * are installed on a media with a FAT32 on it. SYSLINUX 2.x and lower * overwrite the BPB past the end of the FAT12/16 extension with its * bootloader code - and the FAT16 extended BPB is 62 Bytes... * All structurally relevant fields of the FAT32 BPB are within the first * 52 Bytes, so the filesystem is accessible - but the signature check * would reject it. */ #define FAT32_VALIDMSK \ (BPB_SECSIZE_OK | BPB_SECPERCLUS_OK | BPB_CLSIZE_OK | \ BPB_RSVDSECCNT_OK | BPB_NUMFAT_OK | BPB_ROOTENTCNT_OK | \ BPB_TOTSEC_OK | BPB_TOTSEC16_OK | BPB_TOTSEC32_OK | \ BPB_FATSZ_OK | BPB_FATSZ16_OK | BPB_FATSZ32_OK | \ BPB_EXTFLAGS_OK | BPB_FSVER_OK | BPB_ROOTCLUSTER_OK | \ BPB_BPBSIG_OK) /* * FAT32 BPB allows 'versioning' via FSVer32. We follow the 'NULL' spec. */ #define PCFS_SUPPORTED_FSVER 0 /* * Filesystem summary information (introduced originally for FAT32 volumes). * We need to maintain fs_free_clusters or Microsoft Scandisk will be upset. * We keep these values in-core even for FAT12/FAT16 but will never attempt * to write them out to disk then. */ typedef struct fat_fsinfo { uint32_t fs_free_clusters; /* # free clusters. -1 if unknown */ uint32_t fs_next_free; /* search next free after this cn */ } fat_fsi_t; /* * On-disk FSI. All values in little endian. Only FAT32 has this. */ typedef struct fat_od_fsi { uint32_t fsi_leadsig; /* 0x41615252 */ char fsi_reserved1[480]; uint32_t fsi_strucsig; /* 0x61417272 */ fat_fsi_t fsi_incore; /* free/nextfree */ char fsi_reserved2[12]; uint32_t fsi_trailsig; /* 0xaa550000 */ } fat_od_fsi_t; #define FSI_LEADSIG LE_32(0x41615252) #define FSI_STRUCSIG LE_32(0x61417272) #define FSI_TRAILSIG LE_32(0xaa550000) /* same as MBB_MAGIC */ #define FSISIG_OK(fsi) ( \ ((fat_od_fsi_t *)(fsi))->fsi_leadsig == FSI_LEADSIG && \ ((fat_od_fsi_t *)(fsi))->fsi_strucsig == FSI_STRUCSIG && \ ((fat_od_fsi_t *)(fsi))->fsi_trailsig == FSI_TRAILSIG) #define FSINFO_UNKNOWN ((uint32_t)(-1)) /* free/next not valid */ typedef enum { FAT12, FAT16, FAT32, FAT_UNKNOWN, FAT_QUESTIONABLE } fattype_t; struct pcfs { struct vfs *pcfs_vfs; /* vfs for this fs */ int pcfs_flags; /* flags */ int pcfs_ldrive; /* logical DOS drive number */ fattype_t pcfs_fattype; dev_t pcfs_xdev; /* actual device that is mounted */ struct vnode *pcfs_devvp; /* and a vnode for it */ int pcfs_secsize; /* sector size in bytes */ int pcfs_spcl; /* sectors per cluster */ int pcfs_spt; /* sectors per track */ int pcfs_sdshift; /* shift to convert sector into */ /* DEV_BSIZE "sectors"; assume */ /* pcfs_secsize is 2**n times of */ /* DEV_BSIZE */ int pcfs_fatsec; /* number of sec per FAT */ int pcfs_numfat; /* number of FAT copies */ int pcfs_rdirsec; /* number of sec in root dir */ daddr_t pcfs_dosstart; /* start blkno of DOS partition */ daddr_t pcfs_fsistart; /* start blkno of FSI sector */ daddr_t pcfs_fatstart; /* start blkno of first FAT */ daddr_t pcfs_rdirstart; /* start blkno of root dir */ daddr_t pcfs_datastart; /* start blkno of data area */ int pcfs_clsize; /* cluster size in bytes */ int pcfs_ncluster; /* number of clusters in fs */ int pcfs_nrefs; /* number of active pcnodes */ int pcfs_frefs; /* number of active file pcnodes */ int pcfs_nxfrecls; /* next free cluster */ uchar_t *pcfs_fatp; /* ptr to FAT data */ uchar_t *pcfs_fat_changemap; /* map of changed fat data */ int pcfs_fat_changemapsize; /* size of FAT changemap */ time_t pcfs_fattime; /* time FAT becomes invalid */ time_t pcfs_verifytime; /* time to reverify disk */ kmutex_t pcfs_lock; /* per filesystem lock */ kthread_id_t pcfs_owner; /* id of thread locking pcfs */ int pcfs_count; /* # of pcfs locks for pcfs_owner */ struct fat_fsinfo pcfs_fsinfo; /* in-core fsinfo */ struct pcfs *pcfs_nxt; /* linked list of all mounts */ int pcfs_fatjustread; /* Used to flag a freshly found FAT */ struct vnode *pcfs_root; /* vnode for the root dir of the fs */ int pcfs_secondswest; /* recording timezone for this fs */ len_t pcfs_mediasize; int pcfs_rootblksize; int pcfs_mediadesc; /* media descriptor */ pc_cluster32_t pcfs_lastclmark; pc_cluster32_t pcfs_rootclnum; timestruc_t pcfs_mounttime; /* timestamp for "/" */ }; /* * flags */ #define PCFS_FATMOD 0x01 /* FAT has been modified */ #define PCFS_LOCKED 0x02 /* fs is locked */ #define PCFS_WANTED 0x04 /* locked fs is wanted */ #define PCFS_NOCHK 0x800 /* don't resync fat on error */ #define PCFS_BOOTPART 0x1000 /* boot partition type */ #define PCFS_HIDDEN 0x2000 /* show hidden files */ #define PCFS_PCMCIA_NO_CIS 0x4000 /* PCMCIA psuedo floppy */ #define PCFS_FOLDCASE 0x8000 /* fold filenames to lowercase */ #define PCFS_FSINFO_OK 0x10000 /* valid FAT32 fsinfo sector */ #define PCFS_IRRECOV 0x20000 /* FS was messed with during write */ #define PCFS_NOCLAMPTIME 0x40000 /* expose full FAT timestamp range */ #define PCFS_NOATIME 0x80000 /* disable atime updates */ #define IS_FAT12(PCFS) ((PCFS)->pcfs_fattype == FAT12) #define IS_FAT16(PCFS) ((PCFS)->pcfs_fattype == FAT16) #define IS_FAT32(PCFS) ((PCFS)->pcfs_fattype == FAT32) /* for compatibility */ struct old_pcfs_args { int secondswest; /* seconds west of Greenwich */ int dsttime; /* type of dst correction */ }; struct pcfs_args { int secondswest; /* seconds west of Greenwich */ int dsttime; /* type of dst correction */ int flags; }; /* * pcfs mount options. */ #define MNTOPT_PCFS_HIDDEN "hidden" #define MNTOPT_PCFS_NOHIDDEN "nohidden" #define MNTOPT_PCFS_FOLDCASE "foldcase" #define MNTOPT_PCFS_NOFOLDCASE "nofoldcase" #define MNTOPT_PCFS_CLAMPTIME "clamptime" #define MNTOPT_PCFS_NOCLAMPTIME "noclamptime" #define MNTOPT_PCFS_TIMEZONE "timezone" #define MNTOPT_PCFS_SECSIZE "secsize" /* * Disk timeout value in sec. * This is used to time out the in core FAT and to re-verify the disk. * This should be less than the time it takes to change floppys */ #define PCFS_DISKTIMEOUT 2 #define PCFS_MAXOFFSET_T UINT32_MAX /* PCFS max file size */ #define VFSTOPCFS(VFSP) ((struct pcfs *)((VFSP)->vfs_data)) #define PCFSTOVFS(FSP) ((FSP)->pcfs_vfs) /* * special cluster numbers in FAT */ #define PCF_FREECLUSTER 0x00 /* cluster is available */ #define PCF_ERRORCLUSTER 0x01 /* error occurred allocating cluster */ #define PCF_12BCLUSTER 0xFF0 /* 12-bit version of reserved cluster */ #define PCF_RESCLUSTER 0xFFF0 /* 16-bit version of reserved cluster */ #define PCF_RESCLUSTER32 0xFFFFFF0 /* 32-bit version */ #define PCF_BADCLUSTER 0xFFF7 /* bad cluster, do not use */ #define PCF_BADCLUSTER32 0xFFFFFF7 /* 32-bit version */ #define PCF_LASTCLUSTER 0xFFF8 /* >= means last cluster in file */ #define PCF_LASTCLUSTER32 0xFFFFFF8 /* 32-bit version */ #define PCF_LASTCLUSTERMARK 0xFFFF /* value used to mark last cluster */ #define PCF_LASTCLUSTERMARK32 0xFFFFFFF /* 32-bit version */ #define PCF_FIRSTCLUSTER 2 /* first valid cluster number */ /* * file system constants */ #define PC_MAXFATSEC 256 /* maximum number of sectors in FAT */ /* * file system parameter macros */ #define pc_clear_fatchanges(PCFS) \ bzero((PCFS)->pcfs_fat_changemap, (PCFS)->pcfs_fat_changemapsize) #define pc_blksize(PCFS, PCP, OFF) /* file system block size */ \ (((PCTOV(PCP)->v_flag & VROOT) && !IS_FAT32(PCFS)) ? \ ((OFF) >= \ ((PCFS)->pcfs_rdirsec & \ ~((PCFS)->pcfs_spcl - 1)) * ((PCFS)->pcfs_secsize)? \ ((PCFS)->pcfs_rdirsec & \ ((PCFS)->pcfs_spcl - 1)) * ((PCFS)->pcfs_secsize): \ (PCFS)->pcfs_clsize): \ (PCFS)->pcfs_clsize) #define pc_blkoff(PCFS, OFF) /* offset within block */ \ ((int)((OFF) & ((PCFS)->pcfs_clsize - 1))) #define pc_lblkno(PCFS, OFF) /* logical block (cluster) no */ \ ((daddr_t)((OFF) / (PCFS)->pcfs_clsize)) #define pc_dbtocl(PCFS, DB) /* disk blks to clusters */ \ ((int)((DB) / (PCFS)->pcfs_spcl)) #define pc_cltodb(PCFS, CL) /* clusters to disk blks */ \ ((daddr_t)((CL) * (PCFS)->pcfs_spcl)) #define pc_dbdaddr(PCFS, DB) /* sector to DEV_BSIZE "sector" addr */ \ ((DB) << (PCFS)->pcfs_sdshift) #define pc_daddrdb(PCFS, DADDR) /* DEV_BSIZE "sector" addr to sector addr */ \ ((DADDR) >> (PCFS)->pcfs_sdshift) #define pc_cldaddr(PCFS, CL) /* DEV_BSIZE "sector" addr for cluster */ \ pc_dbdaddr(PCFS, ((daddr_t)((PCFS)->pcfs_datastart + \ pc_cltodb(PCFS, (CL) - PCF_FIRSTCLUSTER)))) #define pc_daddrcl(PCFS, DADDR) /* cluster for disk address */ \ ((int)(PCF_FIRSTCLUSTER + \ pc_dbtocl(pc_daddrdb(PCFS, DADDR) - (PCFS)->pcfs_datastart))) /* * Number of directory entries per sector / cluster */ #define pc_direntpersec(PCFS) \ ((int)((PCFS)->pcfs_secsize / sizeof (struct pcdir))) #define pc_direntpercl(PCFS) \ ((int)((PCFS)->pcfs_clsize / sizeof (struct pcdir))) /* * out-of-range check for cluster numbers. */ #define pc_validcl(PCFS, CL) /* check that cluster no is legit */ \ ((int)(CL) >= PCF_FIRSTCLUSTER && \ (int)(CL) < (PCFS)->pcfs_ncluster + PCF_FIRSTCLUSTER) /* * external routines. */ extern int pc_lockfs(struct pcfs *, int, int); /* lock fs and get fat */ extern void pc_unlockfs(struct pcfs *); /* ulock the fs */ extern int pc_getfat(struct pcfs *); /* get fat from disk */ extern void pc_invalfat(struct pcfs *); /* invalidate incore fat */ extern int pc_syncfat(struct pcfs *); /* sync fat to disk */ extern int pc_freeclusters(struct pcfs *); /* num free clusters in fs */ extern pc_cluster32_t pc_alloccluster(struct pcfs *, int); extern void pc_setcluster(struct pcfs *, pc_cluster32_t, pc_cluster32_t); extern void pc_mark_fat_updated(struct pcfs *fsp, pc_cluster32_t cn); extern int pc_fat_is_changed(struct pcfs *fsp, pc_cluster32_t bn); /* * debugging */ extern int pcfsdebuglevel; #define PC_DPRINTF0(level, A) \ if (pcfsdebuglevel >= level) \ cmn_err(CE_CONT, (A)) #define PC_DPRINTF1(level, A, B) \ if (pcfsdebuglevel >= level) \ cmn_err(CE_CONT, (A), (B)) #define PC_DPRINTF2(level, A, B, C) \ if (pcfsdebuglevel >= level) \ cmn_err(CE_CONT, (A), (B), (C)) #define PC_DPRINTF3(level, A, B, C, D) \ if (pcfsdebuglevel >= level) \ cmn_err(CE_CONT, (A), (B), (C), (D)) #define PC_DPRINTF4(level, A, B, C, D, E) \ if (pcfsdebuglevel >= level) \ cmn_err(CE_CONT, (A), (B), (C), (D), (E)) #ifdef __cplusplus } #endif #endif /* _SYS_FS_PC_FS_H */