Changeset 662

Timestamp:

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

Author:

Paul Smedley

Message:

Yet more code cleanups

Location:

GPL/branches/uniaud32-next

Files:

• alsa-kernel/core/seq/seq_memory.c (modified) (1 diff)
• include/linux/gfp.h (modified) (1 diff)
• include/linux/mm.h (modified) (3 diffs)
• include/linux/slab.h (modified) (1 diff)
• include/linux/vmalloc.h (modified) (1 diff)
• lib32/memory.c (modified) (2 diffs)

GPL/branches/uniaud32-next/alsa-kernel/core/seq/seq_memory.c

@@ -375 +375 @@
                 return -EINVAL;
 
-#ifndef TARGET_OS2
         cellptr = kvmalloc_array(sizeof(struct snd_seq_event_cell), pool->size,
                                  GFP_KERNEL);
-#else
-        cellptr = vmalloc(sizeof(struct snd_seq_event_cell) * pool->size);
-#endif
         if (!cellptr)
                 return -ENOMEM;

GPL/branches/uniaud32-next/include/linux/gfp.h

@@ -42 +42 @@
 #define __GFP_COMP      ((__force gfp_t)___GFP_COMP)
 #define __GFP_ZERO      ((__force gfp_t)___GFP_ZERO)
+#define __GFP_RETRY_MAYFAIL     ((__force gfp_t)___GFP_RETRY_MAYFAIL)
 #define GFP_DMA32 0             /* driver must check for 32-bit address */
 

GPL/branches/uniaud32-next/include/linux/mm.h

@@ -10 +10 @@
 #include <linux/err.h>
 
+#define NUMA_NO_NODE    (-1)
 /*
  * GFP bitmasks..
@@ -19 +20 @@
 #define __GFP_IO        0x10
 #define __GFP_SWAP      0x20
+#define ___GFP_ZERO             0x100u
+#define __GFP_ZERO      ((__force gfp_t)___GFP_ZERO)
 
 #ifdef TARGET_OS2
@@ -173 +176 @@
 struct page *vmalloc_to_page(void *addr);
 
+extern void *kvmalloc_node(size_t size, gfp_t flags, int node);
+static inline void *kvmalloc(size_t size, gfp_t flags)
+{
+        return kvmalloc_node(size, flags, NUMA_NO_NODE);
+}
+static inline void *kvzalloc_node(size_t size, gfp_t flags, int node)
+{
+        return kvmalloc_node(size, flags | __GFP_ZERO, node);
+}
+static inline void *kvzalloc(size_t size, gfp_t flags)
+{
+        return kvmalloc(size, flags | __GFP_ZERO);
+}
+static inline void *kvmalloc_array(size_t n, size_t size, gfp_t flags)
+{
+        size_t bytes;
+
+        bytes = n * size;
+
+        return kvmalloc(bytes, flags);
+}
 #endif

GPL/branches/uniaud32-next/include/linux/slab.h

@@ -124 +124 @@
 #define kvzalloc kzalloc
 size_t ksize(const void *);
+
+static inline void *__kmalloc_node(size_t size, gfp_t flags, int node)
+{
+        return __kmalloc(size, flags);
+}
+
+static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
+{
+        return __kmalloc_node(size, flags, node);
+}
+
 #endif  /* _LINUX_SLAB_H */

GPL/branches/uniaud32-next/include/linux/vmalloc.h

@@ -25 +25 @@
 extern struct vm_struct * vmlist;
 extern void *vzalloc(unsigned long size);
+extern void *__vmalloc(unsigned long size, gfp_t gfp_mask);
+void *__vmalloc_node(unsigned long size, unsigned long align, gfp_t gfp_mask,
+                int node, const void *caller);
 #endif
 

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));
+}
+//******************************************************************************
+//******************************************************************************