开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
symSyncLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：51k
源码类别：

VxWorks

开发平台：

C/C++

symSyncLib.c：源码内容
  1. /* symSyncLib.c - host/target symbol table synchronization */
  3. /* Copyright 1996-2002 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01t,03may02,jhw  Added VX_FP_TASK task option to tSymSync. (SPR 66307)
  9. 01s,03apr02,j_s  correct the miscalculation of length limit of symbol name
  10.  in syncSymAddHook/syncSymRemoveHook (SPR 75036).
  11. 01r,30oct01,jn   use symFindSymbol for symbol lookup (SPR #7453)
  12. 01q,01oct01,c_c  Fixed SPR 62583.
  13. 01p,02apr99,jdi  corrected spelling of NOMANUAL in syncTgtSafeModCheck()
  14. 01o,14mar99,jdi  doc: removed refs to config.h and/or configAll.h (SPR 25663).
  15. 01n,01sep98,pcn  Added wtxObjModuleUndefSymAdd definition.
  16. 01m,27jul98,elp  fixed stack size for SIMSPARCSOLARIS (SPR #20150).
  17. 01l,07jul98,pcn  Added include for wtxObjModuleUndefSymAdd.
  18. 01k,24apr98,dbt  fixed WTX timeout error message (SPR #20852).
  19. 01j,14jul97,dgp  doc: edit new additions
  20. 01i,21feb96,elp  improved timeout managements (added warning message).
  21. 01h,13feb97,elp  managed timeout errors on wtxEventGet() (SPR# 7959)
  22.  + network doc enhancements (SPR# 7852).
  23. 01g,06jan97,elp  fixed a typo.
  24. 01f,18dec96,jdi  doc: more enhancements and cleanup; changed title line to
  25.     reflect new name of module.
  26. 01e,12dec96,elp  moved hooks initialization into tSymSync
  27.  + added global symSyncHWtx to enable timeout modifications.
  28.  + added symSyncTimeout()
  29.  + name revision.
  30. 01d,10dec96,jdi  doc: cleanup.
  31. 01c,13nov96,elp  doc generation.
  32. 01b,24oct96,elp  added event notification when synchronization is done
  33.  + synchronize usual target commands (ld(), symAdd(), ...).
  34. 01a,04oct96,elp  written.
  35. */
  37. /*
  38. DESCRIPTION
  39. This module provides host/target symbol table synchronization.
  40. With synchronization, every module or symbol added to the run-time
  41. system from either the target or host side can be seen by facilities
  42. on both the target and the host. Symbol table synchronization makes it 
  43. possible to use host tools to debug application modules loaded with the 
  44. target loader or from a target file system.  To enable synchronization, 
  45. two actions must be performed: 
  47. .iP 1 6
  48. The module is initialized by symSyncLibInit(), which is called automatically 
  49. when the configuration macro INCLUDE_SYM_TBL_SYNC is defined.
  50. .iP 2
  51. The target server is launched with the `-s' option.
  52. .LP
  54. If synchronization is enabled, `symSyncLib' spawns a synchronization task 
  55. on the target, `tSymSync'. This task behaves as a WTX tool and attaches 
  56. itself to the target server.  When the task starts, it synchronizes target 
  57. and host symbol tables so that every module loaded on the target before the 
  58. target server was started can be seen by the host tools.  This feature is 
  59. particularly useful if VxWorks is started with a target-based startup script 
  60. before the target server has been launched.
  62. The `tSymSync' task synchronizes new symbols that are added
  63. by either the target or the host tools.  The task waits for synchronization 
  64. events on two channels:  a WTX event from the host or a message queue additon
  65. from the target.
  67. The `tSymSync' task, like all WTX tools, must be able to connect to the WTX
  68. registry. To make the WTX registry accessible from the target, do one of
  69. the following:
  71. .iP 1 6
  72. Boot the target from a host on the same subnet as the registry.
  73. .iP 2
  74. Start the registry on the same host the target boots from.
  75. .iP 3
  76. Add the needed routes with routeAdd() calls, possibly in a startup script.
  77. .LP
  79. Neither the host tools nor the target loader wait for synchronization
  80. completion to return.  To know when the synchronization is complete, you
  81. can wait for the corresponding event sent by the target server, or,
  82. if your target server was started with the `-V' option, it prints a
  83. message indicating synchronization has completed.
  85. The event sent by the target server is of the following format:
  87. .tS
  88.     SYNC_DONE <syncType> <syncObj> <syncStatus>
  89. .tE
  91. The following are examples of messages displayed by the target server
  92. indicating synchronization is complete:
  93. .CS
  94.     Added target_modules         to target-server.....done
  95.     Added ttTest.o.68k           to target............done
  96. .CE
  98. If synchronization fails, the following message is displayed:
  99. .CS
  100.     Added gopher.o               to target............failed
  101. .CE
  103. This error generally means that synchronization of the corresponding module
  104. or symbol is no longer possible because it no longer exists in the original
  105. symbol table.  If so, it will be followed by:
  106. .CS
  107.     Removed gopher.o             from target..........failed
  108. .CE
  110. Failure can also occur if a timeout is reached.  
  111. Call symSyncTimeoutSet() to modify the WTX timeout between the target
  112. synchronization task and the target server.
  114. LIMITATIONS
  115. Hardware:  Because the synchronization task uses the WTX protocol to
  116. communicate with the target server, the target must include network
  117. facilities.  Depending on how much synchronization is to be done (number
  118. of symbols to transfer), a reasonable throughput between the target server
  119. and target agent is required (the wdbrpc backend is recommended when large
  120. modules are to be loaded).
  122. Performance:  The synchronization task requires some minor overhead in
  123. target routines msgQSend(), loadModule(), symAdd(), and symRemove(); 
  124. however, if an application sends more than 15 synchronization events,
  125. it will fill the message queue and then need to wait for a synchronization
  126. event to be processed by `tSymSync'. Also, waiting for host synchronization 
  127. events is done by polling; thus there may be some impact on performance if 
  128. there are lower-priority tasks than `tSymSync'.  If no more synchronization 
  129. is needed, `tSymSync' can be suspended.
  131. Known problem:  Modules with undefined symbols that are loaded from the target
  132. are not synchronized; however, they are synchronized if they are loaded
  133. from the host.
  135. SEE ALSO
  136. `tgtsvr'
  137. */
  139. /* includes */
  141. #include "symSyncLib.h"
  142. #include "rpcLib.h"
  143. #include "loadLib.h"
  144. #include "unldLib.h"
  145. #include "symLib.h"
  146. #include "msgQLib.h"
  147. #include "sysLib.h"
  148. #include "a_out.h" /* XXX ELP to get N_TYPE definition */
  149. #include "usrLib.h"
  150. #include "logLib.h"
  152. /* typedefs */
  154. typedef struct
  155.     {
  156.     DL_NODE  node;
  157.     UINT16 tgtGroup;
  158.     UINT32 hostGroup;
  159.     } GROUP_NODE;
  161. /* 
  162.  * dummy type that concatenates arguments as only one can be passed to
  163.  * routines called by symEach().
  164.  */
  166. typedef struct 
  167. {
  168. HWTX hWtx;
  169. UINT16 tgtGroup;
  170. UINT32 hostGroup;
  171. } BY_GROUP_ARG_T;
  173. /* defines */
  175. /* #define DEBUG */
  177. #define H_STR_TO_L(str) (strtoul (str, NULL, 16))
  179. #define SYNC_TGT_EVT_MAX 15 /* max number of sync rqsts */
  180. #define OBJ_NAME_MAX 30
  181. #define SYNC_TGT_EVT_LGTH 60 /* max event string length */
  182. #define OBJ_LOADED_EVT "OBJ_LOADED"
  183. #define OBJ_UNLOADED_EVT "OBJ_UNLOADED"
  184. #define SYM_ADDED_EVT "SYM_ADDED"
  185. #define SYM_REMOVED_EVT "SYM_REMOVED"
  186. #define SYM_ADDED_EVT_MSG_NON_NAME_LGTH 34
  187. #define USR_RQST_EVT "USR_RQST"
  188. #define TIMEOUT  sysClkRateGet()
  189. /* for sending/receiving events */
  191. #define SYNC_PRIORITY 90
  193. /* XXX - jhw 
  194.  * The VX_FP_TASK option is needed to prevent corruption of 
  195.  * the floating point registers. All tasks that call
  196.  * (directly or indirectly) C++ code that is compiled without 
  197.  * '-fnoexceptions' with gnu 2.96 are affected.
  198.  * See SPR 66307,70995 for additional info.
  199.  * This module calls unldByModuleId() which calls C++ destructors.
  200.  */
  202. #define SYNC_OPTIONS VX_FP_TASK
  204. #if (CPU_FAMILY == MC680X0) 
  205. #define SYNC_STACK_SIZE 8000
  206. #elif (CPU_FAMILY == I960)
  207. #define SYNC_STACK_SIZE 5000
  208. #elif ((CPU_FAMILY == SIMSPARCSOLARIS) || (CPU_FAMILY == SPARC) || 
  209.        (CPU_FAMILY == SIMSPARCSUNOS))
  210. #define SYNC_STACK_SIZE 15000
  211. #else
  212. #define SYNC_STACK_SIZE 5000
  213. #endif
  215. /* globals */
  217. MSG_Q_ID symSyncMsgQId; /* target synchro event container */
  218. HWTX symSyncHWtx; /* symbol synchro WTX handle */
  220. /* locals */
  222. LOCAL const char SYM_SYNC_TOOL_NAME[] =  "symTblsSync";
  223. LOCAL DL_LIST symSyncLst; /* sync modules list */
  224. LOCAL DL_LIST symSyncTmpLst; /* tmp buffer */
  225. LOCAL BOOL symSyncKill; /* to exit tSymSync loop */
  226. LOCAL UINT32 symSyncWtxTimeout = 5000; /* wtx timeout */
  228. IMPORT CLASS_ID symTblClassId;
  229. IMPORT CLASS_ID moduleClassId;
  230. IMPORT SYMTAB_ID sysSymTbl;
  231. IMPORT struct opaque_auth authCred;
  233. /* forward declarations */
  235. extern  STATUS wtxObjModuleUndefSymAdd (HWTX, char *, UINT32 );
  237. STATUS symSRemove (SYMTAB_ID, char *, SYM_TYPE);
  239. /* group list processing */
  241. LOCAL STATUS groupAdd (DL_LIST *, UINT16, UINT32);
  242. LOCAL GROUP_NODE * groupFind (DL_LIST *, UINT32, FUNCPTR);
  243. LOCAL GROUP_NODE * groupRemove (DL_LIST *, UINT32, FUNCPTR);
  244. LOCAL BOOL isInHostGroupList (DL_NODE *, int);
  245. LOCAL BOOL isInTgtGroupList (DL_NODE *, int);
  247. LOCAL void syncGroupUpdate ();
  248. LOCAL STATUS symSyncMain (HWTX);
  249. LOCAL STATUS symSyncTaskInit (char *);
  251. /* host -> target synchronization */
  253. LOCAL STATUS symSyncTgtUpdate (HWTX, char *, char *);
  254. LOCAL STATUS syncModCTgtUpdate (HWTX, UINT32);
  255. LOCAL STATUS syncModDTgtUpdate (HWTX, UINT32);
  256. LOCAL STATUS syncSymAddTgtUpdate (HWTX, char *);
  257. LOCAL MODULE_ID syncTgtModInfoFill (WTX_MODULE_INFO *);
  259. /* target -> host synchronization */
  261. LOCAL STATUS symSyncHostUpdate (HWTX, char *, char *);
  262. LOCAL STATUS syncModCHostUpdate (HWTX, DL_LIST *, MODULE_ID, BOOL *,BOOL);
  263. LOCAL STATUS syncModDHostUpdate (HWTX, char *, UINT16);
  264. LOCAL STATUS syncSymAddHostUpdate (HWTX, char *, char *, SYM_TYPE, UINT16);
  265. LOCAL STATUS syncSymRemHostUpdate (HWTX, char *, SYM_TYPE);
  266. LOCAL STATUS syncHostModInfoFill (WTX_LD_M_FILE_DESC *, MODULE_ID, BOOL);
  267. LOCAL STATUS syncUsrUpdate (HWTX, int, int);
  268. LOCAL BOOL syncTgtSafeModCheck (MODULE_ID , int);
  269. LOCAL BOOL syncEachSymToHost (char *, int, SYM_TYPE, int, UINT16);
  270. LOCAL BOOL syncSymByGrpToHost (char *, int, SYM_TYPE, int, UINT16);
  272. LOCAL void syncLoadHook (MODULE_ID);
  273. LOCAL void syncUnldHook (MODULE_ID);
  274. LOCAL void syncSymAddHook (char *, char *, SYM_TYPE, UINT16);
  275. LOCAL void syncSymRemoveHook (char *, SYM_TYPE);
  277. /******************************************************************************
  278. * 
  279. * symSyncLibInit - initialize host/target symbol table synchronization
  280. *
  281. * This routine initializes host/target symbol table synchronization. 
  282. * To enable synchronization, it must be called before a target server
  283. * is started.  It is called automatically if the configuration macro
  284. * INCLUDE_SYM_TBL_SYNC is defined.
  285. *
  286. * RETURNS: N/A
  287. */
  289. void symSyncLibInit ()
  290.     {
  292.     /* create the target synchronization event folder */
  293.     symSyncMsgQId = msgQCreate (SYNC_TGT_EVT_MAX, SYNC_TGT_EVT_LGTH,
  294. MSG_Q_FIFO);
  296.     return;
  297.     }
  299. /******************************************************************************
  300. *
  301. * symSyncTimeoutSet - set WTX timeout 
  302. *
  303. * This routine sets the WTX timeout between target server and synchronization
  304. * task.
  305. *
  306. * RETURNS: If <timeout> is 0, the current timeout, otherwise the new timeout
  307. * value in milliseconds.
  308. */
  310. UINT32 symSyncTimeoutSet
  311.     (
  312.     UINT32 timeout /* WTX timeout in milliseconds */
  313.     )
  314.     {
  315.     UINT32 curTimeout;
  317.     if (wtxToolConnected (symSyncHWtx))
  318. {
  319. if (timeout == 0)
  320.     {
  321.     if (wtxTimeoutGet (symSyncHWtx, &curTimeout) == WTX_OK)
  322. return (curTimeout);
  323.     return (symSyncWtxTimeout);
  324.     }
  325. else
  326.     {
  327.     symSyncWtxTimeout = timeout;
  328.     wtxTimeoutSet (symSyncHWtx, symSyncWtxTimeout);
  329.     return (symSyncWtxTimeout);
  330.     }
  331. }
  332.     
  333.     if (timeout == 0)
  334. return (symSyncWtxTimeout);
  335.     symSyncWtxTimeout = timeout;
  336.     return (symSyncWtxTimeout);
  337.     }
  339. /******************************************************************************
  340. *
  341. * syncErrHandler - synchronization error handler
  342. * 
  343. * Some WTX errors may happen in an unpredictable way (because information of
  344. * the synchronization task are not up to date). So these errors should be 
  345. * ignored.
  346. *
  347. * RETURNS: FALSE to prevent from calling other error handler. 
  348. *
  349. * NOMANUAL
  350. */
  352. BOOL32 syncErrHandler
  353.     (
  354.     HWTX hWtx, /* WTX API handle */
  355.     void * pClientData,
  356.     void * errCode
  357.     )
  358.     {
  359.     if (((WTX_ERROR_T)errCode == WTX_OK) ||
  360. ((WTX_ERROR_T)errCode == WTX_ERR_LOADER_OBJ_MODULE_NOT_FOUND) || 
  361. ((WTX_ERROR_T)errCode == WTX_ERR_SYMTBL_SYMBOL_NOT_FOUND) ||
  362. ((WTX_ERROR_T)errCode == WTX_ERR_SYMTBL_NO_SUCH_MODULE))
  363. {
  364. #ifdef DEBUG 
  365. logMsg ("%#x ignoredn", (WTX_ERROR_T)errCode, 0, 0, 0, 0, 0);
  366. #endif
  367. }
  368.     else if (((WTX_ERROR_T)errCode == WTX_ERR_API_NOT_CONNECTED) ||
  369.      ((WTX_ERROR_T)errCode == WTX_ERR_API_TOOL_DISCONNECTED) ||
  370.      ((WTX_ERROR_T)errCode == WTX_ERR_API_REGISTRY_UNREACHABLE) ||
  371.      ((WTX_ERROR_T)errCode == WTX_ERROR))
  372. {
  373. if (!symSyncKill)
  374.     fprintf (stderr,
  375.      "Fatal WTX error (%#x), synchronization stoppedn",
  376.      (int)errCode);
  377. symSyncKill = TRUE;  /* end the task */
  378. }
  379.     else if ((WTX_ERROR_T)errCode == WTX_ERR_API_REQUEST_TIMED_OUT)
  380. {
  381. fprintf (stderr, "Warning: tSymSync WTX timeoutn");
  382. }
  383.     else
  384. {
  385. #ifdef DEBUG
  386. fprintf (stderr, "Unexpected WTX error %#x during synchronizationn",
  387.  (WTX_ERROR_T)errCode);
  388.         taskSuspend (0);
  389. #endif
  390. }
  392.     return (FALSE);
  393.     }
  395. /******************************************************************************
  396. *
  397. * syncSymStart - start the synchronization task
  398. *
  399. * This routine is the entry point that is called by target server.
  400. * It initializes registry inet and RPC credentials and then starts <tSymSync>
  401. * task.
  402. * Once the synchronization task is started, it sends a request to synchronize
  403. * the symbol tables.
  404. *
  405. * RETURNS: tid of <tSymSync> or WTX_ERROR.
  406. *
  407. * NOMANUAL
  408. */
  410. STATUS syncSymStart
  411.     (
  412.     char * tgtSvrName, /* target server name */
  413.     UINT32 registryInet, /* registry address */
  414.     int pCredFlavor, /* RPC credentials information */
  415.     void * pCredBase,
  416.     UINT32 pCredLength
  417.     )
  418.     {
  419.     int tid;
  420.     char startSyncEvt[SYNC_TGT_EVT_LGTH];
  422.     if (OBJ_VERIFY (sysSymTbl, symTblClassId) != OK)
  423. return (WTX_ERROR);
  425.     /* store the registry internet address */
  426.     syncRegistry = registryInet;
  428.     /* store RPC credentials */
  429.     authCred.oa_flavor = pCredFlavor;
  430.     authCred.oa_base = pCredBase;
  431.     authCred.oa_length = pCredLength;
  433.     /*
  434.      * Initialize hooks so that module loads and symbol additions send a
  435.      * message in the synchronization message queue.
  436.      */
  437.     taskLock ();
  438.     syncLoadRtn = (FUNCPTR) syncLoadHook;
  439.     syncUnldRtn = (FUNCPTR) syncUnldHook;
  440.     syncSymAddRtn = (FUNCPTR) syncSymAddHook;
  441.     syncSymRemoveRtn = (FUNCPTR) syncSymRemoveHook;
  442.     taskUnlock ();
  444.     tid = taskSpawn ("tSymSync", SYNC_PRIORITY, SYNC_OPTIONS, SYNC_STACK_SIZE,
  445.      symSyncTaskInit, (int)tgtSvrName, 0,0,0,0,0,0,0,0,0);
  447.     /* bring unknown target symbols to host symbol table */
  448.     sprintf (startSyncEvt, "%s 0x1 0x1", USR_RQST_EVT);
  449.     msgQSend (symSyncMsgQId, startSyncEvt, strlen(startSyncEvt)+1, TIMEOUT, 
  450.       MSG_PRI_NORMAL);
  451.     
  452.     return (tid);
  453.     }
  455. /******************************************************************************
  456. *
  457. * symSyncTaskInit - WTX initializations
  458. *
  459. * This routine initializes RPC then WTX, attaches to target server and 
  460. * registers for concerned events.
  461. * 
  462. * RETURNS: OK or ERROR.
  463. *
  464. * NOMANUAL
  465. */
  467. STATUS symSyncTaskInit
  468.     (
  469.     char * tgtSvrName /* target server name */
  470.     )
  471.     {
  472.     char  regEvtStr[50]; /* registered events */
  473.     WTX_HANDLER_T wtxErrHId;  /* error handler id */
  475.     strcpy (regEvtStr, "(OBJ_(LOAD|UNLOAD)|SYM_(ADD|REMOV))ED|SYNC_STOP");
  477.     /*
  478.      * initialize the synchronized group list : vxWorks symbols are always
  479.      * synchronized (group is 1 on target side and 1 on host side).
  480.      */
  481.     dllInit (&symSyncLst);
  482.     dllInit (&symSyncTmpLst);
  483.     groupAdd (&symSyncLst, 1, 1);
  485.     /* initialize the task access to the RPC package */
  486.     rpcTaskInit ();
  488.     /* initialize WTX session handle */
  489.     if (wtxInitialize (&symSyncHWtx) != WTX_OK)
  490. return (ERROR);
  491.     
  492.     wtxErrHId = wtxErrHandlerAdd (symSyncHWtx,
  493.   (WTX_HANDLER_FUNC)&syncErrHandler, 0);
  494.     if (wtxErrHId == NULL)
  495. {
  496. fprintf (stderr,
  497.  "Unable to initialize synchronization task. Giving up.n");
  498. wtxTerminate (symSyncHWtx);
  499. return (ERROR);
  500. }
  502.     /* attach to Target Server */
  503.     wtxToolAttach (symSyncHWtx, tgtSvrName, SYM_SYNC_TOOL_NAME);
  505.     /* set WTX timeout if necessary */
  506.     if (symSyncWtxTimeout != 0)
  507. wtxTimeoutSet (symSyncHWtx, symSyncWtxTimeout);
  509.     /* register for events */
  510.     wtxRegisterForEvent (symSyncHWtx, regEvtStr);
  512.     /* synchronize symbol tables */
  513.     symSyncMain (symSyncHWtx);
  515.     /* detach from target server */
  516.     wtxToolDetach (symSyncHWtx);
  518.     /* remove error handler */
  519.     wtxErrHandlerRemove (symSyncHWtx, wtxErrHId);
  521.     wtxTerminate (symSyncHWtx);
  522.     return (OK);
  523.     }
  525. /******************************************************************************
  526. *
  527. * symSyncMain - main routine
  528. *
  529. * This routine waits for target or host synchronization events and does the
  530. * corresponding job.
  531. *
  532. * RETURNS: OK or ERROR.
  533. *
  534. * NOMANUAL
  535. */
  536. STATUS symSyncMain 
  537.     (
  538.     HWTX hWtx
  539.     )
  540.     {
  541.     WTX_EVENT_DESC * pEvtDesc; /* event descriptor */
  542.     char  tgtEvtBuffer[SYNC_TGT_EVT_LGTH];
  543.     char  doneEvtBuffer[SYNC_TGT_EVT_LGTH];
  545.     symSyncKill = FALSE;
  547.     while (!symSyncKill)
  548. {
  549. if (msgQReceive (symSyncMsgQId, tgtEvtBuffer, SYNC_TGT_EVT_LGTH,
  550.  TIMEOUT) != ERROR)
  551.     {
  552. #ifdef DEBUG
  553.          logMsg ("tgt evt: %sn", (int)tgtEvtBuffer, 0, 0, 0, 0, 0);
  554. #endif
  555.     symSyncHostUpdate (hWtx, tgtEvtBuffer, doneEvtBuffer);
  556.     }
  557. else
  558.     {
  559.     if ((pEvtDesc = wtxEventGet (hWtx)) == NULL)
  560. continue; /* we got a timeout, may be better next time */
  561.     while (strcmp (pEvtDesc->event, "") != 0) /* no event received */
  562. {
  563. if (strcmp (pEvtDesc->event, "SYNC_STOP") == 0)
  564.          {
  565. #ifdef DEBUG
  566.     logMsg ("stop event receivedn", 0, 0, 0, 0, 0, 0);
  567. #endif
  568.     symSyncKill = TRUE;
  569.     break;
  570.     }
  571. else /* split event string and process it */
  572.     {
  573. #ifdef DEBUG 
  574.     logMsg ("tgtsvr evt: %sn", (int)pEvtDesc->event,0,0,0,0,0);
  575. #endif
  576.     symSyncTgtUpdate (hWtx, pEvtDesc->event, doneEvtBuffer);
  577.     wtxEventAdd (hWtx, doneEvtBuffer, 0, NULL);
  578.     }
  579. wtxResultFree (hWtx, pEvtDesc);
  580. if ((pEvtDesc = wtxEventGet (hWtx)) == NULL)
  581.     break; /* we got a timeout, giving up */
  582. }
  583.     if (pEvtDesc != NULL)
  584. wtxResultFree (hWtx, pEvtDesc);
  585.     }
  586. }
  587.     return (OK);
  588.     }
  590. /******************************************************************************
  591. *
  592. * groupAdd - add a group to a group list.
  593. *
  594. * RETURNS: OK if addition is possible, ERROR otherwise.
  595. *
  596. * NOMANUAL
  597. */
  599. STATUS groupAdd
  600.     (
  601.     DL_LIST * pList,
  602.     UINT16 tgtGroup,
  603.     UINT32 hostGroup
  604.     )
  605.     {
  606.     GROUP_NODE * pToAdd = (GROUP_NODE *) malloc (sizeof (GROUP_NODE));
  608.     if (pToAdd)
  609. {
  610. pToAdd->tgtGroup = tgtGroup;
  611. pToAdd->hostGroup = hostGroup;
  612. dllAdd (pList, (DL_NODE *)pToAdd);
  613. return (OK);
  614. }
  615.     return (ERROR);
  616.     }
  618. /******************************************************************************
  619. *
  620. * groupFind - find if a given group is in a group list
  621. *
  622. * This routine is used to know if a module is already synchronized. If its
  623. * target or host module's group is in the synchronized group list there is
  624. * nothing to do.
  625. *
  626. * RETURNS: a pointer on the GROUP_NODE found or NULL.
  627. *
  628. * NOMANUAL
  629. */
  631. GROUP_NODE * groupFind
  632.     (
  633.     DL_LIST * pList,
  634.     UINT32 group, /* module's group on host or target side */
  635.     FUNCPTR findRtn
  636.     )
  637.     {
  638.     GROUP_NODE * pGroup;
  640.     pGroup = (GROUP_NODE *) dllEach (pList, findRtn, (int)group);
  641.     return (pGroup);
  642.     }
  644. /******************************************************************************
  645. *
  646. * groupRemove - remove a group from a list
  647. *
  648. * RETURNS: a pointer on the group node removed or NULL.
  649. *
  650. * NOMANUAL
  651. */
  653. GROUP_NODE * groupRemove
  654.     (
  655.     DL_LIST * pList,
  656.     UINT32 group,
  657.     FUNCPTR findRtn
  658.     )
  659.     {
  660.     GROUP_NODE * pGroup = groupFind (pList, group, findRtn);
  662.     if (pGroup)
  663. dllRemove (pList, (DL_NODE *)pGroup);
  664.     return (pGroup);
  665.     }
  667. /******************************************************************************
  668. *
  669. * syncGroupUpdate - update <symSyncLst> with elements of <symSyncTmpLst>
  670. *
  671. * <symSyncTmpLst> is used as a buffer to indicate when we are bringing
  672. * target symbols to host, that target module info were already synchronized
  673. * while symbols are not. When every symbols are synchronized then modules 
  674. * of <symSyncTmpLst> can be considered as synchronized.
  675. *
  676. * RETURNS: N/A.
  677. *
  678. * NOMANUAL
  679. */
  681. void syncGroupUpdate ()
  682.     {
  683.     GROUP_NODE * pToAdd = (GROUP_NODE *) dllGet (&symSyncTmpLst);
  685.     while (pToAdd != NULL)
  686. {
  687. if (groupFind (&symSyncLst, pToAdd->tgtGroup, 
  688. (FUNCPTR)isInTgtGroupList) == NULL)
  689.     dllAdd (&symSyncLst, (DL_NODE *)pToAdd);
  690. else 
  691.     free (pToAdd);
  692. pToAdd = (GROUP_NODE *) DLL_NEXT (pToAdd);
  693. }
  694.     }
  696. /******************************************************************************
  697. *
  698. * isInHostGroupList - check a given host group is in the list.
  699. *
  700. * RETURNS: TRUE if we should examine next element, FALSE otherwise.
  701. *
  702. * NOMANUAL
  703. */
  705. BOOL isInHostGroupList
  706.     (
  707.     DL_NODE * pNode,
  708.     int arg
  709.     )
  710.     {
  711.     if (((GROUP_NODE *)pNode)->hostGroup == (UINT32)arg)
  712. return (FALSE);
  713.     return (TRUE);
  714.     }
  716. /******************************************************************************
  717. *
  718. * isInTgtGroupList - check a given target group is in the list.
  719. *
  720. * RETURNS: TRUE if we should examine next element, FALSE otherwise.
  721. *
  722. * NOMANUAL
  723. */
  725. BOOL isInTgtGroupList
  726.     (
  727.     DL_NODE * pNode,
  728.     int arg
  729.     )
  730.     {
  731.     if (((GROUP_NODE *)pNode)->tgtGroup == arg)
  732. return (FALSE);
  733.     return (TRUE);
  734.     }
  736. /* HOST ----> TARGET */
  738. /******************************************************************************
  739. *
  740. * symSyncTgtUpdate - update target symbol table
  741. *
  742. * This routine parses and dispatches the target events received.
  743. *
  744. * RETURNS: OK or ERROR.
  745. *
  746. * NOMANUAL
  747. */
  749. STATUS symSyncTgtUpdate
  750.     (
  751.     HWTX hWtx, /* WTX API handle */
  752.     char * evtString, /* event received */
  753.     char * doneEvt  /* event sent when sync is done */
  754.     )
  755.     {
  756.     char * evtType;
  757.     char * info[3];
  758.     char * pLast = NULL;
  759.     STATUS status = OK;
  761.     evtType = strtok_r (evtString, " ", &pLast);
  762.     if (strcmp (evtType, OBJ_LOADED_EVT) == 0)
  763. {
  764. /* get the host module Id from the event string */
  766. info[0] = strtok_r (NULL, " ", &pLast); /* module Id */
  767. info[1] = strtok_r (NULL, " ", &pLast); /* module name */
  769. status = syncModCTgtUpdate (hWtx, H_STR_TO_L(info[0]));
  770. }
  772.     else if (strcmp (evtType, OBJ_UNLOADED_EVT) == 0)
  773. {
  774. /* get the host module group from the event string */
  776. info[0] = strtok_r (NULL, " ", &pLast); /* module id */
  777. info[1] = strtok_r (NULL, " ", &pLast); /* module name */
  778. info[2] = strtok_r (NULL, " ", &pLast); /* module group */
  780. status = syncModDTgtUpdate (hWtx, H_STR_TO_L(info[2]));
  781. }
  783.     else if (strcmp (evtType, SYM_ADDED_EVT) == 0)
  784. {
  785. info[1] = strtok_r (NULL, " ", &pLast); /* symbol name */
  787. status = syncSymAddTgtUpdate (hWtx, info[1]);
  788. }
  789.     else if (strcmp (evtType, SYM_REMOVED_EVT) == 0)
  790. {
  791. info[1] = strtok_r (NULL, " ", &pLast); /* symbol name */
  792. info[0] = strtok_r (NULL, " ", &pLast); /* symbol type */
  794. status = symSRemove (sysSymTbl, info[1], H_STR_TO_L(info[0]));
  795. }
  796.     else 
  797. return (OK);
  799.     if (strlen (info[1]) > OBJ_NAME_MAX)
  800. info[1][OBJ_NAME_MAX - 1] = '';
  801.     sprintf (doneEvt, "SYNC_DONE t %s %s %d", evtType, info[1], status);
  802.     return (status);
  803.     }
  805. /******************************************************************************
  806. *
  807. * syncModCTgtUpdate - update target info when a module is created on host
  808. *
  809. * RETURNS: OK or ERROR
  810. *
  811. * NOMANUAL
  812. */
  814. STATUS syncModCTgtUpdate
  815.     (
  816.     HWTX hWtx, /* WTX API handle */
  817.     UINT32 id /* host module id */
  818.     )
  819.     {
  820.     WTX_MODULE_INFO * pModInfo; /* host module informations */
  821.     MODULE_ID modId; /* target module Id */
  822.     WTX_SYM_LIST * pSymList; /* symbols of the module */
  823.     WTX_SYMBOL * pSymInfo;
  824.     STATUS status = OK;
  826.     /* Get the module info from the host and update target side */
  828.     if ((pModInfo = wtxObjModuleInfoGet (hWtx, id)) == NULL)
  829. return (ERROR);
  831.     /* check if the module was previously synchronized */
  832.     if (groupFind (&symSyncLst, pModInfo->group, isInHostGroupList) != NULL)
  833. {
  834. wtxResultFree (hWtx, pModInfo);
  835. return (OK);
  836. }
  837.     
  838.     /* create the new target module */
  839.     if ((modId = syncTgtModInfoFill (pModInfo)) == NULL)
  840. {
  841. wtxResultFree (hWtx, pModInfo);
  842. return (ERROR);
  843. }
  845.     /* get symbols from the tgtsvr and add them in target symTbl */
  846.     if ((pSymList = wtxSymListGet (hWtx, NULL, pModInfo->moduleName,
  847.    0, FALSE)) == NULL)
  848. {
  849. /* the module no longer exists on target */
  851. moduleDelete (modId);
  852. wtxResultFree (hWtx, pModInfo);
  853. return (ERROR);
  854. }
  856.     pSymInfo = pSymList->pSymbol;
  857.     while ((pSymInfo != NULL) && (status == OK))
  858. {
  859. status = symSAdd (sysSymTbl, pSymInfo->name, (char *)pSymInfo->value,
  860.   pSymInfo->type, modId->group);
  861. pSymInfo = pSymInfo->next;
  862. }
  864.     /* update synchronized group list */
  865.     groupAdd (&symSyncLst, modId->group, pModInfo->group);
  867.     wtxResultFree (hWtx, pSymList);
  868.     wtxResultFree (hWtx, pModInfo);
  869.     return (status);
  870.     }
  872. /******************************************************************************
  873. *
  874. * syncModDTgtUpdate - update target info when a module is deleted on host
  875. *
  876. * RETURNS: OK or ERROR
  877. *
  878. * NOMANUAL
  879. */
  881. STATUS syncModDTgtUpdate
  882.     (
  883.     HWTX hWtx,  /* WTX API handler */
  884.     UINT32 group /* group (on host) of the deleted module */
  885.     )
  886.     {
  887.     STATUS status = OK;
  889.     MODULE_ID modId; /* target module Id */
  890.     GROUP_NODE * pGroup; /* group node of the module */
  892.     /* remove the module from the synchronized group list */
  894.     if ((pGroup = groupRemove (&symSyncLst, group, 
  895.        (FUNCPTR)isInHostGroupList)) == NULL)
  896. return (ERROR);
  898.     /* unload the module on target side */
  900.     if ((modId = moduleFindByGroup (pGroup->tgtGroup)) != NULL)
  901. status = unldByModuleId (modId, UNLD_SYNC);
  903.     free (pGroup);
  905. #ifdef DEBUG
  906.     if (status == ERROR)
  907. fprintf (stderr, "unload pbn");
  908. #endif
  909.     return (status);
  910.     }
  912. /******************************************************************************
  913. *
  914. * syncSymAddTgtUpdate - update target symbol table when a symbol is added
  915. *
  916. * RETURNS: OK or ERROR
  917. *
  918. * NOMANUAL
  919. */
  921. STATUS syncSymAddTgtUpdate
  922.     (
  923.     HWTX hWtx, /* WTX API handle */
  924.     char * symName /* symbol name */
  925.     )
  926.     {
  927.     GROUP_NODE * pGroup; /* group node of the module */
  928.     WTX_SYMBOL * pSymInfo;
  929.     UINT16  tgtGroup;
  930.     STATUS  status = OK;
  932.     if ((pSymInfo = wtxSymFind (hWtx, symName, 0, TRUE, 0, 0)) == NULL)
  933. return (ERROR);
  935.     /* 
  936.      * get the corresponding target group 
  937.      * the default group number (0) is the same on host and target
  938.      */
  940.     if ((tgtGroup = pSymInfo->group) != 0)
  941. {
  942. if ((pGroup = groupFind (&symSyncLst, pSymInfo->group,
  943.  (FUNCPTR)isInHostGroupList)) == NULL)
  944.     /* XXX ELP inexistant group set to 0 */
  945.     tgtGroup = 0;
  946. tgtGroup = pGroup->tgtGroup;
  947. }
  949.     status = symSAdd (sysSymTbl, pSymInfo->name, (char *)pSymInfo->value,
  950.       pSymInfo->type, tgtGroup);
  952.     wtxResultFree (hWtx, pSymInfo);
  953.     return (status);
  954.     }
  956. /******************************************************************************
  957. *
  958. * syncTgtModInfoFill - fill target module information
  959. *
  960. * From a host module descriptor we get the information to store on the target
  961. * side.
  962. *
  963. * note: flag LOAD_LOADED_BY_TGTSVR is set in order we know that if the
  964. * target-server restarts these modules become obsolete.
  965. * note: To prevent from displaying 0xffffffff on target moduleShow(), segment
  966. * address is set to 0 when the segment does not exist.
  967. * note: The segment flag SEG_FREE_MEMORY is removed to prevent the memory from
  968. * being freed twice when unloading (1 by host and 1 by target).
  969. *
  970. * RETURNS: target module Id or NULL.
  971. *
  972. * NOMANUAL
  973. */
  975. MODULE_ID syncTgtModInfoFill
  976.     (
  977.     WTX_MODULE_INFO *   pModInfo
  978.     )
  979.     {
  980.     MODULE_ID modId;
  981.     int format = -1;
  982.     int flags = 0;
  983.     int segType;
  984.     int segAddr;
  985.     int ix;
  986.     STATUS status = OK;
  988.     /* tarnslate host format into target format */
  989.     
  990.     if (strcmp (pModInfo->format, "a.out") == 0)
  991. format = MODULE_A_OUT;
  992.     else if (strcmp (pModInfo->format, "coff") == 0)
  993. format = MODULE_ECOFF;
  994.     else if (strcmp (pModInfo->format, "elf") == 0)
  995. format = MODULE_ELF;
  997.     /* translate host load flags into target host flags */
  999.     if (pModInfo->loadFlag & 0x1)
  1000. flags |= LOAD_NO_SYMBOLS;
  1001.     if (pModInfo->loadFlag & 0x2)
  1002. flags |= LOAD_LOCAL_SYMBOLS;
  1003.     if (pModInfo->loadFlag & 0x4)
  1004. flags |= LOAD_GLOBAL_SYMBOLS;
  1005.     flags |= (pModInfo->loadFlag & 0x00fffff0);
  1006.     flags |= LOAD_LOADED_BY_TGTSVR;
  1008.     /* create the module on the target */
  1010.     if ((modId = moduleCreate (pModInfo->moduleName, format, flags)) == NULL)
  1011. return (NULL);
  1013.     /* add the segments */
  1014.     
  1015.     for (ix = 0; (ix < pModInfo->nSegments) && (status == OK); ix++)
  1016. {
  1017. switch (ix)
  1018.     {
  1019.     case 0: segType = SEGMENT_TEXT; break;
  1020.     case 1: segType = SEGMENT_DATA; break; 
  1021.     case 2: segType = SEGMENT_BSS; break;
  1022. #ifdef INCLUDE_SDA
  1023.     case 3: segType = SEGMENT_SDATA; break;
  1024.     case 4: segType = SEGMENT_SBSS; break;
  1025.     case 5: segType = SEGMENT_SDATA2; break;
  1026.     case 6: segType = SEGMENT_SBSS2; break;
  1027. #endif
  1028.     default: segType = -1; break;
  1029.     }
  1031. segAddr = ((int)pModInfo->segment[ix].addr != -1) ?
  1032.   (int)pModInfo->segment[ix].addr : 0;
  1033. status = moduleSegAdd (modId, segType, (void *)segAddr,
  1034.        pModInfo->segment[ix].length,
  1035.       (pModInfo->segment[ix].flags & ~SEG_FREE_MEMORY));
  1036. }
  1038.     if (status == OK)
  1039. return (modId);
  1040.     else 
  1041. {
  1042. moduleDelete (modId);
  1043. return (NULL);
  1044. }
  1045.     }
  1047. /* TARGET ----> HOST  */
  1049. /******************************************************************************
  1050. *
  1051. * symSyncHostUpdate -  update host side depending on <evtString>
  1052. *
  1053. * This routine dispatch the WTX events received from the target server
  1054. *
  1055. * RETURNS:
  1056. *
  1057. * NOMANUAL
  1058. */
  1060. STATUS symSyncHostUpdate
  1061.     (
  1062.     HWTX hWtx, /* WTX API handle */
  1063.     char * evtString, /* event received */
  1064.     char * doneEvt /* event sent when sync is done */
  1065.     )
  1066.     {
  1067.     char * pLast = NULL;
  1068.     STATUS status = OK;
  1069.     char * evtType; /* synchronization event type */
  1070.     char * info[4]; /* store event tokens */
  1071.     BOOL eventSend = TRUE;
  1073.     evtType = strtok_r (evtString, " ", &pLast);
  1074.     if (strcmp (evtType, OBJ_LOADED_EVT) == 0)
  1075. {
  1076. info[1] = strtok_r (NULL, " ", &pLast);  /* module id */
  1077. info[0] = strtok_r (NULL, " ", &pLast);  /* module name */
  1079. status = syncModCHostUpdate (hWtx, &symSyncLst,
  1080.      (MODULE_ID)H_STR_TO_L(info[1]),
  1081.      &eventSend, TRUE);
  1082. }
  1083.     else if (strcmp (evtType, OBJ_UNLOADED_EVT) == 0)
  1084. {
  1085. info[0] = strtok_r (NULL, " ", &pLast); /* mod name */
  1086. info[1] = strtok_r (NULL, " ", &pLast); /* mod group */
  1088. status = syncModDHostUpdate (hWtx, info[0], H_STR_TO_L(info[1]));
  1089. }
  1090.     else if (strcmp (evtType, SYM_ADDED_EVT) == 0)
  1091. {
  1092. info[0] = strtok_r (NULL, " ", &pLast); /* sym name */
  1093. info[1] = strtok_r (NULL, " ", &pLast); /* sym val */
  1094. info[2] = strtok_r (NULL, " ", &pLast); /* sym type */
  1095. info[3] = strtok_r (NULL, " ", &pLast); /* sym group */
  1097. status = syncSymAddHostUpdate (hWtx, info[0],
  1098.    (char *)H_STR_TO_L(info[1]),
  1099.    H_STR_TO_L(info[2]), H_STR_TO_L(info[3]));
  1100. }
  1101.     else if (strcmp (evtType, SYM_REMOVED_EVT) == 0)
  1102. {
  1103. info[0] = strtok_r (NULL, " ", &pLast); /* sym name */
  1104. info[1] = strtok_r (NULL, " ", &pLast); /* sym type */
  1106. status = syncSymRemHostUpdate (hWtx, info[0], H_STR_TO_L(info[1]));
  1107. }
  1108.     else if (strcmp (evtType, USR_RQST_EVT) == 0)
  1109. {
  1110. info[0] = "target_modules";
  1111. info[1] = strtok_r (NULL, " ", &pLast); /* sense */
  1112. info[2] = strtok_r (NULL, " ", &pLast); /* starting tgtsvr? */
  1114. status = syncUsrUpdate (hWtx, H_STR_TO_L(info[1]), H_STR_TO_L(info[2]));
  1115. }
  1117.     else 
  1118. {
  1119. #ifdef DEBUG
  1120. logMsg ("unknown target eventn", 0, 0, 0, 0, 0, 0);
  1121. #endif
  1122. return (OK);
  1123. }
  1125.     if (eventSend)
  1126. {
  1127. if (strlen (info[0]) > OBJ_NAME_MAX)
  1128.     info[0][OBJ_NAME_MAX - 1] = '';
  1129. sprintf (doneEvt, "SYNC_DONE h %s %s %d", evtType, info[0], status);
  1130. wtxEventAdd (hWtx, doneEvt, 0, NULL);
  1131. }
  1133.     return (status);
  1134.     }
  1136. /******************************************************************************
  1137. *
  1138. * syncModCHostUpdate - update host side when a module is created on target
  1139. *
  1140. * This routine creates a module on the host with the same information than on
  1141. * the target (except group number). If <addSym> is TRUE the routine looks for
  1142. * the symbol of that module and add them in the host symbol table, otherwise
  1143. * symbols are not added here.
  1144. *
  1145. * RETURNS:
  1146. *
  1147. * NOMANUAL
  1148. */
  1150. STATUS syncModCHostUpdate
  1151.     (
  1152.     HWTX hWtx, /* WTX API handle */
  1153.     DL_LIST * pList, /* where to add the synchronized module */
  1154.     MODULE_ID modId, /* target module Id */
  1155.     BOOL * pEventSend, /* send back an event when synchro is done */
  1156.     BOOL addSym /* add module's symbol or not */
  1157.     )
  1158.     {
  1159.     STATUS status = OK; /* synchro status */
  1160.     WTX_LD_M_FILE_DESC in; /* host mod creation input */
  1161.     WTX_LD_M_FILE_DESC * pObjInfo; /* object file info */
  1162.     WTX_MODULE_INFO * pModInfo; /* host module info */
  1163.     BY_GROUP_ARG_T  modFind;
  1164.     MODULE sMod; /* stored module */
  1166.     /* store module information to get them safely later */
  1167.     taskLock();
  1168.     if (OBJ_VERIFY (modId, moduleClassId) == OK)
  1169. memcpy (&sMod, modId, sizeof(MODULE));
  1170.     else 
  1171. {
  1172. taskUnlock ();
  1173. return (ERROR);
  1174. }
  1175.     taskUnlock();
  1177.     /* check if the module was previously synchronized */
  1178.     
  1179.     if (groupFind (&symSyncLst, sMod.group, isInTgtGroupList) != NULL)
  1180. {
  1181. /* we do not send an event to tgtsvr because no work is performed */
  1183. *pEventSend = FALSE;
  1184. return (OK);
  1185. }
  1187.     /* prepare host module creation */
  1189.     if (syncHostModInfoFill (&in, &sMod, TRUE) == ERROR)
  1190. return (ERROR);
  1192.     /* create the host module (flag LOAD_MODULE_INFO_ONLY is set) */
  1194.     if ((pObjInfo = wtxObjModuleLoad (hWtx, &in)) == NULL)
  1195. {
  1196. free (in.filename);
  1197. free (in.section);
  1198. return (ERROR);
  1199. }
  1200.     free (in.filename);
  1201.     free (in.section);
  1203.     /* get newly created host module information */
  1204.     
  1205.     if ((pModInfo = wtxObjModuleInfoGet (hWtx, pObjInfo->moduleId)) == NULL)
  1206. {
  1207. wtxResultFree (hWtx, pObjInfo);
  1208. return (ERROR);
  1209. }
  1210.     
  1211.     /* add the module in the synchronized group list */
  1212.     
  1213.     groupAdd (pList, sMod.group, pModInfo->group);
  1215.     if (addSym)
  1216. {
  1217. /* add the symbols of the new module */
  1218.     /* 
  1219.      * XXX ELP there is no routine that returns a symbol list as tgtsvr does.
  1220.      * The solution is to go through the whole symTbl and add the concerned 
  1221.      * symbols one by one. Building a list and sending it once should be faster.
  1222.      */
  1224.      modFind.hWtx = hWtx;
  1225. modFind.tgtGroup = sMod.group;
  1226. modFind.hostGroup = pModInfo->group;
  1228. if (symEach (sysSymTbl, (FUNCPTR)syncSymByGrpToHost, (int)&modFind)
  1229.     != NULL)
  1230.     /* because of an error we did not go through the all list */
  1231.     status = ERROR;
  1232. }
  1234.     wtxResultFree (hWtx, pObjInfo);
  1235.     wtxResultFree (hWtx, pModInfo);
  1237.     return (status);
  1238.     }
  1240. /******************************************************************************
  1241. *
  1242. * syncModDHostUpdate - upadte host side when a module is deleted on target
  1243. *
  1244. * RETURNS:
  1245. *
  1246. * NOMANUAL
  1247. */
  1249. STATUS syncModDHostUpdate
  1250.     (
  1251.     HWTX hWtx, /* WTX API handle */
  1252.     char * modName, /* name of the deleted module */
  1253.     UINT16 modGroup /* group of the deleted module */
  1254.     )
  1255.     {
  1256.     GROUP_NODE * pGroup;
  1257.     UINT32 moduleId = 0;
  1259.     /* remove the module from the synchronized group list */
  1261.     if ((pGroup = groupRemove (&symSyncLst, modGroup , isInTgtGroupList))
  1262. == NULL)
  1263. return (OK);
  1264.     free (pGroup);
  1266.     /* check to see if the module should be unloaded on host side */
  1268.     moduleId = wtxObjModuleFindId (hWtx, modName);
  1270.     if (moduleId)
  1271. wtxObjModuleUnload (hWtx, moduleId);
  1272.     
  1273.     return (OK);
  1274.     }
  1276. /******************************************************************************
  1277. *
  1278. * syncSymAddHostUpdate - update host symTbl when a symbol is added on target
  1279. *
  1280. * RETURNS: 
  1281. *
  1282. * NOMANUAL
  1283. */
  1285. STATUS syncSymAddHostUpdate
  1286.     (
  1287.     HWTX hWtx, /* WTX API handle */
  1288.     char * name, /* symbol name */
  1289.     char * val, /* symbol value */
  1290.     SYM_TYPE type, /* symbol type */
  1291.     UINT16 group /* symbol group */
  1292.     )
  1293.     {
  1294.     GROUP_NODE * pGroup;
  1295.     UINT32 hGroup;
  1296.     MODULE_ID modId;
  1297.     STATUS status = OK;
  1298.     BOOL  eventSend = TRUE;
  1299.     char  buf[SYNC_TGT_EVT_LGTH];
  1300.     char  doneEvt[SYNC_TGT_EVT_LGTH];
  1302.     /* find the corresponding host group */
  1304.     if (group == symGroupDefault)
  1305. hGroup = 0; 
  1306.     else if ((pGroup = groupFind (&symSyncLst, group,
  1307.   (FUNCPTR)isInTgtGroupList)) != NULL)
  1308. hGroup = pGroup->hostGroup;
  1309.     else
  1310. {
  1311. /* symbol's group is unknown on host side */
  1313. if ((modId = moduleFindByGroup (group)) == NULL)
  1314.     hGroup = 0; /* XXX ELP */
  1315. else 
  1316.     {
  1317.     /*
  1318.      * it seems very hard to come here but... we answer we failed
  1319.      * and try to load the unsynchronized module.
  1320.      */
  1321.      
  1322.     memset (buf, 0, SYNC_TGT_EVT_LGTH);
  1323.     taskLock();
  1324.     if (OBJ_VERIFY (modId, moduleClassId) == OK)
  1325. {
  1326. strncpy (buf, modId->name, SYNC_TGT_EVT_LGTH - 1);
  1327. buf[SYNC_TGT_EVT_LGTH - 1] = EOS;
  1328. }
  1329.     taskUnlock();
  1331.     status = syncModCHostUpdate (hWtx, &symSyncLst, modId, &eventSend,
  1332.  FALSE);
  1333.     if (eventSend)
  1334. {
  1335. if (strlen (buf) > OBJ_NAME_MAX)
  1336.     buf [OBJ_NAME_MAX - 1] = '';
  1337. sprintf (doneEvt, "SYNC_DONE h OBJ_LOADED %s %d", buf,
  1338.  status);
  1339. wtxEventAdd (hWtx, doneEvt, 0, NULL);
  1340. }
  1341.     return (status);
  1342.     }
  1343. }
  1345.     if (wtxSymAddWithGroup (hWtx, name, (TGT_ADDR_T)val, type, hGroup)
  1346. == WTX_ERROR)
  1347. status = ERROR;
  1349.     return (status);
  1350.     }
  1352. /******************************************************************************
  1353. *
  1354. * syncSymRemHostUpdate - update host symTbl when a target symbol is removed
  1355. * 
  1356. * This routine is called if the target remove a symbol.
  1357. *
  1358. * RETURNS: OK or ERROR.
  1359. *
  1360. * NOMANUAL
  1361. */
  1363. STATUS syncSymRemHostUpdate
  1364.     (
  1365.     HWTX hWtx, /* WTX API handle */
  1366.     char * symName, /* symbol name */
  1367.     SYM_TYPE symType /* symbol type */
  1368.     )
  1369.     {
  1370.     STATUS status = OK;
  1371.     if (wtxSymRemove (hWtx, symName, symType) == WTX_ERROR)
  1372. status = ERROR;
  1374.     return (status);
  1375.     }
  1377. /******************************************************************************
  1378. *
  1379. * syncUsrUpdate - update target from host and host from target
  1380. *
  1381. * This routine is called when the user asks for it.
  1382. * if <sense> is 1 then synchronization is done from target to host.
  1383. *
  1384. * the following is unused
  1385. * if <sense> is 2 then synchronization is done from host to target. 
  1386. * if <sense> is 0 then both synchronization are performed. 
  1387. * <toolId> is used to identify the tool that requested for synchronization
  1388. *
  1389. * note: host symbols that don't belong to a module are not synchronized.
  1390. *
  1391. * RETURNS: OK or ERROR.
  1392. *
  1393. * NOMANUAL
  1394. */
  1396. STATUS syncUsrUpdate
  1397.     (
  1398.     HWTX hWtx, /* WTX API handle */
  1399.     int sense, /* synchronization sense */
  1400.     int start /* TRUE if the target server is starting */
  1401.     )
  1402.     {
  1403.     WTX_MODULE_LIST * pModList;
  1404.     STATUS status = OK;
  1405.     int ix;
  1406.     char evtBuf[60];
  1408.     if ((sense == 0) || (sense == 1))
  1409.      {
  1410. /*
  1411.  * Check every modules that will be synchronized are target modules.
  1412.  * Otherwise the target server may have restarted, thus it considers
  1413.  * segments are no more allocated!
  1414.  */
  1415. if (start)
  1416.     {
  1417.     moduleEach (syncTgtSafeModCheck, (int) hWtx);
  1418.     }
  1420. /* process each symbol of the target symbol table */
  1422. if (OBJ_VERIFY (sysSymTbl, symTblClassId) == OK)
  1423.     {
  1424.     if (symEach (sysSymTbl, (FUNCPTR)syncEachSymToHost,
  1425.  (int)hWtx) != NULL)
  1426. return (ERROR);
  1428.     /* add modules that was not yet in the sync group list */
  1429.     syncGroupUpdate ();
  1430.     }
  1431. }
  1433.     if ((sense == 0) || (sense == 2))
  1434. {
  1435. pModList = wtxObjModuleList (hWtx);
  1436. for (ix = 0;
  1437.      (pModList != NULL) && (status == OK) && (ix < pModList->numObjMod);
  1438.      ix++)
  1439.     status = syncModCTgtUpdate (hWtx, pModList->modIdList[ix]);
  1440. wtxResultFree (hWtx, pModList);
  1442. sprintf (evtBuf, "SYNC_DONE t USR_RQST target_modules %d", status);
  1443. wtxEventAdd (hWtx, evtBuf, 0, NULL);
  1444. }
  1446.     return (status);
  1447.     }
  1449. /******************************************************************************
  1450. *
  1451. * syncTgtSafeModCheck - check if a target module can be safely used
  1452. *
  1453. * If synchronization is running, modules loaded by the target-server are added
  1454. * to the target side. Then, if the target-server restarts (without rebooting)
  1455. * these modules seem to be loaded on target side while memory is no more 
  1456. * allocated. This routine unloads such modules (it is not possible to
  1457. * automatically reload them because we do not have the path of the file). 
  1458. *
  1459. * RETURNS: TRUE to go through the whole module list, FALSE if an error occured.
  1460. *
  1461. * NOMANUAL
  1462. */
  1464. BOOL syncTgtSafeModCheck
  1465.     (
  1466.     MODULE_ID moduleId,
  1467.     int arg /* WTX API handle */
  1468.     )
  1469.     {
  1470.     /*
  1471.      * if the module is loaded by target server and it is no more in
  1472.      * synchronization list then it is a "zombie" module.
  1473.      */
  1475.     if ((moduleId->flags & LOAD_LOADED_BY_TGTSVR) &&
  1476. (groupFind (&symSyncLst, moduleId->group, isInTgtGroupList) == NULL))
  1477. unldByModuleId (moduleId, UNLD_SYNC);
  1479.     return (TRUE);
  1480.     }
  1482. /******************************************************************************
  1483. *
  1484. * syncEachSymToHost - update the host symbol table if needed
  1485. *
  1486. * This routine examine a symbol to know if it should be added in host symTbl.
  1487. *
  1488. * RETURNS: TRUE if we should go to next symbol, FALSE otherwise.
  1489. *
  1490. * NOMANUAL
  1491. */
  1493. BOOL syncEachSymToHost
  1494.     (
  1495.     char *      name,   /* entry name */
  1496.     int         val,    /* value associated with entry */
  1497.     SYM_TYPE    type,   /* entry type */
  1498.     int         arg,    /* wtx API handle */
  1499.     UINT16      group   /* group number (on target side) */
  1500.     )
  1501.     {
  1502.     HWTX                        hWtx = (HWTX)arg; /* wtx API handle */
  1503.     MODULE_ID                   modId; /* target module Id */
  1504.     GROUP_NODE *                pGroup;
  1505.     UINT32 hGroup;
  1506.     WTX_SYMBOL * pSymbol;
  1507.     BOOL dummy;
  1509.     if (groupFind (&symSyncLst, group, (FUNCPTR)isInTgtGroupList) != NULL)
  1510. /* this module is already synchronized */
  1511. return TRUE;
  1513.     if (group == symGroupDefault)
  1514. {
  1515. /* XXX ELP, 2 possibilities 
  1516.  * 1. we do not synchronize these symbols in forced mode since we do
  1517.  *    not know if it was already done before. 
  1518.  * 2. we examine host symbol table to see if the symbol is already
  1519.  *    existing. if so we return, otherwise we add it.
  1520.  * choose 2
  1521.  */
  1522. hGroup = 0;
  1523. if ((pSymbol = wtxSymFind (hWtx, name, 0, TRUE, type, N_TYPE))
  1524.     != NULL)
  1525.     {
  1526.     if ((pSymbol->value == val) && (pSymbol->group == hGroup))
  1527. {
  1528. wtxResultFree (hWtx, pSymbol);
  1529. return (TRUE);
  1530. }
  1531.     wtxResultFree (hWtx, pSymbol);
  1532.     }
  1533. }
  1534.     else if ((pGroup = groupFind (&symSyncTmpLst, group, 
  1535.   (FUNCPTR)isInTgtGroupList)) == NULL)
  1536. {
  1537. /* this module is unknown on host, we must add it */
  1539. if ((modId = moduleFindByGroup (group)) == NULL)
  1540.     return (FALSE);
  1541. if (syncModCHostUpdate (hWtx, &symSyncTmpLst, modId, &dummy, FALSE)
  1542.     == ERROR)
  1543.     return (FALSE);
  1544. if ((pGroup = groupFind (&symSyncTmpLst, group,
  1545.  (FUNCPTR)isInTgtGroupList)) == NULL)
  1546.     return (FALSE);
  1547. hGroup = pGroup->hostGroup;
  1548. }
  1549.     else
  1550. hGroup = pGroup->hostGroup;
  1552.     /* add the symbol */
  1553.     
  1554.     if (wtxSymAddWithGroup (hWtx, name, (TGT_ADDR_T)val, type, hGroup)
  1555. != WTX_OK)
  1556. return (FALSE);
  1557.    
  1558.     /* if it is an undefined symbol, update the corresponding module info */
  1560.     if (type == N_UNDF)
  1561. {
  1562. if (wtxObjModuleUndefSymAdd (hWtx, name, hGroup) != WTX_OK)
  1563.     return (FALSE);
  1564. }
  1565.     
  1566.     return (TRUE);
  1567.     }
  1569. /******************************************************************************
  1570. *
  1571. * syncSymByGrpToHost - update host symbol table with symbols of a given group
  1572. *
  1573. * This routine examine each symbol of a given group to know if it should be
  1574. * added in host symTbl.
  1575. *
  1576. * RETURNS: TRUE if we should examine the next symbol, FALSE otherwise.
  1577. *
  1578. * NOMANUAL
  1579. */
  1581. BOOL syncSymByGrpToHost
  1582.     (
  1583.     char *      name,   /* entry name */
  1584.     int         val,    /* value associated with entry */
  1585.     SYM_TYPE    type,   /* entry type */
  1586.     int         arg,    /* wtx API handle, host and target groups */
  1587.     UINT16      group   /* group number (on target side) */
  1588.     )
  1589.     {
  1590.     BY_GROUP_ARG_T * pArg = (BY_GROUP_ARG_T *)arg;
  1592.     if (group != pArg->tgtGroup)
  1593. return (TRUE);
  1595.     if (wtxSymAddWithGroup (pArg->hWtx, name, (TGT_ADDR_T)val, type,
  1596.     pArg->hostGroup) == WTX_ERROR)
  1597. return (FALSE);
  1599.     /* if it is an undefined symbol, update the corresponding module info */
  1601.     if (type == N_UNDF)
  1602. {
  1603. if (wtxObjModuleUndefSymAdd (pArg->hWtx, name, pArg->hostGroup)
  1604.     == WTX_ERROR)
  1605.     return (FALSE);
  1606. }
  1607.     
  1608.     return (TRUE);
  1609.     }
  1611. /******************************************************************************
  1612. *
  1613. * syncHostModInfoFill - fill a host module descriptor from a target MODULE_ID
  1614. * 
  1615. * This routine creates a module on host side with the information provided by 
  1616. * the target module identifier.
  1617. * note: if <synchro> is TRUE, loadFlag LOAD_MODULE_INFO_ONLY is set to indicate
  1618. * that the module is already loaded so wtxObjModuleLoad() will not do it
  1619. * again.
  1620. * note: segment flag is always unset to prevent segment memory from being freed
  1621. * twice when unloading module (1 on target and 1 on host).
  1622. *
  1623. * RETURNS: OK or ERROR
  1624. *
  1625. * NOMANUAL
  1626. */
  1628. STATUS syncHostModInfoFill
  1629.     (
  1630.     WTX_LD_M_FILE_DESC * pFileDesc,
  1631.     MODULE_ID modId,
  1632.     BOOL synchro
  1633.     )
  1634.     {
  1635.     char * fileNameBuf = NULL;
  1636.     SEGMENT_ID segId;
  1637.     int ix;
  1639.     memset (pFileDesc, 0, sizeof(WTX_LD_M_FILE_DESC));
  1640.     
  1641.     if ((fileNameBuf = malloc (PATH_MAX + NAME_MAX)) == NULL)
  1642. return (ERROR);
  1644.     sprintf (fileNameBuf, "%s/%s", modId->path, modId->name);
  1646.     pFileDesc->filename = fileNameBuf;
  1647.     pFileDesc->moduleId = 0;
  1649.     /*
  1650.      * undefined symbol list is initialized empty at first,
  1651.      * if undefined symbol are found when going through symbol table they are
  1652.      * added in this list
  1653.      */
  1654.     
  1655.     pFileDesc->undefSymList.pSymbol = NULL;
  1657.     /* translate target module flags into host module flag */
  1659.     if (modId->flags & LOAD_NO_SYMBOLS)
  1660. pFileDesc->loadFlag |= 0x1;
  1661.     if (modId->flags & LOAD_LOCAL_SYMBOLS)
  1662. pFileDesc->loadFlag |= 0x2;
  1663.     if (modId->flags & LOAD_GLOBAL_SYMBOLS)
  1664. pFileDesc->loadFlag |= 0x4;
  1665.     pFileDesc->loadFlag |= (modId->flags & HIDDEN_MODULE);
  1667.     if (!synchro)
  1668. {
  1669. /* we want to load the file, letting target-server decide where */
  1671. pFileDesc->nSections = 0;
  1672. return (OK);
  1673. }
  1675.     pFileDesc->loadFlag |= LOAD_MODULE_INFO_ONLY;
  1676.     pFileDesc->nSections = dllCount (&modId->segmentList);
  1677.     if ((pFileDesc->section = (LD_M_SECTION *)
  1678.  malloc (pFileDesc->nSections * sizeof (LD_M_SECTION))) == NULL)
  1679. {
  1680. free (fileNameBuf);
  1681. return (ERROR);
  1682. }
  1684.     for (segId = (SEGMENT *)DLL_FIRST (&modId->segmentList);
  1685.  segId != NULL; segId = (SEGMENT *)DLL_NEXT (segId))
  1686. {
  1687. switch (segId->type)
  1688.     {
  1689.     case SEGMENT_TEXT: ix = 0; break;
  1690.     case SEGMENT_DATA: ix = 1; break;
  1691.     case SEGMENT_BSS: ix = 2; break;
  1692. #ifdef INCLUDE_SDA
  1693.     /*
  1694.      * XXX ELP every segments are put in the list even if SDA segments
  1695.      * are currently useless. (it will be necessary to add the
  1696.      * memPartId info in the LD_M_SECTION structure)
  1697.      */
  1698.     case SEGMENT_SDATA: ix = 3; break;
  1699.     case SEGMENT_SBSS: ix = 4; break;
  1700.     case SEGMENT_SDATA2: ix = 5; break;
  1701.     case SEGMENT_SBSS2: ix = 6; break;
  1702. #endif /* INCLUDE_SDA */
  1703.     default: ix = -1; break;
  1704.     }
  1705. if (ix < 0)
  1706.     continue;
  1707. pFileDesc->section[ix].flags = segId->flags & ~SEG_FREE_MEMORY;
  1708. pFileDesc->section[ix].addr = (segId->size == 0) ? (TGT_ADDR_T) -1 :
  1709.       (TGT_ADDR_T)segId->address;
  1710. pFileDesc->section[ix].length = segId->size;
  1711. }
  1713.     return (OK);
  1714.     }
  1716. /******************************************************************************
  1717. *
  1718. * syncLoadHook - load module hook
  1719. *
  1720. * RETURNS: N/A
  1721. * 
  1722. * NOMANUAL
  1723. */
  1725. void syncLoadHook
  1726.     (
  1727.     MODULE_ID modId
  1728.     )
  1729.     {
  1730.     char buf[SYNC_TGT_EVT_LGTH];
  1731.     char  name[SYNC_TGT_EVT_LGTH - 25];
  1733.     strncpy (name, modId->name, SYNC_TGT_EVT_LGTH - 26);
  1734.     name[SYNC_TGT_EVT_LGTH - 26] = EOS;
  1735.     sprintf (buf, "%s %#x %s", OBJ_LOADED_EVT, (UINT32)modId, name);
  1736.     if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
  1737. == ERROR)
  1738. {
  1739. #ifdef DEBUG
  1740. logMsg ("module 0x%x sync failedn", (int)modId, 0,0,0,0,0);
  1741. #endif
  1742. return;
  1743. }
  1744.     return;
  1745.     }
  1747. /******************************************************************************
  1748. *
  1749. * syncUnldHook - unload module hook
  1750. *
  1751. * RETURNS: N/A
  1752. * 
  1753. * NOMANUAL
  1754. */
  1756. void syncUnldHook
  1757.     (
  1758.     MODULE_ID modId
  1759.     )
  1760.     {
  1761.     char buf[SYNC_TGT_EVT_LGTH];
  1762.     char  name[SYNC_TGT_EVT_LGTH - 25];
  1764.     strncpy (name, modId->name, SYNC_TGT_EVT_LGTH - 26);
  1765.     name[SYNC_TGT_EVT_LGTH - 26] = EOS;
  1767.     sprintf (buf, "%s %s %#x", OBJ_UNLOADED_EVT, name, modId->group);
  1769.     if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
  1770. == ERROR)
  1771. {
  1772. #ifdef DEBUG
  1773. logMsg ("module 0x%x deletion sync failedn", (int)modId,
  1774. 0, 0, 0, 0, 0);
  1775. #endif
  1776. return ;
  1777. }
  1778.     }
  1780. /******************************************************************************
  1781. *
  1782. * syncSymAddHook - symbol addition hook
  1783. *
  1784. * RETURNS: N/A
  1785. *
  1786. * NOMANUAL
  1787. */
  1789. void syncSymAddHook
  1790.     (
  1791.     char * name,
  1792.     char * value,
  1793.     SYM_TYPE type,
  1794.     UINT16 group
  1795.     )
  1796.     {
  1797.     char buf[SYNC_TGT_EVT_LGTH];
  1798.     char  symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH];
  1800.     if (group == 1) /* symbol table group */
  1801. return ;
  1803.     strncpy (symName, name, 
  1804.      SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH - 1);
  1805.     symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH -1] = EOS;
  1806.     
  1807.     /*
  1808.      * The message for SYM_ADDED event will look as follows:
  1809.      *
  1810.      *  "SYM_ADDED <name> 0x<value> 0x<type> 0x<group>"
  1811.      *   |   9   | |    | |  10   | |  4   | |   6   |
  1812.      *
  1813.      * <value>: char*, takes 8 bytes at maximum in the output of sprintf;
  1814.      * <type> : SYM_TYPE, takes 2 bytes at maximum in the output of sprintf;
  1815.      * <group>: UINT16, takes 4 bytes at maximum in the output of sprintf;
  1816.      *
  1817.      * Totally, the non-name information(including white spaces and EOS) takes
  1818.      * at maximum 9+1+1+10+1+4+1+6+1 = 34. So define macro
  1819.      * SYM_ADDED_EVT_MSG_NON_NAME_LGTH to 34
  1820.      */
  1822.     sprintf (buf, "%s %s 0x%x 0x%x 0x%x", SYM_ADDED_EVT, symName, (int)value,
  1823.      type, group);
  1824.     if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
  1825. == ERROR)
  1826. {
  1827. #ifdef DEBUG
  1828. logMsg ("sym %s addition sync failedn", (int)name, 0, 0, 0, 0, 0);
  1829. #endif
  1830. return ;
  1831. }
  1832.     }
  1834. /******************************************************************************
  1835. *
  1836. * syncSymRemoveHook - symbol removing hook
  1837. *
  1838. * RETURNS: N/A
  1839. *
  1840. * NOMANUAL
  1841. */
  1843. void syncSymRemoveHook
  1844.     (
  1845.     char * name,
  1846.     SYM_TYPE type
  1847.     )
  1848.     {
  1849.     /* SYM_ADDED_EVT_MSG_NON_NAME_LGTH is used to calculate space for
  1850.      * symbol name so syncSymRemoveHook and syncSymAdd Hook agree on
  1851.      * acceptable length of symbol name
  1852.      */
  1854.     char buf[SYNC_TGT_EVT_LGTH];
  1855.     char  symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH];
  1857.     strncpy (symName, name, 
  1858.      SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH - 1);
  1859.     symName[SYNC_TGT_EVT_LGTH - SYM_ADDED_EVT_MSG_NON_NAME_LGTH -1] = EOS;
  1861.     sprintf (buf, "%s %s 0x%x", SYM_REMOVED_EVT, symName, type);
  1862.     if (msgQSend (symSyncMsgQId, buf, SYNC_TGT_EVT_LGTH, WAIT_FOREVER, 0)
  1863. == ERROR)
  1864. {
  1865. #ifdef DEBUG
  1866. logMsg ("sym %s removing sync failedn", (int)name, 0, 0, 0, 0, 0);
  1867. #endif
  1868. return ;
  1869. }
  1870.     }
  1872. /*******************************************************************************
  1873. *
  1874. * symSRemove - remove a symbol from a symbol table
  1875. *
  1876. * This routine behaves like symRemove() except it does not test syncRemoveRtn
  1877. * function pointer. Thus it enables to "silently" remove a symbol.
  1878. *
  1879. * RETURNS: OK, or ERROR if the symbol is not found
  1880. * or could not be deallocated.
  1881. *
  1882. * NOMANUAL
  1883. */
  1885. STATUS symSRemove
  1886.     (
  1887.     SYMTAB_ID symTblId,         /* symbol tbl to remove symbol from */
  1888.     char      *name,            /* name of symbol to remove */
  1889.     SYM_TYPE  type              /* type of symbol to remove */
  1890.     )
  1891.     {
  1892.     SYMBOL *pSymbol;
  1894.     if (symFindSymbol (symTblId, name, 0, type, SYM_MASK_ALL, 
  1895.        (SYMBOL_ID *) &pSymbol) != OK)
  1896. return (ERROR);
  1898.     /* XXX JLN symTblRemove should really take a SYMBOL_ID */
  1900.     if (symTblRemove (symTblId, pSymbol) != OK)
  1901. return (ERROR);
  1902.     return (symFree (symTblId, pSymbol));
  1903.     }