From b44170bf319f7aa387742d45bcb64d9542e710dd Mon Sep 17 00:00:00 2001 From: Rafael Kitover Date: Thu, 23 May 2019 14:40:28 -0700 Subject: [PATCH] kernel timer API rework In `config/kernel-timer.m4` refactor slightly to check more generally for the new `timer_setup()` APIs, but also check the callback signature because some kernels (notably 4.14) have the new `timer_setup()` API but use the old callback signature. Also add a check for a `flags` member in `struct timer_list`, which was added in 4.1-rc8. Add compatibility shims to `include/spl/sys/timer.h` to allow using the new timer APIs with the only two caveats being that the callback argument type must be declared as `spl_timer_list_t` and an explicit assignment is required to get the timer variable for the `timer_of()` macro. So the callback would look like this: ```c __cv_wakeup(spl_timer_list_t t) { struct timer_list *tmr = (struct timer_list *)t; struct thing *parent = from_timer(parent, tmr, parent_timer_field); ... /* do stuff with parent */ ``` Make some minor changes to `spl-condvar.c` and `spl-taskq.c` to use the new timer APIs instead of conditional code. Reviewed-by: Tomohiro Kusumi Reviewed-by: Brian Behlendorf Signed-off-by: Rafael Kitover Closes #8647 --- config/kernel-timer.m4 | 63 +++++++++++++++++++++++++------ config/kernel.m4 | 2 +- include/os/linux/spl/sys/timer.h | 25 ++++++++++++ module/os/linux/spl/spl-condvar.c | 29 ++++++++++---- module/os/linux/spl/spl-taskq.c | 24 ++---------- 5 files changed, 103 insertions(+), 40 deletions(-) diff --git a/config/kernel-timer.m4 b/config/kernel-timer.m4 index 4dc3f84ed47e..b0e1afa153ab 100644 --- a/config/kernel-timer.m4 +++ b/config/kernel-timer.m4 @@ -1,26 +1,51 @@ +dnl # 4.14-rc3 API change +dnl # https://lwn.net/Articles/735887/ dnl # -dnl # 4.15 API change -dnl # https://lkml.org/lkml/2017/11/25/90 dnl # Check if timer_list.func get passed a timer_list or an unsigned long dnl # (older kernels). Also sanity check the from_timer() and timer_setup() dnl # macros are available as well, since they will be used in the same newer dnl # kernels that support the new timer_list.func signature. dnl # -AC_DEFUN([ZFS_AC_KERNEL_TIMER_FUNCTION_TIMER_LIST], [ - AC_MSG_CHECKING([whether timer_list.function gets a timer_list]) +dnl # Also check for the existance of flags in struct timer_list, they were +dnl # added in 4.1-rc8 via 0eeda71bc30d. + +AC_DEFUN([ZFS_AC_KERNEL_TIMER_SETUP], [ + AC_MSG_CHECKING([whether timer_setup() is available]) tmp_flags="$EXTRA_KCFLAGS" EXTRA_KCFLAGS="-Werror" + ZFS_LINUX_TRY_COMPILE([ #include - void task_expire(struct timer_list *tl) {} + + struct my_task_timer { + struct timer_list timer; + int data; + }; + + void task_expire(struct timer_list *tl) + { + struct my_task_timer *task_timer = from_timer(task_timer, tl, timer); + task_timer->data = 42; + } + ],[ + struct my_task_timer task_timer; + timer_setup(&task_timer.timer, task_expire, 0); ],[ - #ifndef from_timer - #error "No from_timer() macro" - #endif + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_KERNEL_TIMER_SETUP, 1, + [timer_setup() is available]) + ],[ + AC_MSG_RESULT(no) + ]) - struct timer_list timer; - timer.function = task_expire; - timer_setup(&timer, NULL, 0); + AC_MSG_CHECKING([whether timer function expects timer_list]) + + ZFS_LINUX_TRY_COMPILE([ + #include + void task_expire(struct timer_list *tl) {} + ],[ + struct timer_list tl; + tl.function = task_expire; ],[ AC_MSG_RESULT(yes) AC_DEFINE(HAVE_KERNEL_TIMER_FUNCTION_TIMER_LIST, 1, @@ -28,5 +53,21 @@ AC_DEFUN([ZFS_AC_KERNEL_TIMER_FUNCTION_TIMER_LIST], [ ],[ AC_MSG_RESULT(no) ]) + + AC_MSG_CHECKING([whether struct timer_list has flags]) + + ZFS_LINUX_TRY_COMPILE([ + #include + ],[ + struct timer_list tl; + tl.flags = 2; + ],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_KERNEL_TIMER_LIST_FLAGS, 1, + [struct timer_list has a flags member]) + ],[ + AC_MSG_RESULT(no) + ]) + EXTRA_KCFLAGS="$tmp_flags" ]) diff --git a/config/kernel.m4 b/config/kernel.m4 index 9d720d3c45ce..884f3401ca76 100644 --- a/config/kernel.m4 +++ b/config/kernel.m4 @@ -38,7 +38,7 @@ AC_DEFUN([ZFS_AC_CONFIG_KERNEL], [ ZFS_AC_KERNEL_GROUP_INFO_GID ZFS_AC_KERNEL_WRITE ZFS_AC_KERNEL_READ - ZFS_AC_KERNEL_TIMER_FUNCTION_TIMER_LIST + ZFS_AC_KERNEL_TIMER_SETUP ZFS_AC_KERNEL_DECLARE_EVENT_CLASS ZFS_AC_KERNEL_CURRENT_BIO_TAIL ZFS_AC_KERNEL_SUPER_USER_NS diff --git a/include/os/linux/spl/sys/timer.h b/include/os/linux/spl/sys/timer.h index a6b134570cd8..31d89d3b97d6 100644 --- a/include/os/linux/spl/sys/timer.h +++ b/include/os/linux/spl/sys/timer.h @@ -72,4 +72,29 @@ usleep_range(unsigned long min, unsigned long max) #define USEC_TO_TICK(us) usecs_to_jiffies(us) #define NSEC_TO_TICK(ns) usecs_to_jiffies(ns / NSEC_PER_USEC) +#ifndef from_timer +#define from_timer(var, timer, timer_field) \ + container_of(timer, typeof(*var), timer_field) +#endif + +#ifdef HAVE_KERNEL_TIMER_FUNCTION_TIMER_LIST +typedef struct timer_list *spl_timer_list_t; +#else +typedef unsigned long spl_timer_list_t; +#endif + +#ifndef HAVE_KERNEL_TIMER_SETUP + +static inline void +timer_setup(struct timer_list *timer, void (*func)(spl_timer_list_t), u32 fl) +{ +#ifdef HAVE_KERNEL_TIMER_LIST_FLAGS + (timer)->flags = fl; +#endif + init_timer(timer); + setup_timer(timer, func, (spl_timer_list_t)(timer)); +} + +#endif /* HAVE_KERNEL_TIMER_SETUP */ + #endif /* _SPL_TIMER_H */ diff --git a/module/os/linux/spl/spl-condvar.c b/module/os/linux/spl/spl-condvar.c index 1e6e38b7874b..a7a9d1db9a98 100644 --- a/module/os/linux/spl/spl-condvar.c +++ b/module/os/linux/spl/spl-condvar.c @@ -154,26 +154,39 @@ EXPORT_SYMBOL(__cv_wait_sig); #if defined(HAVE_IO_SCHEDULE_TIMEOUT) #define spl_io_schedule_timeout(t) io_schedule_timeout(t) #else + +struct spl_task_timer { + struct timer_list timer; + struct task_struct *task; +}; + static void -__cv_wakeup(unsigned long data) +__cv_wakeup(spl_timer_list_t t) { - wake_up_process((struct task_struct *)data); + struct timer_list *tmr = (struct timer_list *)t; + struct spl_task_timer *task_timer = from_timer(task_timer, tmr, timer); + + wake_up_process(task_timer->task); } static long spl_io_schedule_timeout(long time_left) { long expire_time = jiffies + time_left; - struct timer_list timer; + struct spl_task_timer task_timer; + struct timer_list *timer = &task_timer.timer; + + task_timer.task = current; - init_timer(&timer); - setup_timer(&timer, __cv_wakeup, (unsigned long)current); - timer.expires = expire_time; - add_timer(&timer); + timer_setup(timer, __cv_wakeup, 0); + + timer->expires = expire_time; + add_timer(timer); io_schedule(); - del_timer_sync(&timer); + del_timer_sync(timer); + time_left = expire_time - jiffies; return (time_left < 0 ? 0 : time_left); diff --git a/module/os/linux/spl/spl-taskq.c b/module/os/linux/spl/spl-taskq.c index 7684257be7ad..a39f94e4cc20 100644 --- a/module/os/linux/spl/spl-taskq.c +++ b/module/os/linux/spl/spl-taskq.c @@ -24,6 +24,7 @@ * Solaris Porting Layer (SPL) Task Queue Implementation. */ +#include #include #include #include @@ -242,20 +243,13 @@ task_expire_impl(taskq_ent_t *t) wake_up(&tq->tq_work_waitq); } -#ifdef HAVE_KERNEL_TIMER_FUNCTION_TIMER_LIST static void -task_expire(struct timer_list *tl) +task_expire(spl_timer_list_t tl) { - taskq_ent_t *t = from_timer(t, tl, tqent_timer); + struct timer_list *tmr = (struct timer_list *)tl; + taskq_ent_t *t = from_timer(t, tmr, tqent_timer); task_expire_impl(t); } -#else -static void -task_expire(unsigned long data) -{ - task_expire_impl((taskq_ent_t *)data); -} -#endif /* * Returns the lowest incomplete taskqid_t. The taskqid_t may @@ -597,9 +591,6 @@ taskq_dispatch(taskq_t *tq, task_func_t func, void *arg, uint_t flags) t->tqent_func = func; t->tqent_arg = arg; t->tqent_taskq = tq; -#ifndef HAVE_KERNEL_TIMER_FUNCTION_TIMER_LIST - t->tqent_timer.data = 0; -#endif t->tqent_timer.function = NULL; t->tqent_timer.expires = 0; t->tqent_birth = jiffies; @@ -649,9 +640,6 @@ taskq_dispatch_delay(taskq_t *tq, task_func_t func, void *arg, t->tqent_func = func; t->tqent_arg = arg; t->tqent_taskq = tq; -#ifndef HAVE_KERNEL_TIMER_FUNCTION_TIMER_LIST - t->tqent_timer.data = (unsigned long)t; -#endif t->tqent_timer.function = task_expire; t->tqent_timer.expires = (unsigned long)expire_time; add_timer(&t->tqent_timer); @@ -744,11 +732,7 @@ taskq_init_ent(taskq_ent_t *t) { spin_lock_init(&t->tqent_lock); init_waitqueue_head(&t->tqent_waitq); -#ifdef HAVE_KERNEL_TIMER_FUNCTION_TIMER_LIST timer_setup(&t->tqent_timer, NULL, 0); -#else - init_timer(&t->tqent_timer); -#endif INIT_LIST_HEAD(&t->tqent_list); t->tqent_id = 0; t->tqent_func = NULL;