decoder: Add resource leak debugging

Add code to track the allocations and frees through
the osa_mem module. By default, the memory debug tracking
is disabled in the makefile. To enable, set DEBUG_OSA_MEM
to "y":

DEBUG_OSA_MEM=y

When osa_mem debug tracing is enabled, whenever a handle
is closed or the module is removed, debug traces will print
showing outstanding allocations.

Signed-off-by: Gaviraju D B <x1046101@ti.com>
Signed-off-by: Angela Stegmaier <angelabaker@ti.com>

11 files changed, 228 insertions, 34 deletions

diff --git a/linux/decoder/Makefile b/linux/decoder/Makefile
index 5bbfffe..7b26228 100644
--- a/linux/decoder/Makefile
+++ b/linux/decoder/Makefile
@@ -57,6 +57,12 @@ ERROR_RECOVERY_SIMULATION ?=n
 # If unsure, say Y
 CAPTURE_CONTIG_ALLOC ?=y
 
+# (8)
+# This config enables debugging of memory allocations through the
+# osa mem module.
+# If unsure, say N
+DEBUG_OSA_MEM ?=n
+
 #VXD
 vxd-dec-objs += $(DRIVER_PATH)/decoder/vxd_core.o
 
@@ -147,6 +153,10 @@ ifeq ($(CAPTURE_CONTIG_ALLOC),y)
 ccflags-y += -DCAPTURE_CONTIG_ALLOC
 endif
 
+ifeq ($(DEBUG_OSA_MEM),y)
+ccflags-y += -DDEBUG_OSA_MEM
+endif
+
 ccflags-y   += -DOSAL_LINUX
 
 obj-$(CONFIG_VIDEO_IMG_VXD_DEC) += vxd-dec.o
diff --git a/linux/decoder/vxd_v4l2.c b/linux/decoder/vxd_v4l2.c
index a076975..fcb487a 100644
--- a/linux/decoder/vxd_v4l2.c
+++ b/linux/decoder/vxd_v4l2.c
@@ -54,6 +54,7 @@
 #include "osal/inc/osa_idr.h"
 #include "osal/inc/osa_define.h"
 #include "osal/inc/osa_page.h"
+#include "osal/inc/osa_delay.h"
 
 #define VXD_DEC_SPIN_LOCK_NAME  "vxd-dec"
 #define IMG_VXD_DEC_MODULE_NAME "vxd-dec"
@@ -1076,6 +1077,12 @@ static int32 vxd_dec_release(struct file *file)
         osa_free(ctx);
 
         osa_mutex_unlock(vxd->mutex);
+
+#ifdef DEBUG_OSA_MEM
+        OSA_PR_ERR("##### At the end of vxd_dec_release #####");
+        osa_print_mem_leak();
+#endif
+
         return ret;
 }
 
@@ -2082,6 +2089,12 @@ static int32 vxd_dec_remove(struct platform_device *pdev)
         osa_free(vxd->dwork);
         osa_mutex_destroy(&vxd->mutex);
 
+#ifdef DEBUG_OSA_MEM
+        osa_msleep(500);
+        OSA_PR_ERR("##### At the end of vxd_dec_remove #####");
+        osa_print_mem_leak();
+#endif
+
         video_unregister_device(vxd->vfd_dec);
         v4l2_m2m_release(vxd->m2m_dev);
         v4l2_device_unregister(&vxd->v4l2_dev);
diff --git a/osal/inc/osa_mem.h b/osal/inc/osa_mem.h
index 3e23142..721fd00 100644
--- a/osal/inc/osa_mem.h
+++ b/osal/inc/osa_mem.h
@@ -23,13 +23,29 @@
 #define osa_container_of(ptr, type, member)     (type *)((int8 *)ptr - ((size_t)&(((type *)0)->member)))
 #define OSA_ALIGN(x, a, type)                   (((x) + ((type)(a) - 1)) & ~((type)(a) - 1))
 
+#ifdef DEBUG_OSA_MEM
+struct memory_release {
+        uint8 flag;
+        void *ptr;
+        uint8 func[200];
+        uint32 line;
+        uint32 size;
+};
+void osa_print_mem_leak(void);
+#endif
+
 /**
  * osa_calloc - allocate memory for an array. The memory is set to zero.
  * @n: number of elements.
  * @size: element size.
  * @flags: the type of memory to allocate (see osa_malloc).
  */
+#ifdef DEBUG_OSA_MEM
+#define osa_calloc(a,b,c) osa_calloc_debug(a,b,c,__func__,__LINE__)
+void *osa_calloc_debug(uint64 n, uint64 size, int64 flags, const uint8 *func, uint32 line);
+#else
 void *osa_calloc(uint64 n, uint64 size, int64 flags);
+#endif
 
 /**
  * osa_malloc - allocate memory
@@ -59,7 +75,12 @@ void *osa_calloc(uint64 n, uint64 size, int64 flags);
  * %OSA_GFP_DMA - Allocation suitable for DMA.
  *   Should only be used for osa_malloc() caches.
  */
+#ifdef DEBUG_OSA_MEM
+#define osa_malloc(a,b) osa_malloc_debug(a,b,__func__,__LINE__)
+void *osa_malloc_debug(uint64 size, int64 flags, const uint8 *func, uint32 line);
+#else
 void *osa_malloc(uint64 size, int64 flags);
+#endif
 
 /**
  * osa_realloc - reallocate memory. The contents will remain unchanged.
@@ -83,14 +104,24 @@ void *osa_realloc(const void *p, uint64 new_size, int64 flags);
  * Don't free memory not originally allocated by osa_malloc()
  * or you will run into trouble.
  */
+#ifdef DEBUG_OSA_MEM
+#define osa_free(a) osa_free_debug(a, __func__, __LINE__)
+void osa_free_debug(const void *objp, const uint8 *func, uint32 line);
+#else
 void osa_free(const void *objp);
+#endif
 
 /**
  * osa_zalloc - allocate memory. The memory is set to zero.
  * @size: how many bytes of memory are required.
  * @flags: the type of memory to allocate (see osa_malloc).
  */
+#ifdef DEBUG_OSA_MEM
+#define osa_zalloc(a,b) osa_zalloc_debug(a,b,__func__,__LINE__)
+void *osa_zalloc_debug(uint64 size, int64 flags, const uint8 *func, uint32 line);
+#else
 void *osa_zalloc(uint64 size, int64 flags);
+#endif
 
 /**
  * osa_malloc_array - allocate memory for an array.
@@ -98,14 +129,24 @@ void *osa_zalloc(uint64 size, int64 flags);
  * @size: element size.
  * @flags: the type of memory to allocate (see osa_malloc).
  */
+#ifdef DEBUG_OSA_MEM
+#define osa_malloc_array(a,b,c) osa_malloc_array_debug(a,b,c,__func__,__LINE__)
+void *osa_malloc_array_debug(size_t n, size_t size, int64 flags, const uint8 *func, uint32 line);
+#else
 void *osa_malloc_array(size_t n, size_t size, int64 flags);
+#endif
 
 /**
  * osa_strdup -  allocate space and copy an existing string.
  * @s: The string to duplicate 
  * @flags: the type of memory to allocate (see osa_malloc).
  */
+#ifdef DEBUG_OSA_MEM
+#define osa_strdup(a,b) osa_strdup_debug(a,b,__func__,__LINE__)
+int8 *osa_strdup_debug(const int8 *s, int64 flags, const uint8 *func, uint32 line);
+#else
 int8 *osa_strdup(const int8 *s, int64 flags);
+#endif
 
 /**
  * osa_memdup - duplicate region of memory
@@ -114,7 +155,12 @@ int8 *osa_strdup(const int8 *s, int64 flags);
  * @len: memory region length
  * @gfp: mask to use
  */
+#ifdef DEBUG_OSA_MEM
+#define osa_memdup(a,b,c) osa_memdup_debug(a,b,c,__func__,__LINE__)
+void *osa_memdup_debug(const void *src, size_t len, int64 flags, const uint8 *func, uint32 line);
+#else
 void *osa_memdup(const void *src, size_t len, int64 flags);
+#endif
 
 /**
  *  osa_vmap  -  map an array of pages into virtually contiguous space
diff --git a/osal/src/linux/osa_atomic.c b/osal/src/linux/osa_atomic.c
index 4ba4ff8..3336f96 100644
--- a/osal/src/linux/osa_atomic.c
+++ b/osal/src/linux/osa_atomic.c
@@ -19,13 +19,14 @@
 #include <linux/printk.h>
 #include <asm/atomic.h>
 #include "../../inc/osa_atomic.h"
+#include "../../inc/osa_mem.h"
 #include "img_errors.h"
 
 
 int32 osa_atomic_create(void **atomic_args)
 {
     atomic_t **obj = (atomic_t **)atomic_args;
-    *obj = kzalloc(sizeof(atomic_t), GFP_KERNEL);
+    *obj = osa_zalloc(sizeof(atomic_t), GFP_KERNEL);
     if (NULL == *obj) {
         pr_err("Memory allocation failed for atomic\n");
         return IMG_ERROR_OUT_OF_MEMORY;
@@ -41,7 +42,7 @@ void osa_atomic_destroy(void **atomic_args)
         pr_err("Invalid atomic object\n");
         return;
     }
-    kfree(*obj);
+    osa_free(*obj);
     *obj = NULL;
 }
 
diff --git a/osal/src/linux/osa_firmware.c b/osal/src/linux/osa_firmware.c
index 871539d..bcb17d6 100644
--- a/osal/src/linux/osa_firmware.c
+++ b/osal/src/linux/osa_firmware.c
@@ -20,13 +20,14 @@
 #include <linux/slab.h>
 
 #include "../../inc/osa_firmware.h"
+#include "../../inc/osa_mem.h"
 
 void osa_init_completion(void **firmware_loading_complete_args)
 {
     struct completion ** firmware_loading_complete =
             (struct completion **) firmware_loading_complete_args;
 
-    *firmware_loading_complete = kmalloc(sizeof(struct completion), GFP_KERNEL);
+    *firmware_loading_complete = osa_malloc(sizeof(struct completion), GFP_KERNEL);
     if(NULL == *firmware_loading_complete)
     {
         pr_err("Memory allocation failed for osa_init_completion\n");
diff --git a/osal/src/linux/osa_idr.c b/osal/src/linux/osa_idr.c
index e429109..83f734b 100644
--- a/osal/src/linux/osa_idr.c
+++ b/osal/src/linux/osa_idr.c
@@ -19,6 +19,7 @@
 #include <linux/slab.h>
 
 #include "../../inc/osa_idr.h"
+#include "../../inc/osa_mem.h"
 
 
 int32 osa_idr_alloc(void *idr, void *ptr, int32 start, int32 end)
@@ -49,13 +50,13 @@ void *osa_idr_get_next(void *idr, int32 *nextid)
 void osa_idr_destroy(void *idr)
 {
     idr_destroy(idr);
-    kfree(idr);
+    osa_free(idr);
 }
 
 void osa_idr_init(void **idr_args)
 {
     struct idr **idr = (struct idr **)idr_args;
-    *idr = kzalloc(sizeof(struct idr), GFP_KERNEL);
+    *idr = osa_zalloc(sizeof(struct idr), GFP_KERNEL);
     if (NULL == *idr)
     {
         pr_err("Memory allocation failed for idr\n");
diff --git a/osal/src/linux/osa_mem.c b/osal/src/linux/osa_mem.c
index fb7b33d..8da7758 100644
--- a/osal/src/linux/osa_mem.c
+++ b/osal/src/linux/osa_mem.c
@@ -20,15 +20,96 @@
 #include <linux/dma-mapping.h>
 
 #include "../../inc/osa_mem.h"
+#include "../../inc/osa_define.h"
 
+#ifdef DEBUG_OSA_MEM
+DEFINE_MUTEX(lock);
+#define MAX_NUM_RESOURCES 5000
+static struct memory_release resource[MAX_NUM_RESOURCES] = {0};
+static uint32 count = 0;
+
+void osa_save_mem(void *ptr, uint32 size, const uint8 *func, uint32 line)
+{
+    uint32 i = 0;
+
+    mutex_lock(&lock);
+    for (i = 0; i < MAX_NUM_RESOURCES; i++) {
+        if (0 == resource[i].flag) {
+            resource[i].flag = 1;
+            strcpy(resource[i].func, func);
+            resource[i].line = line;
+            resource[i].ptr = ptr;
+            resource[i].size = size;
+            count++;
+            mutex_unlock(&lock);
+            return;
+        }
+    }
+    mutex_unlock(&lock);
+    OSA_PR_ERR("##### NO MEMORY #######\n");
+}
+
+void osa_remove_mem(void *ptr, const uint8 *func, uint32 line)
+{
+    uint32 i = 0;
+
+    mutex_lock(&lock);
+    for (i = 0; i < MAX_NUM_RESOURCES; i++) {
+        if (1 == resource[i].flag) {
+            if (ptr == resource[i].ptr) {
+                resource[i].flag = 0;
+                count--;
+                mutex_unlock(&lock);
+                return;
+            }
+        }
+    }
+    mutex_unlock(&lock);
+    OSA_PR_ERR("##### INVALID ADDRESS ####### [0x%llx] function_name = %s line_no = %d\n",
+               (uint64)ptr, func, line);
+}
+
+void osa_print_mem_leak()
+{
+    uint32 i = 0;
+
+    OSA_PR_ERR("##### printing %d outstanding allocations #####\n", count);
+    for (i = 0; i < MAX_NUM_RESOURCES; i++) {
+        if (1 == resource[i].flag) {
+            OSA_PR_ERR("function_name = %s, line_no = %d, ptr = 0x%llx, size = %d\n",
+                       resource[i].func, resource[i].line, (uint64)resource[i].ptr,
+                       resource[i].size);
+        }
+    }
+}
+#endif
+
+#ifdef DEBUG_OSA_MEM
+void *osa_calloc_debug(uint64 n, uint64 size, int64 flags, const uint8 *func, uint32 line)
+#else
 void *osa_calloc(uint64 n, uint64 size, int64 flags)
+#endif
 {
-    return kcalloc(n, size, flags);
+    void *data = NULL;
+    data = kcalloc(n, size, flags);
+#ifdef DEBUG_OSA_MEM
+    osa_save_mem(data, size * n, func, line);
+#endif
+    return data;
 }
 
+#ifdef DEBUG_OSA_MEM
+void *osa_malloc_debug(uint64 size, int64 flags, const uint8 *func, uint32 line)
+#else
 void *osa_malloc(uint64 size, int64 flags)
+#endif
 {
-    return kmalloc(size, flags);
+    void *data = NULL;
+    data = kmalloc(size, flags);
+#ifdef DEBUG_OSA_MEM
+    osa_save_mem(data, size, func, line);
+#endif
+    return data;
 }
 
 void *osa_realloc(const void *p, uint64 new_size, int64 flags)
@@ -36,29 +117,72 @@ void *osa_realloc(const void *p, uint64 new_size, int64 flags)
     return krealloc(p, new_size, flags);
 }
 
+#ifdef DEBUG_OSA_MEM
+void osa_free_debug(const void *objp, const uint8 *func, uint32 line)
+#else
 void osa_free(const void *objp)
+#endif
 {
+#ifdef DEBUG_OSA_MEM
+    osa_remove_mem((void *)objp, func, line);
+#endif
     return kfree(objp);
 }
 
+#ifdef DEBUG_OSA_MEM
+void *osa_zalloc_debug(uint64 size, int64 flags, const uint8 *func, uint32 line)
+#else
 void *osa_zalloc(uint64 size, int64 flags)
+#endif
 {
-    return kzalloc(size, flags);
+    void *data = NULL;
+    data = kzalloc(size, flags);
+#ifdef DEBUG_OSA_MEM
+    osa_save_mem(data, size, func, line);
+#endif
+    return data;
 }
 
+#ifdef DEBUG_OSA_MEM
+void *osa_malloc_array_debug(size_t n, size_t size, int64 flags, const uint8 *func, uint32 line)
+#else
 void *osa_malloc_array(size_t n, size_t size, int64 flags)
+#endif
 {
-    return kmalloc_array(n, size, flags);
+    void *data = NULL;
+    data = kmalloc_array(n, size, flags);
+#ifdef DEBUG_OSA_MEM
+    osa_save_mem(data, n * size, func, line);
+#endif
+    return data;
 }
 
+#ifdef DEBUG_OSA_MEM
+int8 *osa_strdup_debug(const int8 *s, int64 flags, const uint8 *func, uint32 line)
+#else
 int8 *osa_strdup(const int8 *s, int64 flags)
+#endif
 {
-    return kstrdup(s, flags);
+    void *data = NULL;
+    data = kstrdup(s, flags);
+#ifdef DEBUG_OSA_MEM
+    osa_save_mem(data, strlen(s), func, line);
+#endif
+    return data;
 }
 
+#ifdef DEBUG_OSA_MEM
+void *osa_memdup_debug(const void *src, size_t len, int64 flags, const uint8 *func, uint32 line)
+#else
 void *osa_memdup(const void *src, size_t len, int64 flags)
+#endif
 {
-    return kmemdup(src, len, flags);
+    void *data = NULL;
+    data = kmemdup(src, len, flags);
+#ifdef DEBUG_OSA_MEM
+    osa_save_mem(data, len, func, line);
+#endif
+    return data;
 }
 
 void *osa_vmap(void **pages, uint32 count)
diff --git a/osal/src/linux/osa_mutex.c b/osal/src/linux/osa_mutex.c
index eebbfbb..02252ce 100644
--- a/osal/src/linux/osa_mutex.c
+++ b/osal/src/linux/osa_mutex.c
@@ -19,12 +19,13 @@
 #include <linux/printk.h>
 #include <linux/mutex.h>
 #include "../../inc/osa_mutex.h"
+#include "../../inc/osa_mem.h"
 
 
 void osa_mutex_create(void **mutex_args)
 {
     struct mutex **mutex = (struct mutex **)mutex_args;
-    *mutex = kzalloc(sizeof(struct mutex), GFP_KERNEL);
+    *mutex = osa_zalloc(sizeof(struct mutex), GFP_KERNEL);
     if (NULL == *mutex)
     {
         pr_err("Memory allocation failed for mutex\n");
@@ -47,7 +48,7 @@ void osa_mutex_destroy(void **mutex_args)
 {
     struct mutex **mutex = (struct mutex **)mutex_args;
     mutex_destroy(*mutex);
-    kfree(*mutex);
+    osa_free(*mutex);
     *mutex = NULL;
 }
 
diff --git a/osal/src/linux/osa_spin.c b/osal/src/linux/osa_spin.c
index bc40de7..367ed6c 100644
--- a/osal/src/linux/osa_spin.c
+++ b/osal/src/linux/osa_spin.c
@@ -20,13 +20,14 @@
 #include <linux/slab.h>
 
 #include "../../inc/osa_spin.h"
+#include "../../inc/osa_mem.h"
 
 
 
 void osa_spin_lock_create(void **lock_args, const int8 *name)
 {
     spinlock_t **lock = (spinlock_t **)lock_args;
-    *lock = kzalloc(sizeof(spinlock_t), GFP_KERNEL);
+    *lock = osa_zalloc(sizeof(spinlock_t), GFP_KERNEL);
     if (NULL == *lock)
     {
         pr_err("Memory allocation failed for spin-lock\n");
@@ -80,6 +81,6 @@ void osa_spin_unlock_irq(void *lock)
 
 void osa_spin_destroy(void **lock_args)
 {
-    kfree(*lock_args);
+    osa_free(*lock_args);
 }
 
diff --git a/osal/src/linux/osa_time.c b/osal/src/linux/osa_time.c
index c01f39b..b5937b3 100644
--- a/osal/src/linux/osa_time.c
+++ b/osal/src/linux/osa_time.c
@@ -20,6 +20,7 @@
 #include <linux/slab.h>
 
 #include "../../inc/osa_time.h"
+#include "../../inc/osa_mem.h"
 
 uint64 osa_get_number_of_ticks(void)
 {
@@ -44,7 +45,7 @@ void osa_getnstimeofday(void **ts_args)
 
     /* Here memory allocating for struct timespec variable
      * and memory deallocation should be taken care by the user */
-    *ts = kmalloc(sizeof(struct timespec), GFP_KERNEL);
+    *ts = osa_malloc(sizeof(struct timespec), GFP_KERNEL);
     if(NULL == *ts)
     {
         pr_err("Failed to allocate memory in 'osa_getnstimeofday' function \n");
@@ -61,7 +62,7 @@ void *osa_timespec_sub(void *end_time, void *start_time)
 {
     struct timespec *dif_time;
 
-    dif_time = kmalloc(sizeof(struct timespec), GFP_KERNEL);
+    dif_time = osa_malloc(sizeof(struct timespec), GFP_KERNEL);
     if(NULL == dif_time)
     {
         pr_err("Failed to allocate memory in 'osa_timespec_sub' function\n");
diff --git a/osal/src/linux/osa_workqueue.c b/osal/src/linux/osa_workqueue.c
index 609249d..42dd0cb 100644
--- a/osal/src/linux/osa_workqueue.c
+++ b/osal/src/linux/osa_workqueue.c
@@ -20,6 +20,7 @@
 #include <linux/mutex.h>
 
 #include "../../inc/osa_workqueue.h"
+#include "../../inc/osa_mem.h"
 
 DEFINE_MUTEX(mutex);
 
@@ -36,7 +37,7 @@ struct node *delayed_work_head = NULL;
 void osa_insertfirst(struct node **head, void **key)
 {
     //create a link
-    struct node *link = (struct node*) kmalloc(sizeof(struct node), GFP_KERNEL);
+    struct node *link = (struct node*) osa_malloc(sizeof(struct node), GFP_KERNEL);
     
     link->key = key;
     mutex_lock(&mutex);
@@ -167,7 +168,7 @@ void osa_destroy_workqueue(void *wq)
 void osa_init_work(void **work_args, void *work_fn)
 {
     struct work_struct **work = (struct work_struct **)work_args;
-    *work = kzalloc(sizeof(struct work_struct), GFP_KERNEL);
+    *work = osa_zalloc(sizeof(struct work_struct), GFP_KERNEL);
     if(NULL == *work)
     {
         pr_err("Memory allocation failed for work_queue\n");
@@ -181,7 +182,7 @@ void osa_init_work(void **work_args, void *work_fn)
 void osa_init_delayed_work(void **work_args, void *work_fn)
 {
     struct delayed_work **work = (struct delayed_work **)work_args;
-    *work = kzalloc(sizeof(struct delayed_work), GFP_KERNEL);
+    *work = osa_zalloc(sizeof(struct delayed_work), GFP_KERNEL);
     if(NULL == *work)
     {
         pr_err("Memory allocation failed for delayed_work_queue\n");
@@ -303,13 +304,10 @@ void *osa_get_work_buff(void *key, int8 flag)
     void *work = NULL;
 
     data = osa_delete_work_key(key, flag);
-    if(NULL != data)
-    {
-    work = data->key;
-    if(flag == TRUE)
-    {
-        kfree(data);
-        }
+    if (NULL != data) {
+        work = data->key;
+        if (flag == TRUE)
+            osa_free(data);
     }
     return work;
 }
@@ -320,13 +318,10 @@ void *osa_get_delayed_work_buff(void *key, int8 flag)
     void *dwork = NULL;
 
     data = osa_delete_delayed_work_key(key, flag);
-    if(NULL != data)
-    {
-    dwork = data->key;
-    if(flag == TRUE)
-    {
-        kfree(data);
-        }
+    if (NULL != data) {
+        dwork = data->key;
+        if (flag == TRUE)
+            osa_free(data);
     }
     return dwork;
 }