posix-timers: Cure the SIG_IGN mess
Subsystems (12)
v4 cover posix-timers: Cure the SIG_IGN mess
This are the remaining bits to cure the SIG_IGN mess. The preparatory work from the previous version 3 has been merged already. Version 3 can be found here:
https://lore.kernel.org/lkml/[email protected]
Last year I reread a 15 years old comment about the SIG_IGN problem:
"FIXME: What we really want, is to stop this timer completely and restart
it in case the SIG_IGN is removed. This is a non trivial change which involves sighand locking (sigh !), which we don't want to do late in the release cycle. ... A more complex fix which solves also another related inconsistency is already in the pipeline."
The embarrasing part was that I put that comment in back then. So I went back and rumaged through old notes as I completely had forgotten why our attempts to fix this back then failed.
It turned out that the comment is about right: sighand locking and life time issues. So I sat down with the old notes and started to wrap my head around this again.
The problem to solve:
Posix interval timers are not rearmed automatically by the kernel for various reasons:
1) To prevent DoS by extremly short intervals.
2) To avoid timer overhead when a signal is pending and has not yet been delivered.
This is achieved by queueing the signal at timer expiry and rearming the timer at signal delivery to user space. This puts the rearming basically under scheduler control and the work happens in context of the task which asked for the signal.
There is a problem with that vs. SIG_IGN. If a signal has SIG_IGN installed as handler, the related signals are discarded. So in case of posix interval timers this means that such a timer is never rearmed even when SIG_IGN is replaced later with a real handler (including SIG_DFL).
To work around that the kernel self rearms those timers and throttles them when the interval is smaller than a tick to prevent a DoS.
That just keeps timers ticking, which obviously has effects on power and just creates work for nothing.
So ideally these timers should be stopped and rearmed when SIG_IGN is replaced, which aligns with the regular handling of posix timers.
Sounds trivial, but isn't:
1) Lock ordering.
The timer lock cannot be taken with sighand lock held which is problematic vs. the atomicity of sigaction().
2) Life time rules
The timer and the sigqueue are separate entities which requires a lookup of the timer ID in the signal rearm code. This can be handled, but the separate life time rules are not necessarily robust.
3) Finding the relevant timers
Obviosly it is possible to walk the posix timer list under sighand lock and handle it from there. That can be expensive especially in the case that there are no affected timers as the walk would just end up doing nothing.
The following series is a new and this time actually working attempt to solve this. It addresses it by:
1) Embedding the preallocated sigqueue into struct k_itimer, which makes the life time rules way simpler and just needs a trivial reference count.
2) Having a separate list in task::signal on which ignored timers are queued.
This avoids walking a potentially large timer list for nothing on a SIG_IGN to handler transition.
3) Requeueing the timers signal in the relevant signal queue so the timer is rearmed when the signal is actually delivered
That turned out to be the least complicated way to address the sighand lock vs. timer lock ordering issue.
With that timers which have their signal ignored are not longer self rearmed and the relevant workarounds including throttling for DoS prevention are removed.
The series is also available from git:
git://git.kernel.org/pub/scm/linux/kernel/git/tglx/devel.git posixt-v4
Changes vs. V3:
- Rebased to mainline
- Fixed up a intermediate build breakage reported by 0-day
Thanks,
tglx
--- arch/x86/kernel/signal_32.c | 2 arch/x86/kernel/signal_64.c | 2 drivers/power/supply/charger-manager.c | 3 fs/proc/base.c | 4 fs/timerfd.c | 4 include/linux/alarmtimer.h | 10 include/linux/posix-timers.h | 67 +++- include/linux/sched/signal.h | 4 include/uapi/asm-generic/siginfo.h | 2 init/init_task.c | 5 kernel/fork.c | 1 kernel/signal.c | 476 +++++++++++++++++++-------------- kernel/time/alarmtimer.c | 87 ------ kernel/time/itimer.c | 22 + kernel/time/posix-cpu-timers.c | 38 +- kernel/time/posix-timers.c | 227 +++++++-------- kernel/time/posix-timers.h | 8 net/netfilter/xt_IDLETIMER.c | 4 18 files changed, 523 insertions(+), 443 deletions(-)
PATCH v4 1/27 signal: Confine POSIX_TIMERS properly
From: Thomas Gleixner <[email protected]>
Move the itimer rearming out of the signal code and consolidate all posix timer related functions in the signal code under one ifdef.
--- include/linux/posix-timers.h | 5 +- kernel/signal.c | 125 +++++++++++++++----------------------------- kernel/time/itimer.c | 22 +++++++- kernel/time/posix-timers.c | 15 ++++- 4 files changed, 81 insertions(+), 86 deletions(-)
---
include/linux/posix-timers.h +4 -1
@@ -100,6 +100,8 @@ static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct, { pct->bases[CPUCLOCK_SCHED ].nextevt = runtime; } +void posixtimer_rearm_itimer (struct task_struct *p); +void posixtimer_rearm (struct kernel_siginfo *info);/* Init task static initializer */ #define INIT_CPU_TIMERBASE (b) { \
@@ -122,6 +124,8 @@ struct cpu_timer { };static inline void posix_cputimers_init (struct posix_cputimers *pct) { }static inline void posix_cputimers_group_init (struct posix_cputimers *pct,u64 cpu_limit) { } +static inline void posixtimer_rearm_itimer (struct task_struct *p) { } +static inline void posixtimer_rearm (struct kernel_siginfo *info) { }#endif #ifdef CONFIG_POSIX_CPU_TIMERS_TASK_WORK
@@ -196,5 +200,4 @@ void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,int update_rlimit_cpu (struct task_struct *task,unsigned long rlim_new); -void posixtimer_rearm (struct kernel_siginfo *info);#endif
kernel/signal.c +43 -82
159 lines not on this page · raw message
kernel/time/itimer.c +21 -1
@@ -151,7 +151,27 @@ COMPAT_SYSCALL_DEFINE2(getitimer, int, which,#endif /* -* The timer is automagically restarted, when interval != 0 +* Invoked from dequeue_signal() when SIG_ALRM is delivered. +* +* Restart the ITIMER_REAL timer if it is armed as periodic timer. Doing +* this in the signal delivery path instead of self rearming prevents a DoS +* with small increments in the high reolution timer case and reduces timer +* noise in general. +*/ +void posixtimer_rearm_itimer (struct task_struct *tsk) +{ +struct hrtimer *tmr = &tsk->signal->real_timer; + +if (!hrtimer_is_queued (tmr) && tsk->signal->it_real_incr !=0 ) { +hrtimer_forward (tmr, tmr->base->get_time (), + tsk->signal->it_real_incr); +hrtimer_restart (tmr); + } +} + +/* +* Interval timers are restarted in the signal delivery path. See +* posixtimer_rearm_itimer(). */ enum hrtimer_restart it_real_fn (struct hrtimer *timer) {
kernel/time/posix-timers.c +13 -2
@@ -251,7 +251,7 @@ static void common_hrtimer_rearm(struct k_itimer *timr)/* * This function is called from the signal delivery code if -* info->si_sys_private is not zero, which indicates that the timer has to +* info::si_sys_private is not zero, which indicates that the timer has to * be rearmed. Restart the timer and update info::si_overrun. */ void posixtimer_rearm (struct kernel_siginfo *info)
@@ -259,9 +259,15 @@ void posixtimer_rearm(struct kernel_siginfo *info)struct k_itimer *timr;unsigned long flags; +/* +* Release siglock to ensure proper locking order versus +* timr::it_lock. Keep interrupts disabled. +*/ +spin_unlock (¤t->sighand->siglock); + timr =lock_timer (info->si_tid, &flags);if (!timr) -return ; + goto out;if (timr->it_interval && timr->it_requeue_pending == info->si_sys_private) { timr->kclock->timer_rearm (timr);
@@ -275,6 +281,11 @@ void posixtimer_rearm(struct kernel_siginfo *info) }unlock_timer (timr, flags); +out: +spin_lock (¤t->sighand->siglock); + +/* Don't expose the si_sys_private value to userspace */ + info->si_sys_private =0 ; }int posix_timer_queue_signal (struct k_itimer *timr)
Re: [patch v4 01/27] signal: Confine POSIX_TIMERS properly
Quoted 7 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
Move the itimer rearming out of the signal code and consolidate all posix timer related functions in the signal code under one ifdef.
Signed-off-by Thomas Gleixner <[email protected]>
PATCH v4 2/27 signal: Prevent user space from setting si_sys_private
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
The si_sys_private member of siginfo is used to handle posix-timer rearming from the signal delivery path. Prevent user space from setting it as that creates inconsistent state.
--- kernel/signal.c | 8 ++++++++ 1 file changed, 8 insertions(+)
---
kernel/signal.c +8 -0
@@ -3354,6 +3354,14 @@ int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from)static int post_copy_siginfo_from_user (kernel_siginfo_t *info,const siginfo_t __user *from) { +/* +* Clear the si_sys_private field for timer signals as that's the +* indicator for rearming a posix timer. User space submitted +* signals are not allowed to inject that. +*/ +if (info->si_code ==SI_TIMER ) + info->si_sys_private =0 ; +if (unlikely (!known_siginfo_layout (info->si_signo, info->si_code))) {char __user *expansion =si_expansion (from);char buf[SI_EXPANSION_SIZE ];
Re: [patch v4 02/27] signal: Prevent user space from setting si_sys_private
Quoted 8 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
The
si_sys_privatemember of siginfo is used to handle posix-timer rearming from the signal delivery path. Prevent user space from setting it as that creates inconsistent state.Signed-off-by Thomas Gleixner <[email protected]>
Funny that this field is exposed to userspace.
Anyway:
Re: [patch v4 02/27] signal: Prevent user space from setting si_sys_private
In reply to Thomas GleixnerQuoted 22 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
The
si_sys_privatemember of siginfo is used to handle posix-timer rearming from the signal delivery path. Prevent user space from setting it as that creates inconsistent state.Signed-off-by Thomas Gleixner <[email protected]>--- kernel/signal.c | 8 ++++++++ 1 file changed, 8 insertions(+)---
kernel/signal.c +1
-0@@ -3354,6 +3354,14 @@ int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from)static int post_copy_siginfo_from_user (kernel_siginfo_t *info,const siginfo_t __user *from) { +/*
kernel/signal.c int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from) · line 3367
Quoted 10 lines
kernel/signal.c +7
-0+* Clear the si_sys_private field for timer signals as that's the +* indicator for rearming a posix timer. User space submitted +* signals are not allowed to inject that. +*/ +if (info->si_code ==SI_TIMER ) + info->si_sys_private =0 ; +if (unlikely (!known_siginfo_layout (info->si_signo, info->si_code))) {char __user *expansion =si_expansion (from);char buf[SI_EXPANSION_SIZE ];
Can we do this differently for maintainability? The siginfo union sucks to deal with.
Can we place this test after the !known_siginfo_layout test.
Can you further make the case say something like:
if ((siginfo_layout(info->si_signo, info->si_code) == SIL_TIMER) &&
(info->si_sys_private != 0)) {
return -EINVAL?
}Using siginfo_layout is slightly more expensive but it will catch any future oddness that comes up, and I don't think signal injection is a path where we need to optimize every last cycle.
Unless we expect userspace to be injecting signals with info->si_sys_private set to non-zero (and we need to maintain backwards comparability) it is probably better to simply error.
I unfortunately overlooked this corner case when I cleaned up signal copying.
Eric
PATCH v4 3/27 signal: Get rid of resched_timer logic
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
There is no reason for handing the *resched pointer argument through several functions just to check whether the signal is related to a self rearming posix timer.
SI_TIMER is only used by the posix timer code and cannot be queued from user space. The only extra check in collect_signal() to verify whether the queued signal is preallocated is not really useful. Some other places already check purely the SI_TIMER type.
--- kernel/signal.c | 25 +++++++++---------------- 1 file changed, 9 insertions(+), 16 deletions(-)
---
kernel/signal.c +9 -16
@@ -526,8 +526,7 @@ bool unhandled_signal(struct task_struct *tsk, int sig)return !tsk->ptrace; } -static void collect_signal (int sig,struct sigpending *list,kernel_siginfo_t *info, -bool *resched_timer) +static void collect_signal (int sig,struct sigpending *list,kernel_siginfo_t *info) {struct sigqueue *q, *first =NULL ;
@@ -549,12 +548,6 @@ static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *i still_pending:list_del_init (&first->list);copy_siginfo (info, &first->info); - - *resched_timer = - (first->flags &SIGQUEUE_PREALLOC ) && - (info->si_code ==SI_TIMER ) && - (info->si_sys_private); -__sigqueue_free (first); }else {/*
@@ -571,13 +564,12 @@ static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *i } } -static int __dequeue_signal (struct sigpending *pending,sigset_t *mask, -kernel_siginfo_t *info,bool *resched_timer) +static int __dequeue_signal (struct sigpending *pending,sigset_t *mask,kernel_siginfo_t *info) {int sig =next_signal (pending, mask);if (sig) -collect_signal (sig, pending, info, resched_timer); +collect_signal (sig, pending, info);return sig; }
@@ -589,17 +581,15 @@ static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,int dequeue_signal (sigset_t *mask,kernel_siginfo_t *info,enum pid_type *type) {struct task_struct *tsk = current; -bool resched_timer = false;int signr;lockdep_assert_held (&tsk->sighand->siglock); *type =PIDTYPE_PID ; - signr =__dequeue_signal (&tsk->pending, mask, info, &resched_timer); + signr =__dequeue_signal (&tsk->pending, mask, info);if (!signr) { *type =PIDTYPE_TGID ; - signr =__dequeue_signal (&tsk->signal->shared_pending, - mask, info, &resched_timer); + signr =__dequeue_signal (&tsk->signal->shared_pending, mask, info);if (unlikely (signr ==SIGALRM ))posixtimer_rearm_itimer (tsk);
@@ -626,7 +616,7 @@ int dequeue_signal(sigset_t *mask, kernel_siginfo_t *info, enum pid_type *type) }if (IS_ENABLED (CONFIG_POSIX_TIMERS )) { -if (unlikely (resched_timer)) +if (unlikely (info->si_code ==SI_TIMER && info->si_sys_private))posixtimer_rearm (info); }
@@ -1011,6 +1001,9 @@ static int __send_signal_locked(int sig, struct kernel_siginfo *info,lockdep_assert_held (&t->sighand->siglock); +if (WARN_ON_ONCE (!is_si_special (info) && info->si_code ==SI_TIMER )) +return 0 ; + result =TRACE_SIGNAL_IGNORED ;if (!prepare_signal (sig, t, force)) goto ret;
Re: [patch v4 03/27] signal: Get rid of resched_timer logic
Quoted 6 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
There is no reason for handing the *resched pointer argument through several functions just to check whether the signal is related to a self rearming posix timer.
Quoted 7 lines
SI_TIMERis only used by the posix timer code and cannot be queued from user space. The only extra check incollect_signal()to verify whether the queued signal is preallocated is not really useful. Some other places already check purely theSI_TIMERtype.Signed-off-by Thomas Gleixner <[email protected]>
Re: [patch v4 03/27] signal: Get rid of resched_timer logic
In reply to Thomas GleixnerQuoted 8 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
There is no reason for handing the *resched pointer argument through several functions just to check whether the signal is related to a self rearming posix timer.
SI_TIMERis only used by the posix timer code and cannot be queued from user space.
Huh??? We have rt_sigqueueinfo. You just touched the code that copies the queued signal from userspace.
Quoted 3 lines
The only extra check in
collect_signal()to verify whether the queued signal is preallocated is not really useful. Some other places already check purely theSI_TIMERtype.
The check to see if the signal was preallocated prevents shenanigans with setting si_sys_private.
That is today you can queue a signal with rt_sigqueueinfo and set si_sys_private and it will make it to userspace. I don't know how much we care but that is the case.
Which means that WARN_ON you added in __send_signal_locked can most definitely be triggered by userspace.
Eric
Quoted 89 lines
Signed-off-by Thomas Gleixner <[email protected]>--- kernel/signal.c | 25 +++++++++---------------- 1 file changed, 9 insertions(+), 16 deletions(-)---
kernel/signal.c +9
-16@@ -526,8 +526,7 @@ bool unhandled_signal(struct task_struct *tsk, int sig)return !tsk->ptrace; } -static void collect_signal (int sig,struct sigpending *list,kernel_siginfo_t *info, -bool *resched_timer) +static void collect_signal (int sig,struct sigpending *list,kernel_siginfo_t *info) {struct sigqueue *q, *first =NULL ;@@ -549,12 +548,6 @@ static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *i still_pending:list_del_init (&first->list);copy_siginfo (info, &first->info); - - *resched_timer = - (first->flags &SIGQUEUE_PREALLOC ) && - (info->si_code ==SI_TIMER ) && - (info->si_sys_private); -__sigqueue_free (first); }else {/* @@ -571,13 +564,12 @@ static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *i } } -static int __dequeue_signal (struct sigpending *pending,sigset_t *mask, -kernel_siginfo_t *info,bool *resched_timer) +static int __dequeue_signal (struct sigpending *pending,sigset_t *mask,kernel_siginfo_t *info) {int sig =next_signal (pending, mask);if (sig) -collect_signal (sig, pending, info, resched_timer); +collect_signal (sig, pending, info);return sig; }@@ -589,17 +581,15 @@ static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,int dequeue_signal (sigset_t *mask,kernel_siginfo_t *info,enum pid_type *type) {struct task_struct *tsk = current; -bool resched_timer = false;int signr;lockdep_assert_held (&tsk->sighand->siglock); *type =PIDTYPE_PID ; - signr =__dequeue_signal (&tsk->pending, mask, info, &resched_timer); + signr =__dequeue_signal (&tsk->pending, mask, info);if (!signr) { *type =PIDTYPE_TGID ; - signr =__dequeue_signal (&tsk->signal->shared_pending, - mask, info, &resched_timer); + signr =__dequeue_signal (&tsk->signal->shared_pending, mask, info);if (unlikely (signr ==SIGALRM ))posixtimer_rearm_itimer (tsk);@@ -626,7 +616,7 @@ int dequeue_signal(sigset_t *mask, kernel_siginfo_t *info, enum pid_type *type) }if (IS_ENABLED (CONFIG_POSIX_TIMERS )) { -if (unlikely (resched_timer)) +if (unlikely (info->si_code ==SI_TIMER && info->si_sys_private))posixtimer_rearm (info); }@@ -1011,6 +1001,9 @@ static int __send_signal_locked(int sig, struct kernel_siginfo *info,lockdep_assert_held (&t->sighand->siglock); +if (WARN_ON_ONCE (!is_si_special (info) && info->si_code ==SI_TIMER )) +return 0 ; + result =TRACE_SIGNAL_IGNORED ;if (!prepare_signal (sig, t, force)) goto ret;
PATCH v4 4/27 posix-timers: Cure si_sys_private race
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
The si_sys_private member of the siginfo which is embedded in the preallocated sigqueue is used by the posix timer code to decide whether a timer must be reprogrammed on signal delivery.
The handling of this is racy as a long standing comment in that code documents. It is modified with the timer lock held, but without sighand lock being held. The actual signal delivery code checks for it under sighand lock without holding the timer lock.
Hand the new value to send_sigqueue() as argument and store it with sighand lock held.
--- include/linux/sched/signal.h | 2 +- kernel/signal.c | 10 +++++++++- kernel/time/posix-timers.c | 15 +-------------- 3 files changed, 11 insertions(+), 16 deletions(-)
---
include/linux/sched/signal.h +1 -1
@@ -340,7 +340,7 @@ extern int send_sig(int, struct task_struct *, int);extern int zap_other_threads (struct task_struct *p);extern struct sigqueue *sigqueue_alloc (void );extern void sigqueue_free (struct sigqueue *); -extern int send_sigqueue (struct sigqueue *,struct pid *,enum pid_type ); +extern int send_sigqueue (struct sigqueue *,struct pid *,enum pid_type ,int si_private);extern int do_sigaction (int ,struct k_sigaction *,struct k_sigaction *);static inline void clear_notify_signal (void )
kernel/signal.c +9 -1
@@ -1915,7 +1915,7 @@ void sigqueue_free(struct sigqueue *q)__sigqueue_free (q); } -int send_sigqueue (struct sigqueue *q,struct pid *pid,enum pid_type type) +int send_sigqueue (struct sigqueue *q,struct pid *pid,enum pid_type type,int si_private) {int sig = q->info.si_signo;struct sigpending *pending;
@@ -1950,6 +1950,14 @@ int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)if (!likely (lock_task_sighand (t, &flags))) goto ret; +/* +* Update @q::info::si_sys_private for posix timer signals with +* sighand locked to prevent a race against dequeue_signal() which +* decides based on si_sys_private whether to invoke +* posixtimer_rearm() or not. +*/ + q->info.si_sys_private = si_private; + ret =1 ;/* the signal is ignored */ result =TRACE_SIGNAL_IGNORED ;if (!prepare_signal (sig, t, false))
kernel/time/posix-timers.c +1 -14
@@ -299,21 +299,8 @@ int posix_timer_queue_signal(struct k_itimer *timr)if (timr->it_interval) si_private = ++timr->it_requeue_pending; -/* -* FIXME: if ->sigq is queued we can race with -* dequeue_signal()->posixtimer_rearm(). -* -* If dequeue_signal() sees the "right" value of -* si_sys_private it calls posixtimer_rearm(). -* We re-queue ->sigq and drop ->it_lock(). -* posixtimer_rearm() locks the timer -* and re-schedules it while ->sigq is pending. -* Not really bad, but not that we want. -*/ - timr->sigq->info.si_sys_private = si_private; - type = !(timr->it_sigev_notify &SIGEV_THREAD_ID ) ?PIDTYPE_TGID :PIDTYPE_PID ; - ret =send_sigqueue (timr->sigq, timr->it_pid, type); + ret =send_sigqueue (timr->sigq, timr->it_pid, type, si_private);/* If we failed to send the signal the timer stops. */ return ret >0 ; }
Re: [patch v4 04/27] posix-timers: Cure si_sys_private race
Quoted 10 lines · Thomas Gleixner
From: Thomas Gleixner <[email protected]>
The
si_sys_privatemember of the siginfo which is embedded in the preallocated sigqueue is used by the posix timer code to decide whether a timer must be reprogrammed on signal delivery.The handling of this is racy as a long standing comment in that code documents. It is modified with the timer lock held, but without sighand lock being held. The actual signal delivery code checks for it under sighand lock without holding the timer lock.
I suspect this falls under the ancient all integers are atomic rule in practice.
Quoted 2 lines
Hand the new value to
send_sigqueue()as argument and store it with sighand lock held.
Is there any way we can simply remove the hack of using si_sys_private, and use a field in the structure that contains the preallocated signal?
I don't have any issues with updating send_siqueue so that the locking is consistent. However can we possibly name the argument something like it_requeue_pending instead of si_private?
Eric
Quoted 77 lines
Signed-off-by Thomas Gleixner <[email protected]>--- include/linux/sched/signal.h | 2 +- kernel/signal.c | 10 +++++++++- kernel/time/posix-timers.c | 15 +-------------- 3 files changed, 11 insertions(+), 16 deletions(-)---
include/linux/sched/signal.h +1
-1@@ -340,7 +340,7 @@ extern int send_sig(int, struct task_struct *, int);extern int zap_other_threads (struct task_struct *p);extern struct sigqueue *sigqueue_alloc (void );extern void sigqueue_free (struct sigqueue *); -extern int send_sigqueue (struct sigqueue *,struct pid *,enum pid_type ); +extern int send_sigqueue (struct sigqueue *,struct pid *,enum pid_type ,int si_private);extern int do_sigaction (int ,struct k_sigaction *,struct k_sigaction *);static inline void clear_notify_signal (void )kernel/signal.c +9
-1@@ -1915,7 +1915,7 @@ void sigqueue_free(struct sigqueue *q)__sigqueue_free (q); } -int send_sigqueue (struct sigqueue *q,struct pid *pid,enum pid_type type) +int send_sigqueue (struct sigqueue *q,struct pid *pid,enum pid_type type,int si_private) {int sig = q->info.si_signo;struct sigpending *pending;@@ -1950,6 +1950,14 @@ int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)if (!likely (lock_task_sighand (t, &flags))) goto ret; +/* +* Update @q::info::si_sys_private for posix timer signals with +* sighand locked to prevent a race against dequeue_signal() which +* decides based on si_sys_private whether to invoke +* posixtimer_rearm() or not. +*/ + q->info.si_sys_private = si_private; + ret =1 ;/* the signal is ignored */ result =TRACE_SIGNAL_IGNORED ;if (!prepare_signal (sig, t, false))kernel/time/posix-timers.c +1
-14@@ -299,21 +299,8 @@ int posix_timer_queue_signal(struct k_itimer *timr)if (timr->it_interval) si_private = ++timr->it_requeue_pending; -/* -* FIXME: if ->sigq is queued we can race with -* dequeue_signal()->posixtimer_rearm(). -* -* If dequeue_signal() sees the "right" value of -* si_sys_private it calls posixtimer_rearm(). -* We re-queue ->sigq and drop ->it_lock(). -* posixtimer_rearm() locks the timer -* and re-schedules it while ->sigq is pending. -* Not really bad, but not that we want. -*/ - timr->sigq->info.si_sys_private = si_private; - type = !(timr->it_sigev_notify &SIGEV_THREAD_ID ) ?PIDTYPE_TGID :PIDTYPE_PID ; - ret =send_sigqueue (timr->sigq, timr->it_pid, type); + ret =send_sigqueue (timr->sigq, timr->it_pid, type, si_private);/* If we failed to send the signal the timer stops. */ return ret >0 ; }
PATCH v4 5/27 signal: Allow POSIX timer signals to be dropped
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
In case that a timer was reprogrammed or deleted an already pending signal is obsolete. Right now such signals are kept around and eventually delivered. While POSIX is blury about this:
- "The effect of disarming or resetting a timer with pending expiration notifications is unspecified."
- "The disposition of pending signals for the deleted timer is unspecified."
it is reasonable in both cases to expect that pending signals are discarded as they have no meaning anymore.
Prepare the signal code to allow dropping posix timer signals.
--- include/linux/posix-timers.h | 5 +++-- kernel/signal.c | 7 +++++-- kernel/time/posix-timers.c | 3 ++- 3 files changed, 10 insertions(+), 5 deletions(-)
---
include/linux/posix-timers.h +3 -2
@@ -100,8 +100,9 @@ static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct, { pct->bases[CPUCLOCK_SCHED ].nextevt = runtime; } +void posixtimer_rearm_itimer (struct task_struct *p); -void posixtimer_rearm (struct kernel_siginfo *info); +bool posixtimer_deliver_signal (struct kernel_siginfo *info);/* Init task static initializer */ #define INIT_CPU_TIMERBASE (b) { \
@@ -125,7 +126,7 @@ static inline void posix_cputimers_init(struct posix_cputimers *pct) { }static inline void posix_cputimers_group_init (struct posix_cputimers *pct,u64 cpu_limit) { }static inline void posixtimer_rearm_itimer (struct task_struct *p) { } -static inline void posixtimer_rearm (struct kernel_siginfo *info) { } +static inline bool posixtimer_deliver_signal (struct kernel_siginfo *info) {return false; }#endif #ifdef CONFIG_POSIX_CPU_TIMERS_TASK_WORK
kernel/signal.c +5 -2
@@ -585,6 +585,7 @@ int dequeue_signal(sigset_t *mask, kernel_siginfo_t *info, enum pid_type *type)lockdep_assert_held (&tsk->sighand->siglock); +again: *type =PIDTYPE_PID ; signr =__dequeue_signal (&tsk->pending, mask, info);if (!signr) {
@@ -616,8 +617,10 @@ int dequeue_signal(sigset_t *mask, kernel_siginfo_t *info, enum pid_type *type) }if (IS_ENABLED (CONFIG_POSIX_TIMERS )) { -if (unlikely (info->si_code ==SI_TIMER && info->si_sys_private)) -posixtimer_rearm (info); +if (unlikely (info->si_code ==SI_TIMER && info->si_sys_private)) { +if (!posixtimer_deliver_signal (info)) + goto again; + } }return signr;
kernel/time/posix-timers.c +2 -1
@@ -254,7 +254,7 @@ static void common_hrtimer_rearm(struct k_itimer *timr)* info::si_sys_private is not zero, which indicates that the timer has to * be rearmed. Restart the timer and update info::si_overrun. */ -void posixtimer_rearm (struct kernel_siginfo *info) +bool posixtimer_deliver_signal (struct kernel_siginfo *info) {struct k_itimer *timr;unsigned long flags;
@@ -286,6 +286,7 @@ void posixtimer_rearm(struct kernel_siginfo *info)/* Don't expose the si_sys_private value to userspace */ info->si_sys_private =0 ; +return true; }int posix_timer_queue_signal (struct k_itimer *timr)
PATCH v4 6/27 posix-timers: Drop signal if timer has been deleted or reprogrammed
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
No point in delivering a signal from the past. POSIX does not specify the behaviour here:
- "The effect of disarming or resetting a timer with pending expiration notifications is unspecified."
- "The disposition of pending signals for the deleted timer is unspecified."
In both cases it is reasonable to expect that pending signals are discarded. Especially in the reprogramming case it does not make sense to account for previous overruns or to deliver a signal for a timer which has been disarmed.
Drop the signal as that is conistent and understandable behaviour.
--- kernel/time/posix-timers.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
---
kernel/time/posix-timers.c +5 -4
@@ -250,14 +250,14 @@ static void common_hrtimer_rearm(struct k_itimer *timr) }/* -* This function is called from the signal delivery code if -* info::si_sys_private is not zero, which indicates that the timer has to -* be rearmed. Restart the timer and update info::si_overrun. +* This function is called from the signal delivery code. It decides +* whether the signal should be dropped and rearms interval timers. */ bool posixtimer_deliver_signal (struct kernel_siginfo *info) {struct k_itimer *timr;unsigned long flags; +bool ret = false;/* * Release siglock to ensure proper locking order versus
@@ -279,6 +279,7 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info) info->si_overrun =timer_overrun_to_int (timr, info->si_overrun); } + ret = true;unlock_timer (timr, flags); out:
@@ -286,7 +287,7 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)/* Don't expose the si_sys_private value to userspace */ info->si_sys_private =0 ; -return true; +return ret; }int posix_timer_queue_signal (struct k_itimer *timr)
PATCH v4 7/27 posix-timers: Rename k_itimer::it_requeue_pending
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Prepare for using this struct member to do a proper reprogramming and deletion accounting so that stale signals can be dropped.
No functional change.
--- include/linux/posix-timers.h | 5 ++--- kernel/time/alarmtimer.c | 2 +- kernel/time/posix-cpu-timers.c | 4 ++-- kernel/time/posix-timers.c | 12 ++++++------ 4 files changed, 11 insertions(+), 12 deletions(-)
---
include/linux/posix-timers.h +2 -3
@@ -150,8 +150,7 @@ static inline void posix_cputimers_init_work(void) { }* @it_active: Marker that timer is active * @it_overrun: The overrun counter for pending signals * @it_overrun_last: The overrun at the time of the last delivered signal -* @it_requeue_pending: Indicator that timer waits for being requeued on -* signal delivery +* @it_signal_seq: Sequence count to control signal delivery * @it_sigev_notify: The notify word of sigevent struct for signal delivery * @it_interval: The interval for periodic timers * @it_signal: Pointer to the creators signal struct
@@ -172,7 +171,7 @@ struct k_itimer {int it_active;s64 it_overrun;s64 it_overrun_last; -int it_requeue_pending; +unsigned int it_signal_seq;int it_sigev_notify;ktime_t it_interval;struct signal_struct *it_signal;
kernel/time/alarmtimer.c +1 -1
@@ -584,7 +584,7 @@ static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,* small intervals cannot starve the system. */ ptr->it_overrun +=__alarm_forward_now (alarm, ptr->it_interval, true); - ++ptr->it_requeue_pending; + ++ptr->it_signal_seq; ptr->it_active =1 ; result =ALARMTIMER_RESTART ; }
kernel/time/posix-cpu-timers.c +2 -2
@@ -608,7 +608,7 @@ static void cpu_timer_fire(struct k_itimer *timer)* ticking in case the signal is deliverable next time. */ posix_cpu_timer_rearm (timer); - ++timer->it_requeue_pending; + ++timer->it_signal_seq; } }
@@ -745,7 +745,7 @@ static void __posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *i* - Timers which expired, but the signal has not yet been * delivered */ -if (iv && ((timer->it_requeue_pending &REQUEUE_PENDING ) || sigev_none)) +if (iv && ((timer->it_signal_seq &REQUEUE_PENDING ) || sigev_none)) expires =bump_cpu_timer (timer, now);else expires =cpu_timer_getexpires (&timer->it.cpu);
kernel/time/posix-timers.c +6 -6
@@ -269,13 +269,13 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)if (!timr) goto out; -if (timr->it_interval && timr->it_requeue_pending == info->si_sys_private) { +if (timr->it_interval && timr->it_signal_seq == info->si_sys_private) { timr->kclock->timer_rearm (timr); timr->it_active =1 ; timr->it_overrun_last = timr->it_overrun; timr->it_overrun =-1LL ; - ++timr->it_requeue_pending; + ++timr->it_signal_seq; info->si_overrun =timer_overrun_to_int (timr, info->si_overrun); }
@@ -299,7 +299,7 @@ int posix_timer_queue_signal(struct k_itimer *timr) timr->it_active =0 ;if (timr->it_interval) - si_private = ++timr->it_requeue_pending; + si_private = ++timr->it_signal_seq; type = !(timr->it_sigev_notify &SIGEV_THREAD_ID ) ?PIDTYPE_TGID :PIDTYPE_PID ; ret =send_sigqueue (timr->sigq, timr->it_pid, type, si_private);
@@ -366,7 +366,7 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer) timr->it_overrun +=hrtimer_forward (timer, now, timr->it_interval); ret =HRTIMER_RESTART ; - ++timr->it_requeue_pending; + ++timr->it_signal_seq; timr->it_active =1 ; } }
@@ -667,7 +667,7 @@ void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)* is a SIGEV_NONE timer move the expiry time forward by intervals, * so expiry is > now. */ -if (iv && (timr->it_requeue_pending &REQUEUE_PENDING || sig_none)) +if (iv && (timr->it_signal_seq &REQUEUE_PENDING || sig_none)) timr->it_overrun += kc->timer_forward (timr, now); remaining = kc->timer_remaining (timr, now);
@@ -868,7 +868,7 @@ void posix_timer_set_common(struct k_itimer *timer, struct itimerspec64 *new_set timer->it_interval =0 ;/* Prevent reloading in case there is a signal pending */ - timer->it_requeue_pending = (timer->it_requeue_pending +2 ) & ~REQUEUE_PENDING ; + timer->it_signal_seq = (timer->it_signal_seq +2 ) & ~REQUEUE_PENDING ;/* Reset overrun accounting */ timer->it_overrun_last =0 ; timer->it_overrun =-1LL ;
PATCH v4 8/27 posix-timers: Add proper state tracking
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Right now the state tracking is done by two struct members:
- it_active:
A boolean which tracks armed/disarmed state
- it_signal_seq:
A sequence counter which is used to invalidate settings and prevent rearming
Replace it_active with it_status and keep properly track about the states in one place.
This allows to reuse it_signal_seq to track reprogramming, disarm and delete operations in order to drop signals which are related to the state previous of those operations.
--- include/linux/posix-timers.h | 4 ++-- kernel/time/alarmtimer.c | 2 +- kernel/time/posix-cpu-timers.c | 15 ++++++++------- kernel/time/posix-timers.c | 22 +++++++++++++--------- kernel/time/posix-timers.h | 6 ++++++ 5 files changed, 30 insertions(+), 19 deletions(-)
---
include/linux/posix-timers.h +2 -2
@@ -147,7 +147,7 @@ static inline void posix_cputimers_init_work(void) { }* @kclock: Pointer to the k_clock struct handling this timer * @it_clock: The posix timer clock id * @it_id: The posix timer id for identifying the timer -* @it_active: Marker that timer is active +* @it_status: The status of the timer * @it_overrun: The overrun counter for pending signals * @it_overrun_last: The overrun at the time of the last delivered signal * @it_signal_seq: Sequence count to control signal delivery
@@ -168,7 +168,7 @@ struct k_itimer {const struct k_clock *kclock;clockid_t it_clock;timer_t it_id; -int it_active; +int it_status;s64 it_overrun;s64 it_overrun_last;unsigned int it_signal_seq;
kernel/time/alarmtimer.c +1 -1
@@ -585,7 +585,7 @@ static enum alarmtimer_restart alarm_handle_timer(struct alarm *alarm,*/ ptr->it_overrun +=__alarm_forward_now (alarm, ptr->it_interval, true); ++ptr->it_signal_seq; - ptr->it_active =1 ; + ptr->it_status =POSIX_TIMER_ARMED ; result =ALARMTIMER_RESTART ; }spin_unlock_irqrestore (&ptr->it_lock, flags);
kernel/time/posix-cpu-timers.c +8 -7
@@ -453,7 +453,6 @@ static void disarm_timer(struct k_itimer *timer, struct task_struct *p)struct cpu_timer *ctmr = &timer->it.cpu;struct posix_cputimer_base *base; - timer->it_active =0 ;if (!cpu_timer_dequeue (ctmr))return ;
@@ -494,11 +493,12 @@ static int posix_cpu_timer_del(struct k_itimer *timer)*/ WARN_ON_ONCE (ctmr->head ||timerqueue_node_queued (&ctmr->node)); }else { -if (timer->it.cpu.firing) +if (timer->it.cpu.firing) { ret =TIMER_RETRY ; -else + }else {disarm_timer (timer, p); - + timer->it_status =POSIX_TIMER_DISARMED ; + }unlock_task_sighand (p, &flags); }
@@ -560,7 +560,7 @@ static void arm_timer(struct k_itimer *timer, struct task_struct *p)struct cpu_timer *ctmr = &timer->it.cpu;u64 newexp =cpu_timer_getexpires (ctmr); - timer->it_active =1 ; + timer->it_status =POSIX_TIMER_ARMED ;if (!cpu_timer_enqueue (&base->tqhead, ctmr))return ;
@@ -586,7 +586,8 @@ static void cpu_timer_fire(struct k_itimer *timer) {struct cpu_timer *ctmr = &timer->it.cpu; - timer->it_active =0 ; + timer->it_status =POSIX_TIMER_DISARMED ; +if (unlikely (timer->sigq ==NULL )) {/* * This a special case for clock_nanosleep,
@@ -671,7 +672,7 @@ static int posix_cpu_timer_set(struct k_itimer *timer, int timer_flags, ret =TIMER_RETRY ; }else {cpu_timer_dequeue (ctmr); - timer->it_active =0 ; + timer->it_status =POSIX_TIMER_DISARMED ; }/*
kernel/time/posix-timers.c +13 -9
@@ -272,7 +272,7 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)if (timr->it_interval && timr->it_signal_seq == info->si_sys_private) { timr->kclock->timer_rearm (timr); - timr->it_active =1 ; + timr->it_status =POSIX_TIMER_ARMED ; timr->it_overrun_last = timr->it_overrun; timr->it_overrun =-1LL ; ++timr->it_signal_seq;
@@ -292,14 +292,17 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)int posix_timer_queue_signal (struct k_itimer *timr) { +enum posix_timer_state state =POSIX_TIMER_DISARMED ;int ret, si_private =0 ;enum pid_type type;lockdep_assert_held (&timr->it_lock); - timr->it_active =0 ; -if (timr->it_interval) +if (timr->it_interval) { + state =POSIX_TIMER_REQUEUE_PENDING ; si_private = ++timr->it_signal_seq; + } + timr->it_status = state; type = !(timr->it_sigev_notify &SIGEV_THREAD_ID ) ?PIDTYPE_TGID :PIDTYPE_PID ; ret =send_sigqueue (timr->sigq, timr->it_pid, type, si_private);
@@ -367,7 +370,7 @@ static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer) timr->it_overrun +=hrtimer_forward (timer, now, timr->it_interval); ret =HRTIMER_RESTART ; ++timr->it_signal_seq; - timr->it_active =1 ; + timr->it_status =POSIX_TIMER_ARMED ; } }
@@ -647,10 +650,10 @@ void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)/* interval timer ? */ if (iv) { cur_setting->it_interval =ktime_to_timespec64 (iv); - }else if (!timr->it_active) { + }else if (timr->it_status ==POSIX_TIMER_DISARMED ) {/* * SIGEV_NONE oneshot timers are never queued and therefore -* timr->it_active is always false. The check below +* timr->it_status is always DISARMED. The check below * vs. remaining time will handle this case. * * For all other timers there is nothing to update here, so
@@ -895,7 +898,7 @@ int common_timer_set(struct k_itimer *timr, int flags,if (kc->timer_try_to_cancel (timr) <0 )return TIMER_RETRY ; - timr->it_active =0 ; + timr->it_status =POSIX_TIMER_DISARMED ;posix_timer_set_common (timr, new_setting);/* Keep timer disarmed when it_value is zero */
@@ -908,7 +911,8 @@ int common_timer_set(struct k_itimer *timr, int flags, sigev_none = timr->it_sigev_notify ==SIGEV_NONE ; kc->timer_arm (timr, expires, flags &TIMER_ABSTIME , sigev_none); - timr->it_active = !sigev_none; +if (!sigev_none) + timr->it_status =POSIX_TIMER_ARMED ;return 0 ; }
@@ -1007,7 +1011,7 @@ int common_timer_del(struct k_itimer *timer) timer->it_interval =0 ;if (kc->timer_try_to_cancel (timer) <0 )return TIMER_RETRY ; - timer->it_active =0 ; + timer->it_status =POSIX_TIMER_DISARMED ;return 0 ; }
kernel/time/posix-timers.h +6 -0
@@ -1,6 +1,12 @@/* SPDX-License-Identifier: GPL-2.0 */ #define TIMER_RETRY 1 +enum posix_timer_state { +POSIX_TIMER_DISARMED , +POSIX_TIMER_ARMED , +POSIX_TIMER_REQUEUE_PENDING , +}; +struct k_clock {int (*clock_getres)(const clockid_t which_clock,struct timespec64 *tp);
PATCH v4 9/27 posix-timers: Make signal delivery consistent
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Signals of timers which are reprogammed, disarmed or deleted can deliver signals related to the past. The POSIX spec is blury about this:
- "The effect of disarming or resetting a timer with pending expiration notifications is unspecified."
- "The disposition of pending signals for the deleted timer is unspecified."
In both cases it is reasonable to expect that pending signals are discarded. Especially in the reprogramming case it does not make sense to account for previous overruns or to deliver a signal for a timer which has been disarmed. This makes the behaviour consistent and understandable.
Remove the si_sys_private check from the signal delivery code and invoke posix_timer_deliver_signal() unconditionally.
Change that function so it controls the actual signal delivery via the return value. It now instructs the signal code to drop the signal when:
1) The timer does not longer exist in the hash table
2) The timer signal_seq value is not the same as the si_sys_private value which was set when the signal was queued.
--- include/linux/posix-timers.h | 2 -- kernel/signal.c | 2 +- kernel/time/posix-cpu-timers.c | 2 +- kernel/time/posix-timers.c | 25 +++++++++++++++---------- 4 files changed, 17 insertions(+), 14 deletions(-)
---
include/linux/posix-timers.h +0 -2
@@ -137,8 +137,6 @@ static inline void clear_posix_cputimers_work(struct task_struct *p) { }static inline void posix_cputimers_init_work (void ) { }#endif -#define REQUEUE_PENDING 1 -/** * struct k_itimer - POSIX.1b interval timer structure. * @list: List head for binding the timer to signals->posix_timers
kernel/signal.c +1 -1
@@ -617,7 +617,7 @@ int dequeue_signal(sigset_t *mask, kernel_siginfo_t *info, enum pid_type *type) }if (IS_ENABLED (CONFIG_POSIX_TIMERS )) { -if (unlikely (info->si_code ==SI_TIMER && info->si_sys_private)) { +if (unlikely (info->si_code ==SI_TIMER )) {if (!posixtimer_deliver_signal (info)) goto again; }
kernel/time/posix-cpu-timers.c +1 -1
@@ -746,7 +746,7 @@ static void __posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *i* - Timers which expired, but the signal has not yet been * delivered */ -if (iv && ((timer->it_signal_seq &REQUEUE_PENDING ) || sigev_none)) +if (iv && timer->it_status !=POSIX_TIMER_ARMED ) expires =bump_cpu_timer (timer, now);else expires =cpu_timer_getexpires (&timer->it.cpu);
kernel/time/posix-timers.c +15 -10
@@ -269,7 +269,10 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)if (!timr) goto out; -if (timr->it_interval && timr->it_signal_seq == info->si_sys_private) { +if (timr->it_signal_seq != info->si_sys_private) + goto out_unlock; + +if (timr->it_interval && timr->it_status ==POSIX_TIMER_REQUEUE_PENDING ) { timr->kclock->timer_rearm (timr); timr->it_status =POSIX_TIMER_ARMED ;
@@ -281,6 +284,7 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info) } ret = true; +out_unlock:unlock_timer (timr, flags); out:spin_lock (¤t->sighand->siglock);
@@ -293,19 +297,19 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)int posix_timer_queue_signal (struct k_itimer *timr) {enum posix_timer_state state =POSIX_TIMER_DISARMED ; -int ret, si_private =0 ;enum pid_type type; +int ret;lockdep_assert_held (&timr->it_lock);if (timr->it_interval) { + timr->it_signal_seq++; state =POSIX_TIMER_REQUEUE_PENDING ; - si_private = ++timr->it_signal_seq; } timr->it_status = state; type = !(timr->it_sigev_notify &SIGEV_THREAD_ID ) ?PIDTYPE_TGID :PIDTYPE_PID ; - ret =send_sigqueue (timr->sigq, timr->it_pid, type, si_private); + ret =send_sigqueue (timr->sigq, timr->it_pid, type, timr->it_signal_seq);/* If we failed to send the signal the timer stops. */ return ret >0 ; }
@@ -670,7 +674,7 @@ void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)* is a SIGEV_NONE timer move the expiry time forward by intervals, * so expiry is > now. */ -if (iv && (timr->it_signal_seq &REQUEUE_PENDING || sig_none)) +if (iv && timr->it_status !=POSIX_TIMER_ARMED ) timr->it_overrun += kc->timer_forward (timr, now); remaining = kc->timer_remaining (timr, now);
@@ -870,8 +874,6 @@ void posix_timer_set_common(struct k_itimer *timer, struct itimerspec64 *new_setelse timer->it_interval =0 ; -/* Prevent reloading in case there is a signal pending */ - timer->it_signal_seq = (timer->it_signal_seq +2 ) & ~REQUEUE_PENDING ;/* Reset overrun accounting */ timer->it_overrun_last =0 ; timer->it_overrun =-1LL ;
@@ -889,8 +891,6 @@ int common_timer_set(struct k_itimer *timr, int flags,if (old_setting)common_timer_get (timr, old_setting); -/* Prevent rearming by clearing the interval */ - timr->it_interval =0 ;/* * Careful here. On SMP systems the timer expiry function could be * active and spinning on timr->it_lock.
@@ -940,6 +940,9 @@ static int do_timer_settime(timer_t timer_id, int tmr_flags,if (old_spec64) old_spec64->it_interval =ktime_to_timespec64 (timr->it_interval); +/* Prevent signal delivery and rearming. */ + timr->it_signal_seq++; + kc = timr->kclock;if (WARN_ON_ONCE (!kc || !kc->timer_set)) error = -EINVAL ;
@@ -1008,7 +1011,6 @@ int common_timer_del(struct k_itimer *timer) {const struct k_clock *kc = timer->kclock; - timer->it_interval =0 ;if (kc->timer_try_to_cancel (timer) <0 )return TIMER_RETRY ; timer->it_status =POSIX_TIMER_DISARMED ;
@@ -1036,6 +1038,9 @@ SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)if (!timer)return -EINVAL ; +/* Prevent signal delivery and rearming. */ + timer->it_signal_seq++; +if (unlikely (timer_delete_hook (timer) ==TIMER_RETRY )) {/* Unlocks and relocks the timer if it still exists */ timer =timer_wait_running (timer, &flags);
PATCH v4 10/27 posix-timers: Make signal overrun accounting sensible
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
The handling of the timer overrun in the signal code is inconsistent as it takes previous overruns into account. This is just wrong as after the reprogramming of a timer the overrun count starts over from a clean state, i.e. 0.
Make the accounting in send_sigqueue() consistent with that.
--- kernel/signal.c | 34 ++++++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-)
---
kernel/signal.c +28 -6
@@ -1961,6 +1961,34 @@ int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type, int s*/ q->info.si_sys_private = si_private; +/* +* Set the overrun count to zero unconditionally. The posix timer +* code does not self rearm periodic timers. They are rearmed from +* dequeue_signal(). +* +* But there is a situation where @q is already enqueued: +* +* 1) timer_settime() +* arm_timer() +* 2) timer_expires() +* send_sigqueue(@q) +* enqueue(@q) +* 3) timer_settime() +* arm_timer() +* 4) timer_expires() +* send_sigqueue(@q) <- Observes @q already queued +* +* In this case incrementing si_overrun does not make sense because +* there is no relationship between timer_settime() #1 and #2. +* +* The POSIX specification is useful as always: "The effect of +* disarming or resetting a timer with pending expiration +* notifications is unspecified." +* +* Just do the sensible thing and reset the overrun. +*/ + q->info.si_overrun =0 ; + ret =1 ;/* the signal is ignored */ result =TRACE_SIGNAL_IGNORED ;if (!prepare_signal (sig, t, false))
@@ -1968,15 +1996,9 @@ int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type, int s ret =0 ;if (unlikely (!list_empty (&q->list))) { -/* -* If an SI_TIMER entry is already queue just increment -* the overrun count. -*/ - q->info.si_overrun++; result =TRACE_SIGNAL_ALREADY_PENDING ; goto out; } - q->info.si_overrun =0 ;signalfd_notify (t, sig); pending = (type !=PIDTYPE_PID ) ? &t->signal->shared_pending : &t->pending;
PATCH v4 11/27 posix-cpu-timers: Use dedicated flag for CPU timer nanosleep
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
POSIX CPU timer nanosleep creates a k_itimer on stack and uses the sigq pointer to detect the nanosleep case in the expiry function.
Prepare for embedding sigqueue into struct k_itimer by using a dedicated flag for nanosleep.
--- include/linux/posix-timers.h | 4 +++- kernel/time/posix-cpu-timers.c | 3 ++- 2 files changed, 5 insertions(+), 2 deletions(-)
---
include/linux/posix-timers.h +3 -1
@@ -42,6 +42,7 @@ static inline int clockid_to_fd(const clockid_t clk)* @pid: Pointer to target task PID * @elist: List head for the expiry list * @firing: Timer is currently firing +* @nanosleep: Timer is used for nanosleep and is not a regular posix-timer * @handling: Pointer to the task which handles expiry */ struct cpu_timer {
@@ -49,7 +50,8 @@ struct cpu_timer {struct timerqueue_head *head;struct pid *pid;struct list_head elist; -int firing; +bool firing; +bool nanosleep;struct task_struct __rcu *handling; };
kernel/time/posix-cpu-timers.c +2 -1
@@ -588,7 +588,7 @@ static void cpu_timer_fire(struct k_itimer *timer) timer->it_status =POSIX_TIMER_DISARMED ; -if (unlikely (timer->sigq ==NULL )) { +if (unlikely (ctmr->nanosleep)) {/* * This a special case for clock_nanosleep, * not a normal timer from sys_timer_create.
@@ -1479,6 +1479,7 @@ static int do_cpu_nanosleep(const clockid_t which_clock, int flags, timer.it_overrun =-1 ; error =posix_cpu_timer_create (&timer); timer.it_process = current; + timer.it.cpu.nanosleep = true;if (!error) {static struct itimerspec64 zero_it;
PATCH v4 12/27 posix-timers: Add a refcount to struct k_itimer
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To cure the SIG_IGN handling for posix interval timers, the preallocated sigqueue needs to be embedded into struct k_itimer to prevent life time races of all sorts.
To make that work correctly it needs reference counting so that timer deletion does not free the timer prematuraly when there is a signal queued or delivered concurrently.
Add a rcuref to the posix timer part.
--- include/linux/posix-timers.h | 14 ++++++++++++++ kernel/time/posix-timers.c | 7 ++++--- 2 files changed, 18 insertions(+), 3 deletions(-)
---
include/linux/posix-timers.h +14 -0
@@ -6,11 +6,13 @@#include <linux/list.h> #include <linux/mutex.h> #include <linux/posix-timers_types.h> +#include <linux/rcuref.h> #include <linux/spinlock.h> #include <linux/timerqueue.h> struct kernel_siginfo ;struct task_struct ; +struct k_itimer ;static inline clockid_t make_process_cpuclock (const unsigned int pid,const clockid_t clock)
@@ -105,6 +107,7 @@ static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct,void posixtimer_rearm_itimer (struct task_struct *p);bool posixtimer_deliver_signal (struct kernel_siginfo *info); +void posixtimer_free_timer (struct k_itimer *timer);/* Init task static initializer */ #define INIT_CPU_TIMERBASE (b) { \
@@ -129,6 +132,7 @@ static inline void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit) { }static inline void posixtimer_rearm_itimer (struct task_struct *p) { }static inline bool posixtimer_deliver_signal (struct kernel_siginfo *info) {return false; } +static inline void posixtimer_free_timer (struct k_itimer *timer) { }#endif #ifdef CONFIG_POSIX_CPU_TIMERS_TASK_WORK
@@ -156,6 +160,7 @@ static inline void posix_cputimers_init_work(void) { }* @it_signal: Pointer to the creators signal struct * @it_pid: The pid of the process/task targeted by the signal * @it_process: The task to wakeup on clock_nanosleep (CPU timers) +* @rcuref: Reference count for life time management * @sigq: Pointer to preallocated sigqueue * @it: Union representing the various posix timer type * internals.
@@ -180,6 +185,7 @@ struct k_itimer {struct task_struct *it_process; };struct sigqueue *sigq; +rcuref_t rcuref; union { struct { struct hrtimer timer;
@@ -200,4 +206,12 @@ void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,int update_rlimit_cpu (struct task_struct *task,unsigned long rlim_new); +#ifdef CONFIG_POSIX_TIMERS +static inline void posixtimer_putref (struct k_itimer *tmr) +{ +if (rcuref_put (&tmr->rcuref)) +posixtimer_free_timer (tmr); +} +#endif /* !CONFIG_POSIX_TIMERS */ +#endif
kernel/time/posix-timers.c +4 -3
@@ -417,6 +417,7 @@ static struct k_itimer * alloc_posix_timer(void)return NULL ; }clear_siginfo (&tmr->sigq->info); +rcuref_init (&tmr->rcuref,1 );return tmr; }
@@ -427,7 +428,7 @@ static void k_itimer_rcu_free(struct rcu_head *head)kmem_cache_free (posix_timers_cache, tmr); } -static void posix_timer_free (struct k_itimer *tmr) +void posixtimer_free_timer (struct k_itimer *tmr) {put_pid (tmr->it_pid);sigqueue_free (tmr->sigq);
@@ -439,7 +440,7 @@ static void posix_timer_unhash_and_free(struct k_itimer *tmr)spin_lock (&hash_lock);hlist_del_rcu (&tmr->t_hash);spin_unlock (&hash_lock); -posix_timer_free (tmr); +posixtimer_putref (tmr); }static int common_timer_create (struct k_itimer *new_timer)
@@ -474,7 +475,7 @@ static int do_timer_create(clockid_t which_clock, struct sigevent *event,*/ new_timer_id =posix_timer_add (new_timer);if (new_timer_id <0 ) { -posix_timer_free (new_timer); +posixtimer_free_timer (new_timer);return new_timer_id; }
PATCH v4 13/27 signal: Split up __sigqueue_alloc()
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To cure the SIG_IGN handling for posix interval timers, the preallocated sigqueue needs to be embedded into struct k_itimer to prevent life time races of all sorts.
Reorganize __sigqueue_alloc() so the ucounts retrieval and the initialization can be used independently.
No functional change.
--- kernel/signal.c | 52 +++++++++++++++++++++++++++++++++++----------------- 1 file changed, 35 insertions(+), 17 deletions(-)
---
kernel/signal.c +35 -17
@@ -396,16 +396,9 @@ void task_join_group_stop(struct task_struct *task)task_set_jobctl_pending (task, mask |JOBCTL_STOP_PENDING ); } -/* -* allocate a new signal queue record -* - this may be called without locks if and only if t == current, otherwise an -* appropriate lock must be held to stop the target task from exiting -*/ -static struct sigqueue * -__sigqueue_alloc (int sig,struct task_struct *t,gfp_t gfp_flags, -int override_rlimit,const unsigned int sigqueue_flags) +static struct ucounts *sig_get_ucounts (struct task_struct *t,int sig, +int override_rlimit) { -struct sigqueue *q =NULL ;struct ucounts *ucounts;long sigpending;
@@ -424,19 +417,44 @@ __sigqueue_alloc(int sig, struct task_struct *t, gfp_t gfp_flags,if (!sigpending)return NULL ; -if (override_rlimit ||likely (sigpending <=task_rlimit (t,RLIMIT_SIGPENDING ))) { - q =kmem_cache_alloc (sigqueue_cachep, gfp_flags); - }else { +if (unlikely (!override_rlimit && sigpending >task_rlimit (t,RLIMIT_SIGPENDING ))) { +dec_rlimit_put_ucounts (ucounts,UCOUNT_RLIMIT_SIGPENDING );print_dropped_signal (sig); +return NULL ; } -if (unlikely (q ==NULL )) { +return ucounts; +} + +static void __sigqueue_init (struct sigqueue *q,struct ucounts *ucounts, +const unsigned int sigqueue_flags) +{ +INIT_LIST_HEAD (&q->list); + q->flags = sigqueue_flags; + q->ucounts = ucounts; +} + +/* +* allocate a new signal queue record +* - this may be called without locks if and only if t == current, otherwise an +* appropriate lock must be held to stop the target task from exiting +*/ +static struct sigqueue *__sigqueue_alloc (int sig,struct task_struct *t,gfp_t gfp_flags, +int override_rlimit,const unsigned int sigqueue_flags) +{ +struct ucounts *ucounts =sig_get_ucounts (t, sig, override_rlimit); +struct sigqueue *q; + +if (!ucounts) +return NULL ; + + q =kmem_cache_alloc (sigqueue_cachep, gfp_flags); +if (!q) {dec_rlimit_put_ucounts (ucounts,UCOUNT_RLIMIT_SIGPENDING ); - }else { -INIT_LIST_HEAD (&q->list); - q->flags = sigqueue_flags; - q->ucounts = ucounts; +return NULL ; } + +__sigqueue_init (q, ucounts, sigqueue_flags);return q; }
PATCH v4 14/27 signal: Provide posixtimer_sigqueue_init()
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To cure the SIG_IGN handling for posix interval timers, the preallocated sigqueue needs to be embedded into struct k_itimer to prevent life time races of all sorts.
Provide a new function to initialize the embedded sigqueue to prepare for that.
--- include/linux/posix-timers.h | 2 ++ kernel/signal.c | 11 +++++++++++ 2 files changed, 13 insertions(+)
---
include/linux/posix-timers.h +2 -0
@@ -12,6 +12,7 @@struct kernel_siginfo ;struct task_struct ; +struct sigqueue ;struct k_itimer ; static inline clockid_t make_process_cpuclock(const unsigned int pid,
@@ -106,6 +107,7 @@ static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct, }void posixtimer_rearm_itimer (struct task_struct *p); +bool posixtimer_init_sigqueue (struct sigqueue *q);bool posixtimer_deliver_signal (struct kernel_siginfo *info);void posixtimer_free_timer (struct k_itimer *timer);
kernel/signal.c +11 -0
@@ -1905,6 +1905,17 @@ void flush_itimer_signals(void)__flush_itimer_signals (&tsk->signal->shared_pending); } +bool posixtimer_init_sigqueue (struct sigqueue *q) +{ +struct ucounts *ucounts =sig_get_ucounts (current,-1 ,0 ); + +if (!ucounts) +return false; +clear_siginfo (&q->info); +__sigqueue_init (q, ucounts,SIGQUEUE_PREALLOC ); +return true; +} +struct sigqueue *sigqueue_alloc (void ) {return __sigqueue_alloc (-1 , current,GFP_KERNEL ,0 ,SIGQUEUE_PREALLOC );
PATCH v4 15/27 signal: Add sys_private_ptr to siginfo::_sifields:: _timer
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
On signal delivery collect_signal() copies the queued siginfo into a caller provided siginfo struct. The posix timer signal delivery code then uses siginfo::si_tid to lookup the timer in the hash table.
That's required today as the timer and the sigqueue are separate entities and have different life time rules.
The sigqueue will be embedded into struct k_itimer to address a few issues in the posix timer signal handling, which means the life time rules are not longer separate, which can spare the lookup.
Due to locking rules posixtimer_deliver_signal() cannot be invoked from collect_signal(). The timer pointer could be handed down from collect_signal() to dequeue_signal(), but that's just overhead for the non-posixtimer case.
There is room in the _sifields union for an extra pointer which will be used later for storing the timer pointer. This field is copied with siginfo and cleared before the info is delivered to userspace like the existing si_sys_private field.
--- arch/x86/kernel/signal_32.c | 2 +- arch/x86/kernel/signal_64.c | 2 +- include/uapi/asm-generic/siginfo.h | 2 ++ kernel/signal.c | 6 ++++-- kernel/time/posix-timers.c | 4 +++- 5 files changed, 11 insertions(+), 5 deletions(-)
---
arch/x86/kernel/signal_32.c +1 -1
@@ -456,7 +456,7 @@ CHECK_SI_OFFSET(_timer);/* compat_siginfo_t doesn't have si_sys_private */ CHECK_SI_SIZE (_timer,3 *sizeof (int ));#else -CHECK_SI_SIZE (_timer,4 *sizeof (int )); +CHECK_SI_SIZE (_timer,5 *sizeof (int ));#endif static_assert (offsetof(siginfo32_t , si_tid) ==0x0C );static_assert (offsetof(siginfo32_t , si_overrun) ==0x10 );
arch/x86/kernel/signal_64.c +1 -1
@@ -462,7 +462,7 @@ static_assert(offsetof(siginfo_t, si_pid) == 0x10);static_assert (offsetof(siginfo_t , si_uid) ==0x14 );CHECK_SI_OFFSET (_timer); -CHECK_SI_SIZE (_timer,6 *sizeof (int )); +CHECK_SI_SIZE (_timer,8 *sizeof (int ));static_assert (offsetof(siginfo_t , si_tid) ==0x10 );static_assert (offsetof(siginfo_t , si_overrun) ==0x14 );static_assert (offsetof(siginfo_t , si_value) ==0x18 );
include/uapi/asm-generic/siginfo.h +2 -0
@@ -47,6 +47,7 @@ union __sifields {int _overrun;/* overrun count */ sigval_t _sigval;/* same as below */ int _sys_private;/* not to be passed to user */ +void *_sys_privptr;/* not to be passed to user */ } _timer;/* POSIX.1b signals */
@@ -146,6 +147,7 @@ typedef struct siginfo {#define si_tid _sifields._timer._tid#define si_overrun _sifields._timer._overrun#define si_sys_private _sifields._timer._sys_private +#define si_sys_privptr _sifields._timer._sys_privptr#define si_status _sifields._sigchld._status#define si_utime _sifields._sigchld._utime#define si_stime _sifields._sigchld._stime
kernel/signal.c +4 -2
@@ -3410,12 +3410,14 @@ static int post_copy_siginfo_from_user(kernel_siginfo_t *info, const siginfo_t __user *from) {/* -* Clear the si_sys_private field for timer signals as that's the +* Clear the si_sys_priv* fields for timer signals as that's the * indicator for rearming a posix timer. User space submitted * signals are not allowed to inject that. */ -if (info->si_code ==SI_TIMER ) +if (info->si_code ==SI_TIMER ) { info->si_sys_private =0 ; + info->si_sys_privptr =NULL ; + }if (unlikely (!known_siginfo_layout (info->si_signo, info->si_code))) {char __user *expansion =si_expansion (from);
kernel/time/posix-timers.c +3 -1
@@ -289,8 +289,9 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info) out:spin_lock (¤t->sighand->siglock); -/* Don't expose the si_sys_private value to userspace */ +/* Don't expose the si_sys_priv* values to userspace */ info->si_sys_private =0 ; + info->si_sys_privptr =NULL ;return ret; }
@@ -505,6 +506,7 @@ static int do_timer_create(clockid_t which_clock, struct sigevent *event, new_timer->sigq->info.si_tid = new_timer->it_id; new_timer->sigq->info.si_code =SI_TIMER ; + new_timer->sigq->info.si_sys_privptr = new_timer;if (copy_to_user (created_timer_id, &new_timer_id,sizeof (new_timer_id))) { error = -EFAULT ;
PATCH v4 16/27 posix-timers: Store PID type in the timer
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
instead of re-evaluating the signal delivery mode everywhere.
--- include/linux/posix-timers.h | 2 ++ kernel/time/posix-timers.c | 9 ++++++--- 2 files changed, 8 insertions(+), 3 deletions(-)
---
include/linux/posix-timers.h +2 -0
@@ -5,6 +5,7 @@#include <linux/alarmtimer.h> #include <linux/list.h> #include <linux/mutex.h> +#include <linux/pid.h> #include <linux/posix-timers_types.h> #include <linux/rcuref.h> #include <linux/spinlock.h>
@@ -180,6 +181,7 @@ struct k_itimer {s64 it_overrun_last;unsigned int it_signal_seq;int it_sigev_notify; +enum pid_type it_pid_type;ktime_t it_interval;struct signal_struct *it_signal;union {
kernel/time/posix-timers.c +6 -3
@@ -298,7 +298,6 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)int posix_timer_queue_signal (struct k_itimer *timr) {enum posix_timer_state state =POSIX_TIMER_DISARMED ; -enum pid_type type;int ret;lockdep_assert_held (&timr->it_lock);
@@ -309,8 +308,7 @@ int posix_timer_queue_signal(struct k_itimer *timr) } timr->it_status = state; - type = !(timr->it_sigev_notify &SIGEV_THREAD_ID ) ?PIDTYPE_TGID :PIDTYPE_PID ; - ret =send_sigqueue (timr->sigq, timr->it_pid, type, timr->it_signal_seq); + ret =send_sigqueue (timr->sigq, timr->it_pid, timr->it_pid_type, timr->it_signal_seq);/* If we failed to send the signal the timer stops. */ return ret >0 ; }
@@ -504,6 +502,11 @@ static int do_timer_create(clockid_t which_clock, struct sigevent *event, new_timer->it_pid =get_pid (task_tgid (current)); } +if (new_timer->it_sigev_notify &SIGEV_THREAD_ID ) + new_timer->it_pid_type =PIDTYPE_PID ; +else + new_timer->it_pid_type =PIDTYPE_TGID ; + new_timer->sigq->info.si_tid = new_timer->it_id; new_timer->sigq->info.si_code =SI_TIMER ; new_timer->sigq->info.si_sys_privptr = new_timer;
PATCH v4 17/27 signal: Refactor send_sigqueue()
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To handle posix timers which have their signal ignored via SIG_IGN properly it is required to requeue a ignored signal for delivery when SIG_IGN is lifted so the timer gets rearmed.
Split the required code out of send_sigqueue() so it can be reused in context of sigaction().
While at it rename send_sigqueue() to posixtimer_send_sigqueue() so its clear what this is about.
--- include/linux/posix-timers.h | 1 +- include/linux/sched/signal.h | 1 +- kernel/signal.c | 73 +++++++++++++++++++++++++-------------------- kernel/time/posix-timers.c | 2 +- 4 files changed, 44 insertions(+), 33 deletions(-)
---
include/linux/posix-timers.h +1 -0
@@ -109,6 +109,7 @@ static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct,void posixtimer_rearm_itimer (struct task_struct *p);bool posixtimer_init_sigqueue (struct sigqueue *q); +int posixtimer_send_sigqueue (struct k_itimer *tmr);bool posixtimer_deliver_signal (struct kernel_siginfo *info);void posixtimer_free_timer (struct k_itimer *timer);
include/linux/sched/signal.h +0 -1
@@ -340,7 +340,6 @@ extern int send_sig(int, struct task_struct *, int);extern int zap_other_threads (struct task_struct *p);extern struct sigqueue *sigqueue_alloc (void );extern void sigqueue_free (struct sigqueue *); -extern int send_sigqueue (struct sigqueue *,struct pid *,enum pid_type ,int si_private);extern int do_sigaction (int ,struct k_sigaction *,struct k_sigaction *);static inline void clear_notify_signal (void )
kernel/signal.c +42 -31
111 lines not on this page · raw message
kernel/time/posix-timers.c +1 -1
@@ -308,7 +308,7 @@ int posix_timer_queue_signal(struct k_itimer *timr) } timr->it_status = state; - ret =send_sigqueue (timr->sigq, timr->it_pid, timr->it_pid_type, timr->it_signal_seq); + ret =posixtimer_send_sigqueue (timr);/* If we failed to send the signal the timer stops. */ return ret >0 ; }
PATCH v4 18/27 posix-timers: Embed sigqueue in struct k_itimer
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To cure the SIG_IGN handling for posix interval timers, the preallocated sigqueue needs to be embedded into struct k_itimer to prevent life time races of all sorts.
Now that the prerequisites are in place, embed the sigqueue into struct k_itimer and fixup the relevant usage sites.
Aside of preparing for proper SIG_IGN handling, this spares an extra allocation.
--- fs/proc/base.c | 4 +-- include/linux/posix-timers.h | 23 ++++++++++++++++-- kernel/signal.c | 12 +++++++-- kernel/time/posix-timers.c | 59 +++++++++++++++++++++++++++------------------ 4 files changed, 69 insertions(+), 29 deletions(-)
---
fs/proc/base.c +2 -2
@@ -2496,8 +2496,8 @@ static int show_timer(struct seq_file *m, void *v)seq_printf (m,"ID: %d\n" , timer->it_id);seq_printf (m,"signal: %d/%px\n" , - timer->sigq->info.si_signo, - timer->sigq->info.si_value.sival_ptr); + timer->sigq.info.si_signo, + timer->sigq.info.si_value.sival_ptr); seq_printf(m, "notify: %s/%s.%d\n", nstr[notify & ~SIGEV_THREAD_ID], (notify & SIGEV_THREAD_ID) ? "tid" : "pid",
include/linux/posix-timers.h +21 -2
@@ -39,6 +39,8 @@ static inline int clockid_to_fd(const clockid_t clk)#ifdef CONFIG_POSIX_TIMERS +#include <linux/signal_types.h> +/** * cpu_timer - Posix CPU timer representation for k_itimer * @node: timerqueue node to queue in the task/sig
@@ -165,7 +167,7 @@ static inline void posix_cputimers_init_work(void) { }* @it_pid: The pid of the process/task targeted by the signal * @it_process: The task to wakeup on clock_nanosleep (CPU timers) * @rcuref: Reference count for life time management -* @sigq: Pointer to preallocated sigqueue +* @sigq: Embedded sigqueue * @it: Union representing the various posix timer type * internals. * @rcu: RCU head for freeing the timer.
@@ -189,7 +191,7 @@ struct k_itimer {struct pid *it_pid;struct task_struct *it_process; }; -struct sigqueue *sigq; +struct sigqueue sigq;rcuref_t rcuref; union { struct {
@@ -217,6 +219,23 @@ static inline void posixtimer_putref(struct k_itimer *tmr)if (rcuref_put (&tmr->rcuref))posixtimer_free_timer (tmr); } + +static inline void posixtimer_sigqueue_getref (struct sigqueue *q) +{ + struct k_itimer *tmr = container_of(q, struct k_itimer, sigq); + +WARN_ON_ONCE (!rcuref_get (&tmr->rcuref)); +} + +static inline void posixtimer_sigqueue_putref (struct sigqueue *q) +{ + struct k_itimer *tmr = container_of(q, struct k_itimer, sigq); + +posixtimer_putref (tmr); +} +#else /* CONFIG_POSIX_TIMERS */ +static inline void posixtimer_sigqueue_getref (struct sigqueue *q) { } +static inline void posixtimer_sigqueue_putref (struct sigqueue *q) { }#endif /* !CONFIG_POSIX_TIMERS */ #endif
kernel/signal.c +10 -2
@@ -566,7 +566,12 @@ static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *i still_pending:list_del_init (&first->list);copy_siginfo (info, &first->info); -__sigqueue_free (first); +/* +* Do not drop the reference count for posix timer +* signals. That's done in posix_timer_deliver_signal(). +*/ +if (info->si_code !=SI_TIMER ) +__sigqueue_free (first); }else {/* * Ok, it wasn't in the queue. This must be
@@ -1981,7 +1986,7 @@ static inline struct task_struct *posixtimer_get_target(struct k_itimer *tmr)int posixtimer_send_sigqueue (struct k_itimer *tmr) { -struct sigqueue *q = tmr->sigq; +struct sigqueue *q = &tmr->sigq;int sig = q->info.si_signo;struct task_struct *t;unsigned long flags;
@@ -2041,9 +2046,12 @@ int posixtimer_send_sigqueue(struct k_itimer *tmr) ret =0 ;if (unlikely (!list_empty (&q->list))) { +/* This holds a reference count already */ result =TRACE_SIGNAL_ALREADY_PENDING ; goto out; } + +posixtimer_sigqueue_getref (q);posixtimer_queue_sigqueue (q, t, tmr->it_pid_type); result =TRACE_SIGNAL_DELIVERED ; out:
kernel/time/posix-timers.c +36 -23
121 lines not on this page · raw message
PATCH v4 19/27 signal: Cleanup unused posix-timer leftovers
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Remove the leftovers of sigqueue preallocation as it's not longer used.
--- include/linux/sched/signal.h | 2 -- kernel/signal.c | 43 +++++++------------------------------------ 2 files changed, 7 insertions(+), 38 deletions(-)
---
include/linux/sched/signal.h +0 -2
@@ -338,8 +338,6 @@ extern void force_fatal_sig(int);extern void force_exit_sig (int );extern int send_sig (int ,struct task_struct *,int );extern int zap_other_threads (struct task_struct *p); -extern struct sigqueue *sigqueue_alloc (void ); -extern void sigqueue_free (struct sigqueue *);extern int do_sigaction (int ,struct k_sigaction *,struct k_sigaction *);static inline void clear_notify_signal (void )
kernel/signal.c +7 -36
73 lines not on this page · raw message
PATCH v4 20/27 signal: Add task argument to flush_sigqueue_mask()
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To prepare for handling posix timer signals on sigaction(SIG_IGN) properly, add a task argument to flush_sigqueue_mask() and fixup all call sites.
This argument will be used in a later step to enqueue posix timers on an ignored list, so their signal can be requeued when SIG_IGN is lifted later on.
--- kernel/signal.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-)
---
kernel/signal.c +9 -10
@@ -724,11 +724,10 @@ void signal_wake_up_state(struct task_struct *t, unsigned int state)/* * Remove signals in mask from the pending set and queue. -* Returns 1 if any signals were found. * * All callers must be holding the siglock. */ -static void flush_sigqueue_mask (sigset_t *mask,struct sigpending *s) +static void flush_sigqueue_mask (sigset_t *mask,struct sigpending *s,struct task_struct *ptmr_tsk) {struct sigqueue *q, *n;sigset_t m;
@@ -866,18 +865,18 @@ static bool prepare_signal(int sig, struct task_struct *p, bool force)* This is a stop signal. Remove SIGCONT from all queues. */ siginitset (&flush,sigmask (SIGCONT )); -flush_sigqueue_mask (&flush, &signal->shared_pending); +flush_sigqueue_mask (&flush, &signal->shared_pending,NULL );for_each_thread (p, t) -flush_sigqueue_mask (&flush, &t->pending); +flush_sigqueue_mask (&flush, &t->pending,NULL ); }else if (sig ==SIGCONT ) {unsigned int why;/* * Remove all stop signals from all queues, wake all threads. */ siginitset (&flush,SIG_KERNEL_STOP_MASK ); -flush_sigqueue_mask (&flush, &signal->shared_pending); +flush_sigqueue_mask (&flush, &signal->shared_pending,NULL );for_each_thread (p, t) { -flush_sigqueue_mask (&flush, &t->pending); +flush_sigqueue_mask (&flush, &t->pending,NULL );task_clear_jobctl_pending (t,JOBCTL_STOP_PENDING );if (likely (!(t->ptrace &PT_SEIZED ))) { t->jobctl &= ~JOBCTL_STOPPED ;
@@ -4169,8 +4168,8 @@ void kernel_sigaction(int sig, __sighandler_t action)sigemptyset (&mask);sigaddset (&mask, sig); -flush_sigqueue_mask (&mask, ¤t->signal->shared_pending); -flush_sigqueue_mask (&mask, ¤t->pending); +flush_sigqueue_mask (&mask, ¤t->signal->shared_pending,NULL ); +flush_sigqueue_mask (&mask, ¤t->pending,NULL );recalc_sigpending (); }spin_unlock_irq (¤t->sighand->siglock);
@@ -4237,9 +4236,9 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)if (sig_handler_ignored (sig_handler (p, sig), sig)) {sigemptyset (&mask);sigaddset (&mask, sig); -flush_sigqueue_mask (&mask, &p->signal->shared_pending); +flush_sigqueue_mask (&mask, &p->signal->shared_pending,NULL );for_each_thread (p, t) -flush_sigqueue_mask (&mask, &t->pending); +flush_sigqueue_mask (&mask, &t->pending,NULL ); } }
PATCH v4 21/27 signal: Provide ignored_posix_timers list
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To prepare for handling posix timer signals on sigaction(SIG_IGN) properly, add a list to task::signal.
This list will be used to queue posix timers so their signal can be requeued when SIG_IGN is lifted later.
--- include/linux/sched/signal.h | 1 + init/init_task.c | 5 +++-- kernel/fork.c | 1 + 3 files changed, 5 insertions(+), 2 deletions(-)
---
include/linux/sched/signal.h +1 -0
@@ -138,6 +138,7 @@ struct signal_struct {/* POSIX.1b Interval Timers */ unsigned int next_posix_timer_id;struct hlist_head posix_timers; +struct hlist_head ignored_posix_timers;/* ITIMER_REAL timer for the process */ struct hrtimer real_timer;
init/init_task.c +3 -2
@@ -29,8 +29,9 @@ static struct signal_struct init_signals = { .cred_guard_mutex = __MUTEX_INITIALIZER(init_signals.cred_guard_mutex), .exec_update_lock =__RWSEM_INITIALIZER (init_signals.exec_update_lock), #ifdef CONFIG_POSIX_TIMERS - .posix_timers =HLIST_HEAD_INIT , - .cputimer = { + .posix_timers =HLIST_HEAD_INIT , + .ignored_posix_timers = HLIST_HEAD_INIT, + .cputimer = { .cputime_atomic = INIT_CPUTIME_ATOMIC, }, #endif
kernel/fork.c +1 -0
@@ -1862,6 +1862,7 @@ static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)#ifdef CONFIG_POSIX_TIMERS INIT_HLIST_HEAD (&sig->posix_timers); +INIT_HLIST_HEAD (&sig->ignored_posix_timers);hrtimer_init (&sig->real_timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); sig->real_timer.function = it_real_fn;#endif
PATCH v4 22/27 posix-timers: Handle ignored list on delete and exit
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
To handle posix timer signals on sigaction(SIG_IGN) properly, the timers will be queued on a separate ignored list.
Add the necessary cleanup code for timer_delete() and exit_itimers().
--- include/linux/posix-timers.h | 4 +++- kernel/time/posix-timers.c | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-)
---
include/linux/posix-timers.h +3 -1
@@ -151,7 +151,8 @@ static inline void posix_cputimers_init_work(void) { }/** * struct k_itimer - POSIX.1b interval timer structure. -* @list: List head for binding the timer to signals->posix_timers +* @list: List node for binding the timer to tsk::signal::posix_timers +* @ignored_list: List node for tracking ignored timers in tsk::signal::ignored_posix_timers * @t_hash: Entry in the posix timer hash table * @it_lock: Lock protecting the timer * @kclock: Pointer to the k_clock struct handling this timer
@@ -174,6 +175,7 @@ static inline void posix_cputimers_init_work(void) { }*/ struct k_itimer {struct hlist_node list; +struct hlist_node ignored_list;struct hlist_node t_hash;spinlock_t it_lock;const struct k_clock *kclock;
kernel/time/posix-timers.c +20 -0
@@ -1036,6 +1036,18 @@ int common_timer_del(struct k_itimer *timer)return 0 ; } +/* +* If the deleted timer is on the ignored list, remove it and +* drop the associated reference. +*/ +static inline void posix_timer_cleanup_ignored (struct k_itimer *tmr) +{ +if (!hlist_unhashed (&tmr->ignored_list)) { +hlist_del_init (&tmr->ignored_list); +posixtimer_putref (tmr); + } +} +static inline int timer_delete_hook (struct k_itimer *timer) {const struct k_clock *kc = timer->kclock;
@@ -1068,6 +1080,7 @@ SYSCALL_DEFINE1(timer_delete, timer_t, timer_id)spin_lock (¤t->sighand->siglock);hlist_del (&timer->list); +posix_timer_cleanup_ignored (timer);spin_unlock (¤t->sighand->siglock);/* * A concurrent lookup could check timer::it_signal lockless. It
@@ -1119,6 +1132,8 @@ static void itimer_delete(struct k_itimer *timer) }hlist_del (&timer->list); +posix_timer_cleanup_ignored (timer); +/* * Setting timer::it_signal to NULL is technically not required * here as nothing can access the timer anymore legitimately via
@@ -1151,6 +1166,11 @@ void exit_itimers(struct task_struct *tsk)/* The timers are not longer accessible via tsk::signal */ while (!hlist_empty (&timers)) itimer_delete(hlist_entry(timers.first, struct k_itimer, list)); + +/* Mop up timers which are on the ignored list */ +hlist_move_list (&tsk->signal->ignored_posix_timers, &timers); +while (!hlist_empty (&timers)) + posix_timer_cleanup_ignored(hlist_entry(timers.first, struct k_itimer, list)); } SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock,
PATCH v4 23/27 signal: Handle ignored signals in do_sigaction(action != SIG_IGN)
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
When a real handler (including SIG_DFL) is installed for a signal, which had previously SIG_IGN set, then the list of ignored posix timers has to be checked for timers which are affected by this change.
Add a list walk function which checks for the matching signal number and if found requeues the timers signal, so the timer is rearmed on signal delivery.
Rearming the timer right away is not possible because that requires to drop sighand lock.
No functional change as the counter part which queues the timers on the ignored list is still missing.
--- kernel/signal.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-)
---
kernel/signal.c +53 -1
@@ -2031,7 +2031,55 @@ int posixtimer_send_sigqueue(struct k_itimer *tmr)rcu_read_unlock ();return ret; } -#endif /* CONFIG_POSIX_TIMERS */ + +static void posixtimer_sig_unignore (struct task_struct *tsk,int sig) +{ +struct hlist_head *head = &tsk->signal->ignored_posix_timers; +struct hlist_node *tmp; +struct k_itimer *tmr; + +if (likely (hlist_empty (head))) +return ; + +/* +* Rearming a timer with sighand lock held is not possible due to +* lock ordering vs. tmr::it_lock. Just stick the sigqueue back and +* let the signal delivery path deal with it whether it needs to be +* rearmed or not. This cannot be decided here w/o dropping sighand +* lock and creating a loop retry horror show. +*/ +hlist_for_each_entry_safe (tmr, tmp , head, ignored_list) { +struct task_struct *target; + +/* +* tmr::sigq.info.si_signo is immutable, so accessing it +* without holding tmr::it_lock is safe. +*/ +if (tmr->sigq.info.si_signo != sig) +continue ; + +hlist_del_init (&tmr->ignored_list); + +/* This should never happen and leaks a reference count */ +if (WARN_ON_ONCE (!list_empty (&tmr->sigq.list))) +continue ; + +/* +* Get the target for the signal. If target is a thread and +* has exited by now, drop the reference count. +*/ +rcu_read_lock (); + target =posixtimer_get_target (tmr); +if (target) +posixtimer_queue_sigqueue (&tmr->sigq, target, tmr->it_pid_type); +else +posixtimer_putref (tmr); +rcu_read_unlock (); + } +} +#else /* CONFIG_POSIX_TIMERS */ +static inline void posixtimer_sig_unignore (struct task_struct *tsk,int sig) { } +#endif /* !CONFIG_POSIX_TIMERS */ void do_notify_pidfd (struct task_struct *task) {
@@ -4219,6 +4267,8 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)sigaction_compat_abi (act, oact);if (act) { +bool was_ignored = k->sa.sa_handler ==SIG_IGN ; +sigdelsetmask (&act->sa.sa_mask,sigmask (SIGKILL ) |sigmask (SIGSTOP )); *k = *act;
@@ -4239,6 +4289,8 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)flush_sigqueue_mask (&mask, &p->signal->shared_pending,NULL );for_each_thread (p, t)flush_sigqueue_mask (&mask, &t->pending,NULL ); + }else if (was_ignored) { +posixtimer_sig_unignore (p, sig); } }
PATCH v4 24/27 signal: Queue ignored posixtimers on ignore list
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Queue posixtimers which have their signal ignored on the ignored list:
1) When the timer fires and the signal has SIG_IGN set
2) When SIG_IGN is installed via sigaction() and a timer signal is already queued
This completes the SIG_IGN handling and such timers are not longer self rearmed which avoids pointless wakeups.
--- kernel/signal.c | 44 ++++++++++++++++++++++++++++++++++++-------- 1 file changed, 36 insertions(+), 8 deletions(-)
---
kernel/signal.c +36 -8
@@ -722,6 +722,16 @@ void signal_wake_up_state(struct task_struct *t, unsigned int state)kick_process (t); } +static inline void posixtimer_sig_ignore (struct task_struct *tsk,struct sigqueue *q); + +static void sigqueue_free_ignored (struct task_struct *ptmr_tsk,struct sigqueue *q) +{ +if (likely (!ptmr_tsk || q->info.si_code !=SI_TIMER )) +__sigqueue_free (q); +else +posixtimer_sig_ignore (ptmr_tsk, q); +} +/* * Remove signals in mask from the pending set and queue. *
@@ -740,7 +750,7 @@ static void flush_sigqueue_mask(sigset_t *mask, struct sigpending *s, struct taslist_for_each_entry_safe (q, n, &s->list, list) {if (sigismember (mask, q->info.si_signo)) {list_del_init (&q->list); -__sigqueue_free (q); +sigqueue_free_ignored (ptmr_tsk, q); } } }
@@ -1960,9 +1970,8 @@ int posixtimer_send_sigqueue(struct k_itimer *tmr)int sig = q->info.si_signo;struct task_struct *t;unsigned long flags; -int ret, result; +int result; - ret =-1 ;rcu_read_lock (); t =posixtimer_get_target (tmr);
@@ -2008,13 +2017,24 @@ int posixtimer_send_sigqueue(struct k_itimer *tmr)*/ q->info.si_overrun =0 ; - ret =1 ;/* the signal is ignored */ if (!prepare_signal (sig, t, false)) { result =TRACE_SIGNAL_IGNORED ; + +/* Paranoia check. Try to survive. */ +if (WARN_ON_ONCE (!list_empty (&q->list))) + goto out; + +if (hlist_unhashed (&tmr->ignored_list)) { +hlist_add_head (&tmr->ignored_list, &t->signal->ignored_posix_timers); +posixtimer_sigqueue_getref (q); + } goto out; } - ret =0 ; +/* This should never happen and leaks a reference count */ +if (WARN_ON_ONCE (!hlist_unhashed (&tmr->ignored_list))) +hlist_del_init (&tmr->ignored_list); +if (unlikely (!list_empty (&q->list))) {/* This holds a reference count already */ result =TRACE_SIGNAL_ALREADY_PENDING ;
@@ -2029,7 +2049,14 @@ int posixtimer_send_sigqueue(struct k_itimer *tmr)unlock_task_sighand (t, &flags); ret:rcu_read_unlock (); -return ret; +return 0 ; +} + +static inline void posixtimer_sig_ignore (struct task_struct *tsk,struct sigqueue *q) +{ + struct k_itimer *tmr = container_of(q, struct k_itimer, sigq); + +hlist_add_head (&tmr->ignored_list, &tsk->signal->ignored_posix_timers); }static void posixtimer_sig_unignore (struct task_struct *tsk,int sig)
@@ -2078,6 +2105,7 @@ static void posixtimer_sig_unignore(struct task_struct *tsk, int sig) } }#else /* CONFIG_POSIX_TIMERS */ +static inline void posixtimer_sig_ignore (struct task_struct *tsk,struct sigqueue *q) { }static inline void posixtimer_sig_unignore (struct task_struct *tsk,int sig) { }#endif /* !CONFIG_POSIX_TIMERS */
@@ -4286,9 +4314,9 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)if (sig_handler_ignored (sig_handler (p, sig), sig)) {sigemptyset (&mask);sigaddset (&mask, sig); -flush_sigqueue_mask (&mask, &p->signal->shared_pending,NULL ); +flush_sigqueue_mask (&mask, &p->signal->shared_pending, p);for_each_thread (p, t) -flush_sigqueue_mask (&mask, &t->pending,NULL ); +flush_sigqueue_mask (&mask, &t->pending, p); }else if (was_ignored) {posixtimer_sig_unignore (p, sig); }
PATCH v4 25/27 posix-timers: Cleanup SIG_IGN workaround leftovers
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Now that ignored posix timer signals are requeued and the timers are rearmed on signal delivery the workaround to keep such timers alive and self rearm them is not longer required.
Remove the relevant hacks and the not longer required return values from the related functions. The alarm timer workarounds will be cleaned up in a separate step.
--- include/linux/posix-timers.h | 2 - kernel/signal.c | 3 - kernel/time/alarmtimer.c | 47 +++++------------------------ kernel/time/posix-cpu-timers.c | 18 ++--------- kernel/time/posix-timers.c | 65 +++-------------------------------------- kernel/time/posix-timers.h | 2 - 6 files changed, 21 insertions(+), 116 deletions(-)
---
include/linux/posix-timers.h +1 -1
@@ -111,7 +111,7 @@ static inline void posix_cputimers_rt_wavoid posixtimer_rearm_itimer (struct task_struct *p);bool posixtimer_init_sigqueue (struct sigqueue *q); -int posixtimer_send_sigqueue (struct k_itimer *tmr); +void posixtimer_send_sigqueue (struct k_itimer *tmr);bool posixtimer_deliver_signal (struct kernel_siginfo *info);void posixtimer_free_timer (struct k_itimer *timer);
kernel/signal.c +1 -2
@@ -1964,7 +1964,7 @@ static inline struct task_struct *posixtreturn t; } -int posixtimer_send_sigqueue (struct k_itimer *tmr) +void posixtimer_send_sigqueue (struct k_itimer *tmr) {struct sigqueue *q = &tmr->sigq;int sig = q->info.si_signo;
@@ -2049,7 +2049,6 @@ int posixtimer_send_sigqueue(struct k_itunlock_task_sighand (t, &flags); ret:rcu_read_unlock (); -return 0 ; }static inline void posixtimer_sig_ignore (struct task_struct *tsk,struct sigqueue *q)
kernel/time/alarmtimer.c +9 -38
67 lines not on this page · raw message
kernel/time/posix-cpu-timers.c +4 -14
@@ -595,21 +595,11 @@ static void cpu_timer_fire(struct k_itim*/ wake_up_process (timer->it_process);cpu_timer_setexpires (ctmr,0 ); - }else if (!timer->it_interval) { -/* -* One-shot timer. Clear it as soon as it's fired. -*/ + }else {posix_timer_queue_signal (timer); -cpu_timer_setexpires (ctmr,0 ); - }else if (posix_timer_queue_signal (timer)) { -/* -* The signal did not get queued because the signal -* was ignored, so we won't get any callback to -* reload the timer. But we need to keep it -* ticking in case the signal is deliverable next time. -*/ -posix_cpu_timer_rearm (timer); - ++timer->it_signal_seq; +/* Disable oneshot timers */ +if (!timer->it_interval) +cpu_timer_setexpires (ctmr,0 ); } }
kernel/time/posix-timers.c +5 -60
86 lines not on this page · raw message
kernel/time/posix-timers.h +1 -1
@@ -42,7 +42,7 @@ extern const struct k_clock clock_procesextern const struct k_clock clock_thread;extern const struct k_clock alarm_clock; -int posix_timer_queue_signal (struct k_itimer *timr); +void posix_timer_queue_signal (struct k_itimer *timr);void common_timer_get (struct k_itimer *timr,struct itimerspec64 *cur_setting); int common_timer_set(struct k_itimer *timr, int flags,
PATCH v4 26/27 alarmtimers: Remove the throttle mechanism from alarm_forward_now()
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Now that ignored posix timer signals are requeued and the timers are rearmed on signal delivery the workaround to keep such timers alive and self rearm them is not longer required.
Remove the unused alarm timer parts.
--- kernel/time/alarmtimer.c | 28 ++-------------------------- 1 file changed, 2 insertions(+), 26 deletions(-)
---
kernel/time/alarmtimer.c +2 -26
@@ -467,35 +467,11 @@ u64 alarm_forward(struct alarm *alarm, k }EXPORT_SYMBOL_GPL (alarm_forward); -static u64 __alarm_forward_now (struct alarm *alarm,ktime_t interval,bool throttle) +u64 alarm_forward_now (struct alarm *alarm,ktime_t interval) {struct alarm_base *base = &alarm_bases[alarm->type]; -ktime_t now = base->get_ktime (); - -if (IS_ENABLED (CONFIG_HIGH_RES_TIMERS ) && throttle) { -/* -* Same issue as with posix_timer_fn(). Timers which are -* periodic but the signal is ignored can starve the system -* with a very small interval. The real fix which was -* promised in the context of posix_timer_fn() never -* materialized, but someone should really work on it. -* -* To prevent DOS fake @now to be 1 jiffy out which keeps -* the overrun accounting correct but creates an -* inconsistency vs. timer_gettime(2). -*/ -ktime_t kj =NSEC_PER_SEC /HZ ; -if (interval < kj) - now =ktime_add (now, kj); - } - -return alarm_forward (alarm, now, interval); -} - -u64 alarm_forward_now (struct alarm *alarm,ktime_t interval) -{ -return __alarm_forward_now (alarm, interval, false); +return alarm_forward (alarm, base->get_ktime (), interval); }EXPORT_SYMBOL_GPL (alarm_forward_now);
PATCH v4 27/27 alarmtimers: Remove return value from alarm functions
In reply to Thomas GleixnerFrom: Thomas Gleixner <[email protected]>
Now that the SIG_IGN problem is solved in the core code, the alarmtimer callbacks do not require a return value anymore.
--- drivers/power/supply/charger-manager.c | 3 +-- fs/timerfd.c | 4 +--- include/linux/alarmtimer.h | 10 ++-------- kernel/time/alarmtimer.c | 16 +++++----------- net/netfilter/xt_IDLETIMER.c | 4 +--- 5 files changed, 10 insertions(+), 27 deletions(-)
---
drivers/power/supply/charger-manager.c +1 -2
@@ -1412,10 +1412,9 @@ static inline struct charger_desc *cm_get_drv_data(struct platform_device *pdev)return dev_get_platdata (&pdev->dev); } -static enum alarmtimer_restart cm_timer_func (struct alarm *alarm,ktime_t now) +static void cm_timer_func (struct alarm *alarm,ktime_t now) { cm_timer_set = false; -return ALARMTIMER_NORESTART ; }static int charger_manager_probe (struct platform_device *pdev)
fs/timerfd.c +1 -3
@@ -79,13 +79,11 @@ static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *htmr)return HRTIMER_NORESTART ; } -static enum alarmtimer_restart timerfd_alarmproc (struct alarm *alarm, -ktime_t now) +static void timerfd_alarmproc (struct alarm *alarm,ktime_t now) { struct timerfd_ctx *ctx = container_of(alarm, struct timerfd_ctx, t.alarm);timerfd_triggered (ctx); -return ALARMTIMER_NORESTART ; }/*
include/linux/alarmtimer.h +2 -8
@@ -20,12 +20,6 @@ enum alarmtimer_type { ALARM_BOOTTIME_FREEZER, }; -enum alarmtimer_restart { -ALARMTIMER_NORESTART , -ALARMTIMER_RESTART , -}; - -#define ALARMTIMER_STATE_INACTIVE 0x00#define ALARMTIMER_STATE_ENQUEUED 0x01
@@ -42,14 +36,14 @@ enum alarmtimer_restart {struct alarm {struct timerqueue_node node;struct hrtimer timer; -enum alarmtimer_restart (*function)(struct alarm *,ktime_t now); +void (*function)(struct alarm *,ktime_t now);enum alarmtimer_type type;int state;void *data; };void alarm_init (struct alarm *alarm,enum alarmtimer_type type, -enum alarmtimer_restart (*function)(struct alarm *,ktime_t )); +void (*function)(struct alarm *,ktime_t ));void alarm_start (struct alarm *alarm,ktime_t start);void alarm_start_relative (struct alarm *alarm,ktime_t start);void alarm_restart (struct alarm *alarm);
kernel/time/alarmtimer.c +5 -11
@@ -321,7 +321,7 @@ static int alarmtimer_resume(struct device *dev)static void __alarm_init (struct alarm *alarm,enum alarmtimer_type type, -enum alarmtimer_restart (*function)(struct alarm *,ktime_t )) +void (*function)(struct alarm *,ktime_t )) {timerqueue_init (&alarm->node); alarm->timer.function = alarmtimer_fired;
@@ -337,7 +337,7 @@ __alarm_init(struct alarm *alarm, enum alarmtimer_type type,* @function: callback that is run when the alarm fires */ void alarm_init (struct alarm *alarm,enum alarmtimer_type type, -enum alarmtimer_restart (*function)(struct alarm *,ktime_t )) +void (*function)(struct alarm *,ktime_t )) {hrtimer_init (&alarm->timer, alarm_bases[type].base_clockid,HRTIMER_MODE_ABS );
@@ -530,14 +530,12 @@ static enum alarmtimer_type clock2alarm(clockid_t clockid)* * Return: whether the timer is to be restarted */ -static enum alarmtimer_restart alarm_handle_timer (struct alarm *alarm,ktime_t now) +static void alarm_handle_timer (struct alarm *alarm,ktime_t now) { struct k_itimer *ptr = container_of(alarm, struct k_itimer, it.alarm.alarmtimer);guard (spinlock_irqsave)(&ptr->it_lock);posix_timer_queue_signal (ptr); - -return ALARMTIMER_NORESTART ; }/**
@@ -698,18 +696,14 @@ static int alarm_timer_create(struct k_itimer *new_timer)* @now: time at the timer expiration * * Wakes up the task that set the alarmtimer -* -* Return: ALARMTIMER_NORESTART */ -static enum alarmtimer_restart alarmtimer_nsleep_wakeup (struct alarm *alarm, -ktime_t now) +static void alarmtimer_nsleep_wakeup (struct alarm *alarm,ktime_t now) {struct task_struct *task = alarm->data; alarm->data =NULL ;if (task)wake_up_process (task); -return ALARMTIMER_NORESTART ; }/**
@@ -761,7 +755,7 @@ static int alarmtimer_do_nsleep(struct alarm *alarm, ktime_t absexp,static void alarm_init_on_stack (struct alarm *alarm,enum alarmtimer_type type, -enum alarmtimer_restart (*function)(struct alarm *,ktime_t )) +void (*function)(struct alarm *,ktime_t )) {hrtimer_init_on_stack (&alarm->timer, alarm_bases[type].base_clockid,HRTIMER_MODE_ABS );
net/netfilter/xt_IDLETIMER.c +1 -3
@@ -107,14 +107,12 @@ static void idletimer_tg_expired(struct timer_list *t)schedule_work (&timer->work); } -static enum alarmtimer_restart idletimer_tg_alarmproc (struct alarm *alarm, -ktime_t now) +static void idletimer_tg_alarmproc (struct alarm *alarm,ktime_t now) {struct idletimer_tg *timer = alarm->data;pr_debug ("alarm %s expired\n" , timer->attr.attr.name);schedule_work (&timer->work); -return ALARMTIMER_NORESTART ; }static int idletimer_check_sysfs_name (const char *name,unsigned int size)
Quoted 95 lines · Thomas Gleixner
This are the remaining bits to cure the
SIG_IGNmess. The preparatory work from the previous version 3 has been merged already. Version 3 can be found here:https://lore.kernel.org/lkml/[email protected]Last year I reread a 15 years old comment about the
SIG_IGNproblem:"FIXME: What we really want, is to stop this timer completely and restart
it in case theSIG_IGNis removed. This is a non trivial change which involves sighand locking (sigh !), which we don't want to do late in the release cycle. ... A more complex fix which solves also another related inconsistency is already in the pipeline."The embarrasing part was that I put that comment in back then. So I went back and rumaged through old notes as I completely had forgotten why our attempts to fix this back then failed.
It turned out that the comment is about right: sighand locking and life time issues. So I sat down with the old notes and started to wrap my head around this again.
The problem to solve:
Posix interval timers are not rearmed automatically by the kernel for various reasons:
1) To prevent DoS by extremly short intervals.
2) To avoid timer overhead when a signal is pending and has not yet been delivered.This is achieved by queueing the signal at timer expiry and rearming the timer at signal delivery to user space. This puts the rearming basically under scheduler control and the work happens in context of the task which asked for the signal.
There is a problem with that vs.
SIG_IGN. If a signal hasSIG_IGNinstalled as handler, the related signals are discarded. So in case of posix interval timers this means that such a timer is never rearmed even whenSIG_IGNis replaced later with a real handler (includingSIG_DFL).To work around that the kernel self rearms those timers and throttles them when the interval is smaller than a tick to prevent a DoS.
That just keeps timers ticking, which obviously has effects on power and just creates work for nothing.
So ideally these timers should be stopped and rearmed when
SIG_IGNis replaced, which aligns with the regular handling of posix timers.Sounds trivial, but isn't:
1) Lock ordering.
The timer lock cannot be taken with sighand lock held which is problematic vs. the atomicity of
sigaction().2) Life time rules
The timer and the sigqueue are separate entities which requires a lookup of the timer ID in the signal rearm code. This can be handled, but the separate life time rules are not necessarily robust.
3) Finding the relevant timers
Obviosly it is possible to walk the posix timer list under sighand lock and handle it from there. That can be expensive especially in the case that there are no affected timers as the walk would just end up doing nothing.
The following series is a new and this time actually working attempt to solve this. It addresses it by:
1) Embedding the preallocated sigqueue into struct
k_itimer, which makes the life time rules way simpler and just needs a trivial reference count.2) Having a separate list in
task::signalon which ignored timers are queued.This avoids walking a potentially large timer list for nothing on a
SIG_IGNto handler transition.3) Requeueing the timers signal in the relevant signal queue so the timer is rearmed when the signal is actually delivered
That turned out to be the least complicated way to address the sighand lock vs. timer lock ordering issue.
With that timers which have their signal ignored are not longer self rearmed and the relevant workarounds including throttling for DoS prevention are removed.
The series is also available from git:
Quoted 7 lines
git://git.kernel.org/pub/scm/linux/kernel/git/tglx/devel.gitposixt-v4Changes vs. V3:
- Rebased to mainline
- Fixed up a intermediate build breakage reported by 0-day
I have stopped looking at this after patch 4.
The current code can and does handle userspace injecting a signal with si_sys_private sent to an non-zero value using rt_sigqueueinfo(2) and that value will be delivered to userspace.
I think the at least the ability to inject such a signal (ignoring si_sys_private) is very interesting for debuggers and checkpoint restart applications.
I get the feeling the rest of the patch series depends upon not supporting userspace injecting signals with si_code == SI_TIMER. That seems unnecessary.
It seems reasonable to depend upon something like the SIGQUEUE_PREALLOC in the flags field of struct sigqueue to detect a kernel generated signal. Rather than adding various hacks to make everything work with just a struct kernel_siginfo_t. Especially as the timer signals today are the only signals that are preallocated.
Is there any chance 18/27 posix-timers: Embed sigqueue in struct k_itimer can be moved up?
That should allow removing the reliance on si_sys_private.
That should prevent the need to add another hack with sys_private_ptr in struct kernel_siginfo
Perhaps what needs to happen is to update collect_signal to return the sigqueue entry (if it was preallocated), instead of the resched_timer. Then the timer code can just use container_of to get the struct k_itimer?
After that si_sys_private can move into struct k_itimer, and the code won't need to worry about userspace setting that value, or about needing to clear that value. As si_sys_private will always be 0 in preallocated signals.
Eric
Quoted 14 lines · Eric W. Biederman
I have stopped looking at this after patch 4.
The current code can and does handle userspace injecting a signal with
si_sys_privatesent to an non-zero value usingrt_sigqueueinfo(2)and that value will be delivered to userspace.I think the at least the ability to inject such a signal (ignoring
si_sys_private) is very interesting for debuggers and checkpoint restart applications.I get the feeling the rest of the patch series depends upon not supporting userspace injecting signals with
si_code==SI_TIMER. That seems unnecessary.
Quoted 5 lines
It seems reasonable to depend upon something like the
SIGQUEUE_PREALLOCin the flags field of struct sigqueue to detect a kernel generated signal. Rather than adding various hacks to make everything work with just a structkernel_siginfo_t. Especially as the timer signals today are the only signals that are preallocated.
Fair enough.
Quoted 13 lines
Is there any chance 18/27 posix-timers: Embed sigqueue in struct
k_itimercan be moved up?That should allow removing the reliance on
si_sys_private.That should prevent the need to add another hack with
sys_private_ptrin structkernel_siginfoPerhaps what needs to happen is to update
collect_signalto return the sigqueue entry (if it was preallocated), instead of theresched_timer. Then the timer code can just usecontainer_ofto get the structk_itimer?
Quoted 4 lines
After that
si_sys_privatecan move into structk_itimer, and the code won't need to worry about userspace setting that value, or about needing to clear that value. Assi_sys_privatewill always be 0 in preallocated signals.
Let me try that.
Thanks for taking a look!
tglx