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 kmem_zone       kmem_cache
  82 #define kmem_zone_t     struct kmem_cache
  83
  84 extern void *kmem_zone_alloc(kmem_zone_t *, xfs_km_flags_t);
  85
  86 static inline void *
  87 kmem_zone_zalloc(kmem_zone_t *zone, xfs_km_flags_t flags)
  88 {
  89         return kmem_zone_alloc(zone, flags | KM_ZERO);
  90 }
  91
  92 static inline struct page *
  93 kmem_to_page(void *addr)
  94 {
  95         if (is_vmalloc_addr(addr))
  96                 return vmalloc_to_page(addr);
  97         return virt_to_page(addr);
  98 }
  99
 100 #endif /* __XFS_SUPPORT_KMEM_H__ */