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         int __ret__ = 0;                                                     \
  97                                                                              \
  98         if (shrink_dcache_memory_fn)                                         \
  99                 __ret__ = shrink_dcache_memory_fn(NULL, &sc);                \
 100                                                                              \
 101         __ret__;                                                             \
 102 })
 103 # elif defined(HAVE_3ARGS_SHRINKER_CALLBACK)
 104 typedef int (*shrink_dcache_memory_t)(struct shrinker *, int, gfp_t);
 105 extern shrink_dcache_memory_t shrink_dcache_memory_fn;
 106 #  define shrink_dcache_memory(nr, gfp)                                      \
 107 ({                                                                           \
 108         int __ret__ = 0;                                                     \
 109                                                                              \
 110         if (shrink_dcache_memory_fn)                                         \
 111                 __ret__ = shrink_dcache_memory_fn(NULL, nr, gfp);            \
 112                                                                              \
 113         __ret__;                                                             \
 114 })
 115 # else
 116 typedef int (*shrink_dcache_memory_t)(int, gfp_t);
 117 extern shrink_dcache_memory_t shrink_dcache_memory_fn;
 118 #  define shrink_dcache_memory(nr, gfp)                                      \
 119 ({                                                                           \
 120         int __ret__ = 0;                                                     \
 121                                                                              \
 122         if (shrink_dcache_memory_fn)                                         \
 123                 __ret__ = shrink_dcache_memory_fn(nr, gfp);                  \
 124                                                                              \
 125         __ret__;                                                             \
 126 })
 127 # endif /* HAVE_3ARGS_SHRINKER_CALLBACK */
 128 #endif /* HAVE_SHRINK_DCACHE_MEMORY */
 129
 130 /*
 131  * 2.6.xx API compat,
 132  * There currently exists no exposed API to partially shrink the icache.
 133  * The expected mechanism to shrink the cache is a registered shrinker
 134  * which is called during memory pressure.
 135  */
 136 #ifndef HAVE_SHRINK_ICACHE_MEMORY
 137 # if defined(HAVE_SHRINK_CONTROL_STRUCT)
 138 typedef int (*shrink_icache_memory_t)(struct shrinker *,
 139     struct shrink_control *);
 140 extern shrink_icache_memory_t shrink_icache_memory_fn;
 141 #  define shrink_icache_memory(nr, gfp)                                      \
 142 ({                                                                           \
 143         struct shrink_control sc = { .nr_to_scan = nr, .gfp_mask = gfp };    \
 144         int __ret__ = 0;                                                     \
 145                                                                              \
 146         if (shrink_icache_memory_fn)                                         \
 147                 __ret__ = shrink_icache_memory_fn(NULL, &sc);                \
 148                                                                              \
 149         __ret__;                                                             \
 150 })
 151 # elif defined(HAVE_3ARGS_SHRINKER_CALLBACK)
 152 typedef int (*shrink_icache_memory_t)(struct shrinker *, int, gfp_t);
 153 extern shrink_icache_memory_t shrink_icache_memory_fn;
 154 #  define shrink_icache_memory(nr, gfp)                                      \
 155 ({                                                                           \
 156         int __ret__ = 0;                                                     \
 157                                                                              \
 158         if (shrink_icache_memory_fn)                                         \
 159                 __ret__ = shrink_icache_memory_fn(NULL, nr, gfp);            \
 160                                                                              \
 161         __ret__;                                                             \
 162 })
 163 # else
 164 typedef int (*shrink_icache_memory_t)(int, gfp_t);
 165 extern shrink_icache_memory_t shrink_icache_memory_fn;
 166 #  define shrink_icache_memory(nr, gfp)                                      \
 167 ({                                                                           \
 168         int __ret__ = 0;                                                     \
 169                                                                              \
 170         if (shrink_icache_memory_fn)                                         \
 171                 __ret__ = shrink_icache_memory_fn(nr, gfp);                  \
 172                                                                              \
 173         __ret__;                                                             \
 174 })
 175 # endif /* HAVE_3ARGS_SHRINKER_CALLBACK */
 176 #endif /* HAVE_SHRINK_ICACHE_MEMORY */
 177
 178 /*
 179  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 180  */
 181 #ifdef HAVE_SET_SHRINKER
 182 typedef struct spl_shrinker {
 183         struct shrinker *shrinker;
 184         shrinker_t fn;
 185         int seeks;
 186 } spl_shrinker_t;
 187
 188 static inline void
 189 spl_register_shrinker(spl_shrinker_t *ss)
 190 {
 191         ss->shrinker = set_shrinker(ss->seeks, ss->fn);
 192 }
 193
 194 static inline void
 195 spl_unregister_shrinker(spl_shrinker_t *ss)
 196 {
 197         remove_shrinker(ss->shrinker);
 198 }
 199
 200 # define SPL_SHRINKER_DECLARE(s, x, y)                                 \
 201         static spl_shrinker_t s = {                                    \
 202                 .shrinker = NULL,                                      \
 203                 .fn = x,                                               \
 204                 .seeks = y                                             \
 205         }
 206
 207 # define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                         \
 208         static int fn(int, unsigned int)
 209 # define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                             \
 210 static int                                                             \
 211 fn(int nr_to_scan, unsigned int gfp_mask)                              \
 212 {                                                                      \
 213         struct shrink_control sc;                                      \
 214                                                                        \
 215         sc.nr_to_scan = nr_to_scan;                                    \
 216         sc.gfp_mask = gfp_mask;                                        \
 217                                                                        \
 218         return __ ## fn(NULL, &sc);                                    \
 219 }
 220
 221 #else
 222
 223 # define spl_register_shrinker(x)       register_shrinker(x)
 224 # define spl_unregister_shrinker(x)     unregister_shrinker(x)
 225 # define SPL_SHRINKER_DECLARE(s, x, y)                                 \
 226         static struct shrinker s = {                                   \
 227                 .shrink = x,                                           \
 228                 .seeks = y                                             \
 229         }
 230
 231 /*
 232  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 233  */
 234 # if defined(HAVE_SHRINK_CONTROL_STRUCT)
 235 #  define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                        \
 236         static int fn(struct shrinker *, struct shrink_control *)
 237 #  define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                            \
 238 static int                                                             \
 239 fn(struct shrinker *shrink, struct shrink_control *sc) {               \
 240         return __ ## fn(shrink, sc);                                   \
 241 }
 242
 243 /*
 244  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 245  */
 246 # elif defined(HAVE_3ARGS_SHRINKER_CALLBACK)
 247 #  define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                       \
 248         static int fn(struct shrinker *, int, unsigned int)
 249 #  define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                           \
 250 static int                                                            \
 251 fn(struct shrinker *shrink, int nr_to_scan, unsigned int gfp_mask)    \
 252 {                                                                     \
 253         struct shrink_control sc;                                     \
 254                                                                       \
 255         sc.nr_to_scan = nr_to_scan;                                   \
 256         sc.gfp_mask = gfp_mask;                                       \
 257                                                                       \
 258         return __ ## fn(shrink, &sc);                                 \
 259 }
 260
 261 /*
 262  * Linux 2.6. - 2.6. Shrinker API Compatibility.
 263  */
 264 # else
 265 #  define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn)                       \
 266         static int fn(int, unsigned int)
 267 #  define SPL_SHRINKER_CALLBACK_WRAPPER(fn)                           \
 268 static int                                                            \
 269 fn(int nr_to_scan, unsigned int gfp_mask)                             \
 270 {                                                                     \
 271         struct shrink_control sc;                                     \
 272                                                                       \
 273         sc.nr_to_scan = nr_to_scan;                                   \
 274         sc.gfp_mask = gfp_mask;                                       \
 275                                                                       \
 276         return __ ## fn(NULL, &sc);                                   \
 277 }
 278
 279 # endif
 280 #endif /* HAVE_SET_SHRINKER */
 281
 282 #endif /* SPL_MM_COMPAT_H */