fs/xfs/kmem.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #ifndef __XFS_SUPPORT_KMEM_H__
   7 #define __XFS_SUPPORT_KMEM_H__
   8
   9 #include <linux/slab.h>
  10 #include <linux/sched.h>
  11 #include <linux/mm.h>
  12 #include <linux/vmalloc.h>
  13
  14 /*
  15  * General memory allocation interfaces
  16  */
  17
  18 typedef unsigned __bitwise xfs_km_flags_t;
  19 #define KM_NOFS         ((__force xfs_km_flags_t)0x0004u)
  20 #define KM_MAYFAIL      ((__force xfs_km_flags_t)0x0008u)
  21 #define KM_ZERO         ((__force xfs_km_flags_t)0x0010u)
  22
  23 /*
  24  * We use a special process flag to avoid recursive callbacks into
  25  * the filesystem during transactions.  We will also issue our own
  26  * warnings, so we explicitly skip any generic ones (silly of us).
  27  */
  28 static inline gfp_t
  29 kmem_flags_convert(xfs_km_flags_t flags)
  30 {
  31         gfp_t   lflags;
  32
  33         BUG_ON(flags & ~(KM_NOFS|KM_MAYFAIL|KM_ZERO));
  34
  35         lflags = GFP_KERNEL | __GFP_NOWARN;
  36         if (flags & KM_NOFS)
  37                 lflags &= ~__GFP_FS;
  38
  39         /*
  40          * Default page/slab allocator behavior is to retry for ever
  41          * for small allocations. We can override this behavior by using
  42          * __GFP_RETRY_MAYFAIL which will tell the allocator to retry as long
  43          * as it is feasible but rather fail than retry forever for all
  44          * request sizes.
  45          */
  46         if (flags & KM_MAYFAIL)
  47                 lflags |= __GFP_RETRY_MAYFAIL;
  48
  49         if (flags & KM_ZERO)
  50                 lflags |= __GFP_ZERO;
  51
  52         return lflags;
  53 }
  54
  55 extern void *kmem_alloc(size_t, xfs_km_flags_t);
  56 extern void *kmem_alloc_io(size_t size, int align_mask, xfs_km_flags_t flags);
  57 extern void *kmem_alloc_large(size_t size, xfs_km_flags_t);
  58 extern void *kmem_realloc(const void *, size_t, xfs_km_flags_t);
  59 static inline void  kmem_free(const void *ptr)
  60 {
  61         kvfree(ptr);
  62 }
  63
  64
  65 static inline void *
  66 kmem_zalloc(size_t size, xfs_km_flags_t flags)
  67 {
  68         return kmem_alloc(size, flags | KM_ZERO);
  69 }
  70
  71 static inline void *
  72 kmem_zalloc_large(size_t size, xfs_km_flags_t flags)
  73 {
  74         return kmem_alloc_large(size, flags | KM_ZERO);
  75 }
  76
  77 /*
  78  * Zone interfaces
  79  */
  80
  81 #define KM_ZONE_HWALIGN SLAB_HWCACHE_ALIGN
  82 #define KM_ZONE_RECLAIM SLAB_RECLAIM_ACCOUNT
  83 #define KM_ZONE_SPREAD  SLAB_MEM_SPREAD
  84 #define KM_ZONE_ACCOUNT SLAB_ACCOUNT
  85
  86 #define kmem_zone       kmem_cache
  87 #define kmem_zone_t     struct kmem_cache
  88
  89 static inline kmem_zone_t *
  90 kmem_zone_init(int size, char *zone_name)
  91 {
  92         return kmem_cache_create(zone_name, size, 0, 0, NULL);
  93 }
  94
  95 static inline kmem_zone_t *
  96 kmem_zone_init_flags(int size, char *zone_name, slab_flags_t flags,
  97                      void (*construct)(void *))
  98 {
  99         return kmem_cache_create(zone_name, size, 0, flags, construct);
 100 }
 101
 102 static inline void
 103 kmem_zone_free(kmem_zone_t *zone, void *ptr)
 104 {
 105         kmem_cache_free(zone, ptr);
 106 }
 107
 108 static inline void
 109 kmem_zone_destroy(kmem_zone_t *zone)
 110 {
 111         kmem_cache_destroy(zone);
 112 }
 113
 114 extern void *kmem_zone_alloc(kmem_zone_t *, xfs_km_flags_t);
 115
 116 static inline void *
 117 kmem_zone_zalloc(kmem_zone_t *zone, xfs_km_flags_t flags)
 118 {
 119         return kmem_zone_alloc(zone, flags | KM_ZERO);
 120 }
 121
 122 static inline struct page *
 123 kmem_to_page(void *addr)
 124 {
 125         if (is_vmalloc_addr(addr))
 126                 return vmalloc_to_page(addr);
 127         return virt_to_page(addr);
 128 }
 129
 130 #endif /* __XFS_SUPPORT_KMEM_H__ */