[Tracing] Add hook to PartitionAlloc for heap profiling

third_party/WebKit/Source/wtf/PartitionAlloc.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 393 matching lines @@
 WTF_EXPORT void partitionPurgeMemory(PartitionRoot*, int);
 WTF_EXPORT void partitionPurgeMemoryGeneric(PartitionRootGeneric*, int);
 
 WTF_EXPORT NEVER_INLINE void* partitionAllocSlowPath(PartitionRootBase*, int, size_t, PartitionBucket*);
 WTF_EXPORT NEVER_INLINE void partitionFreeSlowPath(PartitionPage*);
 WTF_EXPORT NEVER_INLINE void* partitionReallocGeneric(PartitionRootGeneric*, void*, size_t);
 
 WTF_EXPORT void partitionDumpStats(PartitionRoot*, const char* partitionName, bool isLightDump, PartitionStatsDumper*);
 WTF_EXPORT void partitionDumpStatsGeneric(PartitionRootGeneric*, const char* partitionName, bool isLightDump, PartitionStatsDumper*);
 
+extern WTF_EXPORT void (*partitionAllocHookAlloc)(void* addr, size_t size);

[Primiano Tucci (use gerrit), 2015/10/12 16:36:46]

Hmm I think that if you split this into the actual fptr declaration and the
storage definition it will be more clear and will reduce code duplication w.r.t.
the .cc file
also making them static fields of some class would remove the need of the
awkward "extern"

[Ruud van Asseldonk, 2015/10/13 10:42:18]

Done.

+extern WTF_EXPORT void (*partitionAllocHookFree)(void* addr);
+
 ALWAYS_INLINE PartitionFreelistEntry* partitionFreelistMask(PartitionFreelistEntry* ptr)
 {
     // We use bswap on little endian as a fast mask for two reasons:
     // 1) If an object is freed and its vtable used where the attacker doesn't
     // get the chance to run allocations between the free and use, the vtable
     // dereference is likely to fault.
     // 2) If the attacker has a linear buffer overflow and elects to try and
     // corrupt a freelist pointer, partial pointer overwrite attacks are
     // thwarted.
     // For big endian, similar guarantees are arrived at with a negation.
@@ skipping 270 matching lines @@
     void* result = malloc(size);
     RELEASE_ASSERT(result);
     return result;
 #else
     ASSERT(root->initialized);
     size = partitionCookieSizeAdjustAdd(size);
     PartitionBucket* bucket = partitionGenericSizeToBucket(root, size);
     spinLockLock(&root->lock);
     void* ret = partitionBucketAlloc(root, flags, size, bucket);
     spinLockUnlock(&root->lock);
+
+    if (UNLIKELY(partitionAllocHookAlloc != nullptr))

[Primiano Tucci (use gerrit), 2015/10/12 16:36:46]

see my previous comment about locking. I think you might want to move this under
the spinlock.

[Primiano Tucci (use gerrit), 2015/10/12 16:36:46]

Also, if you hook only partitionAllocGeneric you will miss the calls entering
via partitionAlloc() and partitionFree() 

[Ruud van Asseldonk, 2015/10/13 10:42:18]

Oooops, should have hooked |partitionBucketAlloc| and |partitionFreeWithPage| in
the common code path.

+        partitionAllocHookAlloc(ret, size);
+
     return ret;
 #endif
 }
 
 ALWAYS_INLINE void* partitionAllocGeneric(PartitionRootGeneric* root, size_t size)
 {
     return partitionAllocGenericFlags(root, 0, size);
 }
 
 ALWAYS_INLINE void partitionFreeGeneric(PartitionRootGeneric* root, void* ptr)
 {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
     free(ptr);
 #else
     ASSERT(root->initialized);
 
+    if (UNLIKELY(partitionAllocHookFree != nullptr))

[Primiano Tucci (use gerrit), 2015/10/12 16:36:46]

ditto

[Ruud van Asseldonk, 2015/10/13 10:42:18]

Yes.

+        partitionAllocHookFree(ptr);
+
     if (UNLIKELY(!ptr))
         return;
 
     ptr = partitionCookieFreePointerAdjust(ptr);
     ASSERT(partitionPointerIsValid(ptr));
     PartitionPage* page = partitionPointerToPage(ptr);
     spinLockLock(&root->lock);
     partitionFreeWithPage(ptr, page);
     spinLockUnlock(&root->lock);
 #endif
@@ skipping 84 matching lines @@
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 using WTF::partitionAllocActualSize;
 using WTF::partitionAllocSupportsGetSize;
 using WTF::partitionAllocGetSize;
 
 #endif // WTF_PartitionAlloc_h