modulelib.c

VXWORKS源代码

/* moduleLib.c - object module management library */
 
/* Copyright 1992-1996 Wind River Systems, Inc. */
#include "copyright_wrs.h"
 
/*
modification history
--------------------
01r,15mar99,c_c  Doc: updated moduleSegAdd () (SPR #6138).
01q,27sep96,pad  reinstated a line I deleted accidentally.
01p,11sep96,pad  strengthened group number handling (SPR #7133).
01o,10oct95,jdi  doc: added .tG Shell to SEE ALSO for moduleShow();
		 changed .pG Cross-Dev to .tG; corrections to moduleCreate().
01n,14mar93,jdi  fixed documentation for moduleDelete().
01m,15feb93,kdl  changed documentation for moduleFlagsGet().
01l,12feb93,jmm  changed documentation for moduleDelete ()
01k,27nov92,jdi  documentation cleanup.
01j,30oct92,jmm  moduleSegInfoGet() now zeros out info structure (spr 1702)
                 moduleFindByName () gets just the name part of moduleName
		     (spr 1718)
01i,14oct92,jdi  made moduleInit() and moduleTerminate() NOMANUAL.
01h,12oct92,jdi  fixed mangen problem in moduleCreateHookDelete().
01g,27aug92,jmm  changed moduleSegInfoGet() to use new MODULE_SEG_INFO struct
                 changed symFlags to flags
		 added moduleNameGet(), moduleFlagsGet()
		 set ctors and dtors to NULL in moduleInit()
01f,31jul92,jmm  cleaned up forward declarations
01e,30jul92,smb  changed format for printf to avoid zero padding.
01d,28jul92,jmm  made NODE_TO_ID macro portable to i960
01c,20jul92,jmm  removed checksum() routine (duplicate of routine in cksumLib.c)
                 removed bzero() of segment id from moduleSegGet()
		 added check for HIDDEN_MODULE flag to moduleDisplayGeneric()
01b,18jul92,smb  Changed errno.h to errnoLib.h.
01a,jmm,01may92  written 
*/
 
/*
DESCRIPTION
This library is a class manager, using the standard VxWorks class/object
facilities.  The library is used to keep track of which object modules
have been loaded into VxWorks, to maintain information about object
module segments associated with each module, and to track which
symbols belong to which module.  Tracking modules makes it possible to
list which modules are currently loaded, and to unload them when
they are no longer needed.

The module object contains the following information:

    - name
    - linked list of segments, including base addresses
      and sizes
    - symbol group number
    - format of the object module (a.out, COFF, ECOFF, etc.)
    - the <symFlag> passed to ld() when the module was
      loaded.  (For more information about <symFlag> and the
      loader, see the manual entry for loadLib.)

Multiple modules with the same name are allowed (the same module may
be loaded without first being unloaded) but "find" functions find the
most recently created module.

The symbol group number is a unique number for each module, used to
identify the module's symbols in the symbol table.  This number is
assigned by moduleLib when a module is created.

In general, users will not access these routines directly, with the
exception of moduleShow(), which displays information about currently
loaded modules.  Most calls to this library will be from routines in
loadLib and unldLib.

INCLUDE FILES: moduleLib.h

SEE ALSO: loadLib,
.tG "Cross-Development"
*/

#include "vxWorks.h"
#include "classLib.h"
#include "dllLib.h"
#include "errnoLib.h"
#include "moduleLib.h"
#include "objLib.h"
#include "pathLib.h"
#include "semLib.h"
#include "stdio.h"
#include "stdlib.h"
#include "stddef.h"
#include "string.h"
#include "vxLib.h"
#include "loadLib.h"

#define NODE_TO_ID(pNode) (pNode != NULL ? (MODULE_ID) ((char *) pNode - \
				         offsetof (MODULE, moduleNode)) : NULL)

typedef struct
    {
    DL_NODE node;
    FUNCPTR func;
    } MODCREATE_HOOK;

/* forward declarations */
 
LOCAL STATUS moduleDestroy (MODULE_ID moduleId, BOOL dealloc);
LOCAL STATUS moduleDisplayGeneric (MODULE_ID moduleId, UINT options);
LOCAL STATUS moduleSegInfoGet (MODULE_ID moduleId,
			       MODULE_SEG_INFO *pModSegInfo);
LOCAL BOOL   moduleCheckSegment (SEGMENT_ID segmentId);
LOCAL BOOL   moduleCheckOne (MODULE_ID moduleId, int options);
LOCAL STATUS moduleInsert (MODULE_ID newModule);


/* LOCALS */

static BOOL	 moduleLibInitialized = FALSE; /* prevent multiple inits */

LOCAL OBJ_CLASS	 moduleClass;

LOCAL DL_LIST 	 moduleCreateHookList;
LOCAL SEM_ID	 moduleCreateHookSem;
LOCAL BOOL 	 moduleCreateHookInitialized 	= FALSE;

LOCAL BOOL  	 moduleLibDebug 		= FALSE;

LOCAL DL_LIST	 moduleList;	/* list of loaded modules */
LOCAL SEM_ID	 moduleListSem;	/* semaphore to protect moduleList */

LOCAL SEM_ID	 moduleSegSem;	/* semaphore to protect all segment lists */

LOCAL FUNCPTR 	 moduleDisplayRtn;

/* GLOBALS */

CLASS_ID moduleClassId = &moduleClass;

/******************************************************************************
*
* moduleLibInit - initialize object module library
* 
* This routine initializes the object module tracking facility.  It
* should be called once from usrRoot().
* 
* RETURNS: OK or ERROR.
* 
* NOMANUAL
*/

STATUS moduleLibInit
    (
    void
    )
    {
    STATUS      returnValue;	/* function return value */

    /*
     * If moduleLibInitialized has been set to TRUE, the library's already
     * initialized.  Return OK.
     */

    if (moduleLibInitialized)
        return (OK);

    /* Initialize the module list and its protecting semaphore */

    moduleListSem = semMCreate (SEM_DELETE_SAFE);
    dllInit (&moduleList);

    /* Initialize the semaphore protecting all segment lists */

    moduleSegSem = semMCreate (SEM_DELETE_SAFE);

    /* Initialize the create hook list */

    moduleCreateHookSem = semMCreate (SEM_DELETE_SAFE);
    dllInit (&moduleCreateHookList);
    moduleCreateHookInitialized = TRUE;

    /*
     * Initialize the display routine function pointer.
     * Currently, this is hard-coded to moduleDisplayGeneric().
     * At some future point, when we need to display other object
     * module formats, this will need to be changed.
     */

    moduleDisplayRtn = moduleDisplayGeneric;

    /* Initialize the module class */

    returnValue = classInit (moduleClassId, sizeof (MODULE),
			     OFFSET (MODULE, objCore),
			     (FUNCPTR) moduleCreate, (FUNCPTR) moduleInit,
			     (FUNCPTR) moduleDestroy);

    /* Library has been initialized, return */

    moduleLibInitialized = TRUE;

    return (returnValue);
    }

/******************************************************************************
*
* moduleCreate - create and initialize a module
* 
* This routine creates an object module descriptor.
* 
* The arguments specify the name of the object module file, 
* the object module format, and an argument specifying which symbols
* to add to the symbol table.  See the loadModuleAt() description of <symFlag>
* for possibles <flags> values.
* 
* Space for the new module is dynamically allocated.
* 
* RETURNS: MODULE_ID, or NULL if there is an error.
*
* SEE ALSO: loadModuleAt()
*/

MODULE_ID moduleCreate
    (
    char *	name,	 /* module name */
    int 	format,	 /* object module format */
    int		flags	 /* <symFlag> as passed to loader (see loadModuleAt()) */
    )
    {
    MODULE_ID	moduleId;

    /* Allocate the object, return NULL if objAlloc() fails */

    moduleId = objAlloc (moduleClassId);

    if (moduleId == NULL)
	{
	printf ("errno %#x\n", errnoGet());
        return (NULL);
	}

    /* Call moduleInit() to do the real work */

    if (moduleInit (moduleId, name, format, flags) != OK)
	{
	objFree (moduleClassId, (char *) moduleId);
        return (NULL);
	}

    return (moduleId);
    }

/******************************************************************************
*
* moduleInit - initialize a module
* 
* This routine initializes an object module descriptor.  Instead of
* dynamically allocating the space for the module descriptor,
* moduleInit() takes a pointer to an existing MODULE structure to initialize.
* The other arguments are identical to the moduleCreate() arguments.
* 
* RETURNS: OK, or ERROR.
*
* NOMANUAL
*/

STATUS moduleInit
    (
    MODULE_ID		moduleId,	/* ptr to module to initialize */
    char *		name,		/* module name */
    int 		format,		/* object module format */
    int			flags		/* symFlags as passed to loader */
    )
    {
    static UINT16 	nextGroupNumber = 1;	/* 1 is VxWorks */
    MODCREATE_HOOK *	createHookNode;
    MODULE_ID		oldModule;		/* ID of previous same module */
    MODULE_ID		lastModule;		/* ID of last module in list */

    /* Split the name into it's name and path components */

    pathSplit (name, moduleId->path, moduleId->name);

    /* see if the module was loaded earlier */

    semTake (moduleListSem, WAIT_FOREVER);

    if ((oldModule = moduleFindByName (moduleId->name)) != NULL)
	{
	/* we found an old module, mark it as obsolete */

	oldModule->flags |= MODULE_REPLACED;
	}

    /*
     * Today, due to a poor/incomplete implementation of the module group
     * concept, only 65534 modules can be loaded in a VxWorks session's life.
     * The group number counter was simply incremented at each load operation.
     * See SPR #7133 for more precisions on the troubles this brought.
     *
     * Reset the next group number counter to the highest value actually
     * available. This is a first step to work around SPR #7133.
     */

    if ((lastModule = NODE_TO_ID (DLL_LAST (&moduleList))) != NULL)
	{
	nextGroupNumber = lastModule->group;
	nextGroupNumber++;
	}
	
    /* Set the module's group number */

    if (nextGroupNumber < MODULE_GROUP_MAX)
	{
        moduleId->group = nextGroupNumber++;

	/* Add the module to the end of the module list */

	dllAdd (&moduleList, &moduleId->moduleNode);
	}
    else
	{
	/*
	 * When all group slots are apparently used, we must walk through the
	 * module list and try to find a free group number due to previous
	 * unloadings. This is the second step to work around SPR #7133.
	 */

	if (moduleInsert (moduleId) != OK)
	    {
            printf ("No free group number. Abort load operation.\n");
	    errnoSet (S_moduleLib_MAX_MODULES_LOADED);
            return (ERROR);
	    }
	}

    semGive (moduleListSem);
    
    /* Set the module format and flags */

    moduleId->flags = flags;
    moduleId->format = format;

    moduleId->ctors = NULL;
    moduleId->dtors = NULL;

    /* Initialize the segment list */

    if (dllInit (&moduleId->segmentList) != OK)
	return (ERROR);
    
    /* Initialize the object stuff */

    objCoreInit (&moduleId->objCore, moduleClassId);

    /* Call any moduleCreateHook routines */

    semTake (moduleCreateHookSem, WAIT_FOREVER);

    for (createHookNode = (MODCREATE_HOOK *) DLL_FIRST (&moduleCreateHookList);
	 createHookNode != NULL;
	 createHookNode = (MODCREATE_HOOK *) DLL_NEXT ((DL_NODE *)
						       createHookNode))
	{
	(* createHookNode->func) (moduleId);
	}

    semGive (moduleCreateHookSem);
    
    /* If debugging is on, print out the name of the module. */

    if (moduleLibDebug)
        printf ("Module %s, group %d added\n", moduleId->name, moduleId->group);

    return (OK);
    }

/******************************************************************************
*
* moduleInsert - insert the module in list when possible
*
* This routine walks the module list in order to find a hole in the group
* numbering. As soon as a free group number is found, the new module is
* inserted in the list and is given the available group number.  
*
* This routine should be called only when all the group numbers have been
* allocated (i.e. when the group number counter reaches its maximum).
*
* WARNING: the module list semaphore must be taken by the caller.
*
* RETURNS: OK or ERROR if the module could not be inserted.
*/

LOCAL STATUS moduleInsert
    (
    MODULE_ID 	newModule		/* module to insert */
    )
    {
    MODULE_ID 	currentModule;		/* module pointer */
    MODULE_ID 	nextModule;		/* module pointer */

    /* Go through the module list and try to insert the new module */

    for (currentModule = NODE_TO_ID (DLL_FIRST (&moduleList));
	 currentModule != NULL;
	 currentModule = NODE_TO_ID (DLL_NEXT (&currentModule->moduleNode)))
	{
	nextModule = NODE_TO_ID (DLL_NEXT (&currentModule->moduleNode));

	/* Check if we reached the end of the list: this means no room left */

	if (nextModule == NULL)
	    break;

	/* Insert the new module when there is a whole in the group numbers */

	if (nextModule->group > (currentModule->group + 1))
	    {
	    dllInsert (&moduleList, &currentModule->moduleNode,
		       &newModule->moduleNode);
	    newModule->group = currentModule->group + 1;
	    break;
	    }
	}

    if (nextModule == NULL)
	return (ERROR);
    else
	return (OK);
    }

/******************************************************************************
*
* moduleTerminate - terminate a module
* 
* This routine terminates a static object module descriptor that was
* initialized with moduleInit().
* 
* RETURNS: OK or ERROR.
* 
* NOMANUAL
*/

STATUS moduleTerminate
    (
    MODULE_ID moduleId		/* module to terminate */
    )
    {
    return (moduleDestroy (moduleId, FALSE));
    }

/******************************************************************************
*
* moduleDelete - delete module ID information (use unld() to reclaim space)
* 
* This routine deletes a module descriptor, freeing any space that was
* allocated for the use of the module ID.
*
* This routine does not free space allocated for the object module itself --
* this is done by unld().
* 
* RETURNS: OK or ERROR.
*/

STATUS moduleDelete
    (
    MODULE_ID moduleId		/* module to delete */
    )
    {
    return (moduleDestroy (moduleId, TRUE));
    }

/******************************************************************************
*
* moduleDestroy - destroy module
*
* This is the underlying routine for moduleDelete() and moduleTerminate().
* 
* RETURNS: OK or ERROR.
* 
* NOMANUAL
*/

LOCAL STATUS moduleDestroy
    (
    MODULE_ID 	moduleId,	/* module to destroy */
    BOOL      	dealloc		/* deallocate memory associated with module */
    )
    {
    SEGMENT_ID	pSegment;	/* temp. storage for deleting segments */

    /* Make sure moduleId is a real object of class moduleClassId */

    if (OBJ_VERIFY (moduleId, moduleClassId) != OK)  /* validate module id */
	{
	return (ERROR);
	}

    objCoreTerminate (&moduleId->objCore);	/* INVALIDATE */

    /* Remove the module from the module list */

    semTake (moduleListSem, WAIT_FOREVER);
    dllRemove (&moduleList, &moduleId->moduleNode);
    semGive (moduleListSem);

    /* Remove any segment records associated with the module. */

    while ((pSegment = moduleSegGet (moduleId)) != NULL)
        free (pSegment);

    /* Deallocate the module id object itself */

    if (dealloc)