Skip to contentSkip to conversation

extend print_fatal_signals for reached RLIMIT_SIGPENDING

PATCH In review Naohiro Ooiwa 2 participants 3 messages Nov 8, 2009 – Nov 9, 2009 Documentation

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 extend print_fatal_signals for reached RLIMIT_SIGPENDING

When the system has too many timers or too many aggregate queued signals, the EAGAIN error is returned to application from kernel, including timer_create().
It means that exceeded limit of pending signals at all. But we can't imagine it.

This patch show the message when reached limit of pending signals and enabled print_fatal_signals.
If you see this message and your system behaved unexpectedly, you can run following command.

   # ulimit -i unlimited

With help from Hiroshi Shimamoto <[email protected]>.

---
 Documentation/kernel-parameters.txt |   11 +++++++++--
 kernel/signal.c                     |   21 ++++++++++++++++++---
 2 files changed, 27 insertions(+), 5 deletions(-)
(quoted diff) +0 -0

b/Documentation/kernel-parameters.txt
index 9107b38..3bbd92f 100644

Documentation/kernel-parameters.txt +0 -0
@@ -2032,8 +2032,15 @@ and is between 256 and 4096 characters. It is defined in

the file

print-fatal-signals=
[KNL] debug: print fatal signals
- print-fatal-signals=1: print segfault info to
- the kernel console.
+
+ If enabled, warn about various signal handling
+ related application anomalies: too many signals,
+ too many POSIX.1 timers, fatal signals causing a
+ coredump - etc.
+
+ If you hit the warning due to signal overflow,
+ you might want to try "ulimit -i unlimited".
+
default: off.

printk.time= Show timing data prefixed to each printk message line

kernel/signal.c +13 -0
index 6705320..56e9c00 100644
@@ -41,6 +41,8 @@
 
 static struct kmem_cache *sigqueue_cachep;
 
+int print_fatal_signals __read_mostly;
+
 static void __user *sig_handler(struct task_struct *t, int sig)
 {
 	return t->sighand->action[sig - 1].sa.sa_handler;
@@ -188,6 +190,17 @@ int next_signal(struct sigpending *pending, sigset_t *mask)
 	return sig;
 }
 
+static void show_reach_rlimit_sigpending(void)
+{
+	static DEFINE_RATELIMIT_STATE(printk_rl_state, 5 * HZ, 10);
+
+	if (!__ratelimit(&printk_rl_state))
+		return;
+
+	printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING.\n",
+				current->comm, current->pid);
+}
+
 /*
  * allocate a new signal queue record
  * - this may be called without locks if and only if t == current, otherwise an
@@ -209,8 +222,12 @@ static struct sigqueue *__sigqueue_alloc(struct task_struct

*t, gfp_t flags,
atomic_inc(&user->sigpending);
if (override_rlimit ||
atomic_read(&user->sigpending) <=
- t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
+ t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur) {
q = kmem_cache_alloc(sigqueue_cachep, flags);
+ } else {
+ if (print_fatal_signals)
+ show_reach_rlimit_sigpending();
+ }
if (unlikely(q == NULL)) {
atomic_dec(&user->sigpending);
free_uid(user);
@@ -925,8 +942,6 @@ static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
return __send_signal(sig, info, t, group, from_ancestor_ns);
}

-int print_fatal_signals;
-
static void print_fatal_signal(struct pt_regs *regs, int signr) {
printk("%s/%d: potentially unexpected fatal signal %d.\n",
-- 1.5.4.1

#1 lore raw
Quoted 15 lines · Naohiro Ooiwa

When the system has too many timers or too many aggregate queued signals, the EAGAIN error is returned to application from kernel, including timer_create().
It means that exceeded limit of pending signals at all. But we can't imagine it.

This patch show the message when reached limit of pending signals and enabled print_fatal_signals.
If you see this message and your system behaved unexpectedly, you can run following command.

   # ulimit -i unlimited

With help from Hiroshi Shimamoto <[email protected]>.

Quoted 6 lines
---
 Documentation/kernel-parameters.txt |   11 +++++++++--
 kernel/signal.c                     |   21 ++++++++++++++++++---
 2 files changed, 27 insertions(+), 5 deletions(-)

Thanks, i've applied your patch to tip:core/signal, for v2.6.33 merge (if it passes all tests).

I made a few (very small) changes, see the -tip commit notification email in this thread with the final commit:

- Extended the functions so that we can print which precise signal got dropped - app writers will likely want to know that

- Changed the message to:

task/1234: reached RLIMIT_SIGPENDING, dropping signal

which is slightly more informative.

- Cleaned up small cleanliness details in surrounding code that caught my eyes.

- Changed a few variable and function names to be a tiny bit more expressive.

- Pushed the print_fatal_printks check into the new utility function (print_dropped_signal()), to not clutter __sigqueue_alloc() needlessly.

- Clarified the commit log message a bit, gave sample output of the new behavior.

Thanks,

Ingo

#2 lore raw

[tip:core/signal] signal: Print warning message when dropping signals

In reply to Naohiro Ooiwa
Commit-ID:  f84d49b218b7d4c6cba2e0b41f24bd4045403962
Gitweb:     http://git.kernel.org/tip/f84d49b218b7d4c6cba2e0b41f24bd4045403962
Author:     Naohiro Ooiwa <[email protected]>
AuthorDate: Mon, 9 Nov 2009 00:46:42 +0900
Committer:  Ingo Molnar <[email protected]>
CommitDate: Mon, 9 Nov 2009 09:44:26 +0100

signal: Print warning message when dropping signals

When the system has too many timers or too many aggregate queued signals, the EAGAIN error is returned to application from kernel, including timer_create() [POSIX.1b].

It means that the app exceeded the limit of pending signals, but in general application writers do not expect this outcome and the current silent failure can cause rare app failures under very high load.

This patch adds a new message when we reach the limit and if print_fatal_signals is enabled:

task/1234: reached RLIMIT_SIGPENDING, dropping signal

If you see this message and your system behaved unexpectedly, you can run following command to lift the limit:

   # ulimit -i unlimited

With help from Hiroshi Shimamoto <[email protected]>.

Cc Andrew Morton <[email protected]>
Cc Hiroshi Shimamoto <[email protected]>
Cc Roland McGrath <[email protected]>
Cc Peter Zijlstra <[email protected]>

LKML-Reference: <[email protected]>

[ Modified a few small details, gave surrounding code some love. ]
---
 Documentation/kernel-parameters.txt |   11 +++++++-
 kernel/signal.c                     |   46 +++++++++++++++++++++++++----------
 2 files changed, 42 insertions(+), 15 deletions(-)
Documentation/kernel-parameters.txt +9 -2
index 9107b38..3bbd92f 100644
@@ -2032,8 +2032,15 @@ and is between 256 and 4096 characters. It is defined in the file
 
 	print-fatal-signals=
 			[KNL] debug: print fatal signals
-			print-fatal-signals=1: print segfault info to
-			the kernel console.
+
+			If enabled, warn about various signal handling
+			related application anomalies: too many signals,
+			too many POSIX.1 timers, fatal signals causing a
+			coredump - etc.
+
+			If you hit the warning due to signal overflow,
+			you might want to try "ulimit -i unlimited".
+
 			default: off.
 
 	printk.time=	Show timing data prefixed to each printk message line
kernel/signal.c +33 -13

113 lines not on this page · raw message