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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
usrWdbTask.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：11k
源码类别：

VxWorks

开发平台：

C/C++

usrWdbTask.c：源码内容
  1. /* usrWdbTask.c - configuration file for the WDB task agent */
  3. /* Copyright 1997-2001 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01j,26nov01,jhw  Moved wdbInfo back into WIND_TCB.
  9. 01i,20oct01,jhw  Moved wdbExitHook out of WIND_TCB.
  10. 01h,29may01,pch  Fix compiler warning
  11. 01g,18apr01,kab  Added Altivec support
  12. 01f,16nov00,zl   added DSP support.
  13. 01e,07apr99,cym  changing vxTaskRegsGet to match with src/config.
  14.  (SPR #26387)
  15. 01d,15feb99,dbt  remove task creation hook only if it has been previously
  16.                  installed (SPR #24195)
  17. 01c,18may98,dbt  integrated latest WDB stuff
  18. 01b,09oct97,ms   use _func_ioTaskStdSet to break binding to iosLib
  19. 01a,21jul97,ms   taken from 01y of usrWdb.c. moved some macros to configAll.h
  20. */
  22. /*
  23. DESCRIPTION
  25. This library configures and initializes the WDB task agent.
  26. */
  28. /* defines */
  30. #define MILLION 1000000
  32. /* globals */
  34. FUNCPTR wdbTaskFpRegsGet;
  35. FUNCPTR wdbTaskFpRegsSet;
  36. FUNCPTR wdbTaskDspRegsGet;
  37. FUNCPTR wdbTaskDspRegsSet;
  38. FUNCPTR wdbTaskAvRegsGet;
  39. FUNCPTR wdbTaskAvRegsSet;
  41. /* externals */
  43. extern WDB_RT_IF  wdbRtIf;
  44. extern VOIDFUNCPTR wdbTaskRestartHook;
  45. extern BOOL wdbIsInitialized;
  47. /* locals */
  49. static VOIDFUNCPTR      wdbCreateHook = NULL;   /* WDB task create hook */
  51. /* forward declarations */
  53. static void wdbTaskRtIfInit ();
  55. /******************************************************************************
  56. *
  57. * wdbTaskRestart - restart the WDB task
  58. */
  60. static void wdbTaskRestart (void)
  61.     {
  62.     static int  restartCnt;
  63.     extern int  wdbTaskId;
  65.     /*
  66.      * if the exception is in the agent task, restart the agent
  67.      * after a delay.
  68.      */
  70.     if (((int)taskIdCurrent == wdbTaskId) && (restartCnt < WDB_MAX_RESTARTS))
  71.         {
  72.         restartCnt++;
  73.         if (_func_logMsg != NULL)
  74.             _func_logMsg ("WDB exception. restarting agent in %d seconds...n",
  75.                 WDB_RESTART_TIME, 0,0,0,0,0);
  76.         taskDelay (sysClkRateGet() * WDB_RESTART_TIME);
  77.         taskRestart (0);
  78.         }
  79.     }
  81. /******************************************************************************
  82. *
  83. * wdbTaskModeInit - configure and initialize the WDB task mode agent.
  84. *
  85. */
  87. STATUS wdbTaskModeInit (void)
  88.     {
  89.     if (!wdbIsInitialized) /* test if WDB is initialized */
  90. return (ERROR);
  92.     wdbTaskRtIfInit ();
  94.     if (wdbTaskInit (WDB_TASK_PRIORITY,
  95. WDB_TASK_OPTIONS, NULL, WDB_STACK_SIZE) == ERROR)
  96. return (ERROR);
  98.     wdbModeSet (WDB_MODE_TASK);
  100.     wdbTaskRestartHook = wdbTaskRestart;
  102.     return (OK);
  103.     }
  105. /******************************************************************************
  106. *
  107. * vxTaskCreate - WDB callout to create a task (and leave suspended).
  108. */
  110. static int vxTaskCreate
  111.     (
  112.     char *   name,       /* name of new task (stored at pStackBase)   */
  113.     int      priority,   /* priority of new task                      */
  114.     int      options,    /* task option word                          */
  115.     caddr_t  stackBase,  /* base of stack. ignored by VxWorks       */
  116.     int      stackSize,  /* size (bytes) of stack needed plus name    */
  117.     caddr_t  entryPt,    /* entry point of new task                   */
  118.     int      arg[10],  /* 1st of 10 req'd task args to pass to func */
  119.     int      fdIn,  /* fd for input redirection       */
  120.     int      fdOut,  /* fd for output redirection       */
  121.     int      fdErr  /* fd for error output redirection       */
  122.     )
  123.     {
  124.     int tid;
  126.     if (stackSize == 0)
  127. stackSize = WDB_SPAWN_STACK_SIZE;
  129.     tid = taskCreat (name, priority, options, stackSize, (int (*)())entryPt,
  130. arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6],
  131. arg[7], arg[8], arg[9]);
  133.     if (tid == 0) /* create failed */
  134. return (ERROR);
  136.     if (_func_ioTaskStdSet != NULL)
  137. {
  138. if (fdIn != 0)
  139.     _func_ioTaskStdSet (tid, 0, fdIn);
  140. if (fdOut != 0)
  141.     _func_ioTaskStdSet (tid, 1, fdOut);
  142. if (fdErr != 0)
  143.     _func_ioTaskStdSet (tid, 2, fdErr);
  144. }
  146.     return (tid);
  147.     }
  150. /******************************************************************************
  151. *
  152. * vxTaskResume - WDB callout to resume a suspended task.
  153. */
  155. static STATUS vxTaskResume
  156.     (
  157.     WDB_CTX * pContext
  158.     )
  159.     {
  160.     if (pContext->contextType != WDB_CTX_TASK)
  161. return (ERROR);
  163.     return (taskResume (pContext->contextId));
  164.     }
  166. /******************************************************************************
  167. *
  168. * vxTaskSuspend - WDB callout to suspend a task.
  169. */
  171. static STATUS vxTaskSuspend
  172.     (
  173.     WDB_CTX * pContext
  174.     )
  175.     {
  176.     if (pContext->contextType != WDB_CTX_TASK)
  177. return (ERROR);
  179.     return (taskSuspend (pContext->contextId));
  180.     }
  182. /******************************************************************************
  183. *
  184. * vxTaskDelete - WDB callout to delete a task.
  185. */
  187. static STATUS vxTaskDelete
  188.     (
  189.     WDB_CTX * pContext
  190.     )
  191.     {
  192.     if (pContext->contextType != WDB_CTX_TASK)
  193. return (ERROR);
  195.     return (taskDelete (pContext->contextId));
  196.     }
  198. /******************************************************************************
  199. *
  200. * vxTaskRegsSet - WDB callout to get a task register set.
  201. */
  203. static STATUS vxTaskRegsSet
  204.     (
  205.     WDB_CTX *  pContext,
  206.     WDB_REG_SET_TYPE regSetType,
  207.     char *  pRegSet
  208.     )
  209.     {
  210.     if (pContext->contextType != WDB_CTX_TASK)
  211. return (ERROR);
  213.     switch (regSetType)
  214. {
  215. case WDB_REG_SET_IU:
  216.     return (taskRegsSet (pContext->contextId, (REG_SET *)pRegSet));
  218. case WDB_REG_SET_FPU:
  219.     if (wdbTaskFpRegsSet == NULL)
  220. return (ERROR);
  221.     return (wdbTaskFpRegsSet (pContext, pRegSet));
  223. case WDB_REG_SET_DSP:
  224.     if (wdbTaskDspRegsSet == NULL)
  225. return (ERROR);
  226.     return (wdbTaskDspRegsSet (pContext, pRegSet));
  228. case WDB_REG_SET_AV:
  229.     if (wdbTaskAvRegsSet == NULL)
  230. return (ERROR);
  231.     return (wdbTaskAvRegsSet (pContext, pRegSet));
  233. default:
  234.     return (ERROR);
  235. }
  236.     }
  238. /******************************************************************************
  239. *
  240. * vxTaskRegsGet - WDB callout to get a tasks register set.
  241. *
  242. * This routine is not reentrant, but it it only called by one thread (the
  243. * WDB agent).
  244. */
  246. static STATUS vxTaskRegsGet
  247.     (
  248.     WDB_CTX * pContext,
  249.     WDB_REG_SET_TYPE  regSetType,
  250.     char ** ppRegSet
  251.     )
  252.     {
  253.     WIND_TCB * pTcb;
  254.     if (pContext->contextType != WDB_CTX_TASK)
  255. return (ERROR);
  257.     pTcb = taskTcb (pContext->contextId);
  258.     if (pTcb == NULL)
  259. return (ERROR);
  261.     switch (regSetType)
  262. {
  263. case WDB_REG_SET_IU:
  264.     {
  265.     REG_SET dummy;
  266.     /* DO NOT REMOVE THIS CALL TO taskRegsGet (SPR #26387) */
  267.     taskRegsGet (pContext->contextId,&dummy);
  268.     *ppRegSet = (char *) &pTcb->regs;
  269.     return (OK);
  270.     }
  272. case WDB_REG_SET_FPU:
  273.     if (wdbTaskFpRegsGet == NULL)
  274. return (ERROR);
  275.     return (wdbTaskFpRegsGet (pContext, ppRegSet));
  277. case WDB_REG_SET_DSP:
  278.     if (wdbTaskDspRegsGet == NULL)
  279. return (ERROR);
  280.     return (wdbTaskDspRegsGet (pContext, ppRegSet));
  282. case WDB_REG_SET_AV:
  283.     if (wdbTaskAvRegsGet == NULL)
  284. return (ERROR);
  285.     return (wdbTaskAvRegsGet (pContext, ppRegSet));
  287. default:
  288.     return (ERROR);
  289. }
  290.     }
  292. /******************************************************************************
  293. *
  294. * vxSemCreate - create a SEMAPHORE
  295. */
  297. static void * vxSemCreate (void)
  298.     {
  299.     return ((void *)semBCreate (0, 0));
  300.     }
  302. /******************************************************************************
  303. *
  304. * vxSemGive - give a semaphore
  305. */
  307. static STATUS vxSemGive
  308.     (
  309.     void * semId
  310.     )
  311.     {
  312.     return (semGive ((SEM_ID)semId));
  313.     }
  315. /******************************************************************************
  316. *
  317. * vxSemTake - take a semaphore
  318. */
  320. static STATUS vxSemTake
  321.     (
  322.     void * semId,
  323.     struct timeval * tv
  324.     )
  325.     {
  326.     return (semTake ((SEM_ID) semId, 
  327. (tv == NULL ? WAIT_FOREVER :
  328. tv->tv_sec * sysClkRateGet() +
  329. (tv->tv_usec * sysClkRateGet()) / MILLION)));
  330.     }
  332. /******************************************************************************
  333. *
  334. * __wdbTaskDeleteHook -
  335. */
  337. static int __wdbTaskDeleteHook
  338.     (
  339.     WIND_TCB *pTcb
  340.     )
  341.     {
  342.     WDB_CTX     ctx;
  343.     void        (*hook)();
  345.     hook = (pTcb->wdbInfo).wdbExitHook;
  347.     if (hook != NULL)
  348.         {
  349.         ctx.contextType = WDB_CTX_TASK;
  350.         ctx.contextId   = (UINT32)pTcb;
  351.         (*hook) (ctx, pTcb->exitCode, pTcb->errorStatus);
  352.         }
  354.     return (OK);
  355.     }
  357. /******************************************************************************
  358. *
  359. * vxTaskDeleteHookAdd - task-specific delete hook (one per task).
  360. *
  361. * currently only one hook per task.
  362. */
  364. static STATUS vxTaskDeleteHookAdd
  365.     (
  366.     UINT32      tid,
  367.     void        (*hook)()
  368.     )
  369.     {
  370.     static BOOL initialized = FALSE;
  372.     if (taskIdVerify ((int)tid) == ERROR)
  373.         return (ERROR);
  375.     (taskTcb (tid)->wdbInfo).wdbExitHook = hook;
  377.     if (!initialized)
  378.         {
  379.         taskDeleteHookAdd (__wdbTaskDeleteHook);
  380.         initialized = TRUE;
  381.         }
  383.     return (OK);
  384.     }
  386. /******************************************************************************
  387. *
  388. * __wdbTaskCreateHook - task create hook
  389. *
  390. * This hook is called each time a task is created.
  391. *
  392. * RETURNS : OK always
  393. */ 
  395. static int __wdbTaskCreateHook
  396.     (
  397.     WIND_TCB * pTcb
  398.     )
  399.     {
  400.     WDB_CTX createdCtx;
  401.     WDB_CTX creationCtx;
  403.     if (wdbCreateHook != NULL)
  404. {
  405. /* fill createdCtx structure */
  407. createdCtx.contextType = WDB_CTX_TASK;
  408. createdCtx.contextId = (UINT32)pTcb;
  410. /* fill creationCtx structure */
  412. creationCtx.contextType = WDB_CTX_TASK;
  413. creationCtx.contextId = (UINT32)taskIdCurrent;
  415. (*wdbCreateHook) (&createdCtx, &creationCtx);
  416. }
  418.     return (OK);
  419.     }
  421. /******************************************************************************
  422. *
  423. * vxTaskCreateHookAdd - install WDB task create hook.
  424. *
  425. * This routine installs or remove the WDB task create hook. 
  426. *
  427. * RETURNS : OK always.
  428. */ 
  430. static STATUS vxTaskCreateHookAdd
  431.     (
  432.     void (*hook)()
  433.     )
  434.     {
  435.     static BOOL initialized = FALSE;
  437.     wdbCreateHook = hook;
  439.     if ((hook == NULL) && initialized) /* remove task creation hook */
  440. {
  441. taskCreateHookDelete (__wdbTaskCreateHook);
  442. initialized = FALSE;
  443. }
  444.     else if (!initialized) /* install task creation hook */
  445. {
  446. taskCreateHookAdd (__wdbTaskCreateHook);
  447. initialized = TRUE;
  448. }
  450.     return (OK);
  451.     }
  453. /******************************************************************************
  454. *
  455. * wdbTaskRtIfInit - Initialize pointers to the VxWorks routines.
  456. */
  458. static void wdbTaskRtIfInit ()
  459.     {
  460.     wdbRtIf.taskCreate = vxTaskCreate;
  461.     wdbRtIf.taskResume = vxTaskResume;
  462.     wdbRtIf.taskSuspend = vxTaskSuspend;
  463.     wdbRtIf.taskDelete = vxTaskDelete;
  465.     wdbRtIf.taskLock = (VOIDFUNCPTR) taskLock;
  466.     wdbRtIf.taskUnlock = (VOIDFUNCPTR) taskUnlock;
  468.     wdbRtIf.taskRegsSet = vxTaskRegsSet;
  469.     wdbRtIf.taskRegsGet = vxTaskRegsGet;
  471.     wdbRtIf.malloc = malloc;
  472.     wdbRtIf.free = free;
  474.     wdbRtIf.semCreate = vxSemCreate;
  475.     wdbRtIf.semGive = vxSemGive;
  476.     wdbRtIf.semTake = vxSemTake;
  478.     wdbRtIf.taskDeleteHookAdd = vxTaskDeleteHookAdd;
  479.     wdbRtIf.taskSwitchHookAdd = (STATUS (*)())taskSwitchHookAdd;
  480.     wdbRtIf.taskCreateHookAdd = (STATUS (*)())vxTaskCreateHookAdd;
  481.     }