include/linux/mm_compat.h

   1 /*****************************************************************************\
   2  *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
   3  *  Copyright (C) 2007 The Regents of the University of California.
   4  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
   5  *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
   6  *  UCRL-CODE-235197
   7  *
   8  *  This file is part of the SPL, Solaris Porting Layer.
   9  *  For details, see <http://github.com/behlendorf/spl/>.
  10  *
  11  *  The SPL is free software; you can redistribute it and/or modify it
  12  *  under the terms of the GNU General Public License as published by the
  13  *  Free Software Foundation; either version 2 of the License, or (at your
  14  *  option) any later version.
  15  *
  16  *  The SPL is distributed in the hope that it will be useful, but WITHOUT
  17  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19  *  for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
  23 \*****************************************************************************/
  24
  25 #ifndef _SPL_MM_COMPAT_H
  26 #define _SPL_MM_COMPAT_H
  27
  28 #include <linux/mm.h>
  29 #include <linux/fs.h>
  30
  31 /*
  32  * Linux 2.6.31 API Change.
  33  * Individual pages_{min,low,high} moved in to watermark array.
  34  */
  35 #ifndef min_wmark_pages
  36 #define min_wmark_pages(z)      (z->pages_min)
  37 #endif
  38
  39 #ifndef low_wmark_pages
  40 #define low_wmark_pages(z)      (z->pages_low)
  41 #endif
  42
  43 #ifndef high_wmark_pages
  44 #define high_wmark_pages(z)     (z->pages_high)
  45 #endif
  46
  47 /*
  48  * 2.6.37 API compat,
  49  * The function invalidate_inodes() is no longer exported by the kernel.
  50  * The prototype however is still available which means it is safe
  51  * to acquire the symbol's address using spl_kallsyms_lookup_name().
  52  *
  53  * 2.6.39 API compat,
  54  * As for 2.6.39 invalidate_inodes() was updated to take a second
  55  * argument which controls how dirty inodes should be handled.
  56  */
  57 #ifdef HAVE_INVALIDATE_INODES
  58 # ifdef HAVE_2ARGS_INVALIDATE_INODES
  59 #  define spl_invalidate_inodes(sb, kd) invalidate_inodes(sb, kd)
  60 # else
  61 #  define spl_invalidate_inodes(sb, kd) invalidate_inodes(sb)
  62 # endif /* HAVE_2ARGS_INVALIDATE_INODES */
  63 #else
  64 # ifdef HAVE_2ARGS_INVALIDATE_INODES
  65 typedef int (*invalidate_inodes_t)(struct super_block *sb, bool kd);
  66 extern invalidate_inodes_t invalidate_inodes_fn;
  67 #  define spl_invalidate_inodes(sb, kd) invalidate_inodes_fn(sb, kd)
  68 # else
  69 typedef int (*invalidate_inodes_t)(struct super_block *sb);
  70 extern invalidate_inodes_t invalidate_inodes_fn;
  71 #  define spl_invalidate_inodes(sb, kd) invalidate_inodes_fn(sb)
  72 # endif /* HAVE_2ARGS_INVALIDATE_INODES */
  73 #endif /* HAVE_INVALIDATE_INODES */
  74
  75 #if !defined(HAVE_SHRINK_CONTROL_STRUCT)
  76 struct shrink_control {
  77         gfp_t gfp_mask;
  78         unsigned long nr_to_scan;
  79 };
  80 #endif /* HAVE_SHRINK_CONTROL_STRUCT */
  81
  82 /*
  83  * 2.6.xx API compat,
  84  * There currently exists no exposed API to partially shrink the dcache.
  85  * The expected mechanism to shrink the cache is a registered shrinker
  86  * which is called during memory pressure.
  87  */
  88 #ifndef HAVE_SHRINK_DCACHE_MEMORY
  89 # if defined(HAVE_SHRINK_CONTROL_STRUCT)
  90 typedef int (*shrink_dcache_memory_t)(struct shrinker *,
  91     struct shrink_control *);
  92 extern shrink_dcache_memory_t shrink_dcache_memory_fn;
  93 #  define shrink_dcache_memory(nr, gfp)                                      \
  94 ({                                                                           \
  95         struct shrink_control sc = { .nr_to_scan = nr, .gfp_mask = gfp };    \
  96         shrink_dcache_memory_fn(NULL, &sc);                                  \
  97 })
  98 # elif defined(HAVE_3ARGS_SHRINKER_CALLBACK)
  99 typedef int (*shrink_dcache_memory_t)(struct shrinker *, int, gfp_t);
 100 extern shrink_dcache_memory_t shrink_dcache_memory_fn;
 101 #  define shrink_dcache_memory(nr, gfp) shrink_dcache_memory_fn(NULL, nr, gfp)
 102 # else
 103 typedef int (*shrink_dcache_memory_t)(int, gfp_t);
 104 extern shrink_dcache_memory_t shrink_dcache_memory_fn;
 105 #  define shrink_dcache_memory(nr, gfp) shrink_dcache_memory_fn(nr, gfp)
 106 # endif /* HAVE_3ARGS_SHRINKER_CALLBACK */
 107 #endif /* HAVE_SHRINK_DCACHE_MEMORY */
 108
 109 /*
 110  * 2.6.xx API compat,
 111  * There currently exists no exposed API to partially shrink the icache.
 112  * The expected mechanism to shrink the cache is a registered shrinker
 113  * which is called during memory pressure.
 114  */
 115 #ifndef HAVE_SHRINK_ICACHE_MEMORY
 116 # if defined(HAVE_SHRINK_CONTROL_STRUCT)
 117 typedef int (*shrink_icache_memory_t)(struct shrinker *,
 118     struct shrink_control *);
 119 extern shrink_icache_memory_t shrink_icache_memory_fn;
 120 #  define shrink_icache_memory(nr, gfp)                                      \
 121 ({                                                                           \
 122         struct shrink_control sc = { .nr_to_scan = nr, .gfp_mask = gfp };    \
 123         shrink_icache_memory_fn(NULL, &sc);                                  \
 124 })
 125 # elif defined(HAVE_3ARGS_SHRINKER_CALLBACK)
 126 typedef int (*shrink_icache_memory_t)(struct shrinker *, int, gfp_t);
 127 extern shrink_icache_memory_t shrink_icache_memory_fn;
 128 #  define shrink_icache_memory(nr, gfp) shrink_icache_memory_fn(NULL, nr, gfp)
 129 # else
 130 typedef int (*shrink_icache_memory_t)(int, gfp_t);
 131 extern shrink_icache_memory_t shrink_icache_memory_fn;
 132 #  define shrink_icache_memory(nr, gfp) shrink_icache_memory_fn(nr, gfp)
 133 # endif /* HAVE_3ARGS_SHRINKER_CALLBACK */
 134 #endif /* HAVE_SHRINK_ICACHE_MEMORY */
 135
 136 /*
 137  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 138  */
 139 #ifdef HAVE_SET_SHRINKER
 140 typedef struct spl_shrinker {
 141         struct shrinker *shrinker;
 142         shrinker_t fn;
 143         int seeks;
 144 } spl_shrinker_t;
 145
 146 static inline void
 147 spl_register_shrinker(spl_shrinker_t *ss)
 148 {
 149         ss->shrinker = set_shrinker(ss->seeks, ss->fn);
 150 }
 151
 152 static inline void
 153 spl_unregister_shrinker(spl_shrinker_t *ss)
 154 {
 155         remove_shrinker(ss->shrinker);
 156 }
 157
 158 # define SPL_SHRINKER_DECLARE(s, x, y)                                 \
 159         static spl_shrinker_t s = {                                    \
 160                 .shrinker = NULL,                                      \
 161                 .fn = x,                                               \
 162                 .seeks = y                                             \
 163         }
 164
 165 # define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                         \
 166         static int fn(int, unsigned int)
 167 # define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                             \
 168 static int                                                             \
 169 fn(int nr_to_scan, unsigned int gfp_mask)                              \
 170 {                                                                      \
 171         struct shrink_control sc;                                      \
 172                                                                        \
 173         sc.nr_to_scan = nr_to_scan;                                    \
 174         sc.gfp_mask = gfp_mask;                                        \
 175                                                                        \
 176         return __ ## fn(NULL, &sc);                                    \
 177 }
 178
 179 #else
 180
 181 # define spl_register_shrinker(x)       register_shrinker(x)
 182 # define spl_unregister_shrinker(x)     unregister_shrinker(x)
 183 # define SPL_SHRINKER_DECLARE(s, x, y)                                 \
 184         static struct shrinker s = {                                   \
 185                 .shrink = x,                                           \
 186                 .seeks = y                                             \
 187         }
 188
 189 /*
 190  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 191  */
 192 # if defined(HAVE_SHRINK_CONTROL_STRUCT)
 193 #  define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                        \
 194         static int fn(struct shrinker *, struct shrink_control *)
 195 #  define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                            \
 196 static int                                                             \
 197 fn(struct shrinker *shrink, struct shrink_control *sc) {               \
 198         return __ ## fn(shrink, sc);                                   \
 199 }
 200
 201 /*
 202  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 203  */
 204 # elif defined(HAVE_3ARGS_SHRINKER_CALLBACK)
 205 #  define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                       \
 206         static int fn(struct shrinker *, int, unsigned int)
 207 #  define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                           \
 208 static int                                                            \
 209 fn(struct shrinker *shrink, int nr_to_scan, unsigned int gfp_mask)    \
 210 {                                                                     \
 211         struct shrink_control sc;                                     \
 212                                                                       \
 213         sc.nr_to_scan = nr_to_scan;                                   \
 214         sc.gfp_mask = gfp_mask;                                       \
 215                                                                       \
 216         return __ ## fn(shrink, &sc);                                 \
 217 }
 218
 219 /*
 220  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 221  */
 222 # else
 223 #  define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                       \
 224         static int fn(int, unsigned int)
 225 #  define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                           \
 226 static int                                                            \
 227 fn(int nr_to_scan, unsigned int gfp_mask)                             \
 228 {                                                                     \
 229         struct shrink_control sc;                                     \
 230                                                                       \
 231         sc.nr_to_scan = nr_to_scan;                                   \
 232         sc.gfp_mask = gfp_mask;                                       \
 233                                                                       \
 234         return __ ## fn(NULL, &sc);                                   \
 235 }
 236
 237 # endif
 238 #endif /* HAVE_SET_SHRINKER */
 239
 240 #endif /* SPL_MM_COMPAT_H */