Changeset 1072 for trunk/dll/fortify.c

Timestamp:

Jul 17, 2008, 7:39:14 PM (17 years ago)

Author:

Steven Levine

Message:

Add Fortify_SetOwner Fortify_ChangeOwner to support cross thread allocations

File:

• trunk/dll/fortify.c (modified) (14 diffs)

trunk/dll/fortify.c

@@ -43 +43 @@
  /* 06 May 08 SHL Rework scope logic to be MT capable
     26 May 08 SHL Show TID for leaking scope
+    17 Jul 08 SHL Add Fortify_SetOwner Fortify_ChangeOwner
  */
 
@@ -64 +65 @@
 
 
-#if defined(__WATCOMC__) && defined(_MT)
-#define MT_SCOPES 1
+#ifdef MT_SCOPES
 unsigned long Get_TID_Ordinal(void);
 // Get tib_ptib2 from TIB
@@ -100 +100 @@
     struct Header *Next;        /* Next link                         */
     char          *Label;       /* User's Label (may be null)        */
-    unsigned char  Scope;       /* Scope level of the caller         */
+    unsigned char  Scope;       /* Scope level of the owner          */
     unsigned char  Allocator;   /* malloc/realloc/new/etc            */
 #   ifdef MT_SCOPES
-    unsigned short Ordinal;     /* TID ordinal of caller             */
+    unsigned short Owner;       /* TID ordinal of block owner        */
 #   endif
 };
 
 #define FORTIFY_HEADER_SIZE ROUND_UP(sizeof(struct Header), sizeof(unsigned short))
-
 
 
@@ -177 +176 @@
 static unsigned long  st_LastVerifiedLine;
 #ifdef MT_SCOPES
-static unsigned volatile st_cScopes;
-static unsigned volatile char*  st_pScopes;
+static unsigned volatile st_cOrdinals;          // Number of known threads
+static unsigned volatile char*  st_pScopes;     // Scope level of blocks allocated by thread
+static unsigned volatile long*  st_pOwners;     // Owner of blocks allocated by thread
 #else
 static unsigned char  st_Scope            = 0;
@@ -416 +416 @@
 #   ifdef MT_SCOPES
     ordinal = Get_TID_Ordinal();
+    // In case owner overridden by Fortify_SetOwner
+    if (ordinal < st_cOrdinals)
+        ordinal = st_pOwners[ordinal];
 #   endif
 
@@ -428 +431 @@
     h->Prev      = 0;
 #   ifdef MT_SCOPES
-    h->Scope     = ordinal < st_cScopes ? st_pScopes[ordinal] : 0;
-    h->Ordinal = ordinal;
+    h->Scope     = ordinal < st_cOrdinals ? st_pScopes[ordinal] : 0;
+    h->Owner = ordinal;
 #   else
     h->Scope     = st_Scope;
@@ -690 +693 @@
 #ifdef MT_SCOPES
     ordinal = Get_TID_Ordinal();
-    if (ordinal < st_cScopes && st_pScopes[ordinal] > 0)
+    if (ordinal < st_cOrdinals && st_pScopes[ordinal] > 0)
 #else
     if(st_Scope > 0)
@@ -977 +980 @@
 #ifdef MT_SCOPES
     unsigned ordinal = Get_TID_Ordinal();
-
-    if (ordinal >= st_cScopes) {
-        st_pScopes = realloc((void*)st_pScopes, sizeof(*st_pScopes) * (st_cScopes = (ordinal + 1)));
-        st_pScopes[ordinal] = 0;
+    unsigned i;
+    unsigned c;
+
+    if (ordinal >= st_cOrdinals) {
+        // Expand arrays
+        FORTIFY_LOCK();
+        i = st_cOrdinals;
+        c = ordinal + 1;
+        st_pScopes = realloc((void*)st_pScopes, sizeof(*st_pScopes) * c);
+        st_pOwners = realloc((void*)st_pOwners, sizeof(*st_pOwners) * c);
+        for (; i <= ordinal; i++) {
+            st_pScopes[i] = 0;          // Default to scope level 0
+            st_pOwners[i] = i;          // Default block owner to self
+        }
+        st_cOrdinals = c;
+        FORTIFY_UNLOCK();
     }
     return(++st_pScopes[ordinal]);
@@ -1010 +1025 @@
     // Complain on leave without enter 06 May 08 SHL
     ordinal = Get_TID_Ordinal();
-    if (ordinal < st_cScopes && st_pScopes[ordinal] > 0)
+    if (ordinal < st_cOrdinals && st_pScopes[ordinal] > 0)
         st_pScopes[ordinal]--;
     else {
@@ -1029 +1044 @@
     {
 #ifdef MT_SCOPES
-        if(curr->Ordinal == ordinal && ordinal < st_cScopes && curr->Scope > st_pScopes[ordinal])
+        if(curr->Owner == ordinal && ordinal < st_cOrdinals && curr->Scope > st_pScopes[ordinal])
 #else
         if(curr->Scope > st_Scope)
@@ -1071 +1086 @@
      */
 #ifdef MT_SCOPES
-    st_PurgeDeallocatedScope( ordinal < st_cScopes ? st_pScopes[ordinal] : 0,
+    st_PurgeDeallocatedScope( ordinal < st_cOrdinals ? st_pScopes[ordinal] : 0,
                               file, line );
 #else
@@ -1080 +1095 @@
     FORTIFY_UNLOCK();
 #ifdef MT_SCOPES
-    return(ordinal < st_cScopes ? st_pScopes[ordinal] : 0);
+    return(ordinal < st_cOrdinals ? st_pScopes[ordinal] : 0);
 #else
     return(st_Scope);
@@ -1700 +1715 @@
         next = curr->Next;
 #ifdef MT_SCOPES
-        if(curr->Ordinal == ordinal && curr->Scope >= Scope)
+        if(curr->Owner == ordinal && curr->Scope >= Scope)
 #else
         if(curr->Scope >= Scope)
@@ -2399 +2414 @@
 #endif /* __cplusplus */
 
+#ifdef MT_SCOPES
+
+/**
+ * Set/reset owner of blocks allocated by this thread
+ * Use when worker thread will allocate blocks for another thread
+ * and other thread is known
+ * More efficient than Fortify_ChangeOwner
+ * @param lOwnerTID is new owner TID, -1 requests reset of self
+ */
+
+void Fortify_SetOwner(long lOwnerTID)
+{
+    unsigned ordinal = Get_TID_Ordinal();
+
+    if (ordinal >= st_cOrdinals) {
+        // Expand arrays
+        unsigned i;
+        unsigned c;
+        FORTIFY_LOCK();
+        i = st_cOrdinals;
+        c = ordinal + 1;
+        st_pScopes = realloc((void*)st_pScopes, sizeof(*st_pScopes) * c);
+        st_pOwners = realloc((void*)st_pOwners, sizeof(*st_pOwners) * c);
+        for (; i <= ordinal; i++) {
+            st_pScopes[i] = 0;
+            st_pOwners[i] = i;          // Block owner is self
+        }
+        st_cOrdinals = c;
+        FORTIFY_UNLOCK();
+    }
+    // Set owner for blocks allocated by this thread
+    st_pOwners[ordinal] = lOwnerTID != -1 ? lOwnerTID : ordinal;
+}
+
+/**
+ * Take ownership of block allocated by some other thread
+ * Allows scope enter/exit logic to correctly report leaks in 
+ * cross thread allocations
+ * @param pVoid is point to block allocated by Fortify
+ */
+
+void Fortify_ChangeOwner(void *pBlock)
+{
+    unsigned char *ptr = (unsigned char *)pBlock -
+                             FORTIFY_HEADER_SIZE -
+                             FORTIFY_ALIGNED_BEFORE_SIZE;
+    struct Header *h = (struct Header *)ptr;
+
+    unsigned ordinal = Get_TID_Ordinal();
+
+    h->Scope = ordinal < st_cOrdinals ? st_pScopes[ordinal] : 0;
+    h->Owner = ordinal;         // Take ownership
+}
+
+#endif // MT_SCOPES
+
 #endif /* FORTIFY */