diff --git a/config/kernel-shrink.m4 b/config/kernel-shrink.m4 index 8cf0f2761bde..0c702153e8c4 100644 --- a/config/kernel-shrink.m4 +++ b/config/kernel-shrink.m4 @@ -1,151 +1,188 @@ dnl # dnl # 3.1 API change dnl # The super_block structure now stores a per-filesystem shrinker. dnl # This interface is preferable because it can be used to specifically dnl # target only the zfs filesystem for pruning. dnl # AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK], [ ZFS_LINUX_TEST_SRC([super_block_s_shrink], [ #include int shrink(struct shrinker *s, struct shrink_control *sc) { return 0; } static const struct super_block sb __attribute__ ((unused)) = { .s_shrink.seeks = DEFAULT_SEEKS, .s_shrink.batch = 0, }; ],[]) ]) AC_DEFUN([ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK], [ AC_MSG_CHECKING([whether super_block has s_shrink]) ZFS_LINUX_TEST_RESULT([super_block_s_shrink], [ AC_MSG_RESULT(yes) ],[ ZFS_LINUX_TEST_ERROR([sb->s_shrink()]) ]) ]) dnl # dnl # 3.12 API change dnl # The nid member was added to struct shrink_control to support dnl # NUMA-aware shrinkers. dnl # AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID], [ ZFS_LINUX_TEST_SRC([shrink_control_nid], [ #include ],[ struct shrink_control sc __attribute__ ((unused)); unsigned long scnidsize __attribute__ ((unused)) = sizeof(sc.nid); ]) ]) AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID], [ AC_MSG_CHECKING([whether shrink_control has nid]) ZFS_LINUX_TEST_RESULT([shrink_control_nid], [ AC_MSG_RESULT(yes) AC_DEFINE(SHRINK_CONTROL_HAS_NID, 1, [struct shrink_control has nid]) ],[ AC_MSG_RESULT(no) ]) ]) +AC_DEFUN([ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG], [ + ZFS_LINUX_TEST_SRC([register_shrinker_vararg], [ + #include + unsigned long shrinker_cb(struct shrinker *shrink, + struct shrink_control *sc) { return 0; } + ],[ + struct shrinker cache_shrinker = { + .count_objects = shrinker_cb, + .scan_objects = shrinker_cb, + .seeks = DEFAULT_SEEKS, + }; + register_shrinker(&cache_shrinker, "vararg-reg-shrink-test"); + ]) +]) + AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK], [ ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control], [ #include int shrinker_cb(struct shrinker *shrink, struct shrink_control *sc) { return 0; } ],[ struct shrinker cache_shrinker = { .shrink = shrinker_cb, .seeks = DEFAULT_SEEKS, }; register_shrinker(&cache_shrinker); ]) ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control_split], [ #include unsigned long shrinker_cb(struct shrinker *shrink, struct shrink_control *sc) { return 0; } ],[ struct shrinker cache_shrinker = { .count_objects = shrinker_cb, .scan_objects = shrinker_cb, .seeks = DEFAULT_SEEKS, }; register_shrinker(&cache_shrinker); ]) ]) AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[ dnl # - dnl # 3.0 - 3.11 API change - dnl # cs->shrink(struct shrinker *, struct shrink_control *sc) + dnl # 6.0 API change + dnl # register_shrinker() becomes a var-arg function that takes + dnl # a printf-style format string as args > 0 dnl # - AC_MSG_CHECKING([whether new 2-argument shrinker exists]) - ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control], [ + AC_MSG_CHECKING([whether new var-arg register_shrinker() exists]) + ZFS_LINUX_TEST_RESULT([register_shrinker_vararg], [ AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_SINGLE_SHRINKER_CALLBACK, 1, - [new shrinker callback wants 2 args]) + AC_DEFINE(HAVE_REGISTER_SHRINKER_VARARG, 1, + [register_shrinker is vararg]) + + dnl # We assume that the split shrinker callback exists if the + dnl # vararg register_shrinker() exists, because the latter is + dnl # a much more recent addition, and the macro test for the + dnl # var-arg version only works if the callback is split + AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1, + [cs->count_objects exists]) ],[ AC_MSG_RESULT(no) - dnl # - dnl # 3.12 API change, - dnl # cs->shrink() is logically split in to - dnl # cs->count_objects() and cs->scan_objects() + dnl # 3.0 - 3.11 API change + dnl # cs->shrink(struct shrinker *, struct shrink_control *sc) dnl # - AC_MSG_CHECKING([whether cs->count_objects callback exists]) - ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control_split], [ + AC_MSG_CHECKING([whether new 2-argument shrinker exists]) + ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control], [ AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1, - [cs->count_objects exists]) + AC_DEFINE(HAVE_SINGLE_SHRINKER_CALLBACK, 1, + [new shrinker callback wants 2 args]) ],[ - ZFS_LINUX_TEST_ERROR([shrinker]) + AC_MSG_RESULT(no) + + dnl # + dnl # 3.12 API change, + dnl # cs->shrink() is logically split in to + dnl # cs->count_objects() and cs->scan_objects() + dnl # + AC_MSG_CHECKING([if cs->count_objects callback exists]) + ZFS_LINUX_TEST_RESULT( + [shrinker_cb_shrink_control_split],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, 1, + [cs->count_objects exists]) + ],[ + ZFS_LINUX_TEST_ERROR([shrinker]) + ]) ]) ]) ]) dnl # dnl # 2.6.39 API change, dnl # Shrinker adjust to use common shrink_control structure. dnl # AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT], [ ZFS_LINUX_TEST_SRC([shrink_control_struct], [ #include ],[ struct shrink_control sc __attribute__ ((unused)); sc.nr_to_scan = 0; sc.gfp_mask = GFP_KERNEL; ]) ]) AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT], [ AC_MSG_CHECKING([whether struct shrink_control exists]) ZFS_LINUX_TEST_RESULT([shrink_control_struct], [ AC_MSG_RESULT(yes) AC_DEFINE(HAVE_SHRINK_CONTROL_STRUCT, 1, [struct shrink_control exists]) ],[ ZFS_LINUX_TEST_ERROR([shrink_control]) ]) ]) AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER], [ ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT + ZFS_AC_KERNEL_SRC_REGISTER_SHRINKER_VARARG ]) AC_DEFUN([ZFS_AC_KERNEL_SHRINKER], [ ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID ZFS_AC_KERNEL_SHRINKER_CALLBACK ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT ]) diff --git a/include/os/linux/spl/sys/shrinker.h b/include/os/linux/spl/sys/shrinker.h index e5b7a9c955dd..d472754be4f4 100644 --- a/include/os/linux/spl/sys/shrinker.h +++ b/include/os/linux/spl/sys/shrinker.h @@ -1,109 +1,113 @@ /* * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC. * Copyright (C) 2007 The Regents of the University of California. * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). * Written by Brian Behlendorf . * UCRL-CODE-235197 * * This file is part of the SPL, Solaris Porting Layer. * * The SPL is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * * The SPL is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * for more details. * * You should have received a copy of the GNU General Public License along * with the SPL. If not, see . */ #ifndef _SPL_SHRINKER_H #define _SPL_SHRINKER_H #include #include /* * Due to frequent changes in the shrinker API the following * compatibility wrappers should be used. They are as follows: * * SPL_SHRINKER_DECLARE(varname, countfunc, scanfunc, seek_cost); * * SPL_SHRINKER_DECLARE is used to declare a shrinker with the name varname, * which is passed to spl_register_shrinker()/spl_unregister_shrinker(). * The countfunc returns the number of free-able objects. * The scanfunc returns the number of objects that were freed. * The callbacks can return SHRINK_STOP if further calls can't make any more * progress. Note that a return value of SHRINK_EMPTY is currently not * supported. * * Example: * * static unsigned long * my_count(struct shrinker *shrink, struct shrink_control *sc) * { * ...calculate number of objects in the cache... * * return (number of objects in the cache); * } * * static unsigned long * my_scan(struct shrinker *shrink, struct shrink_control *sc) * { * ...scan objects in the cache and reclaim them... * } * * SPL_SHRINKER_DECLARE(my_shrinker, my_count, my_scan, DEFAULT_SEEKS); * * void my_init_func(void) { * spl_register_shrinker(&my_shrinker); * } */ +#ifdef HAVE_REGISTER_SHRINKER_VARARG +#define spl_register_shrinker(x) register_shrinker(x, "zfs-arc-shrinker") +#else #define spl_register_shrinker(x) register_shrinker(x) +#endif #define spl_unregister_shrinker(x) unregister_shrinker(x) /* * Linux 3.0 to 3.11 Shrinker API Compatibility. */ #if defined(HAVE_SINGLE_SHRINKER_CALLBACK) #define SPL_SHRINKER_DECLARE(varname, countfunc, scanfunc, seek_cost) \ static int \ __ ## varname ## _wrapper(struct shrinker *shrink, struct shrink_control *sc)\ { \ if (sc->nr_to_scan != 0) { \ (void) scanfunc(shrink, sc); \ } \ return (countfunc(shrink, sc)); \ } \ \ static struct shrinker varname = { \ .shrink = __ ## varname ## _wrapper, \ .seeks = seek_cost, \ } #define SHRINK_STOP (-1) /* * Linux 3.12 and later Shrinker API Compatibility. */ #elif defined(HAVE_SPLIT_SHRINKER_CALLBACK) #define SPL_SHRINKER_DECLARE(varname, countfunc, scanfunc, seek_cost) \ static struct shrinker varname = { \ .count_objects = countfunc, \ .scan_objects = scanfunc, \ .seeks = seek_cost, \ } #else /* * Linux 2.x to 2.6.22, or a newer shrinker API has been introduced. */ #error "Unknown shrinker callback" #endif #endif /* SPL_SHRINKER_H */