source: trunk/kLdr/kLdrDyld.c@ 2836

/* $Id: kLdrDyld.c 2836 2006-10-26 03:58:53Z bird $ */
/** @file
 *
 * kLdr - The Dynamic Loader.
 *
 * Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
 *
 *
 * This file is part of kLdr.
 *
 * kLdr 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; either version 2 of the License, or
 * (at your option) any later version.
 *
 * kLdr 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 kLdr; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


/*******************************************************************************
*   Header Files                                                               *
*******************************************************************************/
#include <kLdr.h>
#include "kLdrHlp.h"
#include "kLdrInternal.h"


/*******************************************************************************
*   Defined Constants And Macros                                               *
*******************************************************************************/
/** @def KLDRDYLD_STRICT
 * Define KLDRDYLD_STRICT to enabled strict checks in kLdrDyld. */
#define KLDRDYLD_STRICT 1

/** @def KLDRDYLD_ASSERT
 * Assert that an expression is true when KLDRDYLD_STRICT is defined.
 */
#ifdef KLDRDYLD_STRICT
# define KLDRDYLD_ASSERT(expr)  kldrHlpAssert(expr)
#else
# define KLDRDYLD_ASSERT(expr)  do {} while (0)
#endif


/*******************************************************************************
*   Global Variables                                                           *
*******************************************************************************/
/** Pointer to the head module (the executable).
 * (This is exported, so no prefix.) */
PKLDRDYLDMOD    kLdrDyldHead = NULL;
/** Pointer to the tail module.
 * (This is exported, so no prefix.) */
PKLDRDYLDMOD    kLdrDyldTail = NULL;
/** Pointer to the head module of the termination order list. */
PKLDRDYLDMOD    g_pkLdrDyldTermHead;
/** Pointer to the tail module of the termination order list. */
PKLDRDYLDMOD    g_pkLdrDyldTermTail;
/** Pointer to the head module of the bind order list.
 * The modules in this list makes up the global namespace used when binding symbol unix fashion. */
PKLDRDYLDMOD    g_pkLdrDyldBindHead;
/** Pointer to the tail module of the bind order list. */
PKLDRDYLDMOD    g_pkLdrDyldBindTail;

/** Stack of modules involved in the active loads.
 *
 * The main purpose is to allow module init routines to loading and unloading
 * modules without upsetting the init order and to assist in dereferencing
 * modules on load failure.
 *
 * Each call to kLdrDyldLoad and kLdrDyldLoadExe will start a load frame
 * when doing a fresh load. All dependant modules will be pushed on each
 * reference. The frame is completed when all the dependant modules has
 * been resolved (or a failure occurs). After doing fixups, the frame is
 * used to do module initialization. Should an error occur during the load
 * the frame will be used to dereference all the modules involved in the
 * load operation (it will not however, be used for termination calls as
 * they are postponed till the last load operation completes).
 *
 * Should any of the init calls load a module, a new frame will be created
 * for that operation and processed before the init call returns to the
 * previous frame.
 */
PPKLDRDYLDMOD   g_pakLdrDyld;
/** The number of used entries in the g_pakLdrDyld array. */
uint32_t        g_ckLdrDyld;
/** The number of entries allocated for the g_pakLdrDyld array. */
uint32_t        g_ckLdrDyldAllocated;

/** The global error buffer. */
char            g_szkLdrDyldError[1024];

/** The Library search path. */
char            kLdrDyldLibraryPath[4096];
/** The executable flags. */
uint32_t        kLdrDyldFlags;


/*******************************************************************************
*   Internal Functions                                                         *
*******************************************************************************/
static int kldrDyldDoLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
                          unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr);
static int kldrDyldDoUnload(PKLDRDYLDMOD pMod);
static int kldrDyldDoFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
                              unsigned fFlags, PPKLDRDYLDMOD ppMod);
static int kldrDyldDoFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment);
static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName);
static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename);
static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind);
static void kldrDyldStartLoading(void);
static void kldrDyldStopLoading(void);
static int kldrDyldCopyError(int rc, char *pszErr, size_t cchErr);



/**
 * Initialize the dynamic loader.
 */
int kldrDyInit(void)
{
    kLdrDyldHead = kLdrDyldTail = NULL;
    g_pkLdrDyldTermHead = g_pkLdrDyldTermTail = NULL;
    g_pkLdrDyldBindHead = g_pkLdrDyldBindTail = NULL;
    kLdrDyldFlags = 0;
    g_szkLdrDyldError[0] = '\0';
    return 0;
}


/**
 * Terminate the dynamic loader.
 */
void kldrDyTerm(void)
{

}


/**
 * Loads a module into the current process.
 *
 * @returns 0 on success, non-zero native OS status code or kLdr status code on failure.
 * @param   pszDll          The name of the dll to open.
 * @param   pszDefPrefix    Prefix to use when searching.
 * @param   pszDefSuffix    Suffix to use when searching.
 * @param   enmSearch       Method to use when locating the module and any modules it may depend on.
 * @param   fFlags          Flags, a combintation of the KLDRYDLD_LOAD_FLAGS_* \#defines.
 * @param   phMod           Where to store the handle to the loaded module.
 * @param   pszErr          Where to store extended error information. (optional)
 * @param   cchErr          The size of the buffer pointed to by pszErr.
 */
int     kLdrDyldLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
                     unsigned fFlags, PHKLDRMOD phMod, char *pszErr, size_t cchErr)
{
    int rc;

    /* validate arguments and initialize return values. */
    if (pszErr && cchErr)
        *pszErr = '\0';
    *phMod = NIL_HKLDRMOD;
    KLDRHLP_VALIDATE_STRING(pszDll);
    KLDRHLP_VALIDATE_OPTIONAL_STRING(pszDefPrefix);
    KLDRHLP_VALIDATE_OPTIONAL_STRING(pszDefSuffix);
    KLDRHLP_VALIDATE_ENUM(enmSearch, KLDRDYLD_SEARCH);
    KLDRHLP_VALIDATE_OPTIONAL_BUFFER(pszErr, cchErr);

    /* get the semaphore and do the job. */
    rc = kldrHlpSemRequest();
    if (!rc)
    {
        PKLDRDYLDMOD pMod = NULL;
        rc = kldrDyldDoLoad(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, phMod, pszErr, cchErr);
        kldrHlpSemRelease();
        *phMod = pMod;
    }
    return rc;
}


/**
 * Unloads a module loaded by kLdrDyldLoad.
 *
 * @returns 0 on success, non-zero native OS status code or kLdr status code on failure.
 * @param   hMod            Module handle.
 */
int     kLdrDyldUnload(HKLDRMOD hMod)
{
    int rc;

    /* validate */
    KLDRDYLD_VALIDATE_HKLDRMOD(hMod);

    /* get sem & do work */
    rc = kldrHlpSemRequest();
    if (!rc)
    {
        rc = kldrDyldDoUnload(hMod);
        kldrHlpSemRelease();
    }
    return rc;
}


/**
 * Finds a module by name or filename.
 *
 * This call does not increase any reference counters and must not be
 * paired with kLdrDyldUnload() like kLdrDyldLoad().
 *
 * @returns 0 on success.
 * @returns KLDR_ERR_MODULE_NOT_FOUND on failure.
 * @param   pszDll          The name of the dll to look for.
 * @param   pszDefPrefix    Prefix than can be used when searching.
 * @param   pszDefSuffix    Suffix than can be used when searching.
 * @param   enmSearch       Method to use when locating the module.
 * @param   fFlags          Flags, a combintation of the KLDRYDLD_LOAD_FLAGS_* \#defines.
 * @param   phMod           Where to store the handle of the module on success.
 */
int     kLdrDyldFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
                           unsigned fFlags, PHKLDRMOD phMod)
{
    int rc;

    /* validate & initialize */
    *phMod = NIL_HKLDRMOD;
    KLDRHLP_VALIDATE_STRING(pszDll);

    /* get sem & do work */
    rc = kldrHlpSemRequest();
    if (!rc)
    {
        PKLDRDYLDMOD pMod = NULL;
        rc = kldrDyldDoFindByName(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, phMod);
        kldrHlpSemRelease();
        *phMod = pMod;
    }
    return rc;
}


/**
 * Finds a module by address.
 *
 * This call does not increase any reference counters and must not be
 * paired with kLdrDyldUnload() like kLdrDyldLoad().
 *
 * @returns 0 on success.
 * @returns KLDR_ERR_MODULE_NOT_FOUND on failure.
 * @param   Address         The address believed to be within some module.
 * @param   phMod           Where to store the module handle on success.
 * @param   piSegment       Where to store the segment number. (optional)
 * @param   poffSegment     Where to store the offset into the segment. (optional)
 */
int     kLdrDyldFindByAddress(uintptr_t Address, PHKLDRMOD phMod, uint32_t *piSegment, uintptr_t *poffSegment)
{
    int rc;

    /* validate & initialize */
    *phMod = NIL_HKLDRMOD;
    if (piSegment)
        *piSegment = ~(uint32_t)0;
    if (poffSegment)
        *poffSegment = ~(uintptr_t)0;

    /* get sem & do work */
    rc = kldrHlpSemRequest();
    if (!rc)
    {
        PKLDRDYLDMOD pMod = NULL;
        rc = kldrDyldDoFindByAddress(Address, &pMod, piSegment, poffSegment);
        kldrHlpSemRelease();
        *phMod = pMod;
    }
    return rc;
}


/**
 * Gets the module name.
 *
 * @returns 0 on success and pszName filled with the name.
 * @returns KLDR_ERR_INVALID_HANDLE or KLDR_ERR_BUFFER_OVERFLOW on failure.
 * @param   hMod        The module handle.
 * @param   pszName     Where to put the name.
 * @param   cchName     The size of the name buffer.
 * @see kLdrDyldGetFilename
 */
int     kLdrDyldGetName(HKLDRMOD hMod, char *pszName, size_t cchName)
{
    int rc;

    /* validate */
    if (pszName && cchName)
        *pszName = '\0';
    KLDRDYLD_VALIDATE_HKLDRMOD(hMod);
    KLDRHLP_VALIDATE_BUFFER(pszName, cchName);

    /* get sem & do work */
    rc = kldrHlpSemRequest();
    if (!rc)
    {
        rc = kldrDyldDoGetName(hMod, pszName, cchName);
        kldrHlpSemRelease();
    }
    return rc;
}


/**
 * Gets the module filename.
 *
 * @returns 0 on success and pszFilename filled with the name.
 * @returns KLDR_ERR_INVALID_HANDLE or KLDR_ERR_BUFFER_OVERFLOW on failure.
 * @param   hMod            The module handle.
 * @param   pszFilename     Where to put the filename.
 * @param   cchFilename     The size of the filename buffer.
 * @see kLdrDyldGetName
 */
int     kLdrDyldGetFilename(HKLDRMOD hMod, char *pszFilename, size_t cchFilename)
{
    int rc;

    /* validate & initialize */
    if  (pszFilename && cchFilename);
        *pszFilename = '\0';
    KLDRDYLD_VALIDATE_HKLDRMOD(hMod);
    KLDRHLP_VALIDATE_BUFFER(pszFilename, cchFilename);

    /* get sem & do work */
    rc = kldrHlpSemRequest();
    if (!rc)
    {
        rc = kldrDyldDoGetFilename(hMod, pszFilename, cchFilename);
        kldrHlpSemRelease();
    }
    return rc;
}


/**
 * Queries the value and type of a symbol.
 *
 * @returns 0 on success and pValue and pfKind set.
 * @returns KLDR_ERR_INVALID_HANDLE or KLDR_ERR_SYMBOL_NOT_FOUND on failure.
 * @param   hMod            The module handle.
 * @param   uSymbolOrdinal  The symbol ordinal. This is ignored if pszSymbolName is non-zero.
 * @param   pszSymbolName   The symbol name.
 * @param   pValue          Where to put the symbol value. Optional if pfKind is non-zero.
 * @param   pfKind          Where to put the symbol kind flags. Optional if pValue is non-zero.
 */
int     kLdrDyldQuerySymbol(HKLDRMOD hMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind)
{
    int rc;

    /* validate & initialize */
    if (pfKind)
        *pfKind = 0;
    if (pValue)
        *pValue = 0;
    if (!pfKind && !pValue)
        return KLDR_ERR_INVALID_PARAMETER;
    KLDRDYLD_VALIDATE_HKLDRMOD(hMod);
    KLDRHLP_VALIDATE_OPTIONAL_STRING(pszSymbolName);

    /* get sem & do work */
    rc = kldrHlpSemRequest();
    if (!rc)
    {
        rc = kldrDyldDoQuerySymbol(hMod, uSymbolOrdinal, pszSymbolName, pValue, pfKind);
        kldrHlpSemRelease();
    }
    return rc;
}





/**
 * Worker for kLdrDyldLoad().
 * @internal
 */
static int kldrDyldDoLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
                          unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr)
{
    int rc;

    /*
     * Try find it among the modules that's already loaded.
     */
    rc = kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
    if (!rc)
    {
        /*
         * If we're in a module termination call we must check that all the modules we
         * depend on are loaded and initialized.
         */
//continue here        if ((*ppMod)->enmState::KLDRSTATE_LOADED)
        {
            kldrHlpAssert(!"implement me");
        }
        return kldrDyldModDynamicLoad(*ppMod);
    }

    /*
     * Try open it.
     */
    kldrDyldStartLoading();
    rc = kldrDyldFindNewModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
    if (!rc)
    {


    }
    return kldrDyldCopyError(rc, pszErr, cchErr);
}


/**
 * Worker for kLdrDyldUnload().
 * @internal
 */
static int kldrDyldDoUnload(PKLDRDYLDMOD pMod)
{
    return kldrDyldModDynamicUnload(pMod);
}


/**
 * Worker for kLdrDyldFindByName().
 * @internal
 */
static int kldrDyldDoFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
                                unsigned fFlags, PPKLDRDYLDMOD ppMod)
{
    return kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
}


/**
 * Worker for kLdrDyldFindByAddress().
 * @internal
 */
static int kldrDyldDoFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment)
{
    /* Scan the segments of each module in the load list. */
    PKLDRDYLDMOD pMod = kLdrDyldHead;
    while (pMod)
    {
        uint32_t iSeg;
        for (iSeg = 0; iSeg < pMod->pMod->cSegments; iSeg++)
        {
            uintmax_t off = (uintmax_t)Address - pMod->pMod->aSegments[iSeg].LoadAddress;
            if (off < pMod->pMod->aSegments[iSeg].cb)
            {
                *ppMod = pMod->hMod;
                if (piSegment)
                    *piSegment = iSeg;
                if (poffSegment)
                    *poffSegment = (uintptr_t)off;
                return 0;
            }
        }

        /* next */
        pMod = pMod->Load.pNext;
    }

    return KLDR_ERR_MODULE_NOT_FOUND;
}


/**
 * Worker for kLdrDyldGetName().
 * @internal
 */
static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName)
{
    return kldrDyldModGetName(pMod, pszName, cchName);
}


/**
 * Worker for kLdrDyldGetFilename().
 * @internal
 */
static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename)
{
    return kldrDyldModGetFilename(pMod, pszFilename, cchFilename);
}


/**
 * Worker for kLdrDyldQuerySymbol().
 * @internal
 */
static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind)
{
    return kldrDyldModQuerySymbol(pMod, uSymbolOrdinal, pszSymbolName, pValue, pfKind);
}


#if 0
void kldrLoadExe(PKLDREXEARGS pArgs)
{
    /*
     * Copy the arguments into the globals and do load init.
     */
    kLdrFlags = pArgs->fFlags;
    kLdrHlpMemCopy(kLdrLibraryPath, pArgs->szLibPath, KLDR_MIN(sizeof(pArgs->szLibPath), sizeof(kLdrLibraryPath)));
    int rc = kldrInit();
    if (rc)
        kldrFailure(rc, "kLdr: Init failure, rc=%d\n", rc);

    /*
     * Open the executable module.
     */
    PKLDRMOD pExe;
    kldrOpenExe(pArgs->szExecutable, &pExe);

    /* Map the segments. */
    kldrModMapSegments(pExe);

    /*
     * This is the point where we switch to the executable
     * stack, allocating it if necessary.
     */
    void *pvBottom;
    kldrModSetupStack(pExe, &pvBottom);
    kldrLoadExecSwitchStack(pvBottom);
}


void kldrLoadExeOnNewStack(void)
{
    /*
     * Load all dependant modules.
     */
    PKLDRMOD pCur;
    do  for (pCur = kLdrModuleHead; pCur; pCur = pCur->pNext)
        {
            if (pCur->enmState >= KLDRSTATE_DEPS)
                continue;
            kldrModLoadDeps(pCur);
        }
    while (pCur);

    /*
     * Do fixups (FIFO).
     */
    for (pCur = kLdrModuleHead; pCur; pCur = pCur->pNext)
    {
        if (pCur->enmState >= KLDRSTATE_FIXED)
            continue;
        kldrModFixup(pCur, 0);
    }

    /*
     * Do module initialization.
     */
    for (pCur = kLdrModuleTail; pCur != kLdrModuleTail; pCur = pCur->pPrev)
    {
        if (pCur->enmState >= KLDRSTATE_INITED)
            continue;
        kldrModCallInit(pCur);
    }

    /*
     * Get the executable start address and commit the work that's been done.
     */
    void *pvEntry;
    kldrModGetExeEntry(&pvEntry);

    for (pCur = kLdrModuleHead; pCur; pCur = pCur->pNext)
        if (pCur->enmState == KLDRSTATE_INITED)
            pCur->enmState = KLDRSTATE_LOADED;

    kldrHlpSemRelease();

    /*
     * We're now ready for starting the executable code.
     */
    kldrOSStartExe(pLdrModuleHead, pvEntry);
}

#endif

/**
 * Starts loading a new module and its dependencies.
 */
static void kldrDyldStartLoading(void)
{
#ifdef KLDRDYLD_STRICT
    /* check that all modules are in the correct state */
    PKLDRDYLDMOD pMod = kLdrDyldHead;
    while (pMod)
    {
        //KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_LOADED);

        /* next */
        pMod = pMod->Load.pNext;
    }
#endif
}


/**
 * Records the loading of the module.
 *
 * @return 0 on success, KLDR_ERR_NO_MEMORY if we can't expand the table.
 * @param   pMod        The module to record.
 */
static int kldrDyldRecord(PKLDRDYLDMOD pMod)
{

}



/**
 * Done loading a module and its dependencies.
 *
 * If the load failed, unload all the modules involved.
 * If the load succeeded,
 *
 * @returns rc.
 * @param   rc  The status code.
 */
static void kldrDyldDoneLoading(int rc)
{

}



/**
 * Panic / failure
 *
 * @returns rc if we're in a position where we can return.
 * @param   rc              Return code.
 * @param   pszFormat       Message string. Limited fprintf like formatted.
 * @param   ...             Message string arguments.
 */
int kldrFailure(int rc, const char *pszFormat, ...)
{
    kldrHlpExit(1);
    return rc;
}


/**
 * Copies the error string to the user buffer.
 *
 * @returns rc.
 * @param   rc      The status code.
 * @param   pszErr  Where to copy the error string to.
 * @param   cchErr  The size of the destination buffer.
 */
static int kldrDyldCopyError(int rc, char *pszErr, size_t cchErr)
{
    size_t cchToCopy;

    /* if no error string, format the rc into a string. */
    if (!g_szkLdrDyldError[0] && rc)
        kldrHlpInt2Ascii(g_szkLdrDyldError, sizeof(g_szkLdrDyldError), rc, 10);

    /* copy it if we got something. */
    if (cchErr && pszErr && g_szkLdrDyldError[0])
    {
        cchToCopy = kLdrHlpStrLen(g_szkLdrDyldError);
        if (cchToCopy >= cchErr)
            cchToCopy = cchErr - 1;
        kLdrHlpMemCopy(pszErr, g_szkLdrDyldError, cchToCopy);
        pszErr[cchToCopy] = '\0';
    }

    return rc;
}