Add queue registry code.

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@384 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

diff --git a/Source/include/FreeRTOS.h b/Source/include/FreeRTOS.h
index 3d64d4595c4cb9a9de542f4a6ec7a8f99b0f67b3..7e2ca21c023d48b7bd31b27947826ee6648e87fc 100644 (file)
--- a/Source/include/FreeRTOS.h
+++ b/Source/include/FreeRTOS.h
@@ -198,6 +198,17 @@ typedef portBASE_TYPE (*pdTASK_HOOK_CODE)( void * );
 #endif\r
 \r
 \r
+#ifndef configQUEUE_REGISTRY_SIZE\r
+       #define configQUEUE_REGISTRY_SIZE 0\r
+#endif\r
+\r
+#if configQUEUE_REGISTRY_SIZE < 1\r
+       #define configQUEUE_REGISTRY_SIZE 0\r
+       #define vQueueAddToRegistry( xQueue, pcName )\r
+       #define vQueueUnregisterQueue( xQueue )\r
+#endif\r
+\r
+\r
 /* Remove any unused trace macros. */\r
 #ifndef traceSTART\r
        /* Used to perform any necessary initialisation - for example, open a file\r

diff --git a/Source/include/queue.h b/Source/include/queue.h
index b0d8cda24676de524d4775019afc1dac2a3d516c..2f7dff4fa6e2c97733d600a3a8172d8f4de6fd18 100644 (file)
--- a/Source/include/queue.h
+++ b/Source/include/queue.h
@@ -1203,6 +1203,32 @@ xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue,
 portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xBlockTime );\r
 portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle xMutex );\r
 \r
+/*\r
+ * The registry is provided as a means for kernel aware debuggers to\r
+ * locate queues, semaphores and mutexes.  Call vQueueAddToRegistry() add\r
+ * a queue, semaphore or mutex handle to the registry if you want the handle \r
+ * to be available to a kernel aware debugger.  If you are not using a kernel \r
+ * aware debugger then this function can be ignored.\r
+ *\r
+ * configQUEUE_REGISTRY_SIZE defines the maximum number of handles the\r
+ * registry can hold.  configQUEUE_REGISTRY_SIZE must be greater than 0 \r
+ * within FreeRTOSConfig.h for the registry to be available.  Its value\r
+ * does not effect the number of queues, semaphores and mutexes that can be \r
+ * created - just the number that the registry can hold.\r
+ *\r
+ * @param xQueue The handle of the queue being added to the registry.  This\r
+ * is the handle returned by a call to xQueueCreate().  Semaphore and mutex\r
+ * handles can also be passed in here.\r
+ *\r
+ * @param pcName The name to be associated with the handle.  This is the\r
+ * name that the kernel aware debugger will display.\r
+ */\r
+#if configQUEUE_REGISTRY_SIZE > 0\r
+       void vQueueAddToRegistry( xQueueHandle xQueue, signed portCHAR *pcName );\r
+#endif\r
+\r
+\r
+\r
 \r
 #ifdef __cplusplus\r
 }\r

diff --git a/Source/queue.c b/Source/queue.c
index b7ef66f2c3e5b515308d1df570722fb39ba91e48..6bf3ca3e8b50afac057e823dec10a0442bee39ea 100644 (file)
--- a/Source/queue.c
+++ b/Source/queue.c
@@ -78,6 +78,7 @@ zero. */
 #define queueSEMAPHORE_QUEUE_ITEM_LENGTH ( 0 )\r
 #define queueDONT_BLOCK                                         ( ( portTickType ) 0 )\r
 #define queueMUTEX_GIVE_BLOCK_TIME              ( ( portTickType ) 0 )\r
+\r
 /*\r
  * Definition of the queue used by the scheduler.\r
  * Items are queued by copy, not reference.\r
@@ -99,6 +100,7 @@ typedef struct QueueDefinition
 \r
        signed portBASE_TYPE xRxLock;                   /*< Stores the number of items received from the queue (removed from the queue) while the queue was locked.  Set to queueUNLOCKED when the queue is not locked. */\r
        signed portBASE_TYPE xTxLock;                   /*< Stores the number of items transmitted to the queue (added to the queue) while the queue was locked.  Set to queueUNLOCKED when the queue is not locked. */\r
+\r
 } xQUEUE;\r
 /*-----------------------------------------------------------*/\r
 \r
@@ -131,7 +133,10 @@ signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue );
 signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue );\r
 unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue );\r
 \r
-\r
+/*\r
+ * Co-routine queue functions differ from task queue functions.  Co-routines are\r
+ * an optional component.\r
+ */\r
 #if configUSE_CO_ROUTINES == 1\r
        signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken );\r
        signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken );\r
@@ -139,6 +144,34 @@ unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue
        signed portBASE_TYPE xQueueCRReceive( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait );\r
 #endif\r
 \r
+/*\r
+ * The queue registry is just a means for kernel aware debuggers to locate\r
+ * queue structures.  It has no other purpose so is an optional component.\r
+ */\r
+#if configQUEUE_REGISTRY_SIZE > 0\r
+       \r
+       /* The type stored within the queue registry array.  This allows a name\r
+       to be assigned to each queue making kernel aware debugging a little \r
+       more user friendly. */\r
+       typedef struct QUEUE_REGISTRY_ITEM\r
+       {\r
+               signed portCHAR *pcQueueName;\r
+               xQueueHandle xHandle;\r
+       } xQueueRegistryItem;\r
+\r
+       /* The queue registry is simply an array of xQueueRegistryItem structures.\r
+       The pcQueueName member of a structure being NULL is indicative of the\r
+       array position being vacant. */\r
+       static xQueueRegistryItem xQueueRegistry[ configQUEUE_REGISTRY_SIZE ];\r
+\r
+       /* Removes a queue from the registry by simply setting the pcQueueName\r
+       member to NULL. */\r
+       static void vQueueUnregisterQueue( xQueueHandle xQueue );\r
+       void vQueueAddToRegistry( xQueueHandle xQueue, signed portCHAR *pcQueueName );\r
+\r
+#endif\r
+\r
+\r
 /*\r
  * Unlocks a queue locked by a call to prvLockQueue.  Locking a queue does not\r
  * prevent an ISR from adding or removing items to the queue, but does prevent\r
@@ -1079,7 +1112,7 @@ unsigned portBASE_TYPE uxReturn;
 void vQueueDelete( xQueueHandle pxQueue )\r
 {\r
        traceQUEUE_DELETE( pxQueue );\r
-\r
+       vQueueUnregisterQueue( pxQueue );\r
        vPortFree( pxQueue->pcHead );\r
        vPortFree( pxQueue );\r
 }\r
@@ -1457,3 +1490,47 @@ signed portBASE_TYPE xReturn;
 #endif\r
 /*-----------------------------------------------------------*/\r
 \r
+#if configQUEUE_REGISTRY_SIZE > 0\r
+\r
+       void vQueueAddToRegistry( xQueueHandle xQueue, signed portCHAR *pcQueueName )\r
+       {\r
+       unsigned portBASE_TYPE ux;\r
+\r
+               /* See if there is an empty space in the registry.  A NULL name denotes\r
+               a free slot. */\r
+               for( ux = 0; ux < configQUEUE_REGISTRY_SIZE; ux++ )\r
+               {\r
+                       if( xQueueRegistry[ ux ].pcQueueName == NULL )\r
+                       {\r
+                               /* Store the information on this queue. */\r
+                               xQueueRegistry[ ux ].pcQueueName = pcQueueName;\r
+                               xQueueRegistry[ ux ].xHandle = xQueue;\r
+                               break;\r
+                       }\r
+               }\r
+       }\r
+\r
+#endif\r
+       /*-----------------------------------------------------------*/\r
+\r
+#if configQUEUE_REGISTRY_SIZE > 0\r
+\r
+       static void vQueueUnregisterQueue( xQueueHandle xQueue )\r
+       {\r
+       unsigned portBASE_TYPE ux;\r
+\r
+               /* See if the handle of the queue being unregistered in actually in the\r
+               registry. */\r
+               for( ux = 0; ux < configQUEUE_REGISTRY_SIZE; ux++ )\r
+               {\r
+                       if( xQueueRegistry[ ux ].xHandle == xQueue )\r
+                       {\r
+                               /* Set the name to NULL to show that this slot if free again. */\r
+                               xQueueRegistry[ ux ].pcQueueName = NULL;\r
+                               break;\r
+                       }\r
+               }       \r
+       }\r
+\r
+#endif\r
+\r