varfile.c

来自「Next BIOS Source code : Extensible Firmw」· C语言 代码 · 共 659 行 · 第 1/2 页

    } else {

        BS->FreePool(Dev);

        DEBUG ((D_VAR|D_ERROR, "VarAddBSStore: Volume not available, NV+BS is using BS only\n"));

        PlInitNvVarStoreMem (Attributes, BankSize, NoBanks);
    }
}

#pragma RUNTIME_CODE(RtVarBSDeviceSetVirtualMapping)
VOID
STATIC RUNTIMEFUNCTION
RtVarBSDeviceSetVirtualMapping (
    IN EFI_EVENT            Event,
    IN VOID                 *Context
    )
{
    VAR_DEV              *VarDevice;
    EFI_CONVERT_POINTER  ConvertPointer;

    VarDevice = Context;

    ConvertPointer = RT->ConvertPointer;

    VarDevice->VarStore.ClearStore  = RtVarBSClearStore;
    VarDevice->VarStore.ReadStore   = RtVarBSReadStore;
    VarDevice->VarStore.UpdateStore = RtVarBSUpdateStore;
    VarDevice->VarStore.SizeStore   = NULL;

    ConvertPointer (EFI_INTERNAL_FNC, (VOID **) &VarDevice->VarStore.ClearStore);
    ConvertPointer (EFI_INTERNAL_FNC, (VOID **) &VarDevice->VarStore.ReadStore);
    ConvertPointer (EFI_INTERNAL_FNC, (VOID **) &VarDevice->VarStore.UpdateStore);
    ConvertPointer (EFI_INTERNAL_FNC, (VOID **) &VarDevice->VarStore.SizeStore);
}

#pragma RUNTIME_CODE(RtVarBSClearStore)
STATIC
EFI_STATUS
RUNTIMEFUNCTION
RtVarBSClearStore(
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                BankNo,
    IN VOID                 *Scratch
    )
{
    return EFI_SUCCESS;
}

#pragma RUNTIME_CODE(RtVarBSReadStore)
STATIC
EFI_STATUS
RUNTIMEFUNCTION
RtVarBSReadStore (
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                BankNo,
    IN UINTN                Offset,
    IN UINTN                BufferSize,
    OUT VOID                *Buffer
    )
{
    RtSetMem (Buffer, BufferSize, 0xff);
    return EFI_SUCCESS;
}

#pragma RUNTIME_CODE(RtVarBSUpdateStore)
STATIC
EFI_STATUS
RUNTIMEFUNCTION
RtVarBSUpdateStore (
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                BankNo,
    IN UINTN                Offset,
    IN UINTN                BufferSize,
    IN VOID                 *UserBuffer
    )
{
    return EFI_SUCCESS;
}


STATIC
VOID
VarOpenBSStore (
    IN VAR_DEV              *Dev,
    IN UINT64               OpenMode,
    OUT UINT64              *AvailableSpace
    )
{
    EFI_HANDLE              Handle;
    EFI_FILE_HANDLE         Vol, DirHandle;
    EFI_FILE_SYSTEM_INFO    *Info;    
    EFI_STATUS              Status;
    UINTN                   BufferSize;
    UINT64                  Attr;
    EFI_DEVICE_PATH         *DevicePath;

    ASSERT (!Dev->File);

    if (AvailableSpace) {
        *AvailableSpace = 0;
    }

    DevicePath = Dev->DevicePath;
    Status = BS->LocateDevicePath (&FileSystemProtocol, &DevicePath, &Handle);
    if (EFI_ERROR(Status) || (Handle == NULL)) {
        return;
    }

    OpenMode = OpenMode | EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE;
    Attr = EFI_FILE_HIDDEN | EFI_FILE_SYSTEM;

    //
    // Connect to the volume
    //

    Vol = LibOpenRoot(Handle);
    if (Vol) {

        //
        // Open/create the efi directory
        //

        Status = Vol->Open (
                    Vol, 
                    &DirHandle, 
                    L"efi",
                    EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE, 
                    EFI_FILE_DIRECTORY
                    );
        if (EFI_ERROR (Status)) {

          Status = Vol->Open (
                      Vol, 
                      &DirHandle, 
                      L"efi",
                      OpenMode, 
                      Attr | EFI_FILE_DIRECTORY
                      );
        }

        if (!EFI_ERROR(Status)) {

            //
            // Open the boot store file
            //

            Status = DirHandle->Open (
                        DirHandle, 
                        &Dev->File, 
                        L"BootStr", 
                        OpenMode,
                        Attr
                        );

            DirHandle->Close (DirHandle);
        }

        //
        // On error, return the available space
        //

        if (EFI_ERROR(Status) && AvailableSpace) {
            BufferSize = sizeof(Info);
            Info = LibFileSystemInfo (Vol);
            if (Info) {
                if (!Info->ReadOnly) {
                    *AvailableSpace = Info->FreeSpace;
                }

                FreePool (Info);
            }
        }

        //
        // Close the volume handle
        //

        Vol->Close (Vol);
    }
}

STATIC
EFI_STATUS
VarBSOpenStore (
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                BankNo,    
    IN UINTN                Offset
    )
{
    EFI_STATUS              Status;    
    VAR_DEV                 *Dev;

    Dev = DEV_FROM_THIS(This);

    //
    // If the boot store file isn't open, open it now
    //

    if (!Dev->File) {
        VarOpenBSStore (Dev, 0, NULL);
    }

    //
    // Set the position for the io
    //

    if (Dev->File) {
        Offset = Offset + BankNo * Dev->BankSize;
        Status = Dev->File->SetPosition (Dev->File, Offset);
    } else {
        DEBUG((D_ERROR,"NVRAM : Can not open \\Efi\\BootStr on %s\n",DevicePathToStr(Dev->DevicePath)));
        Status = EFI_NOT_FOUND;
    }

    return Status;
}
    

STATIC
EFI_STATUS
VarBSClearStore(
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                BankNo,
    IN OUT VOID             *Scratch
    )
{
    EFI_STATUS              Status;
    UINTN                   WriteSize;
    VAR_DEV                 *Dev;

    Dev = DEV_FROM_THIS(This);

    Status = VarBSOpenStore (This, BankNo, 0);

    if (!EFI_ERROR(Status)) {

        //
        // Write all 1 bits to the bank
        //

        WriteSize = Dev->BankSize;
        Status = Dev->File->Write (Dev->File, &WriteSize, Dev->Scratch);
        Dev->File->Flush (Dev->File);
        Dev->File->Close (Dev->File);
    }
    Dev->File = NULL;

    return Status;
}


STATIC
EFI_STATUS
VarBSReadStore (
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                BankNo,
    IN UINTN                Offset,
    IN UINTN                BufferSize,
    OUT VOID                *Buffer
    )
{
    EFI_STATUS              Status;
    VAR_DEV                 *Dev;

    Dev = DEV_FROM_THIS(This);

    Status = VarBSOpenStore (This, BankNo, Offset);

    if (!EFI_ERROR(Status)) {
        Status = Dev->File->Read (Dev->File, &BufferSize, Buffer);
        Dev->File->Flush (Dev->File);
        Dev->File->Close (Dev->File);
    }
    Dev->File = NULL;

    return Status;
}


STATIC
EFI_STATUS
VarBSUpdateStore (
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                BankNo,
    IN UINTN                Offset,
    IN UINTN                BufferSize,
    IN VOID                 *Buffer
    )
{
    EFI_STATUS              Status;
    VAR_DEV                 *Dev;

    Dev = DEV_FROM_THIS(This);

    Status = VarBSOpenStore (This, BankNo, Offset);

    if (!EFI_ERROR(Status)) {
        Status = Dev->File->Write (Dev->File, &BufferSize, Buffer);
        Dev->File->Flush (Dev->File);
        Dev->File->Close (Dev->File);
    }
    Dev->File = NULL;

    return Status;
}

STATIC
EFI_STATUS
VarBSSizeStore (
    IN EFI_VARIABLE_STORE   *This,
    IN UINTN                NoBanks
    )
{
    EFI_STATUS              Status;
    UINT8                   c;
    VAR_DEV                 *Dev;

    Dev = DEV_FROM_THIS(This);

    Status = VarBSUpdateStore (This, NoBanks, -1, 1, &c);
    if (!EFI_ERROR(Status)) {
        Dev->VarStore.NoBanks = (UINT32) NoBanks;
    }

    return Status;
}