symsynclib.c

VXWORKS源代码

	    syncGroupUpdate ();
	    }
	}

    if ((sense == 0) || (sense == 2))
	{
	pModList = wtxObjModuleList (hWtx);
	for (ix = 0;
	     (pModList != NULL) && (status == OK) && (ix < pModList->numObjMod);
	     ix++)
	    status = syncModCTgtUpdate (hWtx, pModList->modIdList[ix]);
	wtxResultFree (hWtx, pModList);

	sprintf (evtBuf, "SYNC_DONE t USR_RQST target_modules %d", status);
	wtxEventAdd (hWtx, evtBuf, 0, NULL);
	}

    return (status);
    }

/******************************************************************************
*
* syncTgtSafeModCheck - check if a target module can be safely used
*
* If synchronization is running, modules loaded by the target-server are added
* to the target side. Then, if the target-server restarts (without rebooting)
* these modules seem to be loaded on target side while memory is no more 
* allocated. This routine unloads such modules (it is not possible to
* automatically reload them because we do not have the path of the file). 
*
* RETURNS: TRUE to go through the whole module list, FALSE if an error occured.
*
* NOMANUAL
*/

BOOL syncTgtSafeModCheck
    (
    MODULE_ID	moduleId,	
    int		arg			/* WTX API handle */
    )
    {
    /*
     * if the module is loaded by target server and it is no more in
     * synchronization list then it is a "zombie" module.
     */

    if ((moduleId->flags & LOAD_LOADED_BY_TGTSVR) &&
	(groupFind (&symSyncLst, moduleId->group, isInTgtGroupList) == NULL))
	unldByModuleId (moduleId, UNLD_SYNC);

    return (TRUE);
    }

/******************************************************************************
*
* syncEachSymToHost - update the host symbol table if needed
*
* This routine examine a symbol to know if it should be added in host symTbl.
*
* RETURNS: TRUE if we should go to next symbol, FALSE otherwise.
*
* NOMANUAL
*/

BOOL syncEachSymToHost
    (
    char *      name,   /* entry name */
    int         val,    /* value associated with entry */
    SYM_TYPE    type,   /* entry type */
    int         arg,    /* wtx API handle */
    UINT16      group   /* group number (on target side) */
    )
    {
    HWTX                        hWtx = (HWTX)arg;	/* wtx API handle */
    MODULE_ID                   modId;			/* target module Id */
    GROUP_NODE *                pGroup;
    UINT32			hGroup;
    WTX_SYMBOL *		pSymbol;
    BOOL			dummy;

    if (groupFind (&symSyncLst, group, (FUNCPTR)isInTgtGroupList) != NULL)
	/* this module is already synchronized */
	return TRUE;

    if (group == symGroupDefault)
	{
	/* XXX ELP, 2 possibilities 
	 * 1. we do not synchronize these symbols in forced mode since we do
	 *    not know if it was already done before. 
	 * 2. we examine host symbol table to see if the symbol is already
	 *    existing. if so we return, otherwise we add it.
	 * choose 2
	 */
	hGroup = 0;
	if ((pSymbol = wtxSymFind (hWtx, name, 0, TRUE, type, N_TYPE))
	    != NULL)
	    {
	    if ((pSymbol->value == val) && (pSymbol->group == hGroup))
		{
		wtxResultFree (hWtx, pSymbol);
		return (TRUE);
		}
	    wtxResultFree (hWtx, pSymbol);
	    }
	}
    else if ((pGroup = groupFind (&symSyncTmpLst, group, 
				  (FUNCPTR)isInTgtGroupList)) == NULL)
	{
	/* this module is unknown on host, we must add it */

	if ((modId = moduleFindByGroup (group)) == NULL)
	    return (FALSE);
	if (syncModCHostUpdate (hWtx, &symSyncTmpLst, modId, &dummy, FALSE)
	    == ERROR)
	    return (FALSE);
	if ((pGroup = groupFind (&symSyncTmpLst, group,
				 (FUNCPTR)isInTgtGroupList)) == NULL)
	    return (FALSE);
	hGroup = pGroup->hostGroup;
	}
    else
	hGroup = pGroup->hostGroup;

    /* add the symbol */
    
    if (wtxSymAddWithGroup (hWtx, name, (TGT_ADDR_T)val, type, hGroup)
	!= WTX_OK)
	return (FALSE);
   
    /* if it is an undefined symbol, update the corresponding module info */

    if (type == N_UNDF)
	{
	if (wtxObjModuleUndefSymAdd (hWtx, name, hGroup) != WTX_OK)
	    return (FALSE);
	}
    
    return (TRUE);
    }

/******************************************************************************
*
* syncSymByGrpToHost - update host symbol table with symbols of a given group
*
* This routine examine each symbol of a given group to know if it should be
* added in host symTbl.
*
* RETURNS: TRUE if we should examine the next symbol, FALSE otherwise.
*
* NOMANUAL
*/

BOOL syncSymByGrpToHost
    (
    char *      name,   /* entry name */
    int         val,    /* value associated with entry */
    SYM_TYPE    type,   /* entry type */
    int         arg,    /* wtx API handle, host and target groups */
    UINT16      group   /* group number (on target side) */
    )
    {
    BY_GROUP_ARG_T *	pArg = (BY_GROUP_ARG_T *)arg;

    if (group != pArg->tgtGroup)
	return (TRUE);

    if (wtxSymAddWithGroup (pArg->hWtx, name, (TGT_ADDR_T)val, type,
			    pArg->hostGroup) == WTX_ERROR)
	return (FALSE);

    /* if it is an undefined symbol, update the corresponding module info */

    if (type == N_UNDF)
	{
	if (wtxObjModuleUndefSymAdd (pArg->hWtx, name, pArg->hostGroup)
	    == WTX_ERROR)
	    return (FALSE);
	}
    
    return (TRUE);
    }

/******************************************************************************
*
* syncHostModInfoFill - fill a host module descriptor from a target MODULE_ID
* 
* This routine creates a module on host side with the information provided by 
* the target module identifier.
* note:	if <synchro> is TRUE, loadFlag LOAD_MODULE_INFO_ONLY is set to indicate
*	that the module is already loaded so wtxObjModuleLoad() will not do it
*	again.
* note:	segment flag is always unset to prevent segment memory from being freed
*	twice when unloading module (1 on target and 1 on host).
*
* RETURNS: OK or ERROR
*
* NOMANUAL
*/

STATUS syncHostModInfoFill
    (
    WTX_LD_M_FILE_DESC *	pFileDesc,
    MODULE_ID			modId,
    BOOL			synchro
    )
    {
    char *		fileNameBuf = NULL;
    SEGMENT_ID		segId;
    int			ix;

    memset (pFileDesc, 0, sizeof(WTX_LD_M_FILE_DESC));
    
    if ((fileNameBuf = malloc (PATH_MAX + NAME_MAX)) == NULL)
	return (ERROR);

    sprintf (fileNameBuf, "%s/%s", modId->path, modId->name);

    pFileDesc->filename = fileNameBuf;
    pFileDesc->moduleId = 0;

    /*
     * undefined symbol list is initialized empty at first,
     * if undefined symbol are found when going through symbol table they are
     * added in this list
     */
    
    pFileDesc->undefSymList.pSymbol = NULL;

    /* translate target module flags into host module flag */

    if (modId->flags & LOAD_NO_SYMBOLS)
	pFileDesc->loadFlag |= 0x1;
    if (modId->flags & LOAD_LOCAL_SYMBOLS)
	pFileDesc->loadFlag |= 0x2;
    if (modId->flags & LOAD_GLOBAL_SYMBOLS)
	pFileDesc->loadFlag |= 0x4;
    pFileDesc->loadFlag |= (modId->flags & HIDDEN_MODULE);

    if (!synchro)
	{
	/* we want to load the file, letting target-server decide where */

	pFileDesc->nSections = 0;
	return (OK);
	}

    pFileDesc->loadFlag |= LOAD_MODULE_INFO_ONLY;
    pFileDesc->nSections = dllCount (&modId->segmentList);
    if ((pFileDesc->section = (LD_M_SECTION *)
	 malloc (pFileDesc->nSections * sizeof (LD_M_SECTION))) == NULL)
	{
	free (fileNameBuf);
	return (ERROR);
	}

    for (segId = (SEGMENT *)DLL_FIRST (&modId->segmentList);
	 segId != NULL; segId = (SEGMENT *)DLL_NEXT (segId))
	{
	switch (segId->type)
	    {
	    case SEGMENT_TEXT: ix = 0; break;
	    case SEGMENT_DATA: ix = 1; break;
	    case SEGMENT_BSS: ix = 2; break;
#ifdef INCLUDE_SDA
	    /*
	     * XXX ELP every segments are put in the list even if SDA segments
	     * are currently useless. (it will be necessary to add the
	     * memPartId info in the LD_M_SECTION structure)
	     */
	    case SEGMENT_SDATA: ix = 3; break;
	    case SEGMENT_SBSS: ix = 4; break;
	    case SEGMENT_SDATA2: ix = 5; break;
	    case SEGMENT_SBSS2: ix = 6; break;
#endif /* INCLUDE_SDA */
	    default: ix = -1; break;
	    }
	if (ix < 0)
	    continue;
	pFileDesc->section[ix].flags = segId->flags & ~SEG_FREE_MEMORY;
	pFileDesc->section[ix].addr = (segId->size == 0) ? (TGT_ADDR_T) -1 :
				      (TGT_ADDR_T)segId->address;
	pFileDesc->section[ix].length = segId->size;
	}

    return (OK);
    }

/******************************************************************************
*
* syncLoadHook - load module hook
*
* RETURNS: N/A
* 
* NOMANUAL
*/

void syncLoadHook
    (
    MODULE_ID modId
    )
    {
    char	buf[SYNC_TGT_EVT_LGTH];
    char 	name[SYNC_TGT_EVT_LGTH - 25];

    strncpy (name, modId->name, SYNC_TGT_EVT_LGTH - 26);
    name[SYNC_TGT_EVT_LGTH - 26] = EOS;
    sprintf (buf, "%s %#x %s", OBJ_LOADED_EVT, (UINT32)modId, name);
    if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
	== ERROR)
	{
#ifdef DEBUG
	logMsg ("module 0x%x sync failed\n", (int)modId, 0,0,0,0,0);
#endif
	return;
	}
    return;
    }

/******************************************************************************
*
* syncUnldHook - unload module hook
*
* RETURNS: N/A
* 
* NOMANUAL
*/

void syncUnldHook
    (
    MODULE_ID	modId
    )
    {
    char	buf[SYNC_TGT_EVT_LGTH];
    char 	name[SYNC_TGT_EVT_LGTH - 25];

    strncpy (name, modId->name, SYNC_TGT_EVT_LGTH - 26);
    name[SYNC_TGT_EVT_LGTH - 26] = EOS;

    sprintf (buf, "%s %s %#x", OBJ_UNLOADED_EVT, name, modId->group);

    if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
	== ERROR)
	{
#ifdef DEBUG
	logMsg ("module 0x%x deletion sync failed\n", (int)modId,
			0, 0, 0, 0, 0);
#endif
	return ;
	}
    }

/******************************************************************************
*
* syncSymAddHook - symbol addition hook
*
* RETURNS: N/A
*
* NOMANUAL
*/

void syncSymAddHook
    (
    char *	name,
    char *	value,
    SYM_TYPE	type,
    UINT16	group
    )
    {
    char	buf[SYNC_TGT_EVT_LGTH];
    char 	symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH];

    if (group == 1)		/* symbol table group */
	return ;

    strncpy (symName, name, 
	     SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH - 1);
    symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH -1] = EOS;
    
    /*
     * The message for SYM_ADDED event will look as follows:
     *
     *  "SYM_ADDED <name> 0x<value> 0x<type> 0x<group>\0"
     *   |   9   | |    | |  10   | |  4   | |   6   |
     *
     * <value>: char*, takes 8 bytes at maximum in the output of sprintf;
     * <type> : SYM_TYPE, takes 2 bytes at maximum in the output of sprintf;
     * <group>: UINT16, takes 4 bytes at maximum in the output of sprintf;
     *
     * Totally, the non-name information(including white spaces and EOS) takes
     * at maximum 9+1+1+10+1+4+1+6+1 = 34. So define macro
     * SYM_ADDED_EVT_MSG_NON_NAME_LGTH to 34
     */

    sprintf (buf, "%s %s 0x%x 0x%x 0x%x", SYM_ADDED_EVT, symName, (int)value,
	     type, group);
    if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
	== ERROR)
	{
#ifdef DEBUG
	logMsg ("sym %s addition sync failed\n", (int)name, 0, 0, 0, 0, 0);
#endif
	return ;
	}
    }

/******************************************************************************
*
* syncSymRemoveHook - symbol removing hook
*
* RETURNS: N/A
*
* NOMANUAL
*/

void syncSymRemoveHook
    (
    char *	name,
    SYM_TYPE	type
    )
    {
    /* SYM_ADDED_EVT_MSG_NON_NAME_LGTH is used to calculate space for
     * symbol name so syncSymRemoveHook and syncSymAdd Hook agree on
     * acceptable length of symbol name
     */

    char	buf[SYNC_TGT_EVT_LGTH];
    char 	symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH];

    strncpy (symName, name, 
	     SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH - 1);
    symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH -1] = EOS;

    sprintf (buf, "%s %s 0x%x", SYM_REMOVED_EVT, symName, type);
    if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
	== ERROR)
	{
#ifdef DEBUG
	logMsg ("sym %s removing sync failed\n", (int)name, 0, 0, 0, 0, 0);
#endif
	return ;
	}
    }

/*******************************************************************************
*
* symSRemove - remove a symbol from a symbol table
*
* This routine behaves like symRemove() except it does not test syncRemoveRtn
* function pointer. Thus it enables to "silently" remove a symbol.
*
* RETURNS: OK, or ERROR if the symbol is not found
* or could not be deallocated.
*
* NOMANUAL
*/

STATUS symSRemove
    (
    SYMTAB_ID symTblId,         /* symbol tbl to remove symbol from */
    char      *name,            /* name of symbol to remove */
    SYM_TYPE  type              /* type of symbol to remove */
    )
    {
    SYMBOL *pSymbol;

    if (symFindSymbol (symTblId, name, 0, type, SYM_MASK_ALL, 
		       (SYMBOL_ID *) &pSymbol) != OK)
	return (ERROR);

    /* XXX JLN symTblRemove should really take a SYMBOL_ID */

    if (symTblRemove (symTblId, pSymbol) != OK)
	return (ERROR);
    return (symFree (symTblId, pSymbol));
    }