slimbootloader/PayloadPkg/OsLoader/BootParameters.c

/** @file

  Copyright (c) 2017 - 2023, Intel Corporation. All rights reserved.<BR>
  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "OsLoader.h"

CONST CHAR16 *mMmcDllStr = L"MMCDLL";

CONST CHAR8 *mAppendCmdLineParams = NULL;

/**
  Get command line arguments from the config file.

  This function will read command line arguments and put
  it into Buffer.

  @param[out] Buffer      Buffer to get command line arguments
  @param[in]  BufferLen   Buffer size
  @param[in]  File        Pointer to the config file
  @param[in]  FileLen     File size

  @retval Number of bytes read from the config file.
**/
UINTN
GetFromConfigFile (
  OUT UINT8                  *Buffer,
  IN  UINT32                  BufferLen,
  IN  UINT8                  *File,
  IN  UINT32                  FileLen
  )
{
  UINTN                     Index;
  UINTN                     Count;

  if (BufferLen == 0) {
    return 0;
  }

  Count = 0;
  for (Index = 0; Index < FileLen ; Index++) {
    if ((CompareMem (EOF, &File[Index], 5) == 0) || ((CHAR8)File[Index] == '\0')) {
      DEBUG ((DEBUG_INFO, "cmd Count = [0x%x]\n", Count));
      break;
    } else {
      if (((CHAR8)File[Index] != '\n') && ((CHAR8)File[Index] != '\r')) {
        if (Count + 1 < BufferLen) {
          Buffer[Count++] = File[Index];
        }
      }
    }
  }

  Buffer[Count] = '\0';
  return Count;
}

/**
  Update OS memory size info

  Multiboot mmap info might be changed since slimboot might reserve
  memory for different OS image. so re-calculate the amount of lower
  and upper memory size (in KB).

  @param[in,out] LoadedImage       Loaded boot image info

**/
VOID
UpdateOsMemSize (
  IN OUT  LOADED_IMAGE       *LoadedImage
  )
{
  UINTN                      Index;
  UINT32                     Count;
  MULTIBOOT_MMAP             *MbMmap;
  MULTIBOOT_INFO             *MbInfo;
  UINT64                     MemLowerSize;
  UINT64                     MemUpperSize;

  if ((LoadedImage->Flags & LOADED_IMAGE_MULTIBOOT) == 0) {
    return;
  }

  MemLowerSize = 0;
  MemUpperSize = 0;

  MbInfo = &LoadedImage->Image.MultiBoot.MbInfo;
  MbMmap = (MULTIBOOT_MMAP *) MbInfo->MmapAddr;
  Count  = MbInfo->MmapLength / sizeof (MULTIBOOT_MMAP);
  for (Index = 0; Index < Count; Index++) {
    if (MbMmap[Index].Type != MEM_MAP_TYPE_RAM) {
      continue;
    }
    if (MbMmap[Index].BaseAddr == 0) {
      MemLowerSize = MbMmap[Index].Length;
    } else if (MbMmap[Index].BaseAddr >= MB_ (1)) {
      MemUpperSize = MbMmap[Index].Length - MB_ (1);
    }
  }

  if ((MemLowerSize != 0) || (MemUpperSize != 0)) {
    // Convert to KB in size
    MbInfo->MemLower = (UINT32) (RShiftU64 (MemLowerSize, 10));
    MbInfo->MemUpper = (UINT32) (RShiftU64 (MemUpperSize, 10));
    MbInfo->Flags   |= MULTIBOOT_INFO_HAS_MEMORY;
  }

}


/**
  Update OS memmap

  Based on memory usage, especially reserved memory usage, this
  function will update OS Memmap.

  @param[in,out] LoadedImage       Loaded boot image info

**/
VOID
UpdateOsMemMap (
  IN OUT  LOADED_IMAGE       *LoadedImage
  )
{
  UINTN                      Index;
  UINT64                     RsvdMemBase;
  UINT64                     RsvdMemSize;
  UINT32                     Count;
  BOOT_PARAMS                *Bp;
  E820_ENTRY                 *E820Entry;
  UINT32                     MmapDiff;
  MULTIBOOT_IMAGE            *MultiBoot;
  OS_CONFIG_DATA_HOB         *OsConfigData;
  UINT32                     TempMemorySize;
  BOOLEAN                    CrashModeDisabled;

  OsConfigData = (OS_CONFIG_DATA_HOB *) GetGuidHobData (NULL, NULL, &gOsConfigDataGuid);
  CrashModeDisabled = (OsConfigData == NULL || OsConfigData->EnableCrashMode == 0);

  GetPayloadReservedRamRegion (&RsvdMemBase, &RsvdMemSize);
  TempMemorySize  = ALIGN_UP (PcdGet32 (PcdPayloadStackSize), EFI_PAGE_SIZE);
  TempMemorySize += ALIGN_UP (PcdGet32 (PcdPayloadHeapSize),  EFI_PAGE_SIZE);

  if ((LoadedImage->Flags & LOADED_IMAGE_MULTIBOOT2) != 0) {
    UpdateMultiboot2MemInfo (&LoadedImage->Image.MultiBoot, RsvdMemBase, RsvdMemSize, CrashModeDisabled ? 0 : TempMemorySize);
    return;
  }
  if (CrashModeDisabled) {
    UpdateOsMemSize (LoadedImage);
    return;
  }

  //
  // If crash mode is enabled, make sure the memory used by payload is set to
  // reserved memory to avoid overriding OS memory in next boot.
  //

  //
  // Linux E820 Mmap is very similar with multiboot MMAP
  // Here find the difference to share same update logic below
  //
  if ((LoadedImage->Flags & LOADED_IMAGE_MULTIBOOT) != 0) {
    MultiBoot = &LoadedImage->Image.MultiBoot;
    E820Entry = (E820_ENTRY *) ((UINT8 *)MultiBoot->MbInfo.MmapAddr + sizeof (UINT32));
    Count     = MultiBoot->MbInfo.MmapLength / sizeof (MULTIBOOT_MMAP);
    MmapDiff  = sizeof (UINT32);
  } else {
    Bp        = (BOOT_PARAMS *) (UINTN)BOOT_PARAMS_BASE;
    E820Entry = &Bp->E820Map[0];
    Count     = Bp->E820Entries;
    if (Count >= 128) {
      Count = 128;
    }
    MmapDiff  = 0;
  }

  for (Index = 0; Index < Count; Index++) {
    // Update payload reserved memory map
    if ((E820Entry->Addr == RsvdMemBase) &&  (E820Entry->Size == RsvdMemSize)) {
      E820Entry->Addr = RsvdMemBase - TempMemorySize;
      E820Entry->Size = RsvdMemSize + TempMemorySize;
    }

    // Update free memory map adjcent to payload reserved memory
    if (E820Entry->Addr + E820Entry->Size == RsvdMemBase) {
      E820Entry->Size -= TempMemorySize;
    }

    E820Entry = (E820_ENTRY *) ((UINT8 *)E820Entry + sizeof (E820_ENTRY) + MmapDiff);
  }
  UpdateOsMemSize (LoadedImage);
}

/**
  Display OS boot parameters.

  @param[in]    LoadedImage       Loaded image info

**/
VOID
DisplayInfo (
  IN     LOADED_IMAGE        *LoadedImage
  )
{
DEBUG_CODE_BEGIN ();
  if ((LoadedImage->Flags & LOADED_IMAGE_MULTIBOOT) != 0) {
    DumpMbInfo (&LoadedImage->Image.MultiBoot.MbInfo);
    DumpMbBootState (&LoadedImage->Image.MultiBoot.BootState);
  } else if ((LoadedImage->Flags & LOADED_IMAGE_MULTIBOOT2) != 0) {
    DumpMb2Info (LoadedImage->Image.MultiBoot.Mb2Info.StartTag);
    DumpMbBootState (&LoadedImage->Image.MultiBoot.BootState);
  } else if ((LoadedImage->Flags & LOADED_IMAGE_LINUX) != 0) {
    DumpLinuxBootParams (GetLinuxBootParams ());
  }
DEBUG_CODE_END ();
}

/**
  Update OS boot parameters

  This function will append required command line parameters,
  and update mem map info.

  @param[in]     CurrentBootOption Current boot option
  @param[in,out] LoadedImage       Normal OS boot image
  @param[in,out] LoadedPreOsImage  Pre-OS image
  @param[in,out] LoadedExtraImages Extra OS images

  @retval   RETURN_SUCCESS         If update OS parameter success
  @retval   Others                 Failed to update OS parameters
**/
EFI_STATUS
UpdateOsParameters (
  IN     OS_BOOT_OPTION      *CurrentBootOption,
  IN OUT LOADED_IMAGE        *LoadedImage,
  IN OUT LOADED_IMAGE        *LoadedPreOsImage,
  IN OUT LOADED_IMAGE        *LoadedExtraImages
  )
{
  IMAGE_DATA                 *CmdFile;
  BOOLEAN                    SerialNumValidity;
  LOADER_SEED_LIST           *SeedList;
  EFI_STATUS                 Status;

  Status       = RETURN_SUCCESS;

  // Check storage serial number validity. eMMC only for now.
  if (PcdGetBool (PcdSeedListEnabled)) {
    SerialNumValidity = FALSE;
    if (CurrentBootOption->DevType == OsBootDeviceEmmc) {
      Status = EmmcSerialNumCheck();
      if (EFI_ERROR (Status)) {
        DEBUG ((DEBUG_WARN, "EmmcSerialNumCheck failed: %r\n", Status));
        SerialNumValidity = FALSE;
      } else {
        SerialNumValidity = TRUE;
      }
    }
    SeedList = (LOADER_SEED_LIST *) AllocateZeroPool (sizeof (LOADER_SEED_LIST));
    if (SeedList == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
    SeedSanityCheck(CurrentBootOption, SeedList);

    if (SerialNumValidity == 1) {
      Status = RpmbKeyProvisioning (CurrentBootOption, SeedList);
      if (!EFI_ERROR(Status)) {
        DEBUG ((DEBUG_INFO, "RpmbKeyProvisioning successful\n"));
      }
    }
    FreePool(SeedList);
  }

  //
  // Multiboot and non-Multiboot share same Cmd Addr
  //
  CmdFile = &LoadedImage->Image.Common.CmdFile;

  if (mAppendCmdLineParams != NULL) {
    if ((AsciiStrSize (mAppendCmdLineParams) + CmdFile->Size) < CMDLINE_LENGTH_MAX) {
      AsciiStrCatS ((CHAR8 *)CmdFile->Addr, CMDLINE_LENGTH_MAX, mAppendCmdLineParams);
    } else {
      DEBUG ((DEBUG_INFO, "Unable to append extra cmd line parameters!\n"));
    }
  }

  CmdFile->Size = CMDLINE_LENGTH_MAX;
  Status = AddSblCommandLine (CurrentBootOption, (CHAR8 *)CmdFile->Addr, &CmdFile->Size, &LoadedImage->ReservedCmdlineData);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  //
  // Update PreOS image if it is loaded.
  //
  if (((CurrentBootOption->BootFlags & BOOT_FLAGS_PREOS) != 0) && (LoadedPreOsImage != NULL)) {
    LoadedImage->Image.MultiBoot.CmdBufferSize       = CMDLINE_LENGTH_MAX;
    if ((CurrentBootOption->PreOsImageType & EnumPreOsTypeTrustyOs) != 0) {
      LoadedPreOsImage->Image.MultiBoot.CmdBufferSize = CMDLINE_LENGTH_MAX;
      Status = SetupTrustyBoot (&LoadedPreOsImage->Image.MultiBoot, &LoadedImage->Image.MultiBoot);
      if (EFI_ERROR (Status)) {
        DEBUG ((DEBUG_ERROR, "ERROR Setting up preOS Boot!\n"));
        return Status;
      }
    }
    UpdateOsMemMap (LoadedPreOsImage);
    DEBUG ((DEBUG_INFO, "\nDump PreOs image info:\n"));
    DisplayInfo (LoadedPreOsImage);
  }

  if ((CurrentBootOption->BootFlags & BOOT_FLAGS_EXTRA) != 0) {
    if ((LoadedExtraImages != NULL) && ((LoadedExtraImages->Flags & LOADED_IMAGE_RUN_EXTRA) != 0)) {
      DEBUG ((DEBUG_INFO, "Extra image is loaded and will run before OS.\n"));
    } else {
      DEBUG ((DEBUG_ERROR, "Warning: Extra image not loaded, or need pass it to OS in boot parameter.\n"));
    }
  }

  UpdateOsMemMap (LoadedImage);
  if ((LoadedImage->Flags & LOADED_IMAGE_LINUX) != 0) {
    GetLinuxBootParams ()->Hdr.CmdlineSize = LoadedImage->Image.Linux.CmdFile.Size;
  }
  DEBUG ((DEBUG_INFO, "\nDump normal boot image info:\n"));
  DisplayInfo (LoadedImage);
  AddMeasurePoint(0x40E0);

  return Status;
}