Add malloc logging tool

STATIC_YOINK("enable_memory_log");

libc/runtime/clone.c

@@ -199,10 +199,11 @@ static int CloneXnu(int (*fn)(void *), char *stk, size_t stksz, int flags,
   wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
   wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
   wt->tls = flags & CLONE_SETTLS ? tls : 0;
-  _seizelock(&wt->lock);  // TODO: How can we get the tid without locking?
+  wt->lock = 1;
   if ((rc = bsdthread_create(fn, arg, wt, 0, PTHREAD_START_CUSTOM_XNU)) != -1) {
     _spinlock(&wt->lock);
     rc = wt->tid;
+    _spunlock(&wt->lock);
   }
   return rc;
 }
@@ -263,9 +264,7 @@ static int CloneFreebsd(int (*func)(void *), char *stk, size_t stksz, int flags,
 // OPEN BESIYATA DISHMAYA
 
 int __tfork(struct __tfork *params, size_t psize, struct CloneArgs *wt);
-asm(".section\t.privileged,\"ax\",@progbits\n\t"
-    ".local\t__tfork\n"
-    "__tfork:\n\t"
+asm("__tfork:\n\t"
     "push\t$8\n\t"
     "pop\t%rax\n\t"
     "mov\t%rdx,%r8\n\t"
@@ -282,11 +281,10 @@ asm(".section\t.privileged,\"ax\",@progbits\n\t"
     "and\t$-16,%rsp\n\t"
     "push\t%rax\n\t"
     "jmp\tOpenbsdThreadMain\n\t"
-    ".size\t__tfork,.-__tfork\n\t"
-    ".previous");
+    ".size\t__tfork,.-__tfork\n\t");
 __attribute__((__used__, __no_reorder__))
 
-static privileged wontreturn void
+static wontreturn void
 OpenbsdThreadMain(struct CloneArgs *wt) {
   wt->func(wt->arg);
   // we no longer use the stack after this point. however openbsd

libc/runtime/getmemtracksize.c

@@ -0,0 +1,27 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/memtrack.internal.h"
+
+noasan size_t GetMemtrackSize(struct MemoryIntervals *mm) {
+  size_t i, n;
+  for (n = i = 0; i < mm->i; ++i) {
+    n += ((size_t)(mm->p[i].y - mm->p[i].x) + 1) << 16;
+  }
+  return n;
+}

libc/runtime/memtrack.internal.h

@@ -63,6 +63,7 @@ int ReleaseMemoryIntervals(struct MemoryIntervals *, int, int,
                            void (*)(struct MemoryIntervals *, int, int)) hidden;
 void ReleaseMemoryNt(struct MemoryIntervals *, int, int) hidden;
 int UntrackMemoryIntervals(void *, size_t) hidden;
+size_t GetMemtrackSize(struct MemoryIntervals *);
 
 #define IsLegalPointer(p) \
   (-0x800000000000 <= (intptr_t)(p) && (intptr_t)(p) <= 0x7fffffffffff)

libc/runtime/mmap.c

@@ -148,14 +148,6 @@ noasan static bool Automap(int count, int align, int *res) {
          *res + count <= FRAME(kAutomapStart + (kAutomapSize - 1));
 }
 
-noasan static size_t GetMemtrackSize(struct MemoryIntervals *mm) {
-  size_t i, n;
-  for (n = i = 0; i < mm->i; ++i) {
-    n += ((size_t)(mm->p[i].y - mm->p[i].x) + 1) << 16;
-  }
-  return n;
-}
-
 static noasan void *FinishMemory(void *addr, size_t size, int prot, int flags,
                                  int fd, int64_t off, int f, int x, int n,
                                  struct DirectMap dm) {
@@ -491,10 +483,15 @@ static noasan inline void *Mmap(void *addr, size_t size, int prot, int flags,
 noasan void *mmap(void *addr, size_t size, int prot, int flags, int fd,
                   int64_t off) {
   void *res;
+  size_t toto;
   _spinlock(&_mmi.lock);
   res = Mmap(addr, size, prot, flags, fd, off);
+#if SYSDEBUG
+  toto = __strace > 0 ? GetMemtrackSize(&_mmi) : 0;
+#endif
   _spunlock(&_mmi.lock);
-  STRACE("mmap(%p, %'zu, %s, %s, %d, %'ld) → %p% m", addr, size,
-         DescribeProtFlags(prot), DescribeMapFlags(flags), fd, off, res);
+  STRACE("mmap(%p, %'zu, %s, %s, %d, %'ld) → %p% m (%'zu bytes total)", addr,
+         size, DescribeProtFlags(prot), DescribeMapFlags(flags), fd, off, res,
+         toto);
   return res;
 }

libc/runtime/munmap.c

@@ -163,9 +163,13 @@ static noasan int Munmap(char *p, size_t n) {
  */
 noasan int munmap(void *p, size_t n) {
   int rc;
+  size_t toto;
   _spinlock(&_mmi.lock);
   rc = Munmap(p, n);
+#if SYSDEBUG
+  toto = __strace > 0 ? GetMemtrackSize(&_mmi) : 0;
+#endif
   _spunlock(&_mmi.lock);
-  STRACE("munmap(%.12p, %'zu) → %d% m", p, n, rc);
+  STRACE("munmap(%.12p, %'zu) → %d% m (%'zu bytes total)", p, n, rc, toto);
   return rc;
 }