source: trunk/kLdr/kLdrInternal.h@ 2836

/* $Id: kLdrInternal.h 2836 2006-10-26 03:58:53Z bird $ */
/** @file
 *
 * kLdr - The Dynamic Loader, internal header.
 *
 * Copyright (c) 2006 knut st. osmundsen <bird-kbuild-src@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
 *
 */


#ifndef __kLdrInternal_h__
#define __kLdrInternal_h__

#ifdef __cplusplus
extern "C" {
#endif

/* ignore definitions in winnt.h */
#undef IMAGE_DOS_SIGNATURE
#undef IMAGE_NT_SIGNATURE

/** @name Signatures we know
 * @{ */
/** ELF signature ("\x7fELF"). */
#define IMAGE_ELF_SIGNATURE KLDRHLP_LE2H_U32(0x7f | ('E' << 8) | ((uint32_t)'L' << 16) | ((uint32_t)'F' << 24))
/** PE signature ("PE\0\0"). */
#define IMAGE_NT_SIGNATURE  KLDRHLP_LE2H_U32('P' | ('E' << 8))
/** LX signature ("LX") */
#define IMAGE_LX_SIGNATURE  KLDRHLP_LE2H_U16('L' | ('X' << 8))
/** LE signature ("LE") */
#define IMAGE_LE_SIGNATURE  KLDRHLP_LE2H_U16('L' | ('E' << 8))
/** NE signature ("NE") */
#define IMAGE_NE_SIGNATURE  KLDRHLP_LE2H_U16('N' | ('E' << 8))
/** MZ signature ("MZ"). */
#define IMAGE_DOS_SIGNATURE KLDRHLP_LE2H_U16('M' | ('Z' << 8))
/** @} */

/** @defgroup grp_kLdrInternal  Internals
 * @internal
 * @{
 */


/** Native file provider operations. */
extern const KLDRRDROPS g_kLdrRdrFileOps;


/**
 * The state of a dynamic loader module.
 */
typedef enum KLDRSTATE
{
    /** The usual invalid 0 enum. */
    KLDRSTATE_INVALID = 0,
    /** The module has just been opened and has no references.
     * Prev state: -
     * Next state: MAPPED, DESTROYED
     */
    KLDRSTATE_OPEN,
    /** The module been mapped.
     * Prev state: OPEN
     * Next state: LOADED_DEPS, DESTROYED
     */
    KLDRSTATE_MAPPED,
    /** The immediate dependencies has been loaded.
     * Prev state: MAPPED
     * Next state: FIXED_UP, DESTROYED
     */
    KLDRSTATE_LOADED_DEPS,
    /** Fixups has been applied.
     * Prev state: LOADED_DEPS
     * Next state: PENDING_INIT, DESTROYED
     */
    KLDRSTATE_FIXED_UP,
    /** Pending initialization.
     * (The loader can now be in a re-entrant mode.)
     * Prev state: FIXED_UP
     * Next state: PENDING_INITIALIZATION, PENDING_GC
     */
    KLDRSTATE_PENDING_INITIALIZATION,
    /** Initializing.
     * (The loader is now in a re-entrant mode.)
     * Prev state: PENDING_INITIALIZATION
     * Next state: GOOD, PENDING_GC
     */
    KLDRSTATE_INITIALIZING,
    /** The module has been successfully loaded and initialized.
     * (The loader can still be in a re-entrant mode.)
     * Prev state: INITIALIZING
     * Next state: PENDING_TERMINATION
     * Re-entrant.
     */
    KLDRSTATE_GOOD,
    /** Pending termination, reference count is 0.
     * (The loader can now be in a re-entrant mode.)
     * Prev state: GOOD
     * Next state: TERMINATING, GOOD
     */
    KLDRSTATE_PENDING_TERMINATION,
    /** Terminating, reference count is still 0.
     * (The loader is now in a re-entrant mode, but loading is a bit restricted.)
     * Prev state: PENDING_TERMINATION
     * Next state: PENDING_GC
     */
    KLDRSTATE_TERMINATING,
    /** Pending garbage collection.
     * (The loader can still be in a re-entrant mode.)
     * Prev state: TERMINATING, INITIALIZING, PENDING_INITIALIZATION
     * Next state: GC, RELOADING
     */
    KLDRSTATE_PENDING_GC,
    /** Being garbage collected.
     * (The loader can still be in a re-entrant mode.)
     * Prev state: PENDING_GC
     * Next state: DESTROYED
     */
    KLDRSTATE_GC,
    /** The module is being reloaded after having been scheduled for termination or/and GC.
     * (The loader can still be in a re-entrant mode.)
     * Prev state: PENDING_GC
     * Next state: PENDING_INITIALIZATION
     */
    KLDRSTATE_RELOADING,
    /** The module has been destroyed and is no longer valid.
     * Prev state: GC
     */
    KLDRSTATE_DESTROYED,
    /** The end of valid states (exclusive) */
    KLDRSTATE_END = KLDRSTATE_DESTROYED,
    /** The usual 32-bit blowup. */
    KLDRSTATE_32BIT_HACK = 0x7fffffff
} KLDRSTATE;


/**
 * Dynamic loader module.
 */
typedef struct KLDRDYLDMOD
{
    /** Magic number. */
    uint32_t            u32MagicHead;
    /** The module state. */
    KLDRSTATE           enmState;
    /** The module. */
    PKLDRMOD            pMod;
    /** The module handle. */
    HKLDRMOD            hMod;
    /** The number of references. */
    uint32_t            cRefs;
    /** The number of dynamic references. */
    uint32_t            cDynRefs;
    /** The number of dynamic load operations in progress.
     * This is used to reject anyone trying to unload a module before the load has
     * been completed. An alternative to this would be to not add the cDynRefs until
     * the load operation has completed... */
    uint32_t            cDynRefsInProgress;
    /** Set if this is the executable module.
     * When clear, the module is a shared object or relocatable object. */
    uint32_t            fExecutable : 1;
    /** Global DLL (set) or specific DLL (clear). */
    uint32_t            fGlobalOrSpecific : 1;
    /** Whether the module contains bindable symbols in the global unix namespace. */
    uint32_t            fBindable : 1;
    /** Reserved for future use. */
    uint32_t            fReserved : 29;
    /** The load list linkage. */
    struct
    {
        /** The next module in the list. */
        struct KLDRDYLDMOD *pNext;
        /** The prev module in the list. */
        struct KLDRDYLDMOD *pPrev;
    } Load;
    /** The termination list linkage. */
    struct
    {
        /** The next module in the list. */
        struct KLDRDYLDMOD *pNext;
        /** The prev module in the list. */
        struct KLDRDYLDMOD *pPrev;
    } Term;
    /** The bind order list linkage.
     * The module is not in this list when fBindable is clear. */
    struct
    {
        /** The next module in the list. */
        struct KLDRDYLDMOD *pNext;
        /** The prev module in the list. */
        struct KLDRDYLDMOD *pPrev;
    } Bind;
    /** Magic number. */
    uint32_t            u32MagicTail;
} KLDRDYLDMOD, *PKLDRDYLDMOD, **PPKLDRDYLDMOD;

/** KLDRDYLDMOD magic value. (Fuyumi Soryo) */
#define KLDRDYMOD_MAGIC     0x19590106

/** Return / crash validation of a module handle argument. */
#define KLDRDYLD_VALIDATE_HKLDRMOD(hMod) \
    do  { \
        if (    (hMod) == NIL_HKLDRMOD \
            ||  (hMod)->u32MagicHead != KLDRDYMOD_MAGIC \
            ||  (hMod)->u32MagicTail != KLDRDYMOD_MAGIC) \
        { \
            return KLDR_ERR_INVALID_HANDLE; \
        } \
    } while (0)


int kldrDyldFindNewModule(const char *pszName, const char *pszDefPrefix, const char *pszDefSuffix,
                          KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRDYLDMOD ppMod);
int kldrDyldFindExistingModule(const char *pszName, const char *pszDefPrefix, const char *pszDefSuffix,
                               KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRDYLDMOD ppMod);


int kldrDyldModCreate(PKLDRRDR pRdr, PPKLDRDYLDMOD ppMod);
int kldrDyldModDestroy(PKLDRDYLDMOD pMod);
int kldrDyldModAddDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pModDep);
int kldrDyldModRemoveDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pModDep);
int kldrDyldModDynamicLoad(PKLDRDYLDMOD pMod);
int kldrDyldModDynamicUnload(PKLDRDYLDMOD pMod);
int kldrDyldModMarkGlobal(PKLDRDYLDMOD pMod);
int kldrDyldModMarkSpecific(PKLDRDYLDMOD pMod);
int kldrDyldModSetBindable(PKLDRDYLDMOD pMod);
int kldrDyldModClearBindable(PKLDRDYLDMOD pMod);
int kldrDyldModSetDeepBindable(PKLDRDYLDMOD pMod);
int kldrDyldModClearDeepBindable(PKLDRDYLDMOD pMod);
int kldrDyldModMap(PKLDRDYLDMOD pMod);
int kldrDyldModUnmap(PKLDRDYLDMOD pMod);
int kldrDyldModLoadDependencies(PKLDRDYLDMOD pMod);
int kldrDyldModFixup(PKLDRDYLDMOD pMod);
int kldrDyldModCallInit(PKLDRDYLDMOD pMod);
int kldrDyldModCallTerm(PKLDRDYLDMOD pMod);
int kldrDyldModAttachThread(PKLDRDYLDMOD pMod);
int kldrDyldModDetachThread(PKLDRDYLDMOD pMod);
int kldrDyldModGetStackInfo(PKLDRDYLDMOD pMod, void *pvStack, size_t *pcbStack, size_t);
int kldrDyldModStartExe(PKLDRDYLDMOD pMod);

int kldrDyldModGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName);
int kldrDyldModGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename);
int kldrDyldModQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind);


void kldrDyldFailure(const char *pszFilename, ...);


/** Pointer to the head module of the load list (the executable). */
extern PKLDRDYLDMOD     kLdrDyldModuleHead;
/** Pointer to the tail module of the load list. */
extern PKLDRDYLDMOD     kLdrDyldModuleTail;
/** Pointer to the head module of the termination order list. */
extern PKLDRDYLDMOD     g_pkLdrDyldTermHead;
/** Pointer to the tail module of the termination order list. */
extern 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. */
extern PKLDRDYLDMOD     g_pkLdrDyldBindHead;
/** Pointer to the tail module of the bind order list. */
extern PKLDRDYLDMOD     g_pkLdrDyldBindTail;

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

/** The Library search path. */
extern char             kLdrDyldLibraryPath[4096];


/** @} */
#ifdef __cplusplus
}
#endif

#endif