pc_fs.h revision 9251:f12a52a5aac6
1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21/* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26#ifndef _SYS_FS_PC_FS_H 27#define _SYS_FS_PC_FS_H 28 29#include <sys/thread.h> 30#include <sys/ksynch.h> 31#include <sys/sysmacros.h> 32#include <sys/byteorder.h> 33 34#ifdef __cplusplus 35extern "C" { 36#endif 37 38typedef uint16_t pc_cluster16_t; 39typedef uint32_t pc_cluster32_t; 40 41/* 42 * PC (MSDOS) compatible virtual file system. 43 * 44 * A main goal of the implementation was to maintain statelessness 45 * except while files are open. Thus mounting and unmounting merely 46 * declared the file system name. The user may change disks at almost 47 * any time without concern (just like the PC). It is assumed that when 48 * files are open for writing the disk access light will be on, as a 49 * warning not to change disks. The implementation must, however, detect 50 * disk change and recover gracefully. It does this by comparing the 51 * in core entry for a directory to the on disk entry whenever a directory 52 * is searched. If a discrepancy is found active directories become root and 53 * active files are marked invalid. 54 * 55 * There are only two type of nodes on the PC file system; files and 56 * directories. These are represented by two separate vnode op vectors, 57 * and they are kept in two separate tables. Files are known by the 58 * disk block number and block (cluster) offset of the files directory 59 * entry. Directories are known by the starting cluster number. 60 * 61 * The file system is locked for during each user operation. This is 62 * done to simplify disk verification error conditions. 63 * 64 * Notes on FAT32 support 65 * ---------------------- 66 * The basic difference between FAT32 and FAT16 is that cluster numbers are now 67 * 32-bit instead of 16-bit. The FAT is thus an array of 32-bit cluster numbers, 68 * and because of this the cluster size can be much smaller on a large disk 69 * (4k, say, on a 1 Gig drive instead of 16k). Unfortunately, the FAT is not 70 * the only place cluster numbers are stored - the starting cluster is stored 71 * in the directory entry for a file, and of course it's only 16-bit. Luckily, 72 * there's a 16-bit OS/2 Extended Attribute field that is now used to store the 73 * upper 16-bits of the starting cluster number. 74 * 75 * Most of the FAT32 changes to pcfs are under 'if it's FAT32' to minimize the 76 * effect on non-FAT32 filesystems (and still share the code), except for the 77 * starting cluster changes. It seemed easier to make common functions to 78 * handle that. 79 * 80 * Other changes: 81 * 82 * 1. FAT32 partitions are indicated by partition types 0xB and 0xC. 83 * 2. The boot sector is now 2 sectors, to make room for FAT32 extensions. 84 * 3. The root directory is no longer stored in a fixed location. Its' 85 * starting cluster is stored in the extended boot sector. 86 * 4. "Summary information" is now stored and we need to (at least) maintain 87 * the number of free clusters or scandisk will be upset. Though the 88 * sector this info is in is pointed to by the extensions in the boot 89 * sector, the magic offset of this information is just that so 90 * far - magic. 0x1e0. 91 * 5. FAT32 can use the alternate FAT. But we don't. 92 * 93 * FAT32 also exposed a latent bug: we bread() each copy of the FAT in one 94 * big chunk. This is not good on a large FAT32 drive, such as a 1 Gig 95 * Jaz drive that has 4k clusters, since the FAT becomes 1 Meg in size and 96 * bread blocks forever. So now we read the FAT in chunks. 97 */ 98 99 100/* 101 * The FAT bootsector uses little-endian multibyte values not aligned at 102 * a 'native' wordsize. Instead of defining a strange data structure and 103 * odd accessor methods for some members while using standard C accesses 104 * for others, we don't bother and just define the structure offsets, and 105 * a common set of misaligned-littleendian accessor macros. 106 * 107 * The "bootsec" and "fat32_bootsec" structures are only provided for 108 * compatibility with old code including <sys/fs/pc_fs.h> but not used 109 * by the PCFS kernel driver anymore. 110 */ 111struct bootsec { 112 uchar_t instr[3]; 113 uchar_t version[8]; 114 uchar_t bps[2]; /* bytes per sector */ 115 uchar_t spcl; /* sectors per allocation unit */ 116 uchar_t res_sec[2]; /* reserved sectors, starting at 0 */ 117 uchar_t nfat; /* number of FATs */ 118 uchar_t rdirents[2]; /* number of root directory entries */ 119 uchar_t numsect[2]; /* old total sectors in logical image */ 120 uchar_t mediadesriptor; /* media descriptor byte */ 121 ushort_t fatsec; /* number of sectors per FAT */ 122 ushort_t spt; /* sectors per track */ 123 ushort_t nhead; /* number of heads */ 124 uint_t hiddensec; /* number of hidden sectors */ 125 uint_t totalsec; /* total sectors in logical image */ 126}; 127 128/* 129 * FAT32 volumes have a bigger boot sector. They include the normal 130 * boot sector. 131 */ 132struct fat32_bootsec { 133 struct bootsec f_bs; 134 uint32_t f_fatlength; /* size of FAT */ 135 uint16_t f_flags; 136 uint8_t f_major; /* major filesystem version #? */ 137 uint8_t f_minor; /* minor filesystem version #? */ 138 uint32_t f_rootcluster; /* first cluster in root directory */ 139 uint16_t f_infosector; /* where summary info is */ 140 uint16_t f_backupboot; /* backup boot sector */ 141 uint16_t f_reserved2[6]; 142}; 143 144 145#define OFF_JMPBOOT 0 146#define OFF_OEMNAME 3 147#define OFF_BYTESPERSEC 11 148#define OFF_SECPERCLUS 13 149#define OFF_RSVDSECCNT 14 150#define OFF_NUMFATS 16 151#define OFF_ROOTENTCNT 17 152#define OFF_TOTSEC16 19 153#define OFF_MEDIA 21 154#define OFF_FATSZ16 22 155#define OFF_SECPERTRK 24 156#define OFF_NUMHEADS 26 157#define OFF_HIDDSEC 28 158#define OFF_TOTSEC32 32 159#define OFF_BPBSIG 510 160 161#define OFF_DRVNUM16 36 162#define OFF_BOOTSIG16 38 163#define OFF_VOLID16 39 164#define OFF_VOLLAB16 43 165#define OFF_FILSYSTYP16 54 166 167#define OFF_FATSZ32 36 168#define OFF_EXTFLAGS32 40 169#define OFF_FSVER32 42 170#define OFF_ROOTCLUS32 44 171#define OFF_FSINFO32 48 172#define OFF_BKBOOTSEC32 50 173#define OFF_DRVNUM32 64 174#define OFF_BOOTSIG32 66 175#define OFF_VOLID32 67 176#define OFF_VOLLAB32 71 177#define OFF_FILSYSTYP32 82 178 179#define LE_16_NA(addr) \ 180 (((uint16_t)*((uint8_t *)(addr))) + \ 181 ((uint16_t)*((uint8_t *)(addr) + 1) << 8)) 182 183#define LE_32_NA(addr) \ 184 (((uint32_t)*((uint8_t *)(addr))) + \ 185 ((uint32_t)*((uint8_t *)(addr) + 1) << 8) + \ 186 ((uint32_t)*((uint8_t *)(addr) + 2) << 16) + \ 187 ((uint32_t)*((uint8_t *)(addr) + 3) << 24)) 188 189/* 190 * Generic FAT BPB fields 191 */ 192#define bpb_jmpBoot(bpb) ((unsigned char *)(bpb)) 193#define bpb_OEMName(bpb) ((char *)(bpb) + OFF_OEMNAME) 194#define bpb_get_BytesPerSec(bpb) LE_16_NA((bpb) + OFF_BYTESPERSEC) 195#define bpb_get_SecPerClus(bpb) (((uint8_t *)(bpb))[OFF_SECPERCLUS]) 196#define bpb_get_RsvdSecCnt(bpb) LE_16_NA((bpb) + OFF_RSVDSECCNT) 197#define bpb_get_NumFATs(bpb) (((uint8_t *)(bpb))[OFF_NUMFATS]) 198#define bpb_get_RootEntCnt(bpb) LE_16_NA((bpb) + OFF_ROOTENTCNT) 199#define bpb_get_TotSec16(bpb) LE_16_NA((bpb) + OFF_TOTSEC16) 200#define bpb_get_Media(bpb) (((uint8_t *)(bpb))[OFF_MEDIA]) 201#define bpb_get_FatSz16(bpb) LE_16_NA((bpb) + OFF_FATSZ16) 202#define bpb_get_SecPerTrk(bpb) LE_16_NA((bpb) + OFF_SECPERTRK) 203#define bpb_get_NumHeads(bpb) LE_16_NA((bpb) + OFF_NUMHEADS) 204#define bpb_get_HiddSec(bpb) LE_32_NA((bpb) + OFF_HIDDSEC) 205#define bpb_get_TotSec32(bpb) LE_32_NA((bpb) + OFF_TOTSEC32) 206#define bpb_get_BPBSig(bpb) LE_16_NA((bpb) + OFF_BPBSIG) 207 208/* 209 * FAT12/16 extended BPB fields 210 */ 211#define bpb_get_DrvNum16(bpb) (((uint8_t *)(bpb))[OFF_DRVNUM16]) 212#define bpb_get_BootSig16(bpb) (((uint8_t *)(bpb))[OFF_BOOTSIG16]) 213#define bpb_VolLab16(bpb) ((char *)(bpb) + OFF_VOLLAB16) 214#define bpb_FilSysType16(bpb) ((char *)(bpb) + OFF_FILSYSTYP16) 215#define bpb_get_VolID16(bpb) LE_32_NA((bpb) + OFF_VOLID16) 216 217/* 218 * FAT32 extended BPB fields 219 */ 220#define bpb_get_FatSz32(bpb) LE_32_NA((bpb) + OFF_FATSZ32) 221#define bpb_get_ExtFlags32(bpb) LE_16_NA((bpb) + OFF_EXTFLAGS32) 222#define bpb_get_FSVer32(bpb) LE_16_NA((bpb) + OFF_FSVER32) 223#define bpb_get_RootClus32(bpb) LE_32_NA((bpb) + OFF_ROOTCLUS32) 224#define bpb_get_FSInfo32(bpb) LE_16_NA((bpb) + OFF_FSINFO32) 225#define bpb_get_BkBootSec32(bpb) LE_16_NA((bpb) + OFF_BKBOOTSEC32) 226#define bpb_get_DrvNum32(bpb) (((uint8_t *)(bpb))[OFF_DRVNUM32]) 227#define bpb_get_BootSig32(bpb) (((uint8_t *)(bpb))[OFF_BOOTSIG32]) 228#define bpb_get_VolID32(bpb) LE_32_NA((bpb) + OFF_VOLID32) 229#define bpb_VolLab32(bpb) ((char *)(bpb) + OFF_VOLLAB32) 230#define bpb_FilSysType32(bpb) ((char *)(bpb) + OFF_FILSYSTYP32) 231 232/* 233 * Validators 234 */ 235#define VALID_SECSIZE(s) \ 236 (s == 512 || s == 1024 || s == 2048 || s == 4096) 237#define VALID_SPCL(s) (ISP2((s)) && (unsigned int)(s) <= 128) 238#define VALID_CLSIZE(s) (ISP2((s)) && (unsigned int)(s) <= (64 * 1024)) 239#define VALID_NUMFATS(n) ((n) > 0 && (n) < 8) 240#define VALID_RSVDSEC(s) ((s) > 0) 241#define VALID_BPBSIG(sig) ((sig) == MBB_MAGIC) 242#define VALID_BOOTSIG(sig) ((sig) == 0x29) 243#define VALID_MEDIA(m) ((m) == 0xF0 || ((m) >= 0xF8 && (m) <= 0xFF)) 244 245/* 246 * this might require a change for codepage support. In particular, 247 * pc_validchar() cannot be a macro anymore if codepages get involved. 248 */ 249#define VALID_VOLLAB(l) ( \ 250 pc_validchar((l)[0]) && pc_validchar((l)[1]) && \ 251 pc_validchar((l)[2]) && pc_validchar((l)[3]) && \ 252 pc_validchar((l)[4]) && pc_validchar((l)[5]) && \ 253 pc_validchar((l)[6]) && pc_validchar((l)[7]) && \ 254 pc_validchar((l)[8]) && pc_validchar((l)[9]) && \ 255 pc_validchar((l)[10])) 256 257/* 258 * We might actually use the 'validchar' checks as well; it only needs 259 * to be printable. Should this ever caused failed media recognition, 260 * we can change it. Many ISVs put different strings into the "oemname" 261 * field. 262 */ 263#define VALID_OEMNAME(nm) ( \ 264 bcmp((nm), "MSDOS", 5) == 0 || bcmp((nm), "MSWIN", 5) == 0) 265#define VALID_FSTYPSTR16(typ) (bcmp((typ), "FAT", 3) == 0) 266#define VALID_FSTYPSTR32(typ) (bcmp((typ), "FAT32", 5) == 0) 267#define VALID_JMPBOOT(b) ( \ 268 ((b)[0] == 0xeb && (b)[2] == 0x90) || (b)[0] == 0xe9) 269#define VALID_FSVER32(v) ((v) == PCFS_SUPPORTED_FSVER) 270/* 271 * Can we check this properly somehow ? There should be a better way. 272 * The FAT spec doesn't mention reserved bits need to be zero ... 273 */ 274#define VALID_EXTFLAGS(flags) (((flags) & 0x8f) == (flags)) 275 276/* 277 * Validation results 278 */ 279#define BPB_SECSIZE_OK (1 << 0) /* ok: 512/1024/2048/4096 */ 280#define BPB_OEMNAME_OK (1 << 1) /* "MSDOS" or "MSWIN" */ 281#define BPB_JMPBOOT_OK (1 << 2) /* 16bit "jmp" / "call" */ 282#define BPB_SECPERCLUS_OK (1 << 3) /* power of 2, [1 .. 128] */ 283#define BPB_RSVDSECCNT_OK (1 << 4) /* cannot be zero */ 284#define BPB_NUMFAT_OK (1 << 5) /* >= 1, <= 8 */ 285#define BPB_ROOTENTCNT_OK (1 << 6) /* 0 on FAT32, != 0 else */ 286#define BPB_TOTSEC_OK (1 << 7) /* smaller than volume */ 287#define BPB_TOTSEC16_OK (1 << 8) /* 0 on FAT32, != 0 on FAT12 */ 288#define BPB_TOTSEC32_OK (1 << 9) /* 0 on FAT12, != 0 on FAT32 */ 289#define BPB_MEDIADESC_OK (1 << 10) /* 0xf0 or 0xf8..0xff */ 290#define BPB_FATSZ_OK (1 << 11) /* [nclusters], no smaller */ 291#define BPB_FATSZ16_OK (1 << 12) /* 0 on FAT32, != 0 else */ 292#define BPB_FATSZ32_OK (1 << 13) /* non-zero on FAT32 */ 293#define BPB_BPBSIG_OK (1 << 14) /* 0x55, 0xAA */ 294#define BPB_BOOTSIG16_OK (1 << 15) /* 0x29 - if present */ 295#define BPB_BOOTSIG32_OK (1 << 16) /* 0x29 - unless SYSLINUX2.x */ 296#define BPB_FSTYPSTR16_OK (1 << 17) /* At least "FAT" */ 297#define BPB_FSTYPSTR32_OK (1 << 18) /* "FAT32" */ 298#define BPB_EXTFLAGS_OK (1 << 19) /* reserved bits should be 0 */ 299#define BPB_FSVER_OK (1 << 20) /* must be 0 */ 300#define BPB_ROOTCLUSTER_OK (1 << 21) /* must be != 0 and valid */ 301#define BPB_FSISEC_OK (1 << 22) /* != 0, <= reserved */ 302#define BPB_BKBOOTSEC_OK (1 << 23) /* != 0, <= reserved, != fsi */ 303#define BPB_VOLLAB16_OK (1 << 24) /* passes pc_validchar() */ 304#define BPB_VOLLAB32_OK (1 << 25) /* passes pc_validchar() */ 305#define BPB_NCLUSTERS_OK (1 << 26) /* from FAT spec */ 306#define BPB_CLSIZE_OK (1 << 27) /* cluster size */ 307#define BPB_MEDIASZ_OK (1 << 28) /* filesystem fits on device */ 308 309#define FAT12_VALIDMSK \ 310 (BPB_SECSIZE_OK | BPB_SECPERCLUS_OK | BPB_CLSIZE_OK | \ 311 BPB_RSVDSECCNT_OK | BPB_NUMFAT_OK | BPB_ROOTENTCNT_OK | \ 312 BPB_TOTSEC_OK | BPB_TOTSEC16_OK | \ 313 BPB_FATSZ_OK | BPB_FATSZ16_OK | BPB_BPBSIG_OK) 314 315#define FAT16_VALIDMSK \ 316 (BPB_SECSIZE_OK | BPB_SECPERCLUS_OK | BPB_CLSIZE_OK | \ 317 BPB_RSVDSECCNT_OK | BPB_NUMFAT_OK | BPB_ROOTENTCNT_OK | \ 318 BPB_TOTSEC_OK | BPB_TOTSEC16_OK | BPB_TOTSEC32_OK | \ 319 BPB_FATSZ_OK | BPB_FATSZ16_OK | BPB_BPBSIG_OK) 320 321/* 322 * A note on FAT32: According to the FAT spec, FAT32 _must_ have a valid 323 * extended BPB and therefore, as a proof of its existance, the FAT32 324 * boot signature (offset 66) must be valid as well. Why don't we check 325 * for BPB_BOOTSIG32_OK then ? 326 * 327 * We don't test for this here first-pass, because there are media out 328 * there that are valid FAT32 structurally but don't have a valid sig. 329 * This happens if older versions of the SYSLINUX bootloader (below 3.x) 330 * are installed on a media with a FAT32 on it. SYSLINUX 2.x and lower 331 * overwrite the BPB past the end of the FAT12/16 extension with its 332 * bootloader code - and the FAT16 extended BPB is 62 Bytes... 333 * All structurally relevant fields of the FAT32 BPB are within the first 334 * 52 Bytes, so the filesystem is accessible - but the signature check 335 * would reject it. 336 */ 337#define FAT32_VALIDMSK \ 338 (BPB_SECSIZE_OK | BPB_SECPERCLUS_OK | BPB_CLSIZE_OK | \ 339 BPB_RSVDSECCNT_OK | BPB_NUMFAT_OK | BPB_ROOTENTCNT_OK | \ 340 BPB_TOTSEC_OK | BPB_TOTSEC16_OK | BPB_TOTSEC32_OK | \ 341 BPB_FATSZ_OK | BPB_FATSZ16_OK | BPB_FATSZ32_OK | \ 342 BPB_EXTFLAGS_OK | BPB_FSVER_OK | BPB_ROOTCLUSTER_OK | \ 343 BPB_BPBSIG_OK) 344 345/* 346 * FAT32 BPB allows 'versioning' via FSVer32. We follow the 'NULL' spec. 347 */ 348#define PCFS_SUPPORTED_FSVER 0 349 350 351/* 352 * Filesystem summary information (introduced originally for FAT32 volumes). 353 * We need to maintain fs_free_clusters or Microsoft Scandisk will be upset. 354 * We keep these values in-core even for FAT12/FAT16 but will never attempt 355 * to write them out to disk then. 356 */ 357typedef struct fat_fsinfo { 358 uint32_t fs_free_clusters; /* # free clusters. -1 if unknown */ 359 uint32_t fs_next_free; /* search next free after this cn */ 360} fat_fsi_t; 361 362/* 363 * On-disk FSI. All values in little endian. Only FAT32 has this. 364 */ 365typedef struct fat_od_fsi { 366 uint32_t fsi_leadsig; /* 0x41615252 */ 367 char fsi_reserved1[480]; 368 uint32_t fsi_strucsig; /* 0x61417272 */ 369 fat_fsi_t fsi_incore; /* free/nextfree */ 370 char fsi_reserved2[12]; 371 uint32_t fsi_trailsig; /* 0xaa550000 */ 372} fat_od_fsi_t; 373 374#define FSI_LEADSIG LE_32(0x41615252) 375#define FSI_STRUCSIG LE_32(0x61417272) 376#define FSI_TRAILSIG LE_32(0xaa550000) /* same as MBB_MAGIC */ 377 378#define FSISIG_OK(fsi) ( \ 379 ((fat_od_fsi_t *)(fsi))->fsi_leadsig == FSI_LEADSIG && \ 380 ((fat_od_fsi_t *)(fsi))->fsi_strucsig == FSI_STRUCSIG && \ 381 ((fat_od_fsi_t *)(fsi))->fsi_trailsig == FSI_TRAILSIG) 382 383#define FSINFO_UNKNOWN ((uint32_t)(-1)) /* free/next not valid */ 384 385typedef enum { FAT12, FAT16, FAT32, FAT_UNKNOWN, FAT_QUESTIONABLE } fattype_t; 386 387 388struct pcfs { 389 struct vfs *pcfs_vfs; /* vfs for this fs */ 390 int pcfs_flags; /* flags */ 391 int pcfs_ldrive; /* logical DOS drive number */ 392 fattype_t pcfs_fattype; 393 dev_t pcfs_xdev; /* actual device that is mounted */ 394 struct vnode *pcfs_devvp; /* and a vnode for it */ 395 int pcfs_secsize; /* sector size in bytes */ 396 int pcfs_spcl; /* sectors per cluster */ 397 int pcfs_spt; /* sectors per track */ 398 int pcfs_sdshift; /* shift to convert sector into */ 399 /* DEV_BSIZE "sectors"; assume */ 400 /* pcfs_secsize is 2**n times of */ 401 /* DEV_BSIZE */ 402 int pcfs_fatsec; /* number of sec per FAT */ 403 int pcfs_numfat; /* number of FAT copies */ 404 int pcfs_rdirsec; /* number of sec in root dir */ 405 daddr_t pcfs_dosstart; /* start blkno of DOS partition */ 406 daddr_t pcfs_fsistart; /* start blkno of FSI sector */ 407 daddr_t pcfs_fatstart; /* start blkno of first FAT */ 408 daddr_t pcfs_rdirstart; /* start blkno of root dir */ 409 daddr_t pcfs_datastart; /* start blkno of data area */ 410 int pcfs_clsize; /* cluster size in bytes */ 411 int pcfs_ncluster; /* number of clusters in fs */ 412 int pcfs_nrefs; /* number of active pcnodes */ 413 int pcfs_frefs; /* number of active file pcnodes */ 414 int pcfs_nxfrecls; /* next free cluster */ 415 uchar_t *pcfs_fatp; /* ptr to FAT data */ 416 uchar_t *pcfs_fat_changemap; /* map of changed fat data */ 417 int pcfs_fat_changemapsize; /* size of FAT changemap */ 418 time_t pcfs_fattime; /* time FAT becomes invalid */ 419 time_t pcfs_verifytime; /* time to reverify disk */ 420 kmutex_t pcfs_lock; /* per filesystem lock */ 421 kthread_id_t pcfs_owner; /* id of thread locking pcfs */ 422 int pcfs_count; /* # of pcfs locks for pcfs_owner */ 423 struct fat_fsinfo pcfs_fsinfo; /* in-core fsinfo */ 424 struct pcfs *pcfs_nxt; /* linked list of all mounts */ 425 int pcfs_fatjustread; /* Used to flag a freshly found FAT */ 426 struct vnode *pcfs_root; /* vnode for the root dir of the fs */ 427 int pcfs_secondswest; /* recording timezone for this fs */ 428 len_t pcfs_mediasize; 429 int pcfs_rootblksize; 430 int pcfs_mediadesc; /* media descriptor */ 431 pc_cluster32_t pcfs_lastclmark; 432 pc_cluster32_t pcfs_rootclnum; 433 timestruc_t pcfs_mounttime; /* timestamp for "/" */ 434}; 435 436/* 437 * flags 438 */ 439#define PCFS_FATMOD 0x01 /* FAT has been modified */ 440#define PCFS_LOCKED 0x02 /* fs is locked */ 441#define PCFS_WANTED 0x04 /* locked fs is wanted */ 442#define PCFS_NOCHK 0x800 /* don't resync fat on error */ 443#define PCFS_BOOTPART 0x1000 /* boot partition type */ 444#define PCFS_HIDDEN 0x2000 /* show hidden files */ 445#define PCFS_PCMCIA_NO_CIS 0x4000 /* PCMCIA psuedo floppy */ 446#define PCFS_FOLDCASE 0x8000 /* fold filenames to lowercase */ 447#define PCFS_FSINFO_OK 0x10000 /* valid FAT32 fsinfo sector */ 448#define PCFS_IRRECOV 0x20000 /* FS was messed with during write */ 449#define PCFS_NOCLAMPTIME 0x40000 /* expose full FAT timestamp range */ 450#define PCFS_NOATIME 0x80000 /* disable atime updates */ 451 452#define IS_FAT12(PCFS) ((PCFS)->pcfs_fattype == FAT12) 453#define IS_FAT16(PCFS) ((PCFS)->pcfs_fattype == FAT16) 454#define IS_FAT32(PCFS) ((PCFS)->pcfs_fattype == FAT32) 455 456/* for compatibility */ 457struct old_pcfs_args { 458 int secondswest; /* seconds west of Greenwich */ 459 int dsttime; /* type of dst correction */ 460}; 461 462struct pcfs_args { 463 int secondswest; /* seconds west of Greenwich */ 464 int dsttime; /* type of dst correction */ 465 int flags; 466}; 467 468/* 469 * pcfs mount options. 470 */ 471#define MNTOPT_PCFS_HIDDEN "hidden" 472#define MNTOPT_PCFS_NOHIDDEN "nohidden" 473#define MNTOPT_PCFS_FOLDCASE "foldcase" 474#define MNTOPT_PCFS_NOFOLDCASE "nofoldcase" 475#define MNTOPT_PCFS_CLAMPTIME "clamptime" 476#define MNTOPT_PCFS_NOCLAMPTIME "noclamptime" 477#define MNTOPT_PCFS_TIMEZONE "timezone" 478#define MNTOPT_PCFS_SECSIZE "secsize" 479 480/* 481 * Disk timeout value in sec. 482 * This is used to time out the in core FAT and to re-verify the disk. 483 * This should be less than the time it takes to change floppys 484 */ 485#define PCFS_DISKTIMEOUT 2 486 487#define PCFS_MAXOFFSET_T UINT32_MAX /* PCFS max file size */ 488 489#define VFSTOPCFS(VFSP) ((struct pcfs *)((VFSP)->vfs_data)) 490#define PCFSTOVFS(FSP) ((FSP)->pcfs_vfs) 491 492/* 493 * special cluster numbers in FAT 494 */ 495#define PCF_FREECLUSTER 0x00 /* cluster is available */ 496#define PCF_ERRORCLUSTER 0x01 /* error occurred allocating cluster */ 497#define PCF_12BCLUSTER 0xFF0 /* 12-bit version of reserved cluster */ 498#define PCF_RESCLUSTER 0xFFF0 /* 16-bit version of reserved cluster */ 499#define PCF_RESCLUSTER32 0xFFFFFF0 /* 32-bit version */ 500#define PCF_BADCLUSTER 0xFFF7 /* bad cluster, do not use */ 501#define PCF_BADCLUSTER32 0xFFFFFF7 /* 32-bit version */ 502#define PCF_LASTCLUSTER 0xFFF8 /* >= means last cluster in file */ 503#define PCF_LASTCLUSTER32 0xFFFFFF8 /* 32-bit version */ 504#define PCF_LASTCLUSTERMARK 0xFFFF /* value used to mark last cluster */ 505#define PCF_LASTCLUSTERMARK32 0xFFFFFFF /* 32-bit version */ 506#define PCF_FIRSTCLUSTER 2 /* first valid cluster number */ 507 508/* 509 * file system constants 510 */ 511#define PC_MAXFATSEC 256 /* maximum number of sectors in FAT */ 512 513/* 514 * file system parameter macros 515 */ 516 517#define pc_clear_fatchanges(PCFS) \ 518 bzero((PCFS)->pcfs_fat_changemap, (PCFS)->pcfs_fat_changemapsize) 519 520#define pc_blksize(PCFS, PCP, OFF) /* file system block size */ \ 521 (((PCTOV(PCP)->v_flag & VROOT) && !IS_FAT32(PCFS)) ? \ 522 ((OFF) >= \ 523 ((PCFS)->pcfs_rdirsec & \ 524 ~((PCFS)->pcfs_spcl - 1)) * ((PCFS)->pcfs_secsize)? \ 525 ((PCFS)->pcfs_rdirsec & \ 526 ((PCFS)->pcfs_spcl - 1)) * ((PCFS)->pcfs_secsize): \ 527 (PCFS)->pcfs_clsize): \ 528 (PCFS)->pcfs_clsize) 529 530#define pc_blkoff(PCFS, OFF) /* offset within block */ \ 531 ((int)((OFF) & ((PCFS)->pcfs_clsize - 1))) 532 533#define pc_lblkno(PCFS, OFF) /* logical block (cluster) no */ \ 534 ((daddr_t)((OFF) / (PCFS)->pcfs_clsize)) 535 536#define pc_dbtocl(PCFS, DB) /* disk blks to clusters */ \ 537 ((int)((DB) / (PCFS)->pcfs_spcl)) 538 539#define pc_cltodb(PCFS, CL) /* clusters to disk blks */ \ 540 ((daddr_t)((CL) * (PCFS)->pcfs_spcl)) 541 542#define pc_dbdaddr(PCFS, DB) /* sector to DEV_BSIZE "sector" addr */ \ 543 ((DB) << (PCFS)->pcfs_sdshift) 544 545#define pc_daddrdb(PCFS, DADDR) /* DEV_BSIZE "sector" addr to sector addr */ \ 546 ((DADDR) >> (PCFS)->pcfs_sdshift) 547 548#define pc_cldaddr(PCFS, CL) /* DEV_BSIZE "sector" addr for cluster */ \ 549 pc_dbdaddr(PCFS, ((daddr_t)((PCFS)->pcfs_datastart + \ 550 pc_cltodb(PCFS, (CL) - PCF_FIRSTCLUSTER)))) 551 552#define pc_daddrcl(PCFS, DADDR) /* cluster for disk address */ \ 553 ((int)(PCF_FIRSTCLUSTER + \ 554 pc_dbtocl(pc_daddrdb(PCFS, DADDR) - (PCFS)->pcfs_datastart))) 555 556/* 557 * Number of directory entries per sector / cluster 558 */ 559#define pc_direntpersec(PCFS) \ 560 ((int)((PCFS)->pcfs_secsize / sizeof (struct pcdir))) 561 562#define pc_direntpercl(PCFS) \ 563 ((int)((PCFS)->pcfs_clsize / sizeof (struct pcdir))) 564 565/* 566 * out-of-range check for cluster numbers. 567 */ 568#define pc_validcl(PCFS, CL) /* check that cluster no is legit */ \ 569 ((int)(CL) >= PCF_FIRSTCLUSTER && \ 570 (int)(CL) < (PCFS)->pcfs_ncluster + PCF_FIRSTCLUSTER) 571 572/* 573 * external routines. 574 */ 575extern int pc_lockfs(struct pcfs *, int, int); /* lock fs and get fat */ 576extern void pc_unlockfs(struct pcfs *); /* ulock the fs */ 577extern int pc_getfat(struct pcfs *); /* get fat from disk */ 578extern void pc_invalfat(struct pcfs *); /* invalidate incore fat */ 579extern int pc_syncfat(struct pcfs *); /* sync fat to disk */ 580extern int pc_freeclusters(struct pcfs *); /* num free clusters in fs */ 581extern pc_cluster32_t pc_alloccluster(struct pcfs *, int); 582extern void pc_setcluster(struct pcfs *, pc_cluster32_t, pc_cluster32_t); 583extern void pc_mark_fat_updated(struct pcfs *fsp, pc_cluster32_t cn); 584extern int pc_fat_is_changed(struct pcfs *fsp, pc_cluster32_t bn); 585 586/* 587 * debugging 588 */ 589extern int pcfsdebuglevel; 590#define PC_DPRINTF0(level, A) \ 591 if (pcfsdebuglevel >= level) \ 592 cmn_err(CE_CONT, (A)) 593#define PC_DPRINTF1(level, A, B) \ 594 if (pcfsdebuglevel >= level) \ 595 cmn_err(CE_CONT, (A), (B)) 596#define PC_DPRINTF2(level, A, B, C) \ 597 if (pcfsdebuglevel >= level) \ 598 cmn_err(CE_CONT, (A), (B), (C)) 599#define PC_DPRINTF3(level, A, B, C, D) \ 600 if (pcfsdebuglevel >= level) \ 601 cmn_err(CE_CONT, (A), (B), (C), (D)) 602#define PC_DPRINTF4(level, A, B, C, D, E) \ 603 if (pcfsdebuglevel >= level) \ 604 cmn_err(CE_CONT, (A), (B), (C), (D), (E)) 605 606#ifdef __cplusplus 607} 608#endif 609 610#endif /* _SYS_FS_PC_FS_H */ 611