modulelib.c

VXWORKS源代码

	if (objFree (moduleClassId, (char *) moduleId) != OK)
	    return (ERROR);

    return (OK);
    }

/******************************************************************************
*
* moduleIdFigure - translate a module name or ID to a module ID
*
* Some routines take either a module ID (an integer) or a module name.  This
* routine determines whether the parameter is a module name or a module ID and
* returns the module ID. 
*
* RETURNS: A module ID (type MODULE_ID), or NULL.
*
* NOMANUAL
*/

MODULE_ID moduleIdFigure
    (
    void * 	moduleNameOrId	/* module name or module ID */
    )
    {
    MODULE_ID 	moduleId = NULL;	/* default is NULL */

    /*
     * Make sure we're not getting a NULL pointer, OBJ_VERIFY doesn't check
     * for that.
     */

    if (moduleNameOrId == NULL)
        return (NULL);
    
    /* If moduleNameOrId is a moduleId, just return it. */
    
    if (OBJ_VERIFY (moduleNameOrId, moduleClassId) == OK)
	{
	return ((MODULE_ID) moduleNameOrId);
	}
    
    /*
     * moduleNameOrId isn't a legitmate object - see if it's the name
     * of a module.  
     */

    if ((moduleId = moduleFindByName (moduleNameOrId)) == NULL)
	{

	/*
	 * It's neither an object module nor a module name.  Set errno and
	 * return NULL.
	 */

	errnoSet (S_moduleLib_MODULE_NOT_FOUND);
	return (NULL);
	}
    else
        return (moduleId);
    }

/******************************************************************************
*
* moduleShow - show the current status for all the loaded modules
*
* This routine displays a list of the currently loaded modules and
* some information about where the modules are loaded.
* 
* The specific information displayed depends on the format of the object
* modules.  In the case of a.out and ECOFF object modules, moduleShow() displays
* the start of the text, data, and BSS segments.
* 
* If moduleShow() is called with no arguments, a summary list of all
* loaded modules is displayed.  It can also be called with an argument,
* <moduleNameOrId>, which can be either the name of a loaded module or a
* module ID.  If it is called with either of these, more information
* about the specified module will be displayed.
* 
* RETURNS: OK or ERROR.
*
* SEE ALSO:
* .pG "Target Shell,"
* windsh,
* .tG "Shell"
*/

STATUS moduleShow
    (
    char * 		moduleNameOrId,	/* name or ID of the module to show */
    int			options		/* display options */
    )
    {
    MODULE_ID		moduleId;
    static char *	moduleShowHdr [] = {"\n\
MODULE NAME     MODULE ID  GROUP #    TEXT START DATA START  BSS START\n\
--------------- ---------- ---------- ---------- ---------- ----------\n"};


    /*
     * If moduleNameOrId isn't NULL, translate it into a module ID, and
     * display information about that specific module.
     * If it is NULL, set moduleId to NULL, and display info about all
     * loaded modules.
     */

    if (moduleNameOrId != NULL)
	{
        if ((moduleId = moduleIdFigure (moduleNameOrId)) == NULL)
	    {
	    /* moduleIdFigure couldn't find a match */

	    printf ("Module not found\n");
	    return (ERROR);
	    }
	}
    else
        moduleId = NULL;

    /* print the module display header */

    printf ("%s", moduleShowHdr [MODULE_A_OUT]);

    /*
     * If moduleId is a specific module ID, print information about that
     * specific module.  Otherwise, print the summary.
     */

    if (moduleId != NULL)
	{

	/*
	 * We've got a specific module to show.  If no options are specified,
	 * then display all information, otherwise use what's specified.
	 */

        moduleDisplayGeneric (moduleId,
			      options == 0 ? MODDISPLAY_ALL : options);
	}
    else
        {
	/* We need to display all the modules. */

	semTake (moduleListSem, WAIT_FOREVER);
	dllEach (&moduleList, moduleDisplayGeneric,
		 options | MODDISPLAY_IS_DLL_NODE);
	semGive (moduleListSem);
	}

    /*
     * There's nothing that can fail - always return OK
     */

    return (OK);
    }

/******************************************************************************
*
* moduleDisplayGeneric - support routine to show stats for an object module
*
* This routine is normally called via a dllEach() call from moduleShow.
* It prints a single line of information about the specified module.
* Note that the parameter is _not_ of type MODULE_ID, but rather is a
* DL_NODE *.
* 
* RETURNS: TRUE, or FALSE if display should be aborted.
* 
* NOMANUAL
*/

LOCAL STATUS moduleDisplayGeneric
    (
    MODULE_ID	moduleId,	/* pointer to the module node to display */
    UINT	options		/* display options */
    )
    {
    static char	moduleShowFmt[] = "%15s %#10x %10d %#10x %#10x %#10x\n";
    MODULE_SEG_INFO segInfo;    /* segment information */

    /* If MODDISPLAY_IS_DLL_NODE is set, need to convert node to module id */

    if (options & MODDISPLAY_IS_DLL_NODE)
        moduleId = NODE_TO_ID (moduleId);

    /* If HIDDEN_MODULE is set, return OK without displaying anything */

    if (moduleId->flags & HIDDEN_MODULE)
        return (TRUE);

    /* Return FALSE if we can't get information about the module segments */

    if (moduleSegInfoGet (moduleId, &segInfo) != OK)
	{
	printErr ("Can\'t get information about module %#x\n", moduleId);
        return (FALSE);
	}

    /*
     * Print out the module summary line.
     * We only want to print the file name, not the entire path.
     */

    printf (moduleShowFmt, moduleId->name, moduleId,
	    moduleId->group,
	    segInfo.textAddr,
	    segInfo.dataAddr,
	    segInfo.bssAddr);

    /*
     * Print out all the optional information
     */

    if (options & MODDISPLAY_CODESIZE)
	{
	/* Print specific information about the size of module's segments */

	printf ("\nSize of text segment:   %8d\n", segInfo.textSize);
	printf ("Size of data segment:   %8d\n", segInfo.dataSize);
	printf ("Size of bss  segment:   %8d\n", segInfo.bssSize);

	printf ("Total size          :   %8d\n\n",
		segInfo.textSize + segInfo.dataSize
		+ segInfo.bssSize);
	}

    /*
     * Return TRUE to continue displaying modules
     */

    return (TRUE);
    }

/******************************************************************************
*
* moduleSegAdd - add a segment to a module
* 
* This routine adds segment information to an object module descriptor.  The
* specific information recorded depends on the format of the object module.
* 
* The <type> parameter is one of the following:
* .iP SEGMENT_TEXT 25
* The segment is for TEXT.
* .iP SEGMENT_DATA
* The segment is for DATA
* .iP SEGMENT_BSS
* The segment is for BSS
* 
* NOMANUAL
* 
* RETURNS: OK, or ERROR.
*/

STATUS moduleSegAdd
    (
    MODULE_ID	moduleId,	/* module to add segment to*/
    int		type,		/* segment type */
    void *	location,	/* segment address */
    int		length,		/* segment length */
    int		flags		/* segment flags */
    )
    {
    SEGMENT_ID	seg;

    /*
     * Validate module id
     */

    if (OBJ_VERIFY (moduleId, moduleClassId) != OK)
	{
	return (ERROR);
	}
	    
    /*
     * Allocate space for the segment record
     */

    seg = (SEGMENT_ID) malloc (sizeof (*seg));

    if (seg == NULL)
	{
        return (ERROR);
	}

    /*
     * Set the fields of the segment record
     */

    seg->address	= location;
    seg->size		= length;
    seg->type		= type;
    seg->flags		= flags;
    seg->checksum	= checksum (location, length);

    /*
     * Add the segment to the module's segment list
     */

    semTake (moduleSegSem, WAIT_FOREVER);
    dllAdd (&moduleId->segmentList, (DL_NODE *) seg);
    semGive (moduleSegSem);

    return (OK);
    }

/******************************************************************************
*
* moduleSegGet - get (delete and return) the first segment from a module
* 
* This routine returns information about the first segment of a module
* descriptor, and then deletes the segment from the module.
* 
* RETURNS: A pointer to the segment ID, or NULL if the segment list is empty.
*
* SEE ALSO: moduleSegFirst()
*/

SEGMENT_ID moduleSegGet
    (
    MODULE_ID 	moduleId		/* module to get segment from */
    )
    {
    SEGMENT_ID	segmentId;

    /*
     * Validate module id
     */

    if (OBJ_VERIFY (moduleId, moduleClassId) != OK)
	{
	return (NULL);
	}
	    
    semTake (moduleSegSem, WAIT_FOREVER);

    segmentId = (SEGMENT_ID) dllGet (&moduleId->segmentList);

    semGive (moduleSegSem);

    return (segmentId);
    }

/******************************************************************************
*
* moduleSegFirst - find the first segment in a module
* 
* This routine returns information about the first segment of a module
* descriptor.
* 
* RETURNS: A pointer to the segment ID, or NULL if the segment list is empty.
*
* SEE ALSO: moduleSegGet()
*/

SEGMENT_ID moduleSegFirst
    (
    MODULE_ID 	moduleId		/* module to get segment from */
    )
    {
    SEGMENT_ID	newSegId;

    /*
     * Validate module id
     */

    if (OBJ_VERIFY (moduleId, moduleClassId) != OK)
	{
	return (NULL);
	}

    semTake (moduleSegSem, WAIT_FOREVER);
    newSegId = (SEGMENT_ID) DLL_FIRST (&moduleId->segmentList);
    semGive (moduleSegSem);

    return (newSegId);
    }

/******************************************************************************
*
* moduleSegNext - find the next segment in a module
* 
* This routine returns the segment in the list immediately following
* <segmentId>.
* 
* RETURNS: A pointer to the segment ID, or NULL if there is no next segment.
*/

SEGMENT_ID moduleSegNext
    (
    SEGMENT_ID segmentId	/* segment whose successor is to be found */
    )
    {
    SEGMENT_ID	newSegId;

    semTake (moduleSegSem, WAIT_FOREVER);
    newSegId = (SEGMENT_ID) DLL_NEXT (segmentId);
    semGive (moduleSegSem);

    return (newSegId);
    }

/******************************************************************************
*
* moduleSegEach - call a routine to examine each segment in a module
* 
* This routine calls a user-supplied routine to examine each segment
* associated with a given module.  The routine should be declared as
* follows:
* 
* .CS
*     BOOL routine
*         (
*         SEGMENT_ID 	 segmentId,   /@ The segment to examine @/
*         MODULE_ID	 moduleId,    /@ The associated module @/
*         int		 userArg      /@ An arbitrary user-supplied argument @/
*         )
* .CE
* 
* The user routine should return TRUE if moduleSegEach() is to continue
* calling it for the other segments, or FALSE if moduleSegEach() should
* exit.
* 
* RETURNS: NULL if all segments were examined, or the segment ID that
* caused the support routine to return FALSE.
* 
* NOMANUAL
*/

SEGMENT_ID moduleSegEach
    (
    MODULE_ID	moduleId,	/* The module to examine */
    FUNCPTR 	routine,	/* The routine to call */
    int		userArg		/* arbitrary user-supplied argument */
    )
    {
    SEGMENT_ID	segmentId;

    semTake (moduleSegSem, WAIT_FOREVER);
    for (segmentId = moduleSegFirst (moduleId);
	 segmentId != NULL;
	 segmentId = moduleSegNext (segmentId))
	{
	if ((*routine) (segmentId, moduleId, userArg) == FALSE)
	    {
	    semGive (moduleSegSem);
	    return (segmentId);
	    }
	}
    semGive (moduleSegSem);
    return (NULL);
    }
    
/******************************************************************************
*
* moduleCreateHookAdd - add a routine to be called when a module is added
* 
* This routine adds a specified routine to a list of routines to be
* called when a module is created.  The specified routine should be
* declared as follows:
* .CS
*     void moduleCreateHook
*         (
*         MODULE_ID  moduleId  /@ the module ID @/
*         )
* .CE
* 
* This routine is called after all fields of the module ID have been filled in.
* 
* NOTE:
* Modules do not have information about their object segments when they are
* created.  This information is not available until after the entire load
* process has finished.
* 
* RETURNS: OK or ERROR.
* 
* SEE ALSO: moduleCreateHookDelete()
*/

STATUS moduleCreateHookAdd
    (
    FUNCPTR     moduleCreateHookRtn  /* routine called when module is added */
    )
    {
    MODCREATE_HOOK * pHook;      	 /* pointer to hook node */

    if (!moduleCreateHookInitialized)
	{
	dllInit (&moduleCreateHookList);
	moduleCreateHookInitialized = TRUE;
	}

    /* allocate and initialize hook node */

    if ((pHook = (MODCREATE_HOOK *) malloc (sizeof (MODCREATE_HOOK)))
	== NULL)
	{
	return (ERROR);
	}

    pHook->func = moduleCreateHookRtn;

    /* add it to end of hook list */

    semTake (moduleCreateHookSem, WAIT_FOREVER);
    dllAdd (&moduleCreateHookList, &pHook->node);
    semGive (moduleCreateHookSem);

    return (OK);
    }

/******************************************************************************