Changeset 33415 for branches/meh_branches/ppstack_test/psLib/src/sys/psMemory.c

Timestamp:

Mar 5, 2012, 5:19:48 PM (14 years ago)

Author:

mhuber

Message:

merging latest r33407 trunk changes to meh_branches/ppstack_test

Location:

branches/meh_branches/ppstack_test

Files:

• . (modified) (1 prop)
• psLib/src/sys/psMemory.c (modified) (18 diffs)

branches/meh_branches/ppstack_test/psLib/src/sys/psMemory.c

@@ -56 +56 @@
 
 # define USE_SPINLOCK 0
-# define USE_HARDLOCK 0
+# define USE_HARDLOCK 1
 
 # if (USE_SPINLOCK) 
@@ -100 +100 @@
     PS_MEM_ABORT(__func__, "Unsafe to Continue\n"); \
 }
+
+static bool checkingForCorruption = false;
 
 static bool isBadMemBlock(FILE *output, const psMemBlock *memBlock, const char *file, unsigned int lineo, const char *func);
@@ -337 +339 @@
 /**** Unique ID for allocated blocks and associated accessor functions
  */
-static psMemId memid = 0;
+static volatile psMemId memid = 0;
 
 /* Return memory ID counter for next block to be allocated
@@ -384 +386 @@
 // pointer to the last mem block that was allocated.
 // This is the root of the entire memory list
-static psMemBlock *lastMemBlockAllocated = NULL;
+static volatile psMemBlock *lastMemBlockAllocated = NULL;
 
 // set lock on lastMemBlockAllocated
@@ -515 +517 @@
             continue;
         }
-        if (memBlock->nextBlock && memBlock->nextBlock->inFlight) {
-            // nope, we need to try again
-            MUTEX_UNLOCK(&memBlockListMutex);
-            usleep (BLOCK_SLEEP);
-            retryLock ++;
-            continue;
-        }
-        if (memBlock->previousBlock && memBlock->previousBlock->inFlight) {
-            // nope, we need to try again
-            MUTEX_UNLOCK(&memBlockListMutex);
-            usleep (BLOCK_SLEEP);
-            retryLock ++;
-            continue;
-        }
+        if (memBlock->nextBlock && memBlock->nextBlock->inFlight) {
+            // we reply on the value of 'inFlight'.  we should crash if this block is corrupted
+            if (memBlock->nextBlock->startblock != P_PS_MEMMAGIC) {
+                PS_MEM_ABORT(__func__, "Unsafe to Continue\n");
+            }
+            if (memBlock->nextBlock->endblock != P_PS_MEMMAGIC) {
+                PS_MEM_ABORT(__func__, "Unsafe to Continue\n");
+            }
+            // nope, we need to try again
+            MUTEX_UNLOCK(&memBlockListMutex);
+            usleep (BLOCK_SLEEP);
+            retryLock ++;
+            continue;
+        }
+        if (memBlock->previousBlock && memBlock->previousBlock->inFlight) {
+            // we reply on the value of 'inFlight'.  we should crash if this block is corrupted
+            if (memBlock->previousBlock->startblock != P_PS_MEMMAGIC) {
+                PS_MEM_ABORT(__func__, "Unsafe to Continue\n");
+            }
+            if (memBlock->previousBlock->endblock != P_PS_MEMMAGIC) {
+                PS_MEM_ABORT(__func__, "Unsafe to Continue\n");
+            }
+            // nope, we need to try again
+            MUTEX_UNLOCK(&memBlockListMutex);
+            usleep (BLOCK_SLEEP);
+            retryLock ++;
+            continue;
+        }
 
         // the markers are ours!
@@ -641 +657 @@
     memBlock->refCounter = 1;                   // one user so far
 
-    psMemBlock *last0 = lastMemBlockAllocated;
-    int flight0 = (lastMemBlockAllocated) ? lastMemBlockAllocated->inFlight : 10;
+    // XXX these lines are test lines that potentially access invalid memory
+    // XXX psMemBlock *last0 = lastMemBlockAllocated;
+    // XXX int flight0 = (lastMemBlockAllocated) ? lastMemBlockAllocated->inFlight : 10;
 
     // need exclusive access of the memory block list now...
@@ -649 +666 @@
     BLOCKLAST_LOCK ();
 
-    psMemBlock *last1 = lastMemBlockAllocated;
-    int flight1 = (lastMemBlockAllocated) ? lastMemBlockAllocated->inFlight : 10;
-
-    if (false) {
-        fprintf (stderr, "last 0 : %lld, last 1 : %lld, flight0: %d, flight1: %d\n", (long long int) last0, (long long int) last1, (int) flight0, (int) flight1);
-    }
+    // XXX psMemBlock *last1 = lastMemBlockAllocated;
+    // XXX int flight1 = (lastMemBlockAllocated) ? lastMemBlockAllocated->inFlight : 10;
+
+    // XXX if (false) {
+    // XXX      fprintf (stderr, "last 0 : %lld, last 1 : %lld, flight0: %d, flight1: %d\n", (long long int) last0, (long long int) last1, (int) flight0, (int) flight1);
+    // XXX }
 
     // increment the memory id only after we've grabbed the memBlockListMutex this value is
@@ -665 +682 @@
         lastMemBlockAllocated->previousBlock = memBlock;
     }
-    memBlock->nextBlock = lastMemBlockAllocated;
+    memBlock->nextBlock = (psMemBlock *) lastMemBlockAllocated;
     lastMemBlockAllocated = memBlock;
 
@@ -731 +748 @@
         }
         fprintf(output, _("\n\tMemory block is corrupted; buffer underflow detected.\n"));
+        if (!checkingForCorruption) {
+          p_psMemCheckCorruption(__FILE__, __LINE__, __func__, output, false);
+        }
         bad = true;
     }
@@ -740 +760 @@
         }
         fprintf(output, _("\n\tMemory block is corrupted; buffer overflow detected.\n"));
+        if (!checkingForCorruption) {
+          p_psMemCheckCorruption(__FILE__, __LINE__, __func__, output, false);
+        }
         bad = true;
     }
@@ -889 +912 @@
                       psMemBlock ***array,
                       FILE * fd,
-                      bool persistence)
+                      bool persistence,
+                      int maxDisplayedLeaksCount          ///< List at most maxDisplayedLeaksCount (-1 for all)
+                  )
 {
     psS32 nleak = 0;
     psS32 j = 0;
-    psMemBlock *topBlock = lastMemBlockAllocated;
+    psMemBlock *topBlock = (psMemBlock *) lastMemBlockAllocated;
 
     // XXX move this elsewhere?
-    fprintf (stderr, "set %d locks, cleared %d locks, retry on %d locks (memID %ld)\n", setLock, clearLock, retryLock, memid);
+    if (fd != NULL) {
+# if (USE_HARDLOCK)
+# else
+      fprintf (fd, "set %d locks, cleared %d locks, retry on %d locks (memID %ld)\n", setLock, clearLock, retryLock, memid);
+# endif
+    }
 
     // make sure that the memblock list is free of corruption before we crawl
@@ -915 +945 @@
     for (memBlock = topBlock; memBlock->nextBlock != NULL; memBlock = memBlock->nextBlock) { }
 
+    int maxToDisplay = maxDisplayedLeaksCount;
+    psMemBlock *memBlockBackup = memBlock;
+    if (maxToDisplay == -1 ) {
+      for (; memBlock != NULL; memBlock = memBlock->previousBlock) {
+        if ( (memBlock->refCounter > 0) &&
+             ( (persistence) || (!persistence && !memBlock->persistent) ) &&
+             (memBlock->id >= id0)) {
+          nleak++;
+        }
+      }
+      maxToDisplay=nleak;
+    }
+    if (fd != NULL) {
+      fprintf(fd, "Number of leaks to display: %d\n", maxToDisplay);
+    }
+    memBlock = memBlockBackup;
+
+    nleak=0;
     // iterate through the block list starting with the oldest block
     for (; memBlock != NULL; memBlock = memBlock->previousBlock) {
@@ -924 +972 @@
 
             // only print a max of 500 leaks (make this an argument)
-            if ((nleak < 500) && (fd != NULL)) {
+            if ( (nleak <= maxToDisplay) && (fd != NULL) ) {
                 if (nleak == 1) {
                     fprintf(fd, "# func at (file:line)  ID: X  Ref: X\n");
@@ -1168 +1216 @@
     #endif
 
+# if (PS_TRACE_ON)    
+    // before freeing a particular block of memory, fill the entire block with FF to poison it
+    // this should trigger any bad reactions early.  this may be costly, so on do it for
+    // unoptimzed builds
+    size_t totalSize = sizeof(psMemBlock) + memBlock->userMemorySize + sizeof(void *);
+    memset ((void *) memBlock, 0xff, totalSize);
+# endif
+
     free(memBlock);
 
@@ -1256 +1312 @@
     MUTEX_LOCK(&memBlockListMutex);
 
+    // this function calls 'isBadMemBlock', which may in turn call this function : avoid nested calls or we will be stuck forever
+    checkingForCorruption = true;
+
     psS32 nbad = 0;               // number of bad blocks
-    for (psMemBlock *memBlock = lastMemBlockAllocated; memBlock != NULL; memBlock = memBlock->nextBlock) {
+    for (psMemBlock *memBlock = (psMemBlock *) lastMemBlockAllocated; memBlock != NULL; memBlock = memBlock->nextBlock) {
         if (isBadMemBlock(output, memBlock, __FILE__, __LINE__, __func__)) {
             nbad++;
@@ -1269 +1328 @@
     }
 
+    checkingForCorruption = true;
+
     // release the lock on the memblock list
     MUTEX_UNLOCK(&memBlockListMutex);
@@ -1288 +1349 @@
 
     // loop through the linked list of memBlocks looking for a matching pointer
-    for (psMemBlock *memBlock = lastMemBlockAllocated; memBlock != NULL; memBlock = memBlock->nextBlock) {
+    for (psMemBlock *memBlock = (psMemBlock *) lastMemBlockAllocated; memBlock != NULL; memBlock = memBlock->nextBlock) {
         if (memBlock == addr) {
             // we found the memBlock
@@ -1339 +1400 @@
     size_t alloc = 0, persist = 0;
     size_t nalloc = 0, npersist = 0;
-    for (psMemBlock* ptr = lastMemBlockAllocated; ptr != NULL; ptr = ptr->nextBlock) {
+    for (psMemBlock* ptr = (psMemBlock *) lastMemBlockAllocated; ptr != NULL; ptr = ptr->nextBlock) {
         assert (ptr->refCounter > 0);