sys/fs/pc_fs.h

	pc_fs.h revision 32d464954b2be825b7a73952618e7b6e73743730
/*
 * 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 <sys/thread.h>
#include <sys/ksynch.h>
#include <sys/sysmacros.h>
#include <sys/byteorder.h>

#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 <sys/fs/pc_fs.h> 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 */