Include nvgpu headers

These are needed to build on NVIDIA's Jetson boards for the time
being. Only a couple structs are required, so it should be fairly
easy to remove this dependency at some point in the future.

1 files changed, 653 insertions, 0 deletions

diff --git a/include/os/linux/kmem.c b/include/os/linux/kmem.c
new file mode 100644
index 0000000..395cc45
--- /dev/null
+++ b/include/os/linux/kmem.c
@@ -0,0 +1,653 @@
+/*
+ * Copyright (c) 2017-2018, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/vmalloc.h>
+#include <linux/stacktrace.h>
+
+#include <nvgpu/lock.h>
+#include <nvgpu/kmem.h>
+#include <nvgpu/atomic.h>
+#include <nvgpu/bug.h>
+#include <nvgpu/gk20a.h>
+
+#include "kmem_priv.h"
+
+/*
+ * Statically declared because this needs to be shared across all nvgpu driver
+ * instances. This makes sure that all kmem caches are _definitely_ uniquely
+ * named.
+ */
+static atomic_t kmem_cache_id;
+
+void *__nvgpu_big_alloc(struct gk20a *g, size_t size, bool clear)
+{
+        void *p;
+
+        if (size > PAGE_SIZE) {
+                if (clear)
+                        p = nvgpu_vzalloc(g, size);
+                else
+                        p = nvgpu_vmalloc(g, size);
+        } else {
+                if (clear)
+                        p = nvgpu_kzalloc(g, size);
+                else
+                        p = nvgpu_kmalloc(g, size);
+        }
+
+        return p;
+}
+
+void nvgpu_big_free(struct gk20a *g, void *p)
+{
+        /*
+         * This will have to be fixed eventually. Allocs that use
+         * nvgpu_big_[mz]alloc() will need to remember the size of the alloc
+         * when freeing.
+         */
+        if (is_vmalloc_addr(p))
+                nvgpu_vfree(g, p);
+        else
+                nvgpu_kfree(g, p);
+}
+
+void *__nvgpu_kmalloc(struct gk20a *g, size_t size, void *ip)
+{
+        void *alloc;
+
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+        alloc = __nvgpu_track_kmalloc(g, size, ip);
+#else
+        alloc = kmalloc(size, GFP_KERNEL);
+#endif
+
+        kmem_dbg(g, "kmalloc: size=%-6ld addr=0x%p gfp=0x%08x",
+                 size, alloc, GFP_KERNEL);
+
+        return alloc;
+}
+
+void *__nvgpu_kzalloc(struct gk20a *g, size_t size, void *ip)
+{
+        void *alloc;
+
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+        alloc = __nvgpu_track_kzalloc(g, size, ip);
+#else
+        alloc = kzalloc(size, GFP_KERNEL);
+#endif
+
+        kmem_dbg(g, "kzalloc: size=%-6ld addr=0x%p gfp=0x%08x",
+                 size, alloc, GFP_KERNEL);
+
+        return alloc;
+}
+
+void *__nvgpu_kcalloc(struct gk20a *g, size_t n, size_t size, void *ip)
+{
+        void *alloc;
+
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+        alloc = __nvgpu_track_kcalloc(g, n, size, ip);
+#else
+        alloc = kcalloc(n, size, GFP_KERNEL);
+#endif
+
+        kmem_dbg(g, "kcalloc: size=%-6ld addr=0x%p gfp=0x%08x",
+                 n * size, alloc, GFP_KERNEL);
+
+        return alloc;
+}
+
+void *__nvgpu_vmalloc(struct gk20a *g, unsigned long size, void *ip)
+{
+        void *alloc;
+
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+        alloc = __nvgpu_track_vmalloc(g, size, ip);
+#else
+        alloc = vmalloc(size);
+#endif
+
+        kmem_dbg(g, "vmalloc: size=%-6ld addr=0x%p", size, alloc);
+
+        return alloc;
+}
+
+void *__nvgpu_vzalloc(struct gk20a *g, unsigned long size, void *ip)
+{
+        void *alloc;
+
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+        alloc = __nvgpu_track_vzalloc(g, size, ip);
+#else
+        alloc = vzalloc(size);
+#endif
+
+        kmem_dbg(g, "vzalloc: size=%-6ld addr=0x%p", size, alloc);
+
+        return alloc;
+}
+
+void __nvgpu_kfree(struct gk20a *g, void *addr)
+{
+        kmem_dbg(g, "kfree: addr=0x%p", addr);
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+        __nvgpu_track_kfree(g, addr);
+#else
+        kfree(addr);
+#endif
+}
+
+void __nvgpu_vfree(struct gk20a *g, void *addr)
+{
+        kmem_dbg(g, "vfree: addr=0x%p", addr);
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+        __nvgpu_track_vfree(g, addr);
+#else
+        vfree(addr);
+#endif
+}
+
+#ifdef CONFIG_NVGPU_TRACK_MEM_USAGE
+
+void nvgpu_lock_tracker(struct nvgpu_mem_alloc_tracker *tracker)
+{
+        nvgpu_mutex_acquire(&tracker->lock);
+}
+
+void nvgpu_unlock_tracker(struct nvgpu_mem_alloc_tracker *tracker)
+{
+        nvgpu_mutex_release(&tracker->lock);
+}
+
+void kmem_print_mem_alloc(struct gk20a *g,
+                         struct nvgpu_mem_alloc *alloc,
+                         struct seq_file *s)
+{
+#ifdef __NVGPU_SAVE_KALLOC_STACK_TRACES
+        int i;
+
+        __pstat(s, "nvgpu-alloc: addr=0x%llx size=%ld\n",
+                alloc->addr, alloc->size);
+        for (i = 0; i < alloc->stack_length; i++)
+                __pstat(s, "  %3d [<%p>] %pS\n", i,
+                        (void *)alloc->stack[i],
+                        (void *)alloc->stack[i]);
+        __pstat(s, "\n");
+#else
+        __pstat(s, "nvgpu-alloc: addr=0x%llx size=%ld src=%pF\n",
+                alloc->addr, alloc->size, alloc->ip);
+#endif
+}
+
+static int nvgpu_add_alloc(struct nvgpu_mem_alloc_tracker *tracker,
+                           struct nvgpu_mem_alloc *alloc)
+{
+        alloc->allocs_entry.key_start = alloc->addr;
+        alloc->allocs_entry.key_end = alloc->addr + alloc->size;
+
+        nvgpu_rbtree_insert(&alloc->allocs_entry, &tracker->allocs);
+        return 0;
+}
+
+static struct nvgpu_mem_alloc *nvgpu_rem_alloc(
+        struct nvgpu_mem_alloc_tracker *tracker, u64 alloc_addr)
+{
+        struct nvgpu_mem_alloc *alloc;
+        struct nvgpu_rbtree_node *node = NULL;
+
+        nvgpu_rbtree_search(alloc_addr, &node, tracker->allocs);
+        if (!node)
+                return NULL;
+
+        alloc = nvgpu_mem_alloc_from_rbtree_node(node);
+
+        nvgpu_rbtree_unlink(node, &tracker->allocs);
+
+        return alloc;
+}