utillidmgr_rt.C

/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/usr/util/runtime/utillidmgr_rt.C $                        */
/*                                                                        */
/* OpenPOWER HostBoot Project                                             */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2013,2017                        */
/* [+] International Business Machines Corp.                              */
/*                                                                        */
/*                                                                        */
/* Licensed under the Apache License, Version 2.0 (the "License");        */
/* you may not use this file except in compliance with the License.       */
/* You may obtain a copy of the License at                                */
/*                                                                        */
/*     http://www.apache.org/licenses/LICENSE-2.0                         */
/*                                                                        */
/* Unless required by applicable law or agreed to in writing, software    */
/* distributed under the License is distributed on an "AS IS" BASIS,      */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
/* implied. See the License for the specific language governing           */
/* permissions and limitations under the License.                         */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
#include <stdio.h>
#include <algorithm>

#include <util/utillidmgr.H>
#include <util/util_reasoncodes.H>
#include <errl/errlmanager.H>
#include <vfs/vfs.H>
#include <runtime/interface.h>
#include <initservice/initserviceif.H>
#include <secureboot/containerheader.H>
#include <trace/interface.H>
#include "../utilbase.H"

UtilLidMgr::UtilLidMgr(uint32_t i_lidId) :
    iv_isLidInPnor(false), iv_lidBuffer(nullptr), iv_lidSize(0),
    iv_isLidInVFS(false), iv_isLidInHbResvMem(false)
{
    iv_spBaseServicesEnabled = INITSERVICE::spBaseServicesEnabled();
    updateLid(i_lidId);
}

UtilLidMgr::~UtilLidMgr()
{
    errlHndl_t l_err = nullptr;

    l_err = cleanup();
    if(l_err)
    {
        //cleanup errors are extermely rare
        ERRORLOG::errlCommit( l_err, UTIL_COMP_ID );
    }
}

errlHndl_t UtilLidMgr::setLidId(uint32_t i_lidId)
{
    errlHndl_t l_err = nullptr;

    //must call cleanup before updateLid
    l_err = cleanup();

    updateLid(i_lidId);

    return l_err;
}

errlHndl_t UtilLidMgr::getLidSize(size_t& o_lidSize)
{
    errlHndl_t l_err = loadLid();
    o_lidSize = iv_lidSize;

    return l_err;
}

errlHndl_t UtilLidMgr::getLid(void* i_dest, size_t i_destSize)
{
    errlHndl_t l_err = loadLid();

    if (iv_lidBuffer != nullptr)
    {
        memcpy(i_dest, iv_lidBuffer, std::min(i_destSize, iv_lidSize));
    }

    return l_err;
}

errlHndl_t UtilLidMgr::getStoredLidImage(void*& o_pLidImage,
                                         size_t& o_lidImageSize)
{
    errlHndl_t l_err = nullptr;

    if((nullptr == iv_lidBuffer) || (0 == iv_lidSize))
    {
        l_err = loadLid();
    }

    if(l_err)
    {
        o_lidImageSize = 0;
        o_pLidImage = nullptr;
    }
    else
    {
        o_lidImageSize = iv_lidSize;
        o_pLidImage = iv_lidBuffer;
    }

    return l_err;
}

errlHndl_t UtilLidMgr::releaseLidImage(void)
{
    // we already figured out where the data is, remember that
    bool l_inPnor = iv_isLidInPnor;
    bool l_inVFS = iv_isLidInVFS;
    bool l_inHbResvMem = iv_isLidInHbResvMem;

    errlHndl_t l_err = cleanup();

    // restore the presence info
    iv_isLidInPnor = l_inPnor;
    iv_isLidInVFS = l_inVFS;
    iv_isLidInHbResvMem = l_inHbResvMem;

    return l_err;
}

errlHndl_t UtilLidMgr::loadLid()
{
    if (nullptr != iv_lidBuffer) return nullptr;

    const char* l_addr = nullptr;
    size_t l_size = 0;
    errlHndl_t l_errl = nullptr;

    do
    {
        if(iv_isLidInHbResvMem)
        {
            iv_lidBuffer = reinterpret_cast<void*>(g_hostInterfaces->
                get_reserved_mem(PNOR::SectionIdToString(iv_lidPnorInfo.id),0));

            // If nullptr returned, set size to 0 to indicate we could not find
            // the lid in HB resv memory
            if (iv_lidBuffer == nullptr)
            {
                UTIL_FT("UtilLidMgr::loadLid - resv mem section not found");
                iv_lidSize = 0;
            }
            else
            {
                UTIL_FT("UtilLidMgr::loadLid - resv mem section found");
                // If section is secure, adjust size and buffer pointer
                if(iv_lidPnorInfo.secure)
                {
                    UTIL_FT("UtilLidMgr::loadLid - resv mem section is secure");
                    // Build a container header object to parse protected size
                    SECUREBOOT::ContainerHeader l_conHdr(iv_lidBuffer);
                    iv_lidSize = l_conHdr.payloadTextSize();

                    // Increment by page size to not expose secure header
                    iv_lidBuffer = static_cast<uint8_t*>(iv_lidBuffer) +
                                   PAGESIZE;
                }
                else
                {
                    // If no secure header, just use PNOR size
                    iv_lidSize = iv_lidPnorInfo.size;

                    // Need to increment past header if one exists
                    if (iv_lidPnorInfo.sha512Version)
                    {
                        UTIL_FT("UtilLidMgr::loadLid - resv mem section is not secure, but has header");
                        // Increment by page size to not expose sha512 version header
                        iv_lidBuffer = static_cast<uint8_t*>(iv_lidBuffer) +
                                       PAGESIZE;
                        iv_lidSize -= PAGESIZE;
                    }
                }
            }
        }
        else if(iv_isLidInVFS)
        {
            l_errl = VFS::module_address(iv_lidFileName, l_addr, l_size);
            if (l_errl)
            {
                break;
            }
            iv_lidBuffer = const_cast<void*>(reinterpret_cast<const void*>
                    (l_addr));
            iv_lidSize = l_size;
        }
        else if (iv_isLidInPnor)
        {
            iv_lidSize = iv_lidPnorInfo.size;
            iv_lidBuffer = reinterpret_cast<char *>(iv_lidPnorInfo.vaddr);
        }
        else if( g_hostInterfaces->lid_load
                 && iv_spBaseServicesEnabled  )
        {
            int rc = g_hostInterfaces->lid_load(iv_lidId, &iv_lidBuffer,
                    &iv_lidSize);
            if (0 != rc)
            {
                /*@
                 * @errortype       ERRL_SEV_INFORMATIONAL
                 * @moduleid        Util::UTIL_LIDMGR_RT
                 * @reasoncode      Util::UTIL_LIDMGR_RC_FAIL
                 * @userdata1       Return code from lid_load call.
                 * @userdata2       Lid number
                 * @devdesc         Unable to load LID via host interface.
                 */
                l_errl = new ERRORLOG::ErrlEntry(
                    ERRORLOG::ERRL_SEV_INFORMATIONAL,
                    Util::UTIL_LIDMGR_RT,
                    Util::UTIL_LIDMGR_RC_FAIL,
                    rc,
                    iv_lidId,
                    true/*SW Error*/);
                break;
            }
        }

        // Could not find the lid anywhere
        if( iv_lidSize == 0 )
        {
            /*@
             * @errortype       ERRL_SEV_INFORMATIONAL
             * @moduleid        Util::UTIL_LIDMGR_RT
             * @reasoncode      Util::UTIL_LIDMGR_NOT_FOUND
             * @userdata1       Lid number
             * @devdesc         Unable to find Lid.
             */
            l_errl = new ERRORLOG::ErrlEntry(
                                             ERRORLOG::ERRL_SEV_INFORMATIONAL,
                                             Util::UTIL_LIDMGR_RT,
                                             Util::UTIL_LIDMGR_NOT_FOUND,
                                             iv_lidId,
                                             0,
                                             true/*SW Error*/);
            break;
        }
    } while (0);
    return l_errl;
}

errlHndl_t UtilLidMgr::cleanup()
{
    errlHndl_t l_err = nullptr;
    if ((!iv_isLidInVFS) && (!iv_isLidInPnor) && (nullptr != iv_lidBuffer) &&
         !iv_isLidInHbResvMem)
    {
        int l_rc = g_hostInterfaces->lid_unload(iv_lidBuffer);
        if (l_rc)
        {
            /*@
             * @errortype       ERRL_SEV_INFORMATIONAL
             * @moduleid        Util::UTIL_LIDMGR_RT
             * @reasoncode      Util::UTIL_LIDMGR_UNLOAD_RC_FAIL
             * @userdata1       Return code from lid_unload call.
             * @devdesc         Unable to unload LID via host interface.
             */
            l_err = new ERRORLOG::ErrlEntry(
                        ERRORLOG::ERRL_SEV_INFORMATIONAL,
                        Util::UTIL_LIDMGR_RT,
                        Util::UTIL_LIDMGR_UNLOAD_RC_FAIL,
                        l_rc);
        }
    }

    iv_lidBuffer   = nullptr;
    iv_lidSize     = 0;
    iv_isLidInPnor = false;
    iv_isLidInVFS  = false;
    iv_isLidInHbResvMem = false;
    return l_err;
}

void UtilLidMgr::updateLid(uint32_t i_lidId)
{
    iv_lidId = i_lidId;

    // First check if lid is already in hostboot reserved memory
    // In securemode the lid is pre-verified
    if (TARGETING::is_sapphire_load() && lidInHbResvMem(iv_lidId))
    {
        UTIL_FT("UtilLidMgr::updateLid - lid in Hb Resv Mem");
        getLidPnorSectionInfo(iv_lidId, iv_lidPnorInfo);
        iv_isLidInHbResvMem = true;
    }
    // Check if PNOR is access is supported
    else if (!g_hostInterfaces->pnor_read ||
             iv_spBaseServicesEnabled )
    {
        iv_isLidInPnor = false;
    }
    else
    {
        UTIL_FT("UtilLidMgr::updateLid - lid in PNOR");
        // If it's in PNOR it's not technically a lid
        // so use a slightly different extension
        iv_isLidInPnor = getLidPnorSectionInfo(iv_lidId, iv_lidPnorInfo);
    }
    sprintf(iv_lidFileName, "%x.lidbin", iv_lidId);
    iv_isLidInVFS  = VFS::module_exists(iv_lidFileName);
}

const uint32_t * UtilLidMgr::getLidList(size_t * o_num)
{
        static uint32_t lidlist[] =
        {
            Util::OCC_LIDID,
            Util::OCC_CONTAINER_LIDID,
            Util::WOF_LIDID,
            Util::WOF_CONTAINER_LIDID,
            Util::NIMBUS_HCODE_LIDID,
            Util::HWREFIMG_RINGOVD_LIDID,
            Util::HCODE_CONTAINER_LIDID,
            Util::HWREFIMG_RINGOVD_LIDID
        };
        *o_num = sizeof(lidlist)/sizeof(lidlist[0]);
        return lidlist;
}

bool UtilLidMgr::lidInHbResvMem(const uint32_t i_lidId) const
{
    // @TODO CQ:SW400352 Remove this when fsp adds in PNOR support
    // hostboot could not verify it from pnor, so it is not in hb resv meomory
    if (iv_spBaseServicesEnabled &&
        (i_lidId == Util::OCC_LIDID || i_lidId == Util::OCC_CONTAINER_LIDID))
    {
        return false;
    }

    return i_lidId == Util::OCC_LIDID ||
           i_lidId == Util::OCC_CONTAINER_LIDID ||
           i_lidId == Util::WOF_LIDID ||
           i_lidId == Util::WOF_CONTAINER_LIDID ||
           i_lidId == Util::NIMBUS_HCODE_LIDID ||
           i_lidId == Util::CUMULUS_HCODE_LIDID ||
           i_lidId == Util::HCODE_CONTAINER_LIDID ||
           i_lidId == Util::HWREFIMG_RINGOVD_LIDID;
}

//------------------------------------------------------------------------

struct registerLidMgr
{
    registerLidMgr()
    {
        runtimeInterfaces_t * rt_intf = getRuntimeInterfaces();
        rt_intf->get_lid_list = &UtilLidMgr::getLidList;
    }
};

registerLidMgr g_registerLidMgr;