windows-server-2003/base/efiutil/efifmt/efifmt.cxx

/*++

Copyright (c) 1999-2001 Microsoft Corporation

Module Name:

    efifmt.cxx

Abstract:

    This is the main program for the efi version of format.

--*/

#pragma warning(disable: 4091)

#include "ulib.hxx"
#include "wstring.hxx"
#include "efickmsg.hxx"
#include "error.hxx"
#include "ifssys.hxx"
#include "rtmsg.h"
#include "ifsentry.hxx"
#include "fatvol.hxx"
#include "layout.hxx"

#include "efiwintypes.hxx"

extern "C" BOOLEAN
InitializeUfat(
    PVOID DllHandle,
    ULONG Reason,
    PCONTEXT Context
    );

extern "C"
BOOLEAN
InitializeIfsUtil(
    PVOID DllHandle,
    ULONG Reason,
    PCONTEXT Context
    );

int __cdecl
main(
    int     argc,
    WCHAR**  argv,
    WCHAR**  envp
    );

int argc;
WCHAR ** argv;

#if defined(EFI_DEBUG)
VOID
PrintLoadedImageInfo (
    IN  EFI_LOADED_IMAGE    *LoadedImage
    );
#endif

VOID
InvokeAutoFmtMain (
    IN  EFI_HANDLE          ImageHandle,
    IN  EFI_LOADED_IMAGE    *LoadedImage
    );

extern "C" {

EFI_STATUS
__declspec(dllexport)
InitializeEfiFmtApplication(
    IN EFI_HANDLE           ImageHandle,
    IN EFI_SYSTEM_TABLE     *SystemTable
    )
{
    EFI_LOADED_IMAGE    *LoadedImage;

    /*
     *  Initialize the Library. Set BS, RT, &ST globals
     *   BS = Boot Services RT = RunTime Services
     *   ST = System Table
     */
    InitializeLib (ImageHandle, SystemTable);
    InitializeShellApplication( ImageHandle, SystemTable );

    DEBUG((D_INFO,(CHAR8*)"EFIFMT application started\n"));

    Print(TEXT("EFI Disk Format Version 0.2\n"));
    Print(TEXT("Based on EFI Core "));
    Print(TEXT("Version %d.%d.%d.%d\n"),
        EFI_SPECIFICATION_MAJOR_REVISION,
        EFI_SPECIFICATION_MINOR_REVISION,
        EFI_FIRMWARE_MAJOR_REVISION,
        EFI_FIRMWARE_MINOR_REVISION
    );

    BS->HandleProtocol (ImageHandle, &LoadedImageProtocol, (VOID**)&LoadedImage);

#if 0
    PrintLoadedImageInfo (LoadedImage);
#endif

    // call into autofmt.
    InvokeAutoFmtMain (ImageHandle, LoadedImage);

#if 0
    EfiWaitForKey();
    ST->ConOut->OutputString (ST->ConOut, TEXT("\n\n"));
#endif

    return EFI_SUCCESS;
}

} // extern "C"

UINT16 *MemoryType[] = {
            TEXT("reserved  "),
            TEXT("LoaderCode"),
            TEXT("LoaderData"),
            TEXT("BS_code   "),
            TEXT("BS_data   "),
            TEXT("RT_code   "),
            TEXT("RT_data   "),
            TEXT("available "),
            TEXT("Unusable  "),
            TEXT("ACPI_recl "),
            TEXT("ACPI_NVS  "),
            TEXT("MemMapIO  "),
            TEXT("MemPortIO "),
            TEXT("PAL_code  "),
            TEXT("BUG:BUG: MaxMemoryType")
};


VOID
InvokeAutoFmtMain (
    IN  EFI_HANDLE          ImageHandle,
    IN  EFI_LOADED_IMAGE    *LoadedImage
    )
{
    EFI_LOADED_IMAGE    *ParentImage;

    if (!LoadedImage->ParentHandle) {
        /*
         *  If you are loaded from the EFI boot manager the ParentHandle
         *   is Null. Thus a pure EFI application will not have a parrent.
         */
        DEBUG((D_INFO,(CHAR8*)"\n%HImage was loaded from EFI Boot Manager%N\n"));
        return;
    }

    BS->HandleProtocol (LoadedImage->ParentHandle, &LoadedImageProtocol, (VOID**)&ParentImage);

#if 0
    Print(TEXT("\n%HImage Parent was %N%s %Hand it passed the following arguments:%N \n   %s\n\n"), DevicePathToStr (ParentImage->FilePath),LoadedImage->LoadOptions);
#endif

    {
        argc = SI->Argc;
        argv = SI->Argv;

        DEBUG((D_INFO,(CHAR8*)"Launching main...\n"));
        // call main.
        main(argc,argv,NULL);
        DEBUG((D_INFO,(CHAR8*)"Returned from main...\n"));

    }
}

#if defined(EFI_DEBUG)
VOID
PrintLoadedImageInfo (
    IN  EFI_LOADED_IMAGE    *LoadedImage
    )
{
    EFI_STATUS          Status;
    EFI_DEVICE_PATH     *DevicePath;

    Print(TEXT("\n%HImage was loaded from file %N%s\n"), DevicePathToStr (LoadedImage->FilePath));

    BS->HandleProtocol (LoadedImage->DeviceHandle, &DevicePathProtocol, (VOID**)&DevicePath);
    if (DevicePath) {
        Print(TEXT("%HImage was loaded from this device %N%s\n"), DevicePathToStr (DevicePath));

    }

    Print(TEXT("\n Image Base is %X"), LoadedImage->ImageBase);
    Print(TEXT("\n Image Size is %X"), LoadedImage->ImageSize);
    Print(TEXT("\n  Image Code Type %s"), MemoryType[LoadedImage->ImageCodeType]);
    Print(TEXT("\n  Image Data Type %s"), MemoryType[LoadedImage->ImageDataType]);
    Print(TEXT("\n %d Bytes of Options passed to this Image\n"), LoadedImage->LoadOptionsSize);

    if (LoadedImage->ParentHandle) {
        Status = BS->HandleProtocol (LoadedImage->ParentHandle, &DevicePathProtocol, (VOID**)&DevicePath);
        if (Status == EFI_SUCCESS && DevicePath) {
           Print(TEXT("Images parent is %s\n\n"), DevicePathToStr (DevicePath));
        }
    }
}
#endif

int __cdecl
main(
    int     argc,
    WCHAR**  argv,
    WCHAR**  envp
    )
/*++

Routine Description:

    This routine is the main program for AutoFmt

Arguments:

    argc, argv  - Supplies the fully qualified NT path name of the
                  the drive to check.  The syntax of the autofmt
                  command line is:

    AUTOFMT drive-name /FS:target-file-system [/V:label] [/Q] [/A:size] [/C]
            [/S]

Return Value:

    0   - Success.
    1   - Failure.

--*/
{
    if (!InitializeUlib( NULL, ! DLL_PROCESS_DETACH, NULL )     ||
        !InitializeIfsUtil(NULL, ! DLL_PROCESS_DETACH, NULL)    ||
        !InitializeUfat(NULL, ! DLL_PROCESS_DETACH, NULL)
       ) {
        return 1;
    }

    PFAT_VOL            fat_volume;
    PDP_DRIVE            dp_drive;

    EFICHECK_MESSAGE    *message = NULL;
    DSTRING             drive_name;
    DSTRING             file_system_name;
    DSTRING             label;
    DSTRING*            plabel;
    DSTRING             fat_name;
    DSTRING             fat32_name;
    DSTRING             raw_name;
    BOOLEAN             quick = FALSE;
    BOOLEAN             compress = FALSE;
    FORMAT_ERROR_CODE   success;
    BOOLEAN             setup_output = FALSE;
    BOOLEAN             textmode_output = FALSE;
    BOOLEAN             drive_already_specified = FALSE;
    BOOLEAN             force_filesystem = FALSE;
    BOOLEAN             showhelp = FALSE;
    BOOLEAN             labelled = FALSE;
    BIG_INT             bigint;
    ULONG               cluster_size = 0;
    int                 i;
    NTSTATUS            result;

    if (!(perrstk = NEW ERRSTACK)) {
        return 1;
    }

    if (!file_system_name.Initialize()) {
        return 1;
    }
    if (!label.Initialize() || NULL == (dp_drive = NEW DP_DRIVE)) {
        return 1;
    }

    //
    //  Parse the arguments.
    //

//    if ( argc < 2 ) {
//        return 1;
//    }

    message = NEW EFICHECK_MESSAGE;

    if (NULL == message || !message->Initialize()) {
        return 1;
    }

    //
    //  The rest of the arguments are flags.
    //
    for (i = 1; i < argc; i++) {

        if (((argv[i][0] == '/' || argv[i][0] == '=') &&
            (argv[i][1] == '?' )) || showhelp
             ) {
            showhelp = TRUE;
        }
        else if ((argv[i][0] == '/' || argv[i][0] == '-')    &&
            (argv[i][1] == 'f' || argv[i][1] == 'F')    &&
            (argv[i][2] == 's' || argv[i][2] == 'S')    &&
            (argv[i][3] == ':')) {

            if (!file_system_name.Initialize(&argv[i][4])) {
                return 1;
            }
            force_filesystem = TRUE;
            DEBUG((D_INFO,(CHAR8*)"fsname: %ws\n", file_system_name.GetWSTR()));
        }
        else if ((argv[i][0] == '/' || argv[i][0] == '-')    &&
            (argv[i][1] == 'v' || argv[i][1] == 'V')    &&
            (argv[i][2] == ':')) {

            if (!label.Initialize(&argv[i][3])) {
                return 1;
            }
            labelled = TRUE;
        }
        else if ((argv[i][0] == '/' || argv[i][0] == '-')    &&
            (argv[i][1] == 'a' || argv[i][1] == 'A')    &&
            (argv[i][2] == ':')) {

            // Check to see if the size is specified in Kb
            if ((argv[i][StrLen(argv[i])-1] == 'k') || (argv[i][StrLen(argv[i])-1] == 'K')) {
                argv[i][StrLen(argv[i])-1] = '\0'; // remove the K and null terminate the string
                cluster_size = (ULONG)Atoi(&argv[i][3]) * 1024;                
            } 
            else {
                cluster_size = (ULONG)Atoi(&argv[i][3]);
            }
        }
        else if (0 == StriCmp(argv[i], TEXT("/Q")) || 0 == StriCmp(argv[i], TEXT("-Q"))) {
            quick = TRUE;
        }
        else if (argv[i][0] != '/' && argv[i][0] != '-') {
            // it's not a switch, assume it is the drive
            // we don't allow two drive at the same time
            if( drive_already_specified ) {
                message->Set(MSG_FMT_INVALID_DRIVE_SPEC);
                message->Display();
                return 1;
            }
            drive_already_specified = TRUE;
            if ( !drive_name.Initialize( argv[i] ) ) {
                return 1;
            }
            DEBUG((D_INFO,(CHAR8*)"drive name: %ws\n", drive_name.GetWSTR()));
        }
        else {
            // its not any vaild option we know of
            message->Set(MSG_INVALID_PARAMETER);
            message->Display("%ws",argv[i]);
            message->Set(MSG_BLANK_LINE);
            message->Display();
            showhelp = TRUE;
        }
    }

    DEBUG((D_INFO,(CHAR8*)"Parsed Args.\n"));

    if(showhelp || !drive_already_specified) {
        message->Set(MSG_FORMAT_INFO);
        message->Display();
        message->Set(MSG_FORMAT_COMMAND_LINE_1);
        message->Display();
        message->Set(MSG_FORMAT_COMMAND_LINE_2);
        message->Display();
        message->Set(MSG_FORMAT_COMMAND_LINE_4);
        message->Display();
        message->Set(MSG_FORMAT_SLASH_V);
        message->Display();
        message->Set(MSG_FORMAT_SLASH_Q);
        message->Display();
        message->Set(MSG_FORMAT_SLASH_F);
        message->Display();
        message->Set(MSG_FORMAT_SUPPORTED_SIZES);
        message->Display();

        return 1;
    }

    textmode_output = TRUE;

#if 0 // Shouldn't limit the cluster size as long as it is reasonable.
    if (cluster_size != 0 && cluster_size != 512 && cluster_size != 1024 &&
        cluster_size != 2048 && cluster_size != 4096) {

        message->Set(MSG_UNSUPPORTED_PARAMETER);
        message->Display();

        DeRegister( argc, argv );

        return 1;
    }
#endif
    DEBUG((D_INFO,(CHAR8*)"Determining file system type.\n"));

    if (0 == file_system_name.QueryChCount()) {

        // attempt to get the current filesystem type from disk

        if (!IFS_SYSTEM::QueryFileSystemName(&drive_name, &file_system_name, &result, NULL)) {

            message->Set( MSG_FS_NOT_DETERMINED );
            message->Display( "%W", &drive_name );

            DEBUG((D_ERROR,(CHAR8*)"Unable to determine file system type.\n"));

            if(result != 0) {
                message->Set(MSG_CANT_DASD);
                message->Display();
            }

            return 1;
        }
        file_system_name.Strupr();
    }

    if (!fat_name.Initialize("FAT") ||
        !fat32_name.Initialize("FAT32") ||
        !raw_name.Initialize("RAW") ) {

        return 1;
    }

    file_system_name.Strupr();

    //
    // If compression is requested, make sure it's available.
    //
#if 0
    if (compress) {

        message->Set(MSG_COMPRESSION_NOT_AVAILABLE);
        message->Display("%W", &file_system_name);
        return 1;
    }
#endif

    DEBUG((D_INFO,(CHAR8*)"Init DP_DRIVE.\n"));
    if (!dp_drive->Initialize(&drive_name, message)) {
        DEBUG((D_ERROR,(CHAR8*)"Failed Init DP_DRIVE.\n"));
        return 1;
    }
    DEBUG((D_INFO,(CHAR8*)"Init DP_DRIVE success.\n"));

    message->Set(MSG_WARNING_FORMAT);
    message->Display("%W", &drive_name);
    if (!message->IsYesResponse(FALSE)) {
        return 5;
    }

    if (dp_drive->IsFloppy()) {
        DEBUG((D_INFO,(CHAR8*)"**** Is a floppy.\n"));
//        return 1; BUGBUG should i fail this?
    }

    //
    // Print the "formatting <size>" message.
    //

    if (quick) {
        message->Set(MSG_QUICKFORMATTING_MB);
    } else {
        message->Set(MSG_FORMATTING_MB);
    }

    if( labelled == FALSE ) {
        plabel = NULL;
    } else {
        plabel = &label;
    }

    DEBUG((D_INFO,(CHAR8*)"QuerySector count.\n"));

    bigint = dp_drive->QuerySectors() * dp_drive->QuerySectorSize() /
        1048576;

    DEBUG((D_INFO,(CHAR8*)"Sector count is %ld.\n",dp_drive->QuerySectors()));
    DEBUG((D_INFO,(CHAR8*)"Sector size is %d.\n",dp_drive->QuerySectorSize()));

    DebugAssert(bigint.GetHighPart() == 0);

    message->Display("%d", bigint.GetLowPart());

#if 0
    PART_DESCRIPTOR partdes;
    UINT32 fatsize;


    // if the user hasn't forced a filesystem
    if( force_filesystem == FALSE ) {
        // if the disk is big enough to put at least FAT16 on it
        if (dp_drive->QuerySectors() >= (ULONG)MinSectorsFat16(dp_drive->QuerySectorSize())) {
            DEBUG((D_INFO,(CHAR8*)"Drive is big enough for FAT16 >= %d.\n",MinSectorsFat16(dp_drive->QuerySectorSize())));
            partdes.SectorCount = (dp_drive->QuerySectors()).GetQuadPart();
            partdes.SectorSize = dp_drive->QuerySectorSize();
            partdes.HeaderCount = HEADER_F16;
            partdes.FatEntrySize = 2;
            partdes.MinClusterCount = MIN_CLUSTER_F16;
            partdes.MaxClusterCount = MAX_CLUSTER_F16;
            partdes.FatType = FAT_TYPE_F16;
            file_system_name.Initialize(fat_name.QueryWSTR());

            // if this disk is big enough for FAT32
            if (dp_drive->QuerySectors() >= (ULONG)MinSectorsFat32(dp_drive->QuerySectorSize())) {
                DEBUG((D_INFO,(CHAR8*)"Drive is big enough for FAT32 >= %d\n",MinSectorsFat32(dp_drive->QuerySectorSize())));
                partdes.SectorCount = (dp_drive->QuerySectors()).GetQuadPart();
                partdes.SectorSize = dp_drive->QuerySectorSize();
                partdes.HeaderCount = HEADER_F32;
                partdes.FatEntrySize = 4;
                partdes.MinClusterCount = MIN_CLUSTER_F32;
                partdes.MaxClusterCount = MAX_CLUSTER_F32;
                partdes.FatType = FAT_TYPE_F32;
                file_system_name.Initialize(fat32_name.QueryWSTR());
            }

            // if the user hasn't forced a cluster size, select an appropriate one for him
            if( cluster_size==0 ) {
                PickClusterSize(&partdes,(UINT32*)&cluster_size,&fatsize); // note this routine doesn't work for FAT12

                cluster_size = cluster_size * dp_drive->QuerySectorSize(); // PickClusterSize return cluster size in sectors
                DEBUG((D_INFO,(CHAR8*)"User hasn't forced a cluster size, picking %d\n",cluster_size));
            }
        } else {
            // do the default, which is going to be FAT12 and whatever regular format picks.
            file_system_name.Initialize(fat_name.QueryWSTR());
        }
    } else {
        // if the drive is big enough for FAT16
        if (dp_drive->QuerySectors() >= (ULONG)MinSectorsFat16(dp_drive->QuerySectorSize())) {
            // the user forced a file system, did he force a cluster size?
            if( cluster_size==0 ) {
                // nope, setup and pick a good size
                partdes.SectorCount = (dp_drive->QuerySectors()).GetQuadPart();
                partdes.SectorSize = dp_drive->QuerySectorSize();

                if(file_system_name == fat_name) {
                    partdes.HeaderCount = HEADER_F16;
                    partdes.FatEntrySize = 2;
                    partdes.MinClusterCount = MIN_CLUSTER_F16;
                    partdes.MaxClusterCount = MAX_CLUSTER_F16;
                    partdes.FatType = FAT_TYPE_F16;
                } else if(file_system_name == fat32_name){
                    partdes.HeaderCount = HEADER_F32;
                    partdes.FatEntrySize = 4;
                    partdes.MinClusterCount = MIN_CLUSTER_F32;
                    partdes.MaxClusterCount = MAX_CLUSTER_F32;
                    partdes.FatType = FAT_TYPE_F32;
                }
                PickClusterSize(&partdes,(UINT32*)&cluster_size,&fatsize); // note this routine doesn't work for FAT12
                cluster_size = cluster_size * dp_drive->QuerySectorSize(); // PickClusterSize return cluster size in sectors
                DEBUG((D_INFO,(CHAR8*)"FS type forced, user hasn't forced a cluster size, picking %d\n",cluster_size));
            }
        }
    }
#endif

    if (file_system_name == fat_name || file_system_name == fat32_name) {

        BOOLEAN old_fat_vol = TRUE;

        DEBUG((D_INFO,(CHAR8*)"This is an old FAT volume.\n"));

        if( file_system_name == fat32_name ) {
            old_fat_vol = FALSE;
        }

        if( !(fat_volume = NEW FAT_VOL) ||
            NoError != fat_volume->Initialize( &drive_name, message, FALSE, !quick,
                Unknown )) {
            DEBUG((D_ERROR,(CHAR8*)"fat_volume init failed.\n"));
            //return 1;
        }

        DEBUG((D_INFO,(CHAR8*)"fat_volume init succeeded.\n"));

        success = fat_volume->Format(plabel,
                                     message,
                                     old_fat_vol ? FORMAT_BACKWARD_COMPATIBLE : 0,
                                     cluster_size);

        DEBUG((D_INFO,(CHAR8*)"Format return code: %d\n", success));

        DELETE( fat_volume );

    } else {

        DEBUG((D_ERROR,(CHAR8*)"fs not supported.\n"));

        message->Set( MSG_FS_NOT_SUPPORTED );
        message->Display( "%s%W", "EFIFMT", &file_system_name);

        return 1;
    }

    return (success != NoError);
}