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