fs/xfs/kmem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include <linux/backing-dev.h>
   8 #include "xfs_message.h"
   9 #include "xfs_trace.h"
  10
  11 void *
  12 kmem_alloc(size_t size, xfs_km_flags_t flags)
  13 {
  14         int     retries = 0;
  15         gfp_t   lflags = kmem_flags_convert(flags);
  16         void    *ptr;
  17
  18         trace_kmem_alloc(size, flags, _RET_IP_);
  19
  20         do {
  21                 ptr = kmalloc(size, lflags);
  22                 if (ptr || (flags & KM_MAYFAIL))
  23                         return ptr;
  24                 if (!(++retries % 100))
  25                         xfs_err(NULL,
  26         "%s(%u) possible memory allocation deadlock size %u in %s (mode:0x%x)",
  27                                 current->comm, current->pid,
  28                                 (unsigned int)size, __func__, lflags);
  29                 congestion_wait(BLK_RW_ASYNC, HZ/50);
  30         } while (1);
  31 }
  32
  33
  34 /*
  35  * __vmalloc() will allocate data pages and auxiliary structures (e.g.
  36  * pagetables) with GFP_KERNEL, yet we may be under GFP_NOFS context here. Hence
  37  * we need to tell memory reclaim that we are in such a context via
  38  * PF_MEMALLOC_NOFS to prevent memory reclaim re-entering the filesystem here
  39  * and potentially deadlocking.
  40  */
  41 static void *
  42 __kmem_vmalloc(size_t size, xfs_km_flags_t flags)
  43 {
  44         unsigned nofs_flag = 0;
  45         void    *ptr;
  46         gfp_t   lflags = kmem_flags_convert(flags);
  47
  48         if (flags & KM_NOFS)
  49                 nofs_flag = memalloc_nofs_save();
  50
  51         ptr = __vmalloc(size, lflags);
  52
  53         if (flags & KM_NOFS)
  54                 memalloc_nofs_restore(nofs_flag);
  55
  56         return ptr;
  57 }
  58
  59 /*
  60  * Same as kmem_alloc_large, except we guarantee the buffer returned is aligned
  61  * to the @align_mask. We only guarantee alignment up to page size, we'll clamp
  62  * alignment at page size if it is larger. vmalloc always returns a PAGE_SIZE
  63  * aligned region.
  64  */
  65 void *
  66 kmem_alloc_io(size_t size, int align_mask, xfs_km_flags_t flags)
  67 {
  68         void    *ptr;
  69
  70         trace_kmem_alloc_io(size, flags, _RET_IP_);
  71
  72         if (WARN_ON_ONCE(align_mask >= PAGE_SIZE))
  73                 align_mask = PAGE_SIZE - 1;
  74
  75         ptr = kmem_alloc(size, flags | KM_MAYFAIL);
  76         if (ptr) {
  77                 if (!((uintptr_t)ptr & align_mask))
  78                         return ptr;
  79                 kfree(ptr);
  80         }
  81         return __kmem_vmalloc(size, flags);
  82 }
  83
  84 void *
  85 kmem_alloc_large(size_t size, xfs_km_flags_t flags)
  86 {
  87         void    *ptr;
  88
  89         trace_kmem_alloc_large(size, flags, _RET_IP_);
  90
  91         ptr = kmem_alloc(size, flags | KM_MAYFAIL);
  92         if (ptr)
  93                 return ptr;
  94         return __kmem_vmalloc(size, flags);
  95 }
  96
  97 void *
  98 kmem_realloc(const void *old, size_t newsize, xfs_km_flags_t flags)
  99 {
 100         int     retries = 0;
 101         gfp_t   lflags = kmem_flags_convert(flags);
 102         void    *ptr;
 103
 104         trace_kmem_realloc(newsize, flags, _RET_IP_);
 105
 106         do {
 107                 ptr = krealloc(old, newsize, lflags);
 108                 if (ptr || (flags & KM_MAYFAIL))
 109                         return ptr;
 110                 if (!(++retries % 100))
 111                         xfs_err(NULL,
 112         "%s(%u) possible memory allocation deadlock size %zu in %s (mode:0x%x)",
 113                                 current->comm, current->pid,
 114                                 newsize, __func__, lflags);
 115                 congestion_wait(BLK_RW_ASYNC, HZ/50);
 116         } while (1);
 117 }
 118
 119 void *
 120 kmem_zone_alloc(kmem_zone_t *zone, xfs_km_flags_t flags)
 121 {
 122         int     retries = 0;
 123         gfp_t   lflags = kmem_flags_convert(flags);
 124         void    *ptr;
 125
 126         trace_kmem_zone_alloc(kmem_cache_size(zone), flags, _RET_IP_);
 127         do {
 128                 ptr = kmem_cache_alloc(zone, lflags);
 129                 if (ptr || (flags & KM_MAYFAIL))
 130                         return ptr;
 131                 if (!(++retries % 100))
 132                         xfs_err(NULL,
 133                 "%s(%u) possible memory allocation deadlock in %s (mode:0x%x)",
 134                                 current->comm, current->pid,
 135                                 __func__, lflags);
 136                 congestion_wait(BLK_RW_ASYNC, HZ/50);
 137         } while (1);
 138 }