From 65eb1b607d339b6299515c8a05551629db7fcdd2 Mon Sep 17 00:00:00 2001 From: Jesus Alvarez Date: Thu, 14 Nov 2013 21:13:26 -0800 Subject: [PATCH] Update to 0.6.2_3.12-1 --- conf.sh | 2 +- spl-utils/PKGBUILD | 9 +- spl-utils/spl_3.12_fix.patch | 429 +++++++++++++++++++++++++++++++++++ spl/PKGBUILD | 17 +- spl/spl_3.12_fix.patch | 429 +++++++++++++++++++++++++++++++++++ zfs-utils/PKGBUILD | 2 +- zfs/PKGBUILD | 6 +- 7 files changed, 883 insertions(+), 11 deletions(-) create mode 100644 spl-utils/spl_3.12_fix.patch create mode 100644 spl/spl_3.12_fix.patch diff --git a/conf.sh b/conf.sh index f3e3a0b..af045a5 100644 --- a/conf.sh +++ b/conf.sh @@ -5,7 +5,7 @@ PKGREL="3" # The pkgrel of all the archzfs packages ZOL_VERSION="0.6.2" # Linux version dependencies -LINUX_VERSION="3.11.6" +LINUX_VERSION="3.12" LINUX_PKGREL="1" LINUX_VERSION_FULL="$LINUX_VERSION-$LINUX_PKGREL" LINUX_ARCHISO="3.11.2" diff --git a/spl-utils/PKGBUILD b/spl-utils/PKGBUILD index 886c324..6d72c83 100644 --- a/spl-utils/PKGBUILD +++ b/spl-utils/PKGBUILD @@ -11,18 +11,25 @@ pkgname=("spl-utils") # The build script can be found at # https://github.com/demizer/archzfs/blob/master/build.sh # -pkgver=0.6.2_3.11.6 +pkgver=0.6.2_3.12 pkgrel=3 pkgdesc="Solaris Porting Layer kernel module support files." arch=("i686" "x86_64") url="http://zfsonlinux.org/" source=(http://archive.zfsonlinux.org/downloads/zfsonlinux/spl/spl-0.6.2.tar.gz + spl_3.12_fix.patch spl-utils.hostid) groups=("archzfs") md5sums=('f00535bf89a7fde0e08f44a14a1f1e03' + '4d30dbda61995e77c5ca976abb80bad6' 'a54f0041a9e15b050f25c463f1db7449') license=("GPL") +prepare() { + cd "$srcdir/spl-0.6.2" + patch -Np1 < ../spl_3.12_fix.patch +} + build() { cd "$srcdir/spl-0.6.2" ./autogen.sh diff --git a/spl-utils/spl_3.12_fix.patch b/spl-utils/spl_3.12_fix.patch new file mode 100644 index 0000000..b196098 --- /dev/null +++ b/spl-utils/spl_3.12_fix.patch @@ -0,0 +1,429 @@ +commit c3d9c0df3ee8d43db22815ebbfbe8b803fa46e46 +Author: Richard Yao +Date: Tue Nov 5 11:35:54 2013 -0500 + + Linux 3.12 compat: New shrinker API + + torvalds/linux@24f7c6 introduced a new shrinker API while + torvalds/linux@a0b021 dropped support for the old shrinker API. + This patch adds support for the new shrinker API by wrapping + the old one with the new one. + + This change also reorganizes the autotools checks on the shrinker + API such that the configure script will fail early if an unknown + API is encountered in the future. + + Support for the set_shrinker() API which was used by Linux 2.6.22 + and older has been dropped. As a general rule compatibility is + only maintained back to Linux 2.6.26. + + Signed-off-by: Richard Yao + Signed-off-by: Brian Behlendorf + Closes zfsonlinux/zfs#1732 + Closes zfsonlinux/zfs#1822 + Closes #293 + Closes #307 + +diff --git a/config/spl-build.m4 b/config/spl-build.m4 +index b0e3348..7d744db 100644 +--- a/config/spl-build.m4 ++++ b/config/spl-build.m4 +@@ -27,8 +27,7 @@ AC_DEFUN([SPL_AC_CONFIG_KERNEL], [ + SPL_AC_TYPE_ATOMIC64_XCHG + SPL_AC_TYPE_UINTPTR_T + SPL_AC_2ARGS_REGISTER_SYSCTL +- SPL_AC_SET_SHRINKER +- SPL_AC_3ARGS_SHRINKER_CALLBACK ++ SPL_AC_SHRINKER_CALLBACK + SPL_AC_PATH_IN_NAMEIDATA + SPL_AC_TASK_CURR + SPL_AC_CTL_UNNUMBERED +@@ -885,37 +884,18 @@ AC_DEFUN([SPL_AC_2ARGS_REGISTER_SYSCTL], + ]) + ]) + +-dnl # +-dnl # 2.6.23 API change +-dnl # Old set_shrinker API replaced with register_shrinker +-dnl # +-AC_DEFUN([SPL_AC_SET_SHRINKER], [ +- AC_MSG_CHECKING([whether set_shrinker() available]) +- SPL_LINUX_TRY_COMPILE([ +- #include +- ],[ +- return set_shrinker(DEFAULT_SEEKS, NULL); +- ],[ +- AC_MSG_RESULT([yes]) +- AC_DEFINE(HAVE_SET_SHRINKER, 1, +- [set_shrinker() available]) +- ],[ +- AC_MSG_RESULT([no]) +- ]) +-]) +- +-dnl # +-dnl # 2.6.35 API change, +-dnl # Add context to shrinker callback +-dnl # +-AC_DEFUN([SPL_AC_3ARGS_SHRINKER_CALLBACK], +- [AC_MSG_CHECKING([whether shrinker callback wants 3 args]) ++AC_DEFUN([SPL_AC_SHRINKER_CALLBACK],[ + tmp_flags="$EXTRA_KCFLAGS" + EXTRA_KCFLAGS="-Werror" ++ dnl # ++ dnl # 2.6.23 to 2.6.34 API change ++ dnl # ->shrink(int nr_to_scan, gfp_t gfp_mask) ++ dnl # ++ AC_MSG_CHECKING([whether old 2-argument shrinker exists]) + SPL_LINUX_TRY_COMPILE([ + #include + +- int shrinker_cb(struct shrinker *, int, unsigned int); ++ int shrinker_cb(int nr_to_scan, gfp_t gfp_mask); + ],[ + struct shrinker cache_shrinker = { + .shrink = shrinker_cb, +@@ -924,10 +904,86 @@ AC_DEFUN([SPL_AC_3ARGS_SHRINKER_CALLBACK], + register_shrinker(&cache_shrinker); + ],[ + AC_MSG_RESULT(yes) +- AC_DEFINE(HAVE_3ARGS_SHRINKER_CALLBACK, 1, +- [shrinker callback wants 3 args]) ++ AC_DEFINE(HAVE_2ARGS_OLD_SHRINKER_CALLBACK, 1, ++ [old shrinker callback wants 2 args]) + ],[ + AC_MSG_RESULT(no) ++ dnl # ++ dnl # 2.6.35 - 2.6.39 API change ++ dnl # ->shrink(struct shrinker *, ++ dnl # int nr_to_scan, gfp_t gfp_mask) ++ dnl # ++ AC_MSG_CHECKING([whether old 3-argument shrinker exists]) ++ SPL_LINUX_TRY_COMPILE([ ++ #include ++ ++ int shrinker_cb(struct shrinker *, int nr_to_scan, ++ gfp_t gfp_mask); ++ ],[ ++ struct shrinker cache_shrinker = { ++ .shrink = shrinker_cb, ++ .seeks = DEFAULT_SEEKS, ++ }; ++ register_shrinker(&cache_shrinker); ++ ],[ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_3ARGS_SHRINKER_CALLBACK, 1, ++ [old shrinker callback wants 3 args]) ++ ],[ ++ AC_MSG_RESULT(no) ++ dnl # ++ dnl # 3.0 - 3.11 API change ++ dnl # ->shrink(struct shrinker *, ++ dnl # struct shrink_control *sc) ++ dnl # ++ AC_MSG_CHECKING( ++ [whether new 2-argument shrinker exists]) ++ SPL_LINUX_TRY_COMPILE([ ++ #include ++ ++ int shrinker_cb(struct shrinker *, ++ struct shrink_control *sc); ++ ],[ ++ struct shrinker cache_shrinker = { ++ .shrink = shrinker_cb, ++ .seeks = DEFAULT_SEEKS, ++ }; ++ register_shrinker(&cache_shrinker); ++ ],[ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_2ARGS_NEW_SHRINKER_CALLBACK, 1, ++ [new shrinker callback wants 2 args]) ++ ],[ ++ AC_MSG_RESULT(no) ++ dnl # ++ dnl # 3.12 API change, ++ dnl # ->shrink() is logically split in to ++ dnl # ->count_objects() and ->scan_objects() ++ dnl # ++ AC_MSG_CHECKING( ++ [whether ->count_objects callback exists]) ++ SPL_LINUX_TRY_COMPILE([ ++ #include ++ ++ unsigned long shrinker_cb( ++ struct shrinker *, ++ struct shrink_control *sc); ++ ],[ ++ struct shrinker cache_shrinker = { ++ .count_objects = shrinker_cb, ++ .scan_objects = shrinker_cb, ++ .seeks = DEFAULT_SEEKS, ++ }; ++ register_shrinker(&cache_shrinker); ++ ],[ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, ++ 1, [->count_objects exists]) ++ ],[ ++ AC_MSG_ERROR(error) ++ ]) ++ ]) ++ ]) + ]) + EXTRA_KCFLAGS="$tmp_flags" + ]) +diff --git a/include/linux/mm_compat.h b/include/linux/mm_compat.h +index cb1bef9..37c9b08 100644 +--- a/include/linux/mm_compat.h ++++ b/include/linux/mm_compat.h +@@ -148,107 +148,167 @@ extern shrink_icache_memory_t shrink_icache_memory_fn; + #endif /* HAVE_SHRINK_ICACHE_MEMORY */ + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Due to frequent changes in the shrinker API the following ++ * compatibility wrappers should be used. They are as follows: ++ * ++ * SPL_SHRINKER_DECLARE is used to declare the shrinker which is ++ * passed to spl_register_shrinker()/spl_unregister_shrinker(). Use ++ * shrinker_name to set the shrinker variable name, shrinker_callback ++ * to set the callback function, and seek_cost to define the cost of ++ * reclaiming an object. ++ * ++ * SPL_SHRINKER_DECLARE(shrinker_name, shrinker_callback, seek_cost); ++ * ++ * SPL_SHRINKER_CALLBACK_FWD_DECLARE is used when a forward declaration ++ * of the shrinker callback function is required. Only the callback ++ * function needs to be passed. ++ * ++ * SPL_SHRINKER_CALLBACK_FWD_DECLARE(shrinker_callback); ++ * ++ * SPL_SHRINKER_CALLBACK_WRAPPER is used to declare the callback function ++ * which is registered with the shrinker. This function will call your ++ * custom shrinker which must use the following prototype. Notice the ++ * leading __'s, these must be appended to the callback_function name. ++ * ++ * int __shrinker_callback(struct shrinker *, struct shrink_control *) ++ * SPL_SHRINKER_CALLBACK_WRAPPER(shrinker_callback);a ++ * ++ * ++ * Example: ++ * ++ * SPL_SHRINKER_CALLBACK_FWD_DECLARE(my_shrinker_fn); ++ * SPL_SHRINKER_DECLARE(my_shrinker, my_shrinker_fn, 1); ++ * ++ * static int ++ * __my_shrinker_fn(struct shrinker *shrink, struct shrink_control *sc) ++ * { ++ * if (sc->nr_to_scan) { ++ * ...scan objects in the cache and reclaim them... ++ * } ++ * ++ * ...calculate number of objects in the cache... ++ * ++ * return (number of objects in the cache); ++ * } ++ * SPL_SHRINKER_CALLBACK_WRAPPER(my_shrinker_fn); + */ +-#ifdef HAVE_SET_SHRINKER +-typedef struct spl_shrinker { +- struct shrinker *shrinker; +- shrinker_t fn; +- int seeks; +-} spl_shrinker_t; +- +-static inline void +-spl_register_shrinker(spl_shrinker_t *ss) +-{ +- ss->shrinker = set_shrinker(ss->seeks, ss->fn); +-} + +-static inline void +-spl_unregister_shrinker(spl_shrinker_t *ss) +-{ +- remove_shrinker(ss->shrinker); +-} ++#define spl_register_shrinker(x) register_shrinker(x) ++#define spl_unregister_shrinker(x) unregister_shrinker(x) + +-# define SPL_SHRINKER_DECLARE(s, x, y) \ +- static spl_shrinker_t s = { \ +- .shrinker = NULL, \ +- .fn = x, \ +- .seeks = y \ +- } +- +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(int, unsigned int) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(int nr_to_scan, unsigned int gfp_mask) \ +-{ \ +- struct shrink_control sc; \ +- \ +- sc.nr_to_scan = nr_to_scan; \ +- sc.gfp_mask = gfp_mask; \ +- \ +- return __ ## fn(NULL, &sc); \ ++/* ++ * Linux 2.6.23 - 2.6.34 Shrinker API Compatibility. ++ */ ++#if defined(HAVE_2ARGS_OLD_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .shrink = x, \ ++ .seeks = y \ + } + +-#else ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static int fn(int nr_to_scan, unsigned int gfp_mask) + +-# define spl_register_shrinker(x) register_shrinker(x) +-# define spl_unregister_shrinker(x) unregister_shrinker(x) +-# define SPL_SHRINKER_DECLARE(s, x, y) \ +- static struct shrinker s = { \ +- .shrink = x, \ +- .seeks = y \ +- } ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static int \ ++fn(int nr_to_scan, unsigned int gfp_mask) \ ++{ \ ++ struct shrink_control sc; \ ++ \ ++ sc.nr_to_scan = nr_to_scan; \ ++ sc.gfp_mask = gfp_mask; \ ++ \ ++ return (__ ## fn(NULL, &sc)); \ ++} + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Linux 2.6.35 to 2.6.39 Shrinker API Compatibility. + */ +-# if defined(HAVE_SHRINK_CONTROL_STRUCT) +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(struct shrinker *, struct shrink_control *) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(struct shrinker *shrink, struct shrink_control *sc) { \ +- return __ ## fn(shrink, sc); \ ++#elif defined(HAVE_3ARGS_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .shrink = x, \ ++ .seeks = y \ ++} ++ ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static int fn(struct shrinker *, int, unsigned int) ++ ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static int \ ++fn(struct shrinker *shrink, int nr_to_scan, unsigned int gfp_mask) \ ++{ \ ++ struct shrink_control sc; \ ++ \ ++ sc.nr_to_scan = nr_to_scan; \ ++ sc.gfp_mask = gfp_mask; \ ++ \ ++ return (__ ## fn(shrink, &sc)); \ + } + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Linux 3.0 to 3.11 Shrinker API Compatibility. + */ +-# elif defined(HAVE_3ARGS_SHRINKER_CALLBACK) +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(struct shrinker *, int, unsigned int) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(struct shrinker *shrink, int nr_to_scan, unsigned int gfp_mask) \ +-{ \ +- struct shrink_control sc; \ +- \ +- sc.nr_to_scan = nr_to_scan; \ +- sc.gfp_mask = gfp_mask; \ +- \ +- return __ ## fn(shrink, &sc); \ ++#elif defined(HAVE_2ARGS_NEW_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .shrink = x, \ ++ .seeks = y \ ++} ++ ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static int fn(struct shrinker *, struct shrink_control *) ++ ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static int \ ++fn(struct shrinker *shrink, struct shrink_control *sc) \ ++{ \ ++ return (__ ## fn(shrink, sc)); \ + } + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Linux 3.12 and later Shrinker API Compatibility. + */ +-# else +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(int, unsigned int) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(int nr_to_scan, unsigned int gfp_mask) \ +-{ \ +- struct shrink_control sc; \ +- \ +- sc.nr_to_scan = nr_to_scan; \ +- sc.gfp_mask = gfp_mask; \ +- \ +- return __ ## fn(NULL, &sc); \ ++#elif defined(HAVE_SPLIT_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .count_objects = x ## _count_objects, \ ++ .scan_objects = x ## _scan_objects, \ ++ .seeks = y \ + } + +-# endif +-#endif /* HAVE_SET_SHRINKER */ ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static unsigned long fn ## _count_objects(struct shrinker *, \ ++ struct shrink_control *); \ ++static unsigned long fn ## _scan_objects(struct shrinker *, \ ++ struct shrink_control *) ++ ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static unsigned long \ ++fn ## _count_objects(struct shrinker *shrink, struct shrink_control *sc)\ ++{ \ ++ int __ret__; \ ++ \ ++ sc->nr_to_scan = 0; \ ++ __ret__ = __ ## fn(NULL, sc); \ ++ \ ++ /* Errors may not be returned and must be converted to zeros */ \ ++ return ((__ret__ < 0) ? 0 : __ret__); \ ++} \ ++ \ ++static unsigned long \ ++fn ## _scan_objects(struct shrinker *shrink, struct shrink_control *sc) \ ++{ \ ++ int __ret__; \ ++ \ ++ __ret__ = __ ## fn(NULL, sc); \ ++ return ((__ret__ < 0) ? SHRINK_STOP : __ret__); \ ++} ++#else ++/* ++ * Linux 2.x to 2.6.22, or a newer shrinker API has been introduced. ++ */ ++#error "Unknown shrinker callback" ++#endif + + #endif /* SPL_MM_COMPAT_H */ diff --git a/spl/PKGBUILD b/spl/PKGBUILD index f1cb3c6..73df45d 100644 --- a/spl/PKGBUILD +++ b/spl/PKGBUILD @@ -11,19 +11,26 @@ pkgname=("spl") # The build script can be found at # https://github.com/demizer/archzfs/blob/master/build.sh # -pkgver=0.6.2_3.11.6 +pkgver=0.6.2_3.12 pkgrel=3 pkgdesc="Solaris Porting Layer kernel modules." -depends=("spl-utils" "linux=3.11.6-1") -makedepends=("linux-headers=3.11.6-1") +depends=("spl-utils" "linux=3.12-1") +makedepends=("linux-headers=3.12-1") arch=("i686" "x86_64") url="http://zfsonlinux.org/" -source=(http://archive.zfsonlinux.org/downloads/zfsonlinux/spl/spl-0.6.2.tar.gz) +source=(http://archive.zfsonlinux.org/downloads/zfsonlinux/spl/spl-0.6.2.tar.gz + spl_3.12_fix.patch) groups=("archzfs") -md5sums=('f00535bf89a7fde0e08f44a14a1f1e03') +md5sums=('f00535bf89a7fde0e08f44a14a1f1e03' + '4d30dbda61995e77c5ca976abb80bad6') license=("GPL") install=spl.install +prepare() { + cd "$srcdir/spl-0.6.2" + patch -Np1 < ../spl_3.12_fix.patch +} + build() { cd "$srcdir/spl-0.6.2" ./autogen.sh diff --git a/spl/spl_3.12_fix.patch b/spl/spl_3.12_fix.patch new file mode 100644 index 0000000..b196098 --- /dev/null +++ b/spl/spl_3.12_fix.patch @@ -0,0 +1,429 @@ +commit c3d9c0df3ee8d43db22815ebbfbe8b803fa46e46 +Author: Richard Yao +Date: Tue Nov 5 11:35:54 2013 -0500 + + Linux 3.12 compat: New shrinker API + + torvalds/linux@24f7c6 introduced a new shrinker API while + torvalds/linux@a0b021 dropped support for the old shrinker API. + This patch adds support for the new shrinker API by wrapping + the old one with the new one. + + This change also reorganizes the autotools checks on the shrinker + API such that the configure script will fail early if an unknown + API is encountered in the future. + + Support for the set_shrinker() API which was used by Linux 2.6.22 + and older has been dropped. As a general rule compatibility is + only maintained back to Linux 2.6.26. + + Signed-off-by: Richard Yao + Signed-off-by: Brian Behlendorf + Closes zfsonlinux/zfs#1732 + Closes zfsonlinux/zfs#1822 + Closes #293 + Closes #307 + +diff --git a/config/spl-build.m4 b/config/spl-build.m4 +index b0e3348..7d744db 100644 +--- a/config/spl-build.m4 ++++ b/config/spl-build.m4 +@@ -27,8 +27,7 @@ AC_DEFUN([SPL_AC_CONFIG_KERNEL], [ + SPL_AC_TYPE_ATOMIC64_XCHG + SPL_AC_TYPE_UINTPTR_T + SPL_AC_2ARGS_REGISTER_SYSCTL +- SPL_AC_SET_SHRINKER +- SPL_AC_3ARGS_SHRINKER_CALLBACK ++ SPL_AC_SHRINKER_CALLBACK + SPL_AC_PATH_IN_NAMEIDATA + SPL_AC_TASK_CURR + SPL_AC_CTL_UNNUMBERED +@@ -885,37 +884,18 @@ AC_DEFUN([SPL_AC_2ARGS_REGISTER_SYSCTL], + ]) + ]) + +-dnl # +-dnl # 2.6.23 API change +-dnl # Old set_shrinker API replaced with register_shrinker +-dnl # +-AC_DEFUN([SPL_AC_SET_SHRINKER], [ +- AC_MSG_CHECKING([whether set_shrinker() available]) +- SPL_LINUX_TRY_COMPILE([ +- #include +- ],[ +- return set_shrinker(DEFAULT_SEEKS, NULL); +- ],[ +- AC_MSG_RESULT([yes]) +- AC_DEFINE(HAVE_SET_SHRINKER, 1, +- [set_shrinker() available]) +- ],[ +- AC_MSG_RESULT([no]) +- ]) +-]) +- +-dnl # +-dnl # 2.6.35 API change, +-dnl # Add context to shrinker callback +-dnl # +-AC_DEFUN([SPL_AC_3ARGS_SHRINKER_CALLBACK], +- [AC_MSG_CHECKING([whether shrinker callback wants 3 args]) ++AC_DEFUN([SPL_AC_SHRINKER_CALLBACK],[ + tmp_flags="$EXTRA_KCFLAGS" + EXTRA_KCFLAGS="-Werror" ++ dnl # ++ dnl # 2.6.23 to 2.6.34 API change ++ dnl # ->shrink(int nr_to_scan, gfp_t gfp_mask) ++ dnl # ++ AC_MSG_CHECKING([whether old 2-argument shrinker exists]) + SPL_LINUX_TRY_COMPILE([ + #include + +- int shrinker_cb(struct shrinker *, int, unsigned int); ++ int shrinker_cb(int nr_to_scan, gfp_t gfp_mask); + ],[ + struct shrinker cache_shrinker = { + .shrink = shrinker_cb, +@@ -924,10 +904,86 @@ AC_DEFUN([SPL_AC_3ARGS_SHRINKER_CALLBACK], + register_shrinker(&cache_shrinker); + ],[ + AC_MSG_RESULT(yes) +- AC_DEFINE(HAVE_3ARGS_SHRINKER_CALLBACK, 1, +- [shrinker callback wants 3 args]) ++ AC_DEFINE(HAVE_2ARGS_OLD_SHRINKER_CALLBACK, 1, ++ [old shrinker callback wants 2 args]) + ],[ + AC_MSG_RESULT(no) ++ dnl # ++ dnl # 2.6.35 - 2.6.39 API change ++ dnl # ->shrink(struct shrinker *, ++ dnl # int nr_to_scan, gfp_t gfp_mask) ++ dnl # ++ AC_MSG_CHECKING([whether old 3-argument shrinker exists]) ++ SPL_LINUX_TRY_COMPILE([ ++ #include ++ ++ int shrinker_cb(struct shrinker *, int nr_to_scan, ++ gfp_t gfp_mask); ++ ],[ ++ struct shrinker cache_shrinker = { ++ .shrink = shrinker_cb, ++ .seeks = DEFAULT_SEEKS, ++ }; ++ register_shrinker(&cache_shrinker); ++ ],[ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_3ARGS_SHRINKER_CALLBACK, 1, ++ [old shrinker callback wants 3 args]) ++ ],[ ++ AC_MSG_RESULT(no) ++ dnl # ++ dnl # 3.0 - 3.11 API change ++ dnl # ->shrink(struct shrinker *, ++ dnl # struct shrink_control *sc) ++ dnl # ++ AC_MSG_CHECKING( ++ [whether new 2-argument shrinker exists]) ++ SPL_LINUX_TRY_COMPILE([ ++ #include ++ ++ int shrinker_cb(struct shrinker *, ++ struct shrink_control *sc); ++ ],[ ++ struct shrinker cache_shrinker = { ++ .shrink = shrinker_cb, ++ .seeks = DEFAULT_SEEKS, ++ }; ++ register_shrinker(&cache_shrinker); ++ ],[ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_2ARGS_NEW_SHRINKER_CALLBACK, 1, ++ [new shrinker callback wants 2 args]) ++ ],[ ++ AC_MSG_RESULT(no) ++ dnl # ++ dnl # 3.12 API change, ++ dnl # ->shrink() is logically split in to ++ dnl # ->count_objects() and ->scan_objects() ++ dnl # ++ AC_MSG_CHECKING( ++ [whether ->count_objects callback exists]) ++ SPL_LINUX_TRY_COMPILE([ ++ #include ++ ++ unsigned long shrinker_cb( ++ struct shrinker *, ++ struct shrink_control *sc); ++ ],[ ++ struct shrinker cache_shrinker = { ++ .count_objects = shrinker_cb, ++ .scan_objects = shrinker_cb, ++ .seeks = DEFAULT_SEEKS, ++ }; ++ register_shrinker(&cache_shrinker); ++ ],[ ++ AC_MSG_RESULT(yes) ++ AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK, ++ 1, [->count_objects exists]) ++ ],[ ++ AC_MSG_ERROR(error) ++ ]) ++ ]) ++ ]) + ]) + EXTRA_KCFLAGS="$tmp_flags" + ]) +diff --git a/include/linux/mm_compat.h b/include/linux/mm_compat.h +index cb1bef9..37c9b08 100644 +--- a/include/linux/mm_compat.h ++++ b/include/linux/mm_compat.h +@@ -148,107 +148,167 @@ extern shrink_icache_memory_t shrink_icache_memory_fn; + #endif /* HAVE_SHRINK_ICACHE_MEMORY */ + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Due to frequent changes in the shrinker API the following ++ * compatibility wrappers should be used. They are as follows: ++ * ++ * SPL_SHRINKER_DECLARE is used to declare the shrinker which is ++ * passed to spl_register_shrinker()/spl_unregister_shrinker(). Use ++ * shrinker_name to set the shrinker variable name, shrinker_callback ++ * to set the callback function, and seek_cost to define the cost of ++ * reclaiming an object. ++ * ++ * SPL_SHRINKER_DECLARE(shrinker_name, shrinker_callback, seek_cost); ++ * ++ * SPL_SHRINKER_CALLBACK_FWD_DECLARE is used when a forward declaration ++ * of the shrinker callback function is required. Only the callback ++ * function needs to be passed. ++ * ++ * SPL_SHRINKER_CALLBACK_FWD_DECLARE(shrinker_callback); ++ * ++ * SPL_SHRINKER_CALLBACK_WRAPPER is used to declare the callback function ++ * which is registered with the shrinker. This function will call your ++ * custom shrinker which must use the following prototype. Notice the ++ * leading __'s, these must be appended to the callback_function name. ++ * ++ * int __shrinker_callback(struct shrinker *, struct shrink_control *) ++ * SPL_SHRINKER_CALLBACK_WRAPPER(shrinker_callback);a ++ * ++ * ++ * Example: ++ * ++ * SPL_SHRINKER_CALLBACK_FWD_DECLARE(my_shrinker_fn); ++ * SPL_SHRINKER_DECLARE(my_shrinker, my_shrinker_fn, 1); ++ * ++ * static int ++ * __my_shrinker_fn(struct shrinker *shrink, struct shrink_control *sc) ++ * { ++ * if (sc->nr_to_scan) { ++ * ...scan objects in the cache and reclaim them... ++ * } ++ * ++ * ...calculate number of objects in the cache... ++ * ++ * return (number of objects in the cache); ++ * } ++ * SPL_SHRINKER_CALLBACK_WRAPPER(my_shrinker_fn); + */ +-#ifdef HAVE_SET_SHRINKER +-typedef struct spl_shrinker { +- struct shrinker *shrinker; +- shrinker_t fn; +- int seeks; +-} spl_shrinker_t; +- +-static inline void +-spl_register_shrinker(spl_shrinker_t *ss) +-{ +- ss->shrinker = set_shrinker(ss->seeks, ss->fn); +-} + +-static inline void +-spl_unregister_shrinker(spl_shrinker_t *ss) +-{ +- remove_shrinker(ss->shrinker); +-} ++#define spl_register_shrinker(x) register_shrinker(x) ++#define spl_unregister_shrinker(x) unregister_shrinker(x) + +-# define SPL_SHRINKER_DECLARE(s, x, y) \ +- static spl_shrinker_t s = { \ +- .shrinker = NULL, \ +- .fn = x, \ +- .seeks = y \ +- } +- +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(int, unsigned int) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(int nr_to_scan, unsigned int gfp_mask) \ +-{ \ +- struct shrink_control sc; \ +- \ +- sc.nr_to_scan = nr_to_scan; \ +- sc.gfp_mask = gfp_mask; \ +- \ +- return __ ## fn(NULL, &sc); \ ++/* ++ * Linux 2.6.23 - 2.6.34 Shrinker API Compatibility. ++ */ ++#if defined(HAVE_2ARGS_OLD_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .shrink = x, \ ++ .seeks = y \ + } + +-#else ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static int fn(int nr_to_scan, unsigned int gfp_mask) + +-# define spl_register_shrinker(x) register_shrinker(x) +-# define spl_unregister_shrinker(x) unregister_shrinker(x) +-# define SPL_SHRINKER_DECLARE(s, x, y) \ +- static struct shrinker s = { \ +- .shrink = x, \ +- .seeks = y \ +- } ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static int \ ++fn(int nr_to_scan, unsigned int gfp_mask) \ ++{ \ ++ struct shrink_control sc; \ ++ \ ++ sc.nr_to_scan = nr_to_scan; \ ++ sc.gfp_mask = gfp_mask; \ ++ \ ++ return (__ ## fn(NULL, &sc)); \ ++} + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Linux 2.6.35 to 2.6.39 Shrinker API Compatibility. + */ +-# if defined(HAVE_SHRINK_CONTROL_STRUCT) +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(struct shrinker *, struct shrink_control *) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(struct shrinker *shrink, struct shrink_control *sc) { \ +- return __ ## fn(shrink, sc); \ ++#elif defined(HAVE_3ARGS_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .shrink = x, \ ++ .seeks = y \ ++} ++ ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static int fn(struct shrinker *, int, unsigned int) ++ ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static int \ ++fn(struct shrinker *shrink, int nr_to_scan, unsigned int gfp_mask) \ ++{ \ ++ struct shrink_control sc; \ ++ \ ++ sc.nr_to_scan = nr_to_scan; \ ++ sc.gfp_mask = gfp_mask; \ ++ \ ++ return (__ ## fn(shrink, &sc)); \ + } + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Linux 3.0 to 3.11 Shrinker API Compatibility. + */ +-# elif defined(HAVE_3ARGS_SHRINKER_CALLBACK) +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(struct shrinker *, int, unsigned int) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(struct shrinker *shrink, int nr_to_scan, unsigned int gfp_mask) \ +-{ \ +- struct shrink_control sc; \ +- \ +- sc.nr_to_scan = nr_to_scan; \ +- sc.gfp_mask = gfp_mask; \ +- \ +- return __ ## fn(shrink, &sc); \ ++#elif defined(HAVE_2ARGS_NEW_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .shrink = x, \ ++ .seeks = y \ ++} ++ ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static int fn(struct shrinker *, struct shrink_control *) ++ ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static int \ ++fn(struct shrinker *shrink, struct shrink_control *sc) \ ++{ \ ++ return (__ ## fn(shrink, sc)); \ + } + + /* +- * Linux 2.6. - 2.6. Shrinker API Compatibility. ++ * Linux 3.12 and later Shrinker API Compatibility. + */ +-# else +-# define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ +- static int fn(int, unsigned int) +-# define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ +-static int \ +-fn(int nr_to_scan, unsigned int gfp_mask) \ +-{ \ +- struct shrink_control sc; \ +- \ +- sc.nr_to_scan = nr_to_scan; \ +- sc.gfp_mask = gfp_mask; \ +- \ +- return __ ## fn(NULL, &sc); \ ++#elif defined(HAVE_SPLIT_SHRINKER_CALLBACK) ++#define SPL_SHRINKER_DECLARE(s, x, y) \ ++static struct shrinker s = { \ ++ .count_objects = x ## _count_objects, \ ++ .scan_objects = x ## _scan_objects, \ ++ .seeks = y \ + } + +-# endif +-#endif /* HAVE_SET_SHRINKER */ ++#define SPL_SHRINKER_CALLBACK_FWD_DECLARE(fn) \ ++static unsigned long fn ## _count_objects(struct shrinker *, \ ++ struct shrink_control *); \ ++static unsigned long fn ## _scan_objects(struct shrinker *, \ ++ struct shrink_control *) ++ ++#define SPL_SHRINKER_CALLBACK_WRAPPER(fn) \ ++static unsigned long \ ++fn ## _count_objects(struct shrinker *shrink, struct shrink_control *sc)\ ++{ \ ++ int __ret__; \ ++ \ ++ sc->nr_to_scan = 0; \ ++ __ret__ = __ ## fn(NULL, sc); \ ++ \ ++ /* Errors may not be returned and must be converted to zeros */ \ ++ return ((__ret__ < 0) ? 0 : __ret__); \ ++} \ ++ \ ++static unsigned long \ ++fn ## _scan_objects(struct shrinker *shrink, struct shrink_control *sc) \ ++{ \ ++ int __ret__; \ ++ \ ++ __ret__ = __ ## fn(NULL, sc); \ ++ return ((__ret__ < 0) ? SHRINK_STOP : __ret__); \ ++} ++#else ++/* ++ * Linux 2.x to 2.6.22, or a newer shrinker API has been introduced. ++ */ ++#error "Unknown shrinker callback" ++#endif + + #endif /* SPL_MM_COMPAT_H */ diff --git a/zfs-utils/PKGBUILD b/zfs-utils/PKGBUILD index e4573b2..f6ae818 100644 --- a/zfs-utils/PKGBUILD +++ b/zfs-utils/PKGBUILD @@ -11,7 +11,7 @@ pkgname=("zfs-utils") # The build script can be found at # https://github.com/demizer/archzfs/blob/master/build.sh # -pkgver=0.6.2_3.11.6 +pkgver=0.6.2_3.12 pkgrel=3 pkgdesc="Kernel module support files for the Zettabyte File System." depends=("spl") diff --git a/zfs/PKGBUILD b/zfs/PKGBUILD index d6a6763..5ebcc67 100644 --- a/zfs/PKGBUILD +++ b/zfs/PKGBUILD @@ -11,11 +11,11 @@ pkgname=("zfs") # The build script can be found at # https://github.com/demizer/archzfs/blob/master/build.sh # -pkgver=0.6.2_3.11.6 +pkgver=0.6.2_3.12 pkgrel=3 pkgdesc="Kernel modules for the Zettabyte File System." -depends=("spl=0.6.2_3.11.6-3" "zfs-utils" "linux=3.11.6-1") -makedepends=("linux-headers=3.11.6-1") +depends=("spl=0.6.2_3.12-3" "zfs-utils" "linux=3.12-1") +makedepends=("linux-headers=3.12-1") arch=("i686" "x86_64") url="http://zfsonlinux.org/" source=(http://archive.zfsonlinux.org/downloads/zfsonlinux/zfs/zfs-0.6.2.tar.gz)