format.c

从大量的wince源代码中剥离出的fat文件系统源代码.移植性非常高. 里面带有source i.rar

        ppe->Part_FileSystem = PART_DOS3_FAT;   // 16-bit FAT ID
        else
        ppe->Part_FileSystem = PART_DOSX13;     // >32Mb 16-bit FAT ID
    }

    ppe->Part_LastHead = (BYTE)(devpb.DevPrm.OldDevPB.BPB.BPB_Heads - 1);
    ppe->Part_LastSector = (BYTE)(devpb.DevPrm.OldDevPB.BPB.BPB_SectorsPerTrack + ((maxCyl & 0x0300) >> 2));
    ppe->Part_LastTrack = (BYTE)maxCyl;
    ppe->Part_StartSector = devpb.DevPrm.OldDevPB.BPB.BPB_SectorsPerTrack;
    ppe->Part_TotalSectors = devpb.DevPrm.OldDevPB.BPB.BPB_BigTotalSectors - devpb.DevPrm.OldDevPB.BPB.BPB_SectorsPerTrack;

    // Last but not least, store a valid signature at the end
    // of the partition sector.

    *(PWORD)(abSector+DEFAULT_SECTOR_SIZE-2) = BOOTSECTRAILSIGH;

    dwError = ReadWriteDisk(pvol,
                pvol->v_pdsk->d_hdsk,
                DISK_IOCTL_WRITE,
                &pvol->v_pdsk->d_diActive,
                0,      // sector #
                1,      // number of sectors
                abSector);
    if (dwError) {
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FATFS!FormatVolume: cannot write new partition table (%d)\n"), dwError));
        goto exit;
    }
    DEBUGMSG(ZONE_INIT,(DBGTEXT("FATFS!FormatVolume: New MBR successfully written\n")));

    // Zap the rest of the hidden sectors, if any

    for (sec=1; sec < csecHidden; sec++) {

        memset(abSector, 0, devpb.DevPrm.OldDevPB.BPB.BPB_BytesPerSector);

        dwError = ReadWriteDisk(pvol,
                    pvol->v_pdsk->d_hdsk,
                    DISK_IOCTL_WRITE,
                    &pvol->v_pdsk->d_diActive,
                    sec,
                    1,
                    abSector);
        if (dwError) {
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FATFS!FormatVolume: error initializing hidden sectors (%d)\n"), dwError));
        goto exit;
        }
    }
    }

    // Now write the new BPB sector

    {
    SYSTEMTIME st;
    PBOOTSEC pbs = (PBOOTSEC)abSector;
#ifdef FAT32
    PBIGFATBOOTSEC pbgbs = (PBIGFATBOOTSEC)abSector;
#endif
    // The bulk of the BPB sector needs to be zeroed

    memset(abSector, 0, devpb.DevPrm.OldDevPB.BPB.BPB_BytesPerSector);

    pbs->bsJump[0] = BS2BYTJMP;
    pbs->bsJump[1] = 0xfe;
    pbs->bsJump[2] = 0x90;
    pbs->bsBPB = devpb.DevPrm.OldDevPB.BPB;

    if (csecHidden || devpb.DevPrm.OldDevPB.BPB.BPB_HiddenSectors)
        pbs->bsDriveNumber = PART_BOOTABLE;

    pbs->bsBootSignature = EXT_BOOT_SIGNATURE;

    // Now fill in the portions of the BPB that we just calculated

    pbs->bsBPB.BPB_SectorsPerCluster = (BYTE)csecClus;
    pbs->bsBPB.BPB_ReservedSectors = (WORD)csecReserved;
    pbs->bsBPB.BPB_NumberOfFATs = cFATs;
    pbs->bsBPB.BPB_RootEntries = (WORD)cRootEntries;
    pbs->bsBPB.BPB_BigTotalSectors = devpb.DevPrm.OldDevPB.BPB.BPB_BigTotalSectors;
    if (secVolBias == 0)
        pbs->bsBPB.BPB_BigTotalSectors -= csecHidden;

    // Use the ancient BPB_TotalSectors field if the value will fit

    if (pbs->bsBPB.BPB_BigTotalSectors < 65536) {
        pbs->bsBPB.BPB_TotalSectors = (WORD)pbs->bsBPB.BPB_BigTotalSectors;
        pbs->bsBPB.BPB_BigTotalSectors = 0;
    }

    pbs->bsBPB.BPB_MediaDescriptor = bMediaDesc;
    pbs->bsBPB.BPB_SectorsPerFAT = (WORD)(csecFATs / cFATs);
    pbs->bsBPB.BPB_HiddenSectors = devpb.DevPrm.OldDevPB.BPB.BPB_HiddenSectors;

    // Create a (hopefully unique) serial number

    GetSystemTime(&st);
    pbs->bsVolumeID = ((st.wYear + st.wDayOfWeek) << 16) + (st.wMonth + st.wDay) +
              ((st.wHour + st.wSecond)    << 16) + (st.wMinute + st.wMilliseconds);

    memset(pbs->bsVolumeLabel, 0x20, sizeof(pbs->bsVolumeLabel));
    if (FSDMGR_GetDiskName((HDSK)pvol->v_pdsk->d_hdsk, szVolumeName)) {
        WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, szVolumeName, wcslen(szVolumeName), pbs->bsVolumeLabel, sizeof(pbs->bsVolumeLabel), NULL, NULL);
    }    
    

    // Initialize the file system signature to either 'FAT16' or 'FAT12'

    *(DWORD UNALIGNED *)&pbs->bsFileSysType[0] = 0x31544146;
    *(DWORD UNALIGNED *)&pbs->bsFileSysType[4] = (cbitsClus == 16)? 0x20202036 : 0x20202032;

#ifdef FAT32
    if (cbitsClus == 32) {

        // Transfer any fields that immediately follow the old BPB before
        // we start writing to the new (big) BPB, lest we stomp on something.

        pbgbs->bgbsDriveNumber = pbs->bsDriveNumber;
        pbgbs->bgbsReserved1 = 0;
        pbgbs->bgbsBootSignature = pbs->bsBootSignature;
        pbgbs->bgbsVolumeID = pbs->bsVolumeID;
        memset(pbgbs->bgbsVolumeLabel, 0x20, sizeof(pbgbs->bgbsVolumeLabel));
        if (FSDMGR_GetDiskName((HDSK)pvol->v_pdsk->d_hdsk, szVolumeName)) {
            WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, szVolumeName, wcslen(szVolumeName), pbgbs->bgbsVolumeLabel, sizeof(pbgbs->bgbsVolumeLabel), NULL, NULL);
        }    

        // Initialize the file system signature to 'FAT32'

        *(DWORD UNALIGNED *)&pbgbs->bgbsFileSysType[0] = 0x33544146;
        *(DWORD UNALIGNED *)&pbgbs->bgbsFileSysType[4] = 0x20202032;

        // Now zap the key fields in the old BPB that indicate we're dealing
        // with a new (big) BPB.  Note that Win95 (OSR2) normally reserves 32
        // sectors, with the logical sectors 0-2 containing the primary bootstrap
        // (of which sector 1 is also the FSINFO sector), sectors 6-8 containing
        // a backup copy of the bootstrap sectors, and sectors 9-31 unused.

        // NOTE: I'm not sure it's strictly necessary to zero RootEntries, but in
        // any case, the value placed there earlier is not necessarily correct, so
        // we might as well zero it.

        pbs->bsBPB.BPB_SectorsPerFAT = 0;
        pbs->bsBPB.BPB_RootEntries = 0;

        // Now start filling in the fields that are unique to the new (big) BPB.
        // In the interests of being a minimalist, I reserve only two sectors:
        // logical sector 0 for the BPB, and 1 for the FSINFO sector.  I will set
        // BGBPB_BkUpBootSec to zero to indicate there are no backup sectors.
        // Based on the documentation I have, all FAT32-aware systems should be
        // able to handle this format.  But, we'll just have to wait and see.... -JTP

        pbgbs->bgbsBPB.BGBPB_BigSectorsPerFAT = csecFATs / cFATs;
        pbgbs->bgbsBPB.BGBPB_ExtFlags = 0;
        pbgbs->bgbsBPB.BGBPB_FS_Version = FAT32_Curr_FS_Version;
        pbgbs->bgbsBPB.BGBPB_RootDirStrtClus = DATA_CLUSTER;
        pbgbs->bgbsBPB.BGBPB_FSInfoSec = 1;
        pbgbs->bgbsBPB.BGBPB_BkUpBootSec = 0;
        memset(pbgbs->bgbsBPB.BGBPB_Reserved, 0, sizeof(pbgbs->bgbsBPB.BGBPB_Reserved));
    }
#endif

    // Last but not least, store a valid signature at the end
    // of the BPB sector.

    *(PWORD)(abSector+DEFAULT_SECTOR_SIZE-2) = BOOTSECTRAILSIGH;

    dwError = ReadWriteDisk(pvol,
                pvol->v_pdsk->d_hdsk,
                DISK_IOCTL_WRITE,
                &pvol->v_pdsk->d_diActive,
                secVolBias + csecHidden,
                1,
                abSector);

    if (dwError) {
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FATFS!FormatVolume: cannot write new BPB (%d)\n"), dwError));
        goto exit;
    }
    DEBUGMSG(ZONE_INIT,(DBGTEXT("FATFS!FormatVolume: New BPB successfully written\n")));
    }

#ifdef FAT32
    // Now write the combination extended boot sector/FSInfo sector for FAT32 volumes

    if (cbitsClus == 32) {
    
    PBIGFATBOOTFSINFO pFSInfo;

    memset(abSector, 0, devpb.DevPrm.OldDevPB.BPB.BPB_BytesPerSector);

    *(PDWORD)&abSector[0] = SECONDBOOTSECSIG;
    *(PDWORD)&abSector[OFFSETTRLSIG] = BOOTSECTRAILSIG;
    pFSInfo = (PBIGFATBOOTFSINFO)&abSector[OFFSETFSINFOFRMSECSTRT];

    pFSInfo->bfFSInf_Sig = FSINFOSIG;
    pFSInfo->bfFSInf_free_clus_cnt = UNKNOWN_CLUSTER;
    pFSInfo->bfFSInf_next_free_clus = UNKNOWN_CLUSTER;

    dwError = ReadWriteDisk(pvol,
                pvol->v_pdsk->d_hdsk,
                DISK_IOCTL_WRITE,
                &pvol->v_pdsk->d_diActive,
                secVolBias + csecHidden + 1,
                1,
                abSector);

    if (dwError) {
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FATFS!FormatVolume: cannot write new extended boot sector (%d)\n"), dwError));
        goto exit;
    }
    DEBUGMSG(ZONE_INIT,(DBGTEXT("FATFS!FormatVolume: New extended boot sector successfully written\n")));
    }

#endif

    // Now write the new FAT(s)

    sec = csecHidden + csecReserved;

    for (iFAT=0; iFAT < cFATs; iFAT++) {

    DWORD secFAT;
    DWORD csecFAT = csecFATs/cFATs;

    for (secFAT=0; secFAT < csecFAT; sec++,secFAT++) {

        // The bulk of each new FAT sector needs to be zeroed.

        memset(abSector, 0, devpb.DevPrm.OldDevPB.BPB.BPB_BytesPerSector);

        if (secFAT == 0) {

        // The first sector of each FAT needs special EOF
        // marks in the slots corresponding to clusters 0 and 1
        // (which, as you know, are non-existent clusters).

        abSector[0] = bMediaDesc;
        abSector[1] = 0xFF;
        abSector[2] = 0xFF;
        if (cbitsClus >= 16)
            abSector[3] = 0xFF;
#ifdef FAT32
        if (cbitsClus == 32) {
            *(PDWORD)&abSector[4] = FAT32_EOF_MAX;  // this is for cluster 1
            *(PDWORD)&abSector[8] = FAT32_EOF_MAX;  // and this is for cluster 2 (the first -- and initially only -- cluster in the root directory)
        }
#endif
        }

        dwError = ReadWriteDisk(pvol,
                    pvol->v_pdsk->d_hdsk,
                    DISK_IOCTL_WRITE,
                    &pvol->v_pdsk->d_diActive,
                    secVolBias + sec,
                    1,
                    abSector);

        if (dwError) {
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FATFS!FormatVolume: cannot write new FAT sector %d (%d)\n"), sec, dwError));
        goto exit;
        }
    }
    DEBUGMSG(ZONE_INIT,(DBGTEXT("FATFS!FormatVolume: New FAT #%d successfully written\n"), iFAT));
    }

    // Now write the new root directory

#ifdef FAT32
    // Note that if this is a FAT32 volume, then csecRoot wasn't used, and there
    // is no root directory in the traditional sense.  However, we DID automatically
    // reserve the first cluster (DATA_CLUSTER) for the use of the root directory,
    // so we need to zero all the sectors in that first cluster.

    if (cbitsClus == 32) {
    ASSERT(csecRoot == 0);
    csecRoot = csecClus;
    }
#endif

    {
    DWORD secRoot;

    // Each new root directory sector needs to be zeroed.

    memset(abSector, 0, devpb.DevPrm.OldDevPB.BPB.BPB_BytesPerSector);

    for (secRoot=0; secRoot < csecRoot; secRoot++) {

        dwError = ReadWriteDisk(pvol,
                    pvol->v_pdsk->d_hdsk,
                    DISK_IOCTL_WRITE,
                    &pvol->v_pdsk->d_diActive,
                    secVolBias + csecHidden + csecReserved + csecFATs + secRoot,
                    1,
                    abSector);

        if (dwError) {
        DEBUGMSG(ZONE_INIT || ZONE_ERRORS,(DBGTEXT("FATFS!FormatVolume: cannot write new root directory sector %d (%d)\n"), csecHidden + csecReserved + csecFATs + secRoot, dwError));
        goto exit;
        }
    }
    DEBUGMSG(ZONE_INIT,(DBGTEXT("FATFS!FormatVolume: New root directory successfully written\n")));
    }

    DEBUGMSG(ZONE_APIS,(DBGTEXT("FATFS!FormatVolume complete (%d)\n"), dwError));

  exit:
    UnlockVolume(pvol);
    pvol->v_flags &= ~VOLF_FORMATTING;

  abort:
    return dwError;
}