path: root/src/VBox/Devices/EFI/Firmware/VBoxPkg/VBoxApfsJmpStartDxe/VBoxApfsJmpStartDxe.c

/* $Id: VBoxApfsJmpStartDxe.c $ */
/** @file
 * VBoxApfsJmpStartDxe.c - VirtualBox APFS jumpstart driver.
 */

/*
 * Copyright (C) 2019-2022 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * The contents of this file may alternatively be used under the terms
 * of the Common Development and Distribution License Version 1.0
 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
 * in the VirtualBox distribution, in which case the provisions of the
 * CDDL are applicable instead of those of the GPL.
 *
 * You may elect to license modified versions of this file under the
 * terms and conditions of either the GPL or the CDDL or both.
 *
 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
 */


/*********************************************************************************************************************************
*   Header Files                                                                                                                 *
*********************************************************************************************************************************/
#include <Protocol/ComponentName.h>
#include <Protocol/ComponentName2.h>
#include <Protocol/DriverBinding.h>
#include <Protocol/BlockIo.h>
#include <Protocol/DiskIo.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>

#define IN_RING0
#include <iprt/cdefs.h>
#include <iprt/formats/apfs.h>

/**
 * Contains the full jump start context being worked on.
 */
typedef struct
{
    /** Block I/O protocol. */
    EFI_BLOCK_IO *pBlockIo;
    /** Disk I/O protocol. */
    EFI_DISK_IO  *pDiskIo;
    /** Block size. */
    uint32_t     cbBlock;
    /** Controller handle. */
    EFI_HANDLE   hController;
    /** APFS UUID. */
    APFSUUID     Uuid;
} APFSJMPSTARTCTX;
typedef APFSJMPSTARTCTX *PAPFSJMPSTARTCTX;
typedef const APFSJMPSTARTCTX *PCAPFSJMPSTARTCTX;

static EFI_GUID g_ApfsDrvLoadedFromThisControllerGuid = { 0x01aaf8bc, 0x9c37, 0x4dc1,
                                                          { 0xb1, 0x68, 0xe9, 0x67, 0xd4, 0x2c, 0x79, 0x25 } };

typedef struct APFS_DRV_LOADED_INFO
{
    EFI_HANDLE hController;
    EFI_GUID   GuidContainer;
} APFS_DRV_LOADED_INFO;

/** Driver name translation table. */
static CONST EFI_UNICODE_STRING_TABLE       g_aVBoxApfsJmpStartDriverLangAndNames[] =
{
    {   "eng;en",   L"VBox APFS Jumpstart Wrapper Driver" },
    {   NULL,       NULL }
};


/*********************************************************************************************************************************
*   Internal Functions                                                                                                           *
*********************************************************************************************************************************/

/**
 * Reads data from the given offset into the buffer.
 *
 * @returns EFI status code.
 * @param   pCtx            The jump start context.
 * @param   offRead         Where to start reading from.
 * @param   pvBuf           Where to read into.
 * @param   cbRead          Number of bytes to read.
 */
static EFI_STATUS vboxApfsJmpStartRead(IN PAPFSJMPSTARTCTX pCtx, IN APFSPADDR offRead, IN void *pvBuf, IN size_t cbRead)
{
    return pCtx->pDiskIo->ReadDisk(pCtx->pDiskIo, pCtx->pBlockIo->Media->MediaId, offRead * pCtx->cbBlock, cbRead, pvBuf);
}

/**
 * Calculates the fletcher64 checksum of the given APFS block and returns TRUE if it matches the one given in the object header.
 *
 * @returns Flag indicating whether the checksum matched.
 * @param   pObjHdr         The object header containing the checksum to check against.
 * @param   pvStruct        Pointer to the struct to create the checksum of.
 * @param   cbStruct        Size of the struct in bytes.
 */
static BOOLEAN vboxApfsObjPhysIsChksumValid(PCAPFSOBJPHYS pObjHdr, void *pvStruct, size_t cbStruct)
{
    if (cbStruct % sizeof(uint32_t) == 0)
    {
        uint32_t *pu32Data = (uint32_t *)pvStruct + 2; /* Start after the checksum field at the beginning. */
        size_t cWordsLeft = (cbStruct >> 2) - 2;

        uint64_t u64C0 = 0;
        uint64_t u64C1 = 0;
        uint64_t u64ChksumFletcher64 = 0;
        uint64_t u64Check0 = 0;
        uint64_t u64Check1 = 0;

        while (cWordsLeft)
        {
            u64C0 += (uint64_t)*pu32Data++;
            u64C0 %= UINT32_C(0xffffffff);

            u64C1 += u64C0;
            u64C1 %= UINT32_C(0xffffffff);

            cWordsLeft--;
        }

        u64Check0 = UINT32_C(0xffffffff) - (u64C0 + u64C1) % UINT32_C(0xffffffff);
        u64Check1 = UINT32_C(0xffffffff) - (u64C0 + u64Check0) % UINT32_C(0xffffffff);

        u64ChksumFletcher64 = (uint64_t)u64Check1 << 32 | u64Check0;
        if (!CompareMem(&u64ChksumFletcher64, &pObjHdr->abChkSum[0], sizeof(pObjHdr->abChkSum)))
            return TRUE;
        else
            DEBUG((DEBUG_INFO, "vboxApfsObjPhysIsChksumValid: Checksum mismatch, expected 0x%llx got 0x%llx", u64ChksumFletcher64, *(uint64_t *)&pObjHdr->abChkSum[0]));
    }
    else
        DEBUG((DEBUG_INFO, "vboxApfsObjPhysIsChksumValid: Structure not a multiple of 32bit\n"));

    return FALSE;
}

/**
 * Loads and starts the EFI driver contained in the given jump start structure.
 *
 * @returns EFI status code.
 * @param   pCtx            APFS jump start driver context structure.
 * @param   pJmpStart       APFS jump start structure describing the EFI file to load and start.
 */
static EFI_STATUS vboxApfsJmpStartLoadAndExecEfiDriver(IN PAPFSJMPSTARTCTX pCtx, IN PCAPFSEFIJMPSTART pJmpStart)
{
    PCAPFSPRANGE paExtents = (PCAPFSPRANGE)(pJmpStart + 1);
    UINTN cbReadLeft = RT_LE2H_U32(pJmpStart->cbEfiFile);
    EFI_STATUS rc = EFI_SUCCESS;

    void *pvApfsDrv = AllocateZeroPool(cbReadLeft);
    if (pvApfsDrv)
    {
        uint32_t i = 0;
        uint8_t *pbBuf = (uint8_t *)pvApfsDrv;

        for (i = 0; i < RT_LE2H_U32(pJmpStart->cExtents) && !EFI_ERROR(rc) && cbReadLeft; i++)
        {
            UINTN cbRead = RT_MIN(cbReadLeft, (UINTN)RT_LE2H_U64(paExtents[i].cBlocks) * pCtx->cbBlock);

            rc = vboxApfsJmpStartRead(pCtx, RT_LE2H_U64(paExtents[i].PAddrStart), pbBuf, cbRead);
            pbBuf      += cbRead;
            cbReadLeft -= cbRead;
        }

        if (!EFI_ERROR(rc))
        {
            /* Retrieve the parent device path. */
            EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;

            rc = gBS->HandleProtocol(pCtx->hController, &gEfiDevicePathProtocolGuid, (VOID **)&ParentDevicePath);
            if (!EFI_ERROR(rc))
            {
                /* Load image and execute it. */
                EFI_HANDLE hImage;

                rc = gBS->LoadImage(FALSE, gImageHandle, ParentDevicePath,
                                    pvApfsDrv, RT_LE2H_U32(pJmpStart->cbEfiFile),
                                    &hImage);
                if (!EFI_ERROR(rc))
                {
                    /* Try to start the image. */
                    rc = gBS->StartImage(hImage, NULL, NULL);
                    if (!EFI_ERROR(rc))
                    {
                        APFS_DRV_LOADED_INFO *pApfsDrvLoadedInfo = (APFS_DRV_LOADED_INFO *)AllocatePool (sizeof(APFS_DRV_LOADED_INFO));
                        if (pApfsDrvLoadedInfo)
                        {
                            pApfsDrvLoadedInfo->hController = pCtx->hController;
                            CopyMem(&pApfsDrvLoadedInfo->GuidContainer, &pCtx->Uuid, sizeof(pApfsDrvLoadedInfo->GuidContainer));

                            rc = gBS->InstallMultipleProtocolInterfaces(&pCtx->hController, &g_ApfsDrvLoadedFromThisControllerGuid, pApfsDrvLoadedInfo, NULL);
                            if (!EFI_ERROR(rc))
                            {
                                /* Connect the driver with the controller it came from. */
                                EFI_HANDLE ahImage[2];

                                ahImage[0] = hImage;
                                ahImage[1] = NULL;

                                gBS->ConnectController(pCtx->hController, &ahImage[0], NULL, TRUE);
                                return EFI_SUCCESS;
                            }
                            else
                            {
                                FreePool(pApfsDrvLoadedInfo);
                                DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to install APFS driver loaded info protocol with %r\n", rc));
                            }
                        }
                        else
                        {
                            DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to allocate %u bytes for the driver loaded structure\n", sizeof(APFS_DRV_LOADED_INFO)));
                            rc = EFI_OUT_OF_RESOURCES;
                        }
                    }
                    else
                        DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Starting APFS driver failed with %r\n", rc));

                    gBS->UnloadImage(hImage);
                }
                else
                    DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Loading read image failed with %r\n", rc));
            }
            else
                DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Querying device path protocol failed with %r\n", rc));
        }
        else
            DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Reading the jump start extents failed with %r\n", rc));

        FreePool(pvApfsDrv);
    }
    else
    {
        DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to allocate %u bytes for the APFS driver image\n", cbReadLeft));
        rc = EFI_OUT_OF_RESOURCES;
    }

    return rc;
}

/**
 * @copydoc EFI_DRIVER_BINDING_SUPPORTED
 */
static EFI_STATUS EFIAPI
VBoxApfsJmpStart_Supported(IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle,
                           IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL)
{
    /* Check whether the controller supports the block I/O protocol. */
    EFI_STATUS rc = gBS->OpenProtocol(ControllerHandle,
                                      &gEfiBlockIoProtocolGuid,
                                      NULL,
                                      This->DriverBindingHandle,
                                      ControllerHandle,
                                      EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
    if (EFI_ERROR(rc))
        return rc;

    rc = gBS->OpenProtocol(ControllerHandle,
                           &gEfiDiskIoProtocolGuid,
                           NULL,
                           This->DriverBindingHandle,
                           ControllerHandle,
                           EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
    if (EFI_ERROR(rc))
        return rc;

    return EFI_SUCCESS;
}


/**
 * @copydoc EFI_DRIVER_BINDING_START
 */
static EFI_STATUS EFIAPI
VBoxApfsJmpStart_Start(IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle,
                       IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL)
{
    APFSJMPSTARTCTX Ctx;

    /* Check whether the driver was already loaded from this controller. */
    EFI_STATUS rc = gBS->OpenProtocol(ControllerHandle,
                                      &g_ApfsDrvLoadedFromThisControllerGuid,
                                      NULL,
                                      This->DriverBindingHandle,
                                      ControllerHandle,
                                      EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
    if (!EFI_ERROR(rc))
        return EFI_UNSUPPORTED;

    Ctx.cbBlock = 0; /* Will get filled when the superblock was read (starting at 0 anyway). */
    Ctx.hController = ControllerHandle;

    rc = gBS->OpenProtocol(ControllerHandle,
                           &gEfiBlockIoProtocolGuid,
                           (void **)&Ctx.pBlockIo,
                           This->DriverBindingHandle,
                           ControllerHandle,
                           EFI_OPEN_PROTOCOL_GET_PROTOCOL);
    if (!EFI_ERROR(rc))
    {
        rc = gBS->OpenProtocol(ControllerHandle,
                               &gEfiDiskIoProtocolGuid,
                               (void **)&Ctx.pDiskIo,
                               This->DriverBindingHandle,
                               ControllerHandle,
                               EFI_OPEN_PROTOCOL_GET_PROTOCOL);
        if (!EFI_ERROR(rc))
        {
            /* Read the NX superblock structure from the first block and verify it. */
            APFSNXSUPERBLOCK Sb;

            rc = vboxApfsJmpStartRead(&Ctx, 0, &Sb, sizeof(Sb));
            if (   !EFI_ERROR(rc)
                && RT_LE2H_U32(Sb.u32Magic) == APFS_NX_SUPERBLOCK_MAGIC)
            {
                uint8_t *pbBlock = (uint8_t *)AllocateZeroPool(RT_LE2H_U32(Sb.cbBlock));

                if (pbBlock)
                {
                    PCAPFSNXSUPERBLOCK pSb = (PCAPFSNXSUPERBLOCK)pbBlock;

                    /* Read in the complete block (checksums always cover the whole block and not just the structure...). */
                    Ctx.cbBlock = RT_LE2H_U32(Sb.cbBlock);

                    rc = vboxApfsJmpStartRead(&Ctx, 0, pbBlock, Ctx.cbBlock);
                    if (   !EFI_ERROR(rc)
                        && RT_LE2H_U64(Sb.PAddrEfiJmpStart) > 0
                        && vboxApfsObjPhysIsChksumValid(&pSb->ObjHdr, pbBlock, Ctx.cbBlock))
                    {
                        PCAPFSEFIJMPSTART pJmpStart = (PCAPFSEFIJMPSTART)pbBlock;

                        DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Found APFS superblock, reading jumpstart structure from %llx\n", RT_LE2H_U64(Sb.PAddrEfiJmpStart)));

                        CopyMem(&Ctx.Uuid, &pSb->Uuid, sizeof(Ctx.Uuid));

                        rc = vboxApfsJmpStartRead(&Ctx, RT_LE2H_U64(Sb.PAddrEfiJmpStart), pbBlock, Ctx.cbBlock);
                        if (   !EFI_ERROR(rc)
                            && RT_H2LE_U32(pJmpStart->u32Magic) == APFS_EFIJMPSTART_MAGIC
                            && RT_H2LE_U32(pJmpStart->u32Version) == APFS_EFIJMPSTART_VERSION
                            && vboxApfsObjPhysIsChksumValid(&pJmpStart->ObjHdr, pbBlock, Ctx.cbBlock)
                            && RT_H2LE_U32(pJmpStart->cExtents) <= (Ctx.cbBlock - sizeof(*pJmpStart)) / sizeof(APFSPRANGE))
                            rc = vboxApfsJmpStartLoadAndExecEfiDriver(&Ctx, pJmpStart);
                        else
                        {
                            rc = EFI_UNSUPPORTED;
                            DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: The APFS EFI jumpstart structure is invalid\n"));
                        }
                    }
                    else
                    {
                        DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Invalid APFS superblock -> no APFS filesystem (%r %x %llx)\n", rc, Sb.u32Magic, Sb.PAddrEfiJmpStart));
                        rc = EFI_UNSUPPORTED;
                    }

                    FreePool(pbBlock);
                }
                else
                    DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to allocate memory for APFS block data (%u bytes)\n", RT_LE2H_U32(Sb.cbBlock)));
            }
            else
                DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Invalid APFS superblock -> no APFS filesystem (%r %x)\n", rc, Sb.u32Magic));

            gBS->CloseProtocol(ControllerHandle,
                               &gEfiDiskIoProtocolGuid,
                               This->DriverBindingHandle,
                               ControllerHandle);
        }
        else
            DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Opening the Disk I/O protocol failed with %r\n", rc));

        gBS->CloseProtocol(ControllerHandle,
                           &gEfiBlockIoProtocolGuid,
                           This->DriverBindingHandle,
                           ControllerHandle);
    }
    else
        DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Opening the Block I/O protocol failed with %r\n", rc));

    return  rc;
}


/**
 * @copydoc EFI_DRIVER_BINDING_STOP
 */
static EFI_STATUS EFIAPI
VBoxApfsJmpStart_Stop(IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle,
                      IN UINTN NumberOfChildren, IN EFI_HANDLE *ChildHandleBuffer OPTIONAL)
{
    /* EFI_STATUS                  rc; */

    return  EFI_UNSUPPORTED;
}


/** @copydoc EFI_COMPONENT_NAME_GET_DRIVER_NAME */
static EFI_STATUS EFIAPI
VBoxApfsJmpStartCN_GetDriverName(IN EFI_COMPONENT_NAME_PROTOCOL *This,
                                 IN CHAR8 *Language, OUT CHAR16 **DriverName)
{
    return LookupUnicodeString2(Language,
                                This->SupportedLanguages,
                                &g_aVBoxApfsJmpStartDriverLangAndNames[0],
                                DriverName,
                                TRUE);
}

/** @copydoc EFI_COMPONENT_NAME_GET_CONTROLLER_NAME */
static EFI_STATUS EFIAPI
VBoxApfsJmpStartCN_GetControllerName(IN EFI_COMPONENT_NAME_PROTOCOL *This,
                                     IN EFI_HANDLE ControllerHandle,
                                     IN EFI_HANDLE ChildHandle OPTIONAL,
                                     IN CHAR8 *Language, OUT CHAR16 **ControllerName)
{
    /** @todo try query the protocol from the controller and forward the query. */
    return EFI_UNSUPPORTED;
}

/** @copydoc EFI_COMPONENT_NAME2_GET_DRIVER_NAME */
static EFI_STATUS EFIAPI
VBoxApfsJmpStartCN2_GetDriverName(IN EFI_COMPONENT_NAME2_PROTOCOL *This,
                        IN CHAR8 *Language, OUT CHAR16 **DriverName)
{
    return LookupUnicodeString2(Language,
                                This->SupportedLanguages,
                                &g_aVBoxApfsJmpStartDriverLangAndNames[0],
                                DriverName,
                                FALSE);
}

/** @copydoc EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME */
static EFI_STATUS EFIAPI
VBoxApfsJmpStartCN2_GetControllerName(IN EFI_COMPONENT_NAME2_PROTOCOL *This,
                                      IN EFI_HANDLE ControllerHandle,
                                      IN EFI_HANDLE ChildHandle OPTIONAL,
                                      IN CHAR8 *Language, OUT CHAR16 **ControllerName)
{
    /** @todo try query the protocol from the controller and forward the query. */
    return EFI_UNSUPPORTED;
}



/*********************************************************************************************************************************
*   Entry point and driver registration                                                                                          *
*********************************************************************************************************************************/

/** EFI Driver Binding Protocol. */
static EFI_DRIVER_BINDING_PROTOCOL          g_VBoxApfsJmpStartDB =
{
    VBoxApfsJmpStart_Supported,
    VBoxApfsJmpStart_Start,
    VBoxApfsJmpStart_Stop,
    /* .Version             = */    1,
    /* .ImageHandle         = */ NULL,
    /* .DriverBindingHandle = */ NULL
};

/** EFI Component Name Protocol. */
static const EFI_COMPONENT_NAME_PROTOCOL    g_VBoxApfsJmpStartCN =
{
    VBoxApfsJmpStartCN_GetDriverName,
    VBoxApfsJmpStartCN_GetControllerName,
    "eng"
};

/** EFI Component Name 2 Protocol. */
static const EFI_COMPONENT_NAME2_PROTOCOL   g_VBoxApfsJmpStartCN2 =
{
    VBoxApfsJmpStartCN2_GetDriverName,
    VBoxApfsJmpStartCN2_GetControllerName,
    "en"
};


/**
 * VBoxApfsJmpStart entry point.
 *
 * @returns EFI status code.
 *
 * @param   ImageHandle     The image handle.
 * @param   SystemTable     The system table pointer.
 */
EFI_STATUS EFIAPI
VBoxApfsjmpStartEntryDxe(IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable)
{
    EFI_STATUS  rc;
    DEBUG((DEBUG_INFO, "VBoxApfsjmpStartEntryDxe\n"));

    rc = EfiLibInstallDriverBindingComponentName2(ImageHandle, SystemTable,
                                                  &g_VBoxApfsJmpStartDB, ImageHandle,
                                                  &g_VBoxApfsJmpStartCN, &g_VBoxApfsJmpStartCN2);
    ASSERT_EFI_ERROR(rc);
    return rc;
}

EFI_STATUS EFIAPI
VBoxApfsjmpStartUnloadDxe(IN EFI_HANDLE         ImageHandle)
{
    return EFI_SUCCESS;
}