Export the uvm_vmalloc_hdr_t structure to nv-nanos.h. And modify vfree, get alloc_size from ptr

Author: 0x5459

kernel-open/common/inc/nv-linux.h

@@ -506,7 +506,7 @@ static inline void *nv_vmalloc(unsigned long size)
 static inline void nv_vfree(void *ptr, NvU64 size)
 {
     NV_MEMDBG_REMOVE(ptr, size);
-    vfree(ptr, size);
+    vfree(ptr);
 }
 
 static inline void *nv_ioremap(NvU64 phys, NvU64 size)

kernel-open/common/inc/nv-nanos.h

@@ -481,6 +481,18 @@ typedef struct nvidia_event
 #define BUILD_BUG_ON(expr)                  build_assert(!(expr))
 #define BUILD_BUG_ON_NOT_POWER_OF_2(expr)   build_assert(((expr) & ((expr) - 1)) == 0)
 
+// To implement realloc for vmalloc-based allocations we need to track the size
+// of the original allocation. We can do that by allocating a header along with
+// the allocation itself. Since vmalloc is only used for relatively large
+// allocations, this overhead is very small.
+//
+// We don't need this for kmalloc since we can use ksize().
+typedef struct
+{
+    size_t alloc_size;
+    uint8_t ptr[0];
+} uvm_vmalloc_hdr_t;
+
 #define ZERO_SIZE_PTR       pointer_from_u64(16)
 #define ZERO_OR_NULL_PTR(p) (u64_from_pointer(p) <= u64_from_pointer(ZERO_SIZE_PTR))
 
@@ -508,7 +520,12 @@ typedef struct nvidia_event
 #define vzalloc(size)       kzalloc(size, 0)
 #define ksize(p)            objcache_from_object(u64_from_pointer(p), PAGESIZE_2M)->pagesize
 #define is_vmalloc_addr(p)  (objcache_from_object(u64_from_pointer(p), PAGESIZE_2M) == INVALID_ADDRESS)
-#define vfree               NV_KFREE
+#define vfree(p) do {                               \
+    uvm_vmalloc_hdr_t *hdr;                         \
+    hdr = container_of(p, uvm_vmalloc_hdr_t, ptr);  \
+    NV_KFREE(p, hdr->alloc_size);                   \
+} while (0)
+
 
 static inline void *kmalloc(unsigned long size, int flags)
 {

kernel-open/nvidia-modeset/nvidia-modeset-linux.c

@@ -260,7 +260,7 @@ void nvkms_free(void *ptr, size_t size)
     if (size <= KMALLOC_LIMIT) {
         kfree(ptr);
     } else {
-        vfree(ptr, size);
+        vfree(ptr);
     }
 }
 

kernel-open/nvidia-uvm/nv-kthread-q-selftest.c

@@ -241,7 +241,7 @@ static int _multithreaded_q_kthread_function(void *args)
 
 done:
     if (q_items)
-        vfree(q_items, alloc_size);
+        vfree(q_items);
 
     while (!kthread_should_stop())
         schedule();

kernel-open/nvidia-uvm/uvm_kvmalloc.c

@@ -27,18 +27,6 @@
 #include "uvm_kvmalloc.h"
 #include "uvm_rb_tree.h"
 
-// To implement realloc for vmalloc-based allocations we need to track the size
-// of the original allocation. We can do that by allocating a header along with
-// the allocation itself. Since vmalloc is only used for relatively large
-// allocations, this overhead is very small.
-//
-// We don't need this for kmalloc since we can use ksize().
-typedef struct
-{
-    size_t alloc_size;
-    uint8_t ptr[0];
-} uvm_vmalloc_hdr_t;
-
 typedef struct
 {
     const char *file;
@@ -297,20 +285,16 @@ void *__uvm_kvmalloc_zero(size_t size, const char *file, int line, const char *f
 
 void uvm_kvfree(void *p)
 {
-    uvm_vmalloc_hdr_t *hdr = NULL;
-
     if (!p)
         return;
 
     if (uvm_leak_checker)
         alloc_tracking_remove(p);
 
-    if (is_vmalloc_addr(p)){
-        hdr = get_hdr(p);
-        vfree(hdr, hdr->alloc_size);
-    } else {
+    if (is_vmalloc_addr(p))
+        vfree(get_hdr(p));
+    else
         kfree(p);
-    }
 }
 
 // Handle reallocs of kmalloc-based allocations
@@ -338,7 +322,7 @@ static void *realloc_from_vmalloc(void *p, size_t new_size)
     void *new_p;
 
     if (new_size == 0) {
-        vfree(old_hdr, old_hdr->alloc_size);
+        vfree(old_hdr);
         return ZERO_SIZE_PTR; // What krealloc returns for this case
     }
 
@@ -352,7 +336,7 @@ static void *realloc_from_vmalloc(void *p, size_t new_size)
         return NULL;
 
     memcpy(new_p, p, min(new_size, old_hdr->alloc_size));
-    vfree(old_hdr, old_hdr->alloc_size);
+    vfree(old_hdr);
     return new_p;
 }
 

kernel-open/nvidia/linux_nvswitch.c

@@ -711,7 +711,7 @@ _nvswitch_os_free
 
     if (is_vmalloc_addr(ptr))
     {
-        vfree(ptr, -1ull);
+        vfree(ptr);
     }
     else
     {