Apply alloc-type-info.cocci

src/common/address.c

@@ -2133,7 +2133,8 @@ tor_addr_hostname_is_local(const char *name)
 tor_addr_port_t *
 tor_addr_port_new(const tor_addr_t *addr, uint16_t port)
 {
-  tor_addr_port_t *ap = tor_malloc_zero(sizeof(tor_addr_port_t));
+  tor_addr_port_t *ap = tor_malloc_zero_type(sizeof(tor_addr_port_t),
+                                             TOR_STRINGIFY(tor_addr_port_t));
   if (addr)
     tor_addr_copy(&ap->addr, addr);
   ap->port = port;

src/common/aes.c

@@ -278,7 +278,8 @@ static void aes_set_iv(aes_cnt_cipher_t *cipher, const uint8_t *iv);
 aes_cnt_cipher_t*
 aes_new_cipher(const uint8_t *key, const uint8_t *iv, int bits)
 {
-  aes_cnt_cipher_t* result = tor_malloc_zero(sizeof(aes_cnt_cipher_t));
+  aes_cnt_cipher_t* result = tor_malloc_zero_type(sizeof(aes_cnt_cipher_t),
+                                                  TOR_STRINGIFY(aes_cnt_cipher_t));
 
   aes_set_key(result, key, bits);
   aes_set_iv(result, iv);

src/common/buffers.c

@@ -352,7 +352,7 @@ buf_new_with_capacity(size_t size)
 buf_t *
 buf_new(void)
 {
-  buf_t *buf = tor_malloc_zero(sizeof(buf_t));
+  buf_t *buf = tor_malloc_zero_type(sizeof(buf_t), TOR_STRINGIFY(buf_t));
   buf->magic = BUFFER_MAGIC;
   buf->default_chunk_size = 4096;
   return buf;

src/common/compat.c

@@ -284,7 +284,7 @@ tor_mmap_file(const char *filename)
     return NULL;
   }
 
-  res = tor_malloc_zero(sizeof(tor_mmap_t));
+  res = tor_malloc_zero_type(sizeof(tor_mmap_t), TOR_STRINGIFY(tor_mmap_t));
   res->data = string;
   res->size = filesize;
   res->mapping_size = size;
@@ -318,7 +318,8 @@ tor_mmap_t *
 tor_mmap_file(const char *filename)
 {
   TCHAR tfilename[MAX_PATH]= {0};
-  tor_mmap_t *res = tor_malloc_zero(sizeof(tor_mmap_t));
+  tor_mmap_t *res = tor_malloc_zero_type(sizeof(tor_mmap_t),
+                                         TOR_STRINGIFY(tor_mmap_t));
   int empty = 0;
   HANDLE file_handle = INVALID_HANDLE_VALUE;
   DWORD size_low, size_high;
@@ -426,7 +427,7 @@ tor_mmap_file(const char *filename)
   tor_mmap_t *handle;
   if (! res)
     return NULL;
-  handle = tor_malloc_zero(sizeof(tor_mmap_t));
+  handle = tor_malloc_zero_type(sizeof(tor_mmap_t), TOR_STRINGIFY(tor_mmap_t));
   handle->data = res;
   handle->size = st.st_size;
   return handle;
@@ -957,7 +958,8 @@ tor_lockfile_lock(const char *filename, int blocking, int *locked_out)
   }
 #endif /* defined(_WIN32) || ... */
 
-  result = tor_malloc(sizeof(tor_lockfile_t));
+  result = tor_malloc_type(sizeof(tor_lockfile_t),
+                           TOR_STRINGIFY(tor_lockfile_t));
   result->filename = tor_strdup(filename);
   result->fd = fd;
   return result;
@@ -1844,7 +1846,7 @@ log_credential_status(void)
 
   /* log supplementary groups */
   sup_gids_size = 64;
-  sup_gids = tor_calloc(64, sizeof(gid_t));
+  sup_gids = tor_calloc_type(64, sizeof(gid_t), TOR_STRINGIFY(gid_t));
   while ((ngids = getgroups(sup_gids_size, sup_gids)) < 0 &&
          errno == EINVAL &&
          sup_gids_size < NGROUPS_MAX) {
@@ -1894,7 +1896,8 @@ static struct passwd *passwd_cached = NULL;
 static struct passwd *
 tor_passwd_dup(const struct passwd *pw)
 {
-  struct passwd *new_pw = tor_malloc_zero(sizeof(struct passwd));
+  struct passwd *new_pw = tor_malloc_zero_type(sizeof(struct passwd),
+                                               TOR_STRINGIFY(struct passwd));
   if (pw->pw_name)
     new_pw->pw_name = tor_strdup(pw->pw_name);
   if (pw->pw_dir)
@@ -3463,7 +3466,8 @@ tor_getpass(const char *prompt, char *output, size_t buflen)
   }
 
   tor_assert(buflen <= INT_MAX);
-  wchar_t *buf = tor_calloc(buflen, sizeof(wchar_t));
+  wchar_t *buf = tor_calloc_type(buflen, sizeof(wchar_t),
+                                 TOR_STRINGIFY(wchar_t));
 
   wchar_t *ptr = buf, *lastch = buf + buflen - 1;
   while (ptr < lastch) {

src/common/compat_libevent.c

@@ -199,7 +199,8 @@ periodic_timer_new(struct event_base *base,
   tor_assert(base);
   tor_assert(tv);
   tor_assert(cb);
-  timer = tor_malloc_zero(sizeof(periodic_timer_t));
+  timer = tor_malloc_zero_type(sizeof(periodic_timer_t),
+                               TOR_STRINGIFY(periodic_timer_t));
   if (!(timer->ev = tor_event_new(base, -1, EV_PERSIST,
                                   periodic_timer_cb, timer))) {
     tor_free(timer);

src/common/compat_pthreads.c

@@ -72,7 +72,8 @@ spawn_func(void (*func)(void *), void *data)
   if (PREDICT_UNLIKELY(!threads_initialized)) {
     tor_threads_init();
   }
-  d = tor_malloc(sizeof(tor_pthread_data_t));
+  d = tor_malloc_type(sizeof(tor_pthread_data_t),
+                      TOR_STRINGIFY(tor_pthread_data_t));
   d->data = data;
   d->func = func;
   if (pthread_create(&thread, &attr_detached, tor_pthread_helper_fn, d)) {

src/common/compat_threads.c

@@ -33,7 +33,8 @@
 tor_mutex_t *
 tor_mutex_new(void)
 {
-  tor_mutex_t *m = tor_malloc_zero(sizeof(tor_mutex_t));
+  tor_mutex_t *m = tor_malloc_zero_type(sizeof(tor_mutex_t),
+                                        TOR_STRINGIFY(tor_mutex_t));
   tor_mutex_init(m);
   return m;
 }
@@ -42,7 +43,8 @@ tor_mutex_new(void)
 tor_mutex_t *
 tor_mutex_new_nonrecursive(void)
 {
-  tor_mutex_t *m = tor_malloc_zero(sizeof(tor_mutex_t));
+  tor_mutex_t *m = tor_malloc_zero_type(sizeof(tor_mutex_t),
+                                        TOR_STRINGIFY(tor_mutex_t));
   tor_mutex_init_nonrecursive(m);
   return m;
 }
@@ -60,7 +62,8 @@ tor_mutex_free_(tor_mutex_t *m)
 tor_cond_t *
 tor_cond_new(void)
 {
-  tor_cond_t *cond = tor_malloc(sizeof(tor_cond_t));
+  tor_cond_t *cond = tor_malloc_type(sizeof(tor_cond_t),
+                                     TOR_STRINGIFY(tor_cond_t));
   if (BUG(tor_cond_init(cond)<0))
     tor_free(cond); // LCOV_EXCL_LINE
   return cond;

src/common/compress.c

@@ -474,7 +474,8 @@ tor_compress_new(int compress, compress_method_t method,
 {
   tor_compress_state_t *state;
 
-  state = tor_malloc_zero(sizeof(tor_compress_state_t));
+  state = tor_malloc_zero_type(sizeof(tor_compress_state_t),
+                               TOR_STRINGIFY(tor_compress_state_t));
   state->method = method;
 
   switch (method) {

src/common/compress_lzma.c

@@ -183,7 +183,8 @@ tor_lzma_compress_new(int compress,
   // Note that we do not explicitly initialize the lzma_stream object here,
   // since the LZMA_STREAM_INIT "just" initializes all members to 0, which is
   // also what `tor_malloc_zero()` does.
-  result = tor_malloc_zero(sizeof(tor_lzma_compress_state_t));
+  result = tor_malloc_zero_type(sizeof(tor_lzma_compress_state_t),
+                                TOR_STRINGIFY(tor_lzma_compress_state_t));
   result->compress = compress;
   result->allocation = tor_lzma_state_size_precalc(compress, level);
 

src/common/compress_zlib.c

@@ -167,7 +167,8 @@ tor_zlib_compress_new(int compress_,
     compression_level = BEST_COMPRESSION;
   }
 
-  out = tor_malloc_zero(sizeof(tor_zlib_compress_state_t));
+  out = tor_malloc_zero_type(sizeof(tor_zlib_compress_state_t),
+                             TOR_STRINGIFY(tor_zlib_compress_state_t));
   out->stream.zalloc = Z_NULL;
   out->stream.zfree = Z_NULL;
   out->stream.opaque = NULL;

src/common/compress_zstd.c

@@ -188,7 +188,8 @@ tor_zstd_compress_new(int compress,
   tor_zstd_compress_state_t *result;
   size_t retval;
 
-  result = tor_malloc_zero(sizeof(tor_zstd_compress_state_t));
+  result = tor_malloc_zero_type(sizeof(tor_zstd_compress_state_t),
+                                TOR_STRINGIFY(tor_zstd_compress_state_t));
   result->compress = compress;
   result->allocation = tor_zstd_state_size_precalc(compress, preset);
 

src/common/confline.c

@@ -36,7 +36,8 @@ config_line_append(config_line_t **lst,
 
   config_line_t *newline;
 
-  newline = tor_malloc_zero(sizeof(config_line_t));
+  newline = tor_malloc_zero_type(sizeof(config_line_t),
+                                 TOR_STRINGIFY(config_line_t));
   newline->key = tor_strdup(key);
   newline->value = tor_strdup(val);
   newline->next = NULL;
@@ -57,7 +58,8 @@ config_line_prepend(config_line_t **lst,
 
   config_line_t *newline;
 
-  newline = tor_malloc_zero(sizeof(config_line_t));
+  newline = tor_malloc_zero_type(sizeof(config_line_t),
+                                 TOR_STRINGIFY(config_line_t));
   newline->key = tor_strdup(key);
   newline->value = tor_strdup(val);
   newline->next = *lst;
@@ -365,7 +367,8 @@ config_lines_dup_and_filter(const config_line_t *inp,
       inp = inp->next;
       continue;
     }
-    *next_out = tor_malloc_zero(sizeof(config_line_t));
+    *next_out = tor_malloc_zero_type(sizeof(config_line_t),
+                                     TOR_STRINGIFY(config_line_t));
     (*next_out)->key = tor_strdup(inp->key);
     (*next_out)->value = tor_strdup(inp->value);
     inp = inp->next;

src/common/container.c

@@ -1524,7 +1524,8 @@ digestset_new(int max_elements)
    * conserve CPU, and k==13 is pretty big.
    */
   int n_bits = 1u << (tor_log2(max_elements)+5);
-  digestset_t *r = tor_malloc(sizeof(digestset_t));
+  digestset_t *r = tor_malloc_type(sizeof(digestset_t),
+                                   TOR_STRINGIFY(digestset_t));
   r->mask = n_bits - 1;
   r->ba = bitarray_init_zero(n_bits);
   return r;

src/common/crypto.c

@@ -387,7 +387,7 @@ crypto_new_pk_from_rsa_(RSA *rsa)
 {
   crypto_pk_t *env;
   tor_assert(rsa);
-  env = tor_malloc(sizeof(crypto_pk_t));
+  env = tor_malloc_type(sizeof(crypto_pk_t), TOR_STRINGIFY(crypto_pk_t));
   env->refs = 1;
   env->key = rsa;
   return env;
@@ -2122,7 +2122,7 @@ crypto_xof_t *
 crypto_xof_new(void)
 {
   crypto_xof_t *xof;
-  xof = tor_malloc(sizeof(crypto_xof_t));
+  xof = tor_malloc_type(sizeof(crypto_xof_t), TOR_STRINGIFY(crypto_xof_t));
   keccak_xof_init(&xof->s, 256);
   return xof;
 }
@@ -2333,7 +2333,8 @@ init_dh_param(void)
 crypto_dh_t *
 crypto_dh_new(int dh_type)
 {
-  crypto_dh_t *res = tor_malloc_zero(sizeof(crypto_dh_t));
+  crypto_dh_t *res = tor_malloc_zero_type(sizeof(crypto_dh_t),
+                                          TOR_STRINGIFY(crypto_dh_t));
 
   tor_assert(dh_type == DH_TYPE_CIRCUIT || dh_type == DH_TYPE_TLS ||
              dh_type == DH_TYPE_REND);
@@ -2398,7 +2399,8 @@ crypto_dh_new(int dh_type)
 crypto_dh_t *
 crypto_dh_dup(const crypto_dh_t *dh)
 {
-  crypto_dh_t *dh_new = tor_malloc_zero(sizeof(crypto_dh_t));
+  crypto_dh_t *dh_new = tor_malloc_zero_type(sizeof(crypto_dh_t),
+                                             TOR_STRINGIFY(crypto_dh_t));
   tor_assert(dh);
   tor_assert(dh->dh);
   dh_new->dh = dh->dh;

src/common/crypto_openssl_mgt.c

@@ -128,7 +128,8 @@ setup_openssl_threading(void)
   int i;
   int n = CRYPTO_num_locks();
   n_openssl_mutexes_ = n;
-  openssl_mutexes_ = tor_calloc(n, sizeof(tor_mutex_t *));
+  openssl_mutexes_ = tor_calloc_type(n, sizeof(tor_mutex_t *),
+                                     TOR_STRINGIFY(tor_mutex_t *));
   for (i=0; i < n; ++i)
     openssl_mutexes_[i] = tor_mutex_new();
   CRYPTO_set_locking_callback(openssl_locking_cb_);

src/common/di_ops.c

@@ -174,7 +174,8 @@ dimap_add_entry(di_digest256_map_t **map,
     tor_assert(! old_val);
     tor_assert(val);
   }
-  new_ent = tor_malloc_zero(sizeof(di_digest256_map_t));
+  new_ent = tor_malloc_zero_type(sizeof(di_digest256_map_t),
+                                 TOR_STRINGIFY(di_digest256_map_t));
   new_ent->next = *map;
   memcpy(new_ent->key, key, 32);
   new_ent->val = val;

src/common/log.c

@@ -411,7 +411,8 @@ static pending_log_message_t *
 pending_log_message_new(int severity, log_domain_mask_t domain,
                         const char *fullmsg, const char *shortmsg)
 {
-  pending_log_message_t *m = tor_malloc(sizeof(pending_log_message_t));
+  pending_log_message_t *m = tor_malloc_type(sizeof(pending_log_message_t),
+                                             TOR_STRINGIFY(pending_log_message_t));
   m->severity = severity;
   m->domain = domain;
   m->fullmsg = fullmsg ? tor_strdup(fullmsg) : NULL;
@@ -888,7 +889,7 @@ add_stream_log_impl(const log_severity_list_t *severity,
                     const char *name, int fd)
 {
   logfile_t *lf;
-  lf = tor_malloc_zero(sizeof(logfile_t));
+  lf = tor_malloc_zero_type(sizeof(logfile_t), TOR_STRINGIFY(logfile_t));
   lf->fd = fd;
   lf->filename = tor_strdup(name);
   lf->severities = tor_memdup(severity, sizeof(log_severity_list_t));
@@ -947,7 +948,8 @@ logs_set_domain_logging(int enabled)
 void
 add_temp_log(int min_severity)
 {
-  log_severity_list_t *s = tor_malloc_zero(sizeof(log_severity_list_t));
+  log_severity_list_t *s = tor_malloc_zero_type(sizeof(log_severity_list_t),
+                                                TOR_STRINGIFY(log_severity_list_t));
   set_log_severity_config(min_severity, LOG_ERR, s);
   LOCK_LOGS();
   add_stream_log_impl(s, "<temp>", fileno(stdout));
@@ -964,7 +966,7 @@ int
 add_callback_log(const log_severity_list_t *severity, log_callback cb)
 {
   logfile_t *lf;
-  lf = tor_malloc_zero(sizeof(logfile_t));
+  lf = tor_malloc_zero_type(sizeof(logfile_t), TOR_STRINGIFY(logfile_t));
   lf->fd = -1;
   lf->severities = tor_memdup(severity, sizeof(log_severity_list_t));
   lf->filename = tor_strdup("<callback>");
@@ -1184,7 +1186,7 @@ add_syslog_log(const log_severity_list_t *severity,
     openlog(buf, LOG_PID | LOG_NDELAY, LOGFACILITY);
   }
 
-  lf = tor_malloc_zero(sizeof(logfile_t));
+  lf = tor_malloc_zero_type(sizeof(logfile_t), TOR_STRINGIFY(logfile_t));
   lf->fd = -1;
   lf->severities = tor_memdup(severity, sizeof(log_severity_list_t));
   lf->filename = tor_strdup("<syslog>");
@@ -1209,7 +1211,7 @@ add_android_log(const log_severity_list_t *severity,
 {
   logfile_t *lf = NULL;
 
-  lf = tor_malloc_zero(sizeof(logfile_t));
+  lf = tor_malloc_zero_type(sizeof(logfile_t), TOR_STRINGIFY(logfile_t));
   lf->fd = -1;
   lf->severities = tor_memdup(severity, sizeof(log_severity_list_t));
   lf->filename = tor_strdup("<android>");

src/common/memarea.c

@@ -145,7 +145,8 @@ memarea_chunk_free_unchecked(memarea_chunk_t *chunk)
 memarea_t *
 memarea_new(void)
 {
-  memarea_t *head = tor_malloc(sizeof(memarea_t));
+  memarea_t *head = tor_malloc_type(sizeof(memarea_t),
+                                    TOR_STRINGIFY(memarea_t));
   head->first = alloc_chunk(CHUNK_SIZE);
   return head;
 }
@@ -317,7 +318,8 @@ struct memarea_t {
 memarea_t *
 memarea_new(void)
 {
-  memarea_t *ma = tor_malloc_zero(sizeof(memarea_t));
+  memarea_t *ma = tor_malloc_zero_type(sizeof(memarea_t),
+                                       TOR_STRINGIFY(memarea_t));
   ma->pieces = smartlist_new();
   return ma;
 }

src/common/procmon.c

@@ -181,8 +181,8 @@ tor_process_monitor_new(struct event_base *base,
                         tor_procmon_callback_t cb, void *cb_arg,
                         const char **msg)
 {
-  tor_process_monitor_t *procmon = tor_malloc_zero(
-                                       sizeof(tor_process_monitor_t));
+  tor_process_monitor_t *procmon = tor_malloc_zero_type(sizeof(tor_process_monitor_t),
+                                                        TOR_STRINGIFY(tor_process_monitor_t));
   struct parsed_process_specifier_t ppspec;
 
   tor_assert(msg != NULL);

src/common/sandbox.c

@@ -1370,8 +1370,10 @@ new_element2(int syscall, char *value, char *value2)
 {
   smp_param_t *param = NULL;
 
-  sandbox_cfg_t *elem = tor_malloc_zero(sizeof(sandbox_cfg_t));
-  param = elem->param = tor_malloc_zero(sizeof(smp_param_t));
+  sandbox_cfg_t *elem = tor_malloc_zero_type(sizeof(sandbox_cfg_t),
+                                             TOR_STRINGIFY(sandbox_cfg_t));
+  param = elem->param = tor_malloc_zero_type(sizeof(smp_param_t),
+                                             TOR_STRINGIFY(smp_param_t));
 
   param->syscall = syscall;
   param->value = value;

src/common/storagedir.c

@@ -49,7 +49,8 @@ storage_dir_new(const char *dirname, int max_files)
   if (check_private_dir(dirname, CPD_CREATE, NULL) < 0)
     return NULL;
 
-  storage_dir_t *d = tor_malloc_zero(sizeof(storage_dir_t));
+  storage_dir_t *d = tor_malloc_zero_type(sizeof(storage_dir_t),
+                                          TOR_STRINGIFY(storage_dir_t));
   d->directory = tor_strdup(dirname);
   d->max_files = max_files;
   return d;
@@ -535,7 +536,9 @@ storage_dir_shrink(storage_dir_t *d,
   }
 
   const int n = smartlist_len(d->contents);
-  shrinking_dir_entry_t *ents = tor_calloc(n, sizeof(shrinking_dir_entry_t));
+  shrinking_dir_entry_t *ents = tor_calloc_type(n,
+                                                sizeof(shrinking_dir_entry_t),
+                                                TOR_STRINGIFY(shrinking_dir_entry_t));
   SMARTLIST_FOREACH_BEGIN(d->contents, const char *, fname) {
     shrinking_dir_entry_t *ent = &ents[fname_sl_idx];
     struct stat st;

src/common/timers.c

@@ -234,7 +234,8 @@ timers_shutdown(void)
 tor_timer_t *
 timer_new(timer_cb_fn_t cb, void *arg)
 {
-  tor_timer_t *t = tor_malloc(sizeof(tor_timer_t));
+  tor_timer_t *t = tor_malloc_type(sizeof(tor_timer_t),
+                                   TOR_STRINGIFY(tor_timer_t));
   timeout_init(t, 0);
   timer_set_cb(t, cb, arg);
   return t;

src/common/tortls.c

@@ -1119,7 +1119,8 @@ tor_tls_context_new(crypto_pk_t *identity, unsigned int key_lifetime,
     }
   }
 
-  result = tor_malloc_zero(sizeof(tor_tls_context_t));
+  result = tor_malloc_zero_type(sizeof(tor_tls_context_t),
+                                TOR_STRINGIFY(tor_tls_context_t));
   result->refcnt = 1;
   if (!is_client) {
     result->my_link_cert = tor_x509_cert_new(X509_dup(cert));
@@ -1632,7 +1633,8 @@ tor_tls_t *
 tor_tls_new(int sock, int isServer)
 {
   BIO *bio = NULL;
-  tor_tls_t *result = tor_malloc_zero(sizeof(tor_tls_t));
+  tor_tls_t *result = tor_malloc_zero_type(sizeof(tor_tls_t),
+                                           TOR_STRINGIFY(tor_tls_t));
   tor_tls_context_t *context = isServer ? server_tls_context :
     client_tls_context;
   result->magic = TOR_TLS_MAGIC;

src/common/util.c

@@ -180,6 +180,31 @@ tor_malloc_zero_(size_t size DMALLOC_PARAMS)
   return result;
 }
 
+void *tor_malloc_type_(size_t size, const char *t)
+{
+  tor_malloc_increment_stats(t, 1, size);
+  return tor_malloc_(size);
+}
+
+void *tor_malloc_zero_type_(size_t size, const char *t)
+{
+  tor_malloc_increment_stats(t, 1, size);
+  return tor_malloc_zero_(size);
+}
+
+void *tor_calloc_type_(size_t nmemb, size_t size, const char *t)
+{
+  tor_malloc_increment_stats(t, nmemb, size);
+  return tor_calloc_(nmemb, size);
+}
+
+void tor_malloc_increment_stats(const char *type, size_t count, size_t size)
+{
+  (void)type;
+  (void)count;
+  (void)size;
+}
+
 /* The square root of SIZE_MAX + 1.  If a is less than this, and b is less
  * than this, then a*b is less than SIZE_MAX.  (For example, if size_t is
  * 32 bits, then SIZE_MAX is 0xffffffff and this value is 0x10000.  If a and
@@ -2511,7 +2536,8 @@ int
 start_writing_to_file(const char *fname, int open_flags, int mode,
                       open_file_t **data_out)
 {
-  open_file_t *new_file = tor_malloc_zero(sizeof(open_file_t));
+  open_file_t *new_file = tor_malloc_zero_type(sizeof(open_file_t),
+                                               TOR_STRINGIFY(open_file_t));
   const char *open_name;
   int append = 0;
 
@@ -4097,7 +4123,8 @@ tor_process_get_stdout_pipe(process_handle_t *process_handle)
 static process_handle_t *
 process_handle_new(void)
 {
-  process_handle_t *out = tor_malloc_zero(sizeof(process_handle_t));
+  process_handle_t *out = tor_malloc_zero_type(sizeof(process_handle_t),
+                                               TOR_STRINGIFY(process_handle_t));
 
 #ifdef _WIN32
   out->stdin_pipe = INVALID_HANDLE_VALUE;
@@ -4734,14 +4761,17 @@ process_environment_free_(process_environment_t *env)
 process_environment_t *
 process_environment_make(struct smartlist_t *env_vars)
 {
-  process_environment_t *env = tor_malloc_zero(sizeof(process_environment_t));
+  process_environment_t *env = tor_malloc_zero_type(sizeof(process_environment_t),
+                                                    TOR_STRINGIFY(process_environment_t));
   size_t n_env_vars = smartlist_len(env_vars);
   size_t i;
   size_t total_env_length;
   smartlist_t *env_vars_sorted;
 
   tor_assert(n_env_vars + 1 != 0);
-  env->unixoid_environment_block = tor_calloc(n_env_vars + 1, sizeof(char *));
+  env->unixoid_environment_block = tor_calloc_type(n_env_vars + 1,
+                                                   sizeof(char *),
+                                                   TOR_STRINGIFY(char *));
   /* env->unixoid_environment_block is already NULL-terminated,
    * because we assume that NULL == 0 (and check that during compilation). */
 
@@ -5476,7 +5506,7 @@ tor_check_port_forwarding(const char *filename,
        for each smartlist element (one for "-p" and one for the
        ports), and one for the final NULL. */
     args_n = 1 + 2*smartlist_len(ports_to_forward) + 1;
-    argv = tor_calloc(args_n, sizeof(char *));
+    argv = tor_calloc_type(args_n, sizeof(char *), TOR_STRINGIFY(char *));
 
     argv[argv_index++] = filename;
     SMARTLIST_FOREACH_BEGIN(ports_to_forward, const char *, port) {

src/common/util.h

@@ -114,6 +114,16 @@ extern int dmalloc_free(const char *file, const int line, void *pnt,
 #define tor_memdup(s, n)       tor_memdup_(s, n DMALLOC_ARGS)
 #define tor_memdup_nulterm(s, n)       tor_memdup_nulterm_(s, n DMALLOC_ARGS)
 
+void *tor_malloc_type_(size_t size, const char *t) ATTR_MALLOC;
+void *tor_malloc_zero_type_(size_t size, const char *t) ATTR_MALLOC;
+void *tor_calloc_type_(size_t nmemb, size_t size, const char *t) ATTR_MALLOC;
+
+#define tor_malloc_type(size, t)       tor_malloc_type_(size, t)
+#define tor_malloc_zero_type(size, t)  tor_malloc_zero_type_(size, t)
+#define tor_calloc_type(nmemb,size, t) tor_calloc_type_(nmemb, size, t)
+
+void tor_malloc_increment_stats(const char *type, size_t count, size_t size);
+
 /* Aliases for the underlying system malloc/realloc/free. Only use
  * them to indicate "I really want the underlying system function, I know
  * what I'm doing." */

src/common/workqueue.c

@@ -140,7 +140,8 @@ workqueue_entry_new(workqueue_reply_t (*fn)(void*, void*),
                     void (*reply_fn)(void*),
                     void *arg)
 {
-  workqueue_entry_t *ent = tor_malloc_zero(sizeof(workqueue_entry_t));
+  workqueue_entry_t *ent = tor_malloc_zero_type(sizeof(workqueue_entry_t),
+                                                TOR_STRINGIFY(workqueue_entry_t));
   ent->fn = fn;
   ent->reply_fn = reply_fn;
   ent->arg = arg;
@@ -333,7 +334,8 @@ static workerthread_t *
 workerthread_new(int32_t lower_priority_chance,
                  void *state, threadpool_t *pool, replyqueue_t *replyqueue)
 {
-  workerthread_t *thr = tor_malloc_zero(sizeof(workerthread_t));
+  workerthread_t *thr = tor_malloc_zero_type(sizeof(workerthread_t),
+                                             TOR_STRINGIFY(workerthread_t));
   thr->state = state;
   thr->reply_queue = replyqueue;
   thr->in_pool = pool;
@@ -441,7 +443,7 @@ threadpool_queue_update(threadpool_t *pool,
   old_args = pool->update_args;
   old_args_free_fn = pool->free_update_arg_fn;
 
-  new_args = tor_calloc(n_threads, sizeof(void*));
+  new_args = tor_calloc_type(n_threads, sizeof(void *), TOR_STRINGIFY(void *));
   for (i = 0; i < n_threads; ++i) {
     if (dup_fn)
       new_args[i] = dup_fn(arg);
@@ -536,7 +538,8 @@ threadpool_new(int n_threads,
                void *arg)
 {
   threadpool_t *pool;