/*      $NetBSD: rf_debugMem.c,v 1.22 2019/02/09 03:34:00 christos Exp $        */
/*
* Copyright (c) 1995 Carnegie-Mellon University.
* All rights reserved.
*
* Author: Daniel Stodolsky, Mark Holland, Jim Zelenka
*
* Permission to use, copy, modify and distribute this software and
* its documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
*  Software Distribution Coordinator  or  [email protected]
*  School of Computer Science
*  Carnegie Mellon University
*  Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie the
* rights to redistribute these changes.
*/

/* debugMem.c:  memory usage debugging stuff.
* Malloc, Calloc, and Free are #defined everywhere
* to do_malloc, do_calloc, and do_free.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: rf_debugMem.c,v 1.22 2019/02/09 03:34:00 christos Exp $");

#include <dev/raidframe/raidframevar.h>

#include "rf_threadstuff.h"
#include "rf_options.h"
#include "rf_debugMem.h"
#include "rf_general.h"
#include "rf_shutdown.h"

#if RF_DEBUG_MEM

static size_t tot_mem_in_use = 0;

/* Hash table of information about memory allocations */
#define RF_MH_TABLESIZE 1000

struct mh_struct {
       void   *address;
       size_t     size;
       const char *file;
       uint32_t     line;
       char    allocated;
       struct mh_struct *next;
};
static struct mh_struct *mh_table[RF_MH_TABLESIZE];
static rf_declare_mutex2(rf_debug_mem_mutex);
static int mh_table_initialized = 0;

static void memory_hash_insert(void *, size_t,  const char *, uint32_t);
static int memory_hash_remove(void *, size_t);

void
rf_record_malloc(void *p, size_t size, const char *file, uint32_t line)
{
       RF_ASSERT(size != 0);

       /* rf_lock_mutex2(rf_debug_mem_mutex); */
       memory_hash_insert(p, size, file, line);
       tot_mem_in_use += size;
       /* rf_unlock_mutex2(rf_debug_mem_mutex); */
       if ((intptr_t)p == rf_memDebugAddress) {
               printf("%s,%d: %s: Debug address allocated\n", file, line,
                   __func__);
       }
}

void
rf_unrecord_malloc(void *p, size_t sz)
{
       size_t     size;

       /* rf_lock_mutex2(rf_debug_mem_mutex); */
       size = memory_hash_remove(p, sz);
       tot_mem_in_use -= size;
       /* rf_unlock_mutex2(rf_debug_mem_mutex); */
       if ((intptr_t) p == rf_memDebugAddress) {
               /* this is really only a flag line for gdb */
               printf("%s: Found debug address\n", __func__);
       }
}

void
rf_print_unfreed(void)
{
       size_t i;
       int foundone = 0;
       struct mh_struct *p;

       for (i = 0; i < RF_MH_TABLESIZE; i++) {
               for (p = mh_table[i]; p; p = p->next) {
                       if (!p->allocated)
                               continue;
                       if (foundone) {
                               printf("\n\n:%s: There are unfreed memory"
                                   " locations at program shutdown:\n",
                                   __func__);
                       }
                       foundone = 1;
                       printf("%s: @%s,%d: addr %p size %zu\n", __func__,
                           p->file, p->line, p->address, p->size);
               }
       }
       if (tot_mem_in_use) {
               printf("%s: %zu total bytes in use\n",
                   __func__, tot_mem_in_use);
       }
}
#endif /* RF_DEBUG_MEM */

#if RF_DEBUG_MEM
static void
rf_ShutdownDebugMem(void *unused)
{
       rf_destroy_mutex2(rf_debug_mem_mutex);
}
#endif

int
rf_ConfigureDebugMem(RF_ShutdownList_t **listp)
{
#if RF_DEBUG_MEM
       size_t     i;

       rf_init_mutex2(rf_debug_mem_mutex, IPL_VM);
       if (rf_memDebug) {
               for (i = 0; i < RF_MH_TABLESIZE; i++)
                       mh_table[i] = NULL;
               mh_table_initialized = 1;
       }
       rf_ShutdownCreate(listp, rf_ShutdownDebugMem, NULL);
#endif
       return (0);
}

#if RF_DEBUG_MEM

#define HASHADDR(a) ((size_t)((((uintptr_t)a) >> 3) % RF_MH_TABLESIZE))

static void
memory_hash_insert(void *addr, size_t size, const char *file, uint32_t line)
{
       size_t bucket = (size_t)HASHADDR(addr);
       struct mh_struct *p;

       RF_ASSERT(mh_table_initialized);

       /* search for this address in the hash table */
       for (p = mh_table[bucket]; p && (p->address != addr); p = p->next)
               continue;
       if (!p) {
               p = RF_Malloc(sizeof(*p));
               RF_ASSERT(p);
               p->next = mh_table[bucket];
               mh_table[bucket] = p;
               p->address = addr;
               p->allocated = 0;
       }
       if (p->allocated) {
               printf("%s: @%s,%u: ERROR: Reallocated addr %p without free\n",
                   __func__, file, line, addr);
               printf("%s: last allocated @%s,%u\n",
                   __func__, p->file, p->line);
               RF_ASSERT(0);
       }
       p->size = size;
       p->line = line;
       p->file = file;
       p->allocated = 1;
}

static int
memory_hash_remove(void *addr, size_t sz)
{
       size_t bucket = HASHADDR(addr);
       struct mh_struct *p;

       RF_ASSERT(mh_table_initialized);
       for (p = mh_table[bucket]; p && (p->address != addr); p = p->next)
               continue;
       if (!p) {
               printf("%s: ERROR: Freeing never-allocated address %p\n",
                   __func__, addr);
               RF_PANIC();
       }
       if (!p->allocated) {
               printf("%s: ERROR: Freeing unallocated address %p."
                   " Last allocation @%s,%u\n",
                   __func__, addr, p->file, p->line);
               RF_PANIC();
       }
       if (sz > 0 && p->size != sz) {  /* you can suppress this error by
                                        * using a negative value as the size
                                        * to free */
               printf("%s: ERROR: Incorrect size (%zu should be %zu) at"
                   " free for address %p. Allocated @%s,%u\n", __func__,
                   sz, p->size, addr, p->file, p->line);
               RF_PANIC();
       }
       p->allocated = 0;
       return p->size;
}
#endif /* RF_DEBUG_MEM */