Zero-init RTT control block fields if not in BSS, don't init it twice

If SEGGER_RTT_SECTION is defined, the RTT control block is not in BSS
and zero-initialization is needed for not initialized fields.
Moreover, it the control block is already initialized with the expected
SEGGER ID signature, the initialization is skipped to allow seamless
logging between programs that share it.
Typical use case: bootloader and application.

Signed-off-by: Giancarlo Stasi <[email protected]>

Author: giansta

Config/SEGGER_RTT_Conf.h

@@ -98,6 +98,10 @@ Revision: $Rev: 21386 $
 #define SEGGER_RTT_SECTION                        ".dtcm_data"
 #endif
 
+#if defined(CONFIG_SEGGER_RTT_SECTION_FIXED_ADDR)
+#define SEGGER_RTT_SECTION                        ".rtt_buff_data"
+#endif
+
 /*********************************************************************
 *
 *       RTT memcpy configuration

SEGGER/SEGGER_RTT.c

@@ -167,6 +167,26 @@ Additional information:
   #endif
 #endif
 
+#ifndef   SEGGER_RTT_MEMCMP
+  #ifdef  MEMCPY
+    #define SEGGER_RTT_MEMCMP(pDest, pSrc, NumBytes)      MEMCMP((pDest), (pSrc), (NumBytes))
+  #else
+    #define SEGGER_RTT_MEMCMP(pDest, pSrc, NumBytes)      memcmp((pDest), (pSrc), (NumBytes))
+  #endif
+#endif
+
+#ifndef   SEGGER_RTT_MEMSET
+  #ifdef  MEMSET
+    #define SEGGER_RTT_MEMSET(pDest, FillChar, NumBytes)  MEMSET((pDest), (FillChar), (NumBytes))
+  #else
+    #define SEGGER_RTT_MEMSET(pDest, FillChar, NumBytes)  memset((pDest), (FillChar), (NumBytes))
+  #endif
+#endif
+
+#ifndef ARRAY_SIZE
+  # define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#endif
+
 #ifndef   MIN
   #define MIN(a, b)         (((a) < (b)) ? (a) : (b))
 #endif
@@ -254,7 +274,12 @@ Additional information:
 **********************************************************************
 */
 
-static unsigned char _aTerminalId[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+static const unsigned char _aTerminalId[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+static const char _rttCtrBlkSign2[] = "RTT";
+static const char _rttCtrBlkSign1[] = "SEGGER";
+#define SIZEOF_RTT_CTRL_BLK_SIGN2 (ARRAY_SIZE(_rttCtrBlkSign2) - 1)
+#define SIZEOF_RTT_CTRL_BLK_SIGN1 (ARRAY_SIZE(_rttCtrBlkSign1) - 1)
 
 /*********************************************************************
 *
@@ -285,19 +310,9 @@ static unsigned char _ActiveTerminal;
 *
 *  Function description
 *    Initializes the control block an buffers.
-*    May only be called via INIT() to avoid overriding settings.
+*    May only be called via Init() to avoid overriding settings.
 *
 */
-#define INIT()  {                                                                                    \
-                  volatile SEGGER_RTT_CB* pRTTCBInit;                                                \
-                  pRTTCBInit = (volatile SEGGER_RTT_CB*)((char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF); \
-                  do {                                                                               \
-                    if (pRTTCBInit->acID[0] == '\0') {                                               \
-                      _DoInit();                                                                     \
-                    }                                                                                \
-                  } while (0);                                                                       \
-                }
-
 static void _DoInit(void) {
   volatile SEGGER_RTT_CB* p;   // Volatile to make sure that compiler cannot change the order of accesses to the control block
   //
@@ -329,12 +344,48 @@ static void _DoInit(void) {
   // Copy Id string in three steps to make sure "SEGGER RTT" is not found
   // in initializer memory (usually flash) by J-Link
   //
-  STRCPY((char*)&p->acID[7], "RTT");
+  STRCPY((char*)&p->acID[SIZEOF_RTT_CTRL_BLK_SIGN1 + 1], _rttCtrBlkSign2);
   RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
-  STRCPY((char*)&p->acID[0], "SEGGER");
+  STRCPY((char*)&p->acID[0], _rttCtrBlkSign1);
   RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
   p->acID[6] = ' ';
   RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
+#if defined(SEGGER_RTT_SECTION) // Control block not in .bss section: needs explicit zero-initializations
+  // RTT Viewer checks even trailing null bytes to be initialized
+  for (unsigned int i = SIZEOF_RTT_CTRL_BLK_SIGN1 + 1 + SIZEOF_RTT_CTRL_BLK_SIGN2; i < ARRAY_SIZE(p->acID); ++i)
+  {
+	  p->acID[i] = '\0';
+  }
+  RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
+  // Initialize other up buffers
+  for (unsigned int i = 1; i < ARRAY_SIZE(p->aUp); ++i)
+  {
+    SEGGER_RTT_MEMSET((SEGGER_RTT_BUFFER_UP*)&p->aUp[i], 0, sizeof(p->aUp[i]));
+  }
+  RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
+  // Initialize other down buffers
+  for (unsigned int i = 1; i < ARRAY_SIZE(p->aDown); ++i)
+  {
+    SEGGER_RTT_MEMSET((SEGGER_RTT_BUFFER_DOWN*)&p->aDown[i], 0, sizeof(p->aDown[i]));
+  }
+  RTT__DMB();                       // Force order of memory accessed inside core for cores that allow to change the order
+#endif
+}
+
+static void Init(void) {
+  volatile SEGGER_RTT_CB* p;
+  p = (volatile SEGGER_RTT_CB*)((char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);
+
+  /* Check the whole Id string buffer (including trailing zeros) to be the expected value.
+   * If already initialized, the control block initialization is skipped, as it may be shared between bootloader
+   * and application. Not used a single memcmp() to make sure "SEGGER RTT" is not found in initializer
+   * memory (usually flash) by J-Link (as above in initializing). */
+  if (SEGGER_RTT_MEMCMP((char*)&p->acID[0], _rttCtrBlkSign1, SIZEOF_RTT_CTRL_BLK_SIGN1) != 0 ||
+      SEGGER_RTT_MEMCMP((char*)&p->acID[SIZEOF_RTT_CTRL_BLK_SIGN1 + 1], _rttCtrBlkSign2, SIZEOF_RTT_CTRL_BLK_SIGN2) != 0 ||
+      p->acID[6] != ' ' || p->acID[10] != '\0' || p->acID[11] != '\0' || p->acID[12] != '\0' ||
+      p->acID[13] != '\0' || p->acID[14] != '\0' || p->acID[15] != '\0') {
+    _DoInit();
+  }
 }
 
 /*********************************************************************
@@ -564,7 +615,7 @@ unsigned SEGGER_RTT_ReadUpBufferNoLock(unsigned BufferIndex, void* pData, unsign
   SEGGER_RTT_BUFFER_UP*   pRing;
   volatile char*          pSrc;
 
-  INIT();
+  Init();
   pRing = (SEGGER_RTT_BUFFER_UP*)((char*)&_SEGGER_RTT.aUp[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   pBuffer = (unsigned char*)pData;
   RdOff = pRing->RdOff;
@@ -656,7 +707,7 @@ unsigned SEGGER_RTT_ReadNoLock(unsigned BufferIndex, void* pData, unsigned Buffe
   SEGGER_RTT_BUFFER_DOWN* pRing;
   volatile char*          pSrc;
   //
-  INIT();
+  Init();
   pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[BufferIndex] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   pBuffer = (unsigned char*)pData;
   RdOff = pRing->RdOff;
@@ -1160,7 +1211,7 @@ unsigned SEGGER_RTT_WriteNoLock(unsigned BufferIndex, const void* pBuffer, unsig
 unsigned SEGGER_RTT_WriteDownBuffer(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) {
   unsigned Status;
 
-  INIT();
+  Init();
   SEGGER_RTT_LOCK();
   Status = SEGGER_RTT_WriteDownBufferNoLock(BufferIndex, pBuffer, NumBytes);  // Call the non-locking write function
   SEGGER_RTT_UNLOCK();
@@ -1189,7 +1240,7 @@ unsigned SEGGER_RTT_WriteDownBuffer(unsigned BufferIndex, const void* pBuffer, u
 unsigned SEGGER_RTT_Write(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) {
   unsigned Status;
 
-  INIT();
+  Init();
   SEGGER_RTT_LOCK();
   Status = SEGGER_RTT_WriteNoLock(BufferIndex, pBuffer, NumBytes);  // Call the non-locking write function
   SEGGER_RTT_UNLOCK();
@@ -1304,7 +1355,7 @@ unsigned SEGGER_RTT_PutCharSkip(unsigned BufferIndex, char c) {
   //
   // Prepare
   //
-  INIT();
+  Init();
   SEGGER_RTT_LOCK();
   //
   // Get "to-host" ring buffer.
@@ -1363,7 +1414,7 @@ unsigned SEGGER_RTT_PutChar(unsigned BufferIndex, char c) {
   //
   // Prepare
   //
-  INIT();
+  Init();
   SEGGER_RTT_LOCK();
   //
   // Get "to-host" ring buffer.
@@ -1474,7 +1525,7 @@ int SEGGER_RTT_HasKey(void) {
   unsigned RdOff;
   int r;
 
-  INIT();
+  Init();
   pRing = (SEGGER_RTT_BUFFER_DOWN*)((char*)&_SEGGER_RTT.aDown[0] + SEGGER_RTT_UNCACHED_OFF);  // Access uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   RdOff = pRing->RdOff;
   if (RdOff != pRing->WrOff) {
@@ -1550,7 +1601,7 @@ int SEGGER_RTT_AllocDownBuffer(const char* sName, void* pBuffer, unsigned Buffer
   int BufferIndex;
   volatile SEGGER_RTT_CB* pRTTCB;
 
-  INIT();
+  Init();
   SEGGER_RTT_LOCK();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   BufferIndex = 0;
@@ -1598,7 +1649,7 @@ int SEGGER_RTT_AllocUpBuffer(const char* sName, void* pBuffer, unsigned BufferSi
   int BufferIndex;
   volatile SEGGER_RTT_CB* pRTTCB;
 
-  INIT();
+  Init();
   SEGGER_RTT_LOCK();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   BufferIndex = 0;
@@ -1653,7 +1704,7 @@ int SEGGER_RTT_ConfigUpBuffer(unsigned BufferIndex, const char* sName, void* pBu
   volatile SEGGER_RTT_CB* pRTTCB;
   volatile SEGGER_RTT_BUFFER_UP* pUp;
 
-  INIT();
+  Init();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) {
     SEGGER_RTT_LOCK();
@@ -1704,7 +1755,7 @@ int SEGGER_RTT_ConfigDownBuffer(unsigned BufferIndex, const char* sName, void* p
   volatile SEGGER_RTT_CB* pRTTCB;
   volatile SEGGER_RTT_BUFFER_DOWN* pDown;
 
-  INIT();
+  Init();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) {
     SEGGER_RTT_LOCK();
@@ -1747,7 +1798,7 @@ int SEGGER_RTT_SetNameUpBuffer(unsigned BufferIndex, const char* sName) {
   volatile SEGGER_RTT_CB* pRTTCB;
   volatile SEGGER_RTT_BUFFER_UP* pUp;
 
-  INIT();
+  Init();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) {
     SEGGER_RTT_LOCK();
@@ -1782,7 +1833,7 @@ int SEGGER_RTT_SetNameDownBuffer(unsigned BufferIndex, const char* sName) {
   volatile SEGGER_RTT_CB* pRTTCB;
   volatile SEGGER_RTT_BUFFER_DOWN* pDown;
 
-  INIT();
+  Init();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) {
     SEGGER_RTT_LOCK();
@@ -1817,7 +1868,7 @@ int SEGGER_RTT_SetFlagsUpBuffer(unsigned BufferIndex, unsigned Flags) {
   volatile SEGGER_RTT_CB* pRTTCB;
   volatile SEGGER_RTT_BUFFER_UP* pUp;
 
-  INIT();
+  Init();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   if (BufferIndex < SEGGER_RTT_MAX_NUM_UP_BUFFERS) {
     SEGGER_RTT_LOCK();
@@ -1852,7 +1903,7 @@ int SEGGER_RTT_SetFlagsDownBuffer(unsigned BufferIndex, unsigned Flags) {
   volatile SEGGER_RTT_CB* pRTTCB;
   volatile SEGGER_RTT_BUFFER_DOWN* pDown;
 
-  INIT();
+  Init();
   pRTTCB = (volatile SEGGER_RTT_CB*)((unsigned char*)&_SEGGER_RTT + SEGGER_RTT_UNCACHED_OFF);  // Access RTTCB uncached to make sure we see changes made by the J-Link side and all of our changes go into HW directly
   if (BufferIndex < SEGGER_RTT_MAX_NUM_DOWN_BUFFERS) {
     SEGGER_RTT_LOCK();
@@ -1876,7 +1927,7 @@ int SEGGER_RTT_SetFlagsDownBuffer(unsigned BufferIndex, unsigned Flags) {
 *
 */
 void SEGGER_RTT_Init (void) {
-  _DoInit();
+	Init();
 }
 
 /*********************************************************************
@@ -1902,7 +1953,7 @@ int SEGGER_RTT_SetTerminal (unsigned char TerminalId) {
   unsigned Avail;
   int r;
 
-  INIT();
+  Init();
   r = 0;
   ac[0] = 0xFFu;
   if (TerminalId < sizeof(_aTerminalId)) { // We only support a certain number of channels
@@ -1951,7 +2002,7 @@ int SEGGER_RTT_TerminalOut (unsigned char TerminalId, const char* s) {
   unsigned              Avail;
   SEGGER_RTT_BUFFER_UP* pRing;
   //
-  INIT();
+  Init();
   //
   // Validate terminal ID.
   //