Changeset 662 for GPL/branches/uniaud32-next/lib32/memory.c

Timestamp:

Jan 26, 2021, 7:59:05 AM (5 years ago)

Author:

Paul Smedley

Message:

Yet more code cleanups

File:

• GPL/branches/uniaud32-next/lib32/memory.c (modified) (2 diffs)

GPL/branches/uniaud32-next/lib32/memory.c

@@ -449 +449 @@
 //******************************************************************************
 //******************************************************************************
+void *__vmalloc(unsigned long size, gfp_t gfp_mask)
+{
+        return vmalloc(size);
+}
+//******************************************************************************
+//******************************************************************************
+/**
+ * __vmalloc_node - allocate virtually contiguous memory
+ * @size:           allocation size
+ * @align:          desired alignment
+ * @gfp_mask:       flags for the page level allocator
+ * @node:           node to use for allocation or NUMA_NO_NODE
+ * @caller:         caller's return address
+ *
+ * Allocate enough pages to cover @size from the page level allocator with
+ * @gfp_mask flags.  Map them into contiguous kernel virtual space.
+ *
+ * Reclaim modifiers in @gfp_mask - __GFP_NORETRY, __GFP_RETRY_MAYFAIL
+ * and __GFP_NOFAIL are not supported
+ *
+ * Any use of gfp flags outside of GFP_KERNEL should be consulted
+ * with mm people.
+ *
+ * Return: pointer to the allocated memory or %NULL on error
+ */
+void *__vmalloc_node(unsigned long size, unsigned long align,
+                            gfp_t gfp_mask, int node, const void *caller)
+{
+        return vmalloc(size);
+}
+//******************************************************************************
+//******************************************************************************
 void vfree(void *ptr)
 {
@@ -776 +808 @@
 //******************************************************************************
 //******************************************************************************
+/**
+ * kvmalloc_node - attempt to allocate physically contiguous memory, but upon
+ * failure, fall back to non-contiguous (vmalloc) allocation.
+ * @size: size of the request.
+ * @flags: gfp mask for the allocation - must be compatible (superset) with GFP_KERNEL.
+ * @node: numa node to allocate from
+ *
+ * Uses kmalloc to get the memory but if the allocation fails then falls back
+ * to the vmalloc allocator. Use kvfree for freeing the memory.
+ *
+ * Reclaim modifiers - __GFP_NORETRY and __GFP_NOFAIL are not supported.
+ * __GFP_RETRY_MAYFAIL is supported, and it should be used only if kmalloc is
+ * preferable to the vmalloc fallback, due to visible performance drawbacks.
+ *
+ * Please note that any use of gfp flags outside of GFP_KERNEL is careful to not
+ * fall back to vmalloc.
+ *
+ * Return: pointer to the allocated memory of %NULL in case of failure
+ */
+void *kvmalloc_node(size_t size, gfp_t flags, int node)
+{
+        gfp_t kmalloc_flags = flags;
+        void *ret;
+
+        /*
+         * vmalloc uses GFP_KERNEL for some internal allocations (e.g page tables)
+         * so the given set of flags has to be compatible.
+         */
+        if ((flags & GFP_KERNEL) != GFP_KERNEL)
+                return kmalloc_node(size, flags, node);
+
+        /*
+         * We want to attempt a large physically contiguous block first because
+         * it is less likely to fragment multiple larger blocks and therefore
+         * contribute to a long term fragmentation less than vmalloc fallback.
+         * However make sure that larger requests are not too disruptive - no
+         * OOM killer and no allocation failure warnings as we have a fallback.
+         */
+        if (size > PAGE_SIZE) {
+                kmalloc_flags |= __GFP_NOWARN;
+
+                if (!(kmalloc_flags & __GFP_RETRY_MAYFAIL))
+                        kmalloc_flags |= __GFP_NORETRY;
+        }
+
+        ret = kmalloc_node(size, kmalloc_flags, node);
+
+        /*
+         * It doesn't really make sense to fallback to vmalloc for sub page
+         * requests
+         */
+        if (ret || size <= PAGE_SIZE)
+                return ret;
+
+        return __vmalloc_node(size, 1, flags, node,
+                        __builtin_return_address(0));
+}
+//******************************************************************************
+//******************************************************************************