25591c322

Denis Vlasenko

2008-02-16

FAILED Duration: 17s

Subject

libbb: introduce bb_signals and bb_signals_recursive, which sets same handler for many signals. sig_catch is nuked (bb_signals_recursive is more descriptive name). *: use them as appropriate.

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

console-tools/resize.c+6 -4

@@ -37,10 +37,12 @@ int resize_main(int argc, char **argv)
	new = old_termios;
	new.c_cflag \|= (CLOCAL \| CREAD);
	new.c_lflag &= ~(ICANON \| ECHO \| ECHOE \| ISIG);
-	signal(SIGINT, onintr);
-	signal(SIGQUIT, onintr);
-	signal(SIGTERM, onintr);
-	signal(SIGALRM, onintr);
+	bb_signals(0
+	+ (1 << SIGINT)
+	+ (1 << SIGQUIT)
+	+ (1 << SIGTERM)
+	+ (1 << SIGALRM)
+	, onintr);
	tcsetattr(STDERR_FILENO, TCSANOW, &new);

	/* save_cursor_pos 7

coreutils/tee.c+2 -2

@@ -36,12 +36,12 @@ int tee_main(int argc, char **argv)
	mode += (retval & 2); /* Since 'a' is the 2nd option... */

	if (retval & 1) {
-	signal(SIGINT, SIG_IGN); /* TODO - switch to sigaction. */
+	signal(SIGINT, SIG_IGN); /* TODO - switch to sigaction. (why?) */
	}
	retval = EXIT_SUCCESS;
	/* gnu tee ignores SIGPIPE in case one of the output files is a pipe
	* that doesn't consume all its input. Good idea... */
-	signal(SIGPIPE, SIG_IGN); /* TODO - switch to sigaction. */
+	signal(SIGPIPE, SIG_IGN);

	/* Allocate an array of FILE 's, with one extra for a sentinal. /
	fp = files = xzalloc(sizeof(FILE ) (argc + 2));

include/libbb.h+12 -8

@@ -274,14 +274,18 @@ char xrealloc_getcwd_or_warn(char cwd);

	char xmalloc_follow_symlinks(const char path);

-	//TODO: signal(sid, f) is the same? then why?
-	extern void sig_catch(int,void (*)(int));
-	//#define sig_ignore(s) (sig_catch((s), SIG_IGN))
-	//#define sig_uncatch(s) (sig_catch((s), SIG_DFL))
-	extern void sig_block(int);
-	extern void sig_unblock(int);
-	/* UNUSED: extern void sig_blocknone(void); */
-	extern void sig_pause(void);
+	//enum {
+	// BB_SIGS_FATAL = ,
+	//};
+	void bb_signals(int sigs, void (*f)(int));
+	/* Unlike signal() and bb_signals, sets handler with sigaction()
+	* and in a way that while signal handler is run, no other signals
+	* will be blocked: */
+	void bb_signals_recursive(int sigs, void (*f)(int));
+	void sig_block(int);
+	void sig_unblock(int);
+	/* UNUSED: void sig_blocknone(void); */
+	void sig_pause(void);


	void xsetgid(gid_t gid);

init/init.c+29 -19

@@ -319,15 +319,17 @@ static pid_t run(const struct init_action *a)
	/* Child */

	/* Reset signal handlers that were set by the parent process */
-	signal(SIGUSR1, SIG_DFL);
-	signal(SIGUSR2, SIG_DFL);
-	signal(SIGINT, SIG_DFL);
-	signal(SIGTERM, SIG_DFL);
-	signal(SIGHUP, SIG_DFL);
-	signal(SIGQUIT, SIG_DFL);
-	signal(SIGCONT, SIG_DFL);
-	signal(SIGSTOP, SIG_DFL);
-	signal(SIGTSTP, SIG_DFL);
+	bb_signals(0
+	+ (1 << SIGUSR1)
+	+ (1 << SIGUSR2)
+	+ (1 << SIGINT)
+	+ (1 << SIGTERM)
+	+ (1 << SIGHUP)
+	+ (1 << SIGQUIT)
+	+ (1 << SIGCONT)
+	+ (1 << SIGSTOP)
+	+ (1 << SIGTSTP)
+	, SIG_DFL);

	/* Create a new session and make ourself the process
	* group leader */
@@ -349,9 +351,11 @@ static pid_t run(const struct init_action *a)

	if (pid > 0) {
	/* Parent - wait till the child is done */
-	signal(SIGINT, SIG_IGN);
-	signal(SIGTSTP, SIG_IGN);
-	signal(SIGQUIT, SIG_IGN);
+	bb_signals(0
+	+ (1 << SIGINT)
+	+ (1 << SIGTSTP)
+	+ (1 << SIGQUIT)
+	, SIG_IGN);
	signal(SIGCHLD, SIG_DFL);

	waitfor(pid);
@@ -864,15 +868,21 @@ int init_main(int argc, char **argv)
	}
	/* Set up sig handlers -- be sure to
	* clear all of these in run() */
-	signal(SIGHUP, exec_restart_action);
-	signal(SIGQUIT, exec_restart_action);
-	signal(SIGUSR1, halt_reboot_pwoff); /* halt */
-	signal(SIGUSR2, halt_reboot_pwoff); /* poweroff */
-	signal(SIGTERM, halt_reboot_pwoff); /* reboot */
+	bb_signals(0
+	+ (1 << SIGHUP)
+	+ (1 << SIGQUIT)
+	, exec_restart_action);
+	bb_signals(0
+	+ (1 << SIGUSR1) /* halt */
+	+ (1 << SIGUSR2) /* poweroff */
+	+ (1 << SIGTERM) /* reboot */
+	, halt_reboot_pwoff);
	signal(SIGINT, ctrlaltdel_signal);
	signal(SIGCONT, cont_handler);
-	signal(SIGSTOP, stop_handler);
-	signal(SIGTSTP, stop_handler);
+	bb_signals(0
+	+ (1 << SIGSTOP)
+	+ (1 << SIGTSTP)
+	, stop_handler);

	/* Turn off rebooting via CTL-ALT-DEL -- we get a
	* SIGINT on CAD so we can shut things down gracefully... */

libbb/Kbuild+1 -0

@@ -78,6 +78,7 @@ lib-y += safe_strncpy.o
	lib-y += safe_write.o
	lib-y += setup_environment.o
	lib-y += sha1.o
+	lib-y += signals.o
	lib-y += simplify_path.o
	lib-y += skip_whitespace.o
	lib-y += speed_table.o

libbb/signals.c+80 -0

@@ -0,0 +1,80 @@
+	/* vi: set sw=4 ts=4: */
+	/*
+	* Utility routines.
+	*
+	* Copyright (C) 1999-2004 by Erik Andersen <[email protected]>
+	* Copyright (C) 2006 Rob Landley
+	* Copyright (C) 2006 Denis Vlasenko
+	*
+	* Licensed under GPL version 2, see file LICENSE in this tarball for details.
+	*/
+
+	#include "libbb.h"
+
+	void bb_signals(int sigs, void (*f)(int))
+	{
+	int sig_no = 0;
+	int bit = 1;
+
+	while (sigs) {
+	if (sigs & bit) {
+	sigs &= ~bit;
+	signal(sig_no, f);
+	}
+	sig_no++;
+	bit <<= 1;
+	}
+	}
+
+	void bb_signals_recursive(int sigs, void (*f)(int))
+	{
+	int sig_no = 0;
+	int bit = 1;
+	struct sigaction sa;
+
+	memset(&sa, 0, sizeof(sa));
+	sa.sa_handler = f;
+	/sa.sa_flags = 0;/
+	/sigemptyset(&sa.sa_mask); - hope memset did it/
+
+	while (sigs) {
+	if (sigs & bit) {
+	sigs &= ~bit;
+	sigaction(sig_no, &sa, NULL);
+	}
+	sig_no++;
+	bit <<= 1;
+	}
+	}
+
+	void sig_block(int sig)
+	{
+	sigset_t ss;
+	sigemptyset(&ss);
+	sigaddset(&ss, sig);
+	sigprocmask(SIG_BLOCK, &ss, NULL);
+	}
+
+	void sig_unblock(int sig)
+	{
+	sigset_t ss;
+	sigemptyset(&ss);
+	sigaddset(&ss, sig);
+	sigprocmask(SIG_UNBLOCK, &ss, NULL);
+	}
+
+	#if 0
+	void sig_blocknone(void)
+	{
+	sigset_t ss;
+	sigemptyset(&ss);
+	sigprocmask(SIG_SETMASK, &ss, NULL);
+	}
+	#endif
+
+	void sig_pause(void)
+	{
+	sigset_t ss;
+	sigemptyset(&ss);
+	sigsuspend(&ss);
+	}

libbb/xfuncs.c+0 -42

@@ -234,48 +234,6 @@ void xfflush_stdout(void)
	}
	}

-	void sig_block(int sig)
-	{
-	sigset_t ss;
-	sigemptyset(&ss);
-	sigaddset(&ss, sig);
-	sigprocmask(SIG_BLOCK, &ss, NULL);
-	}
-
-	void sig_unblock(int sig)
-	{
-	sigset_t ss;
-	sigemptyset(&ss);
-	sigaddset(&ss, sig);
-	sigprocmask(SIG_UNBLOCK, &ss, NULL);
-	}
-
-	#if 0
-	void sig_blocknone(void)
-	{
-	sigset_t ss;
-	sigemptyset(&ss);
-	sigprocmask(SIG_SETMASK, &ss, NULL);
-	}
-	#endif
-
-	void sig_catch(int sig, void (*f)(int))
-	{
-	struct sigaction sa;
-	sa.sa_handler = f;
-	sa.sa_flags = 0;
-	sigemptyset(&sa.sa_mask);
-	sigaction(sig, &sa, NULL);
-	}
-
-	void sig_pause(void)
-	{
-	sigset_t ss;
-	sigemptyset(&ss);
-	sigsuspend(&ss);
-	}
-
-
	void xsetenv(const char key, const char value)
	{
	if (setenv(key, value, 1))

loginutils/passwd.c+5 -3

@@ -171,9 +171,11 @@ int passwd_main(int argc, char **argv)

	rlimit_fsize.rlim_cur = rlimit_fsize.rlim_max = 512L * 30000;
	setrlimit(RLIMIT_FSIZE, &rlimit_fsize);
-	signal(SIGHUP, SIG_IGN);
-	signal(SIGINT, SIG_IGN);
-	signal(SIGQUIT, SIG_IGN);
+	bb_signals(0
+	+ (1 << SIGHUP)
+	+ (1 << SIGINT)
+	+ (1 << SIGQUIT)
+	, SIG_IGN);
	umask(077);
	xsetuid(0);

miscutils/less.c+4 -2

@@ -1355,8 +1355,10 @@ int less_main(int argc, char **argv)
	empty_line_marker = "";

	tcgetattr(kbd_fd, &term_orig);
-	signal(SIGTERM, sig_catcher);
-	signal(SIGINT, sig_catcher);
+	bb_signals(0
+	+ (1 << SIGTERM)
+	+ (1 << SIGINT)
+	, sig_catcher);
	term_less = term_orig;
	term_less.c_lflag &= ~(ICANON \| ECHO);
	term_less.c_iflag &= ~(IXON \| ICRNL);

miscutils/microcom.c+6 -4

@@ -99,10 +99,12 @@ int microcom_main(int argc, char **argv)
	}

	// setup signals
-	sig_catch(SIGHUP, signal_handler);
-	sig_catch(SIGINT, signal_handler);
-	sig_catch(SIGTERM, signal_handler);
-	sig_catch(SIGPIPE, signal_handler);
+	bb_signals_recursive(0
+	+ (1 << SIGHUP)
+	+ (1 << SIGINT)
+	+ (1 << SIGTERM)
+	+ (1 << SIGPIPE)
+	, signal_handler);

	// error exit code if we fail to open the device
	signalled = 1;

miscutils/time.c+9 -7

@@ -61,7 +61,7 @@ static const char long_format[] ALIGN1 =
	Return 0 on error, 1 if ok. */

	/* pid_t is short on BSDI, so don't try to promote it. */
-	static int resuse_end(pid_t pid, resource_t * resp)
+	static int resuse_end(pid_t pid, resource_t *resp)
	{
	int status;
	pid_t caught;
@@ -69,7 +69,7 @@ static int resuse_end(pid_t pid, resource_t * resp)
	/* Ignore signals, but don't ignore the children. When wait3
	returns the child process, set the time the command finished. */
	while ((caught = wait3(&status, 0, &resp->ru)) != pid) {
-	if (caught == -1)
+	if (caught == -1 && errno != EINTR)
	return 0;
	}
	resp->elapsed_ms = (monotonic_us() / 1000) - resp->elapsed_ms;
@@ -373,24 +373,26 @@ static void summarize(const char fmt, char command, resource_t resp)

	/* Run command CMD and return statistics on it.
	Put the statistics in RESP. /
-	static void run_command(char const cmd, resource_t * resp)
+	static void run_command(char const cmd, resource_t *resp)
	{
	pid_t pid; /* Pid of child. */
-	__sighandler_t interrupt_signal, quit_signal;
+	void (*interrupt_signal)(int);
+	void (*quit_signal)(int);

	resp->elapsed_ms = monotonic_us() / 1000;
	pid = vfork(); /* Run CMD as child process. */
	if (pid < 0)
	bb_error_msg_and_die("cannot fork");
-	else if (pid == 0) { /* If child. */
+	if (pid == 0) { /* If child. */
	/* Don't cast execvp arguments; that causes errors on some systems,
	versus merely warnings if the cast is left off. */
	BB_EXECVP(cmd[0], cmd);
-	bb_error_msg("cannot run %s", cmd[0]);
-	_exit(errno == ENOENT ? 127 : 126);
+	xfunc_error_retval = (errno == ENOENT ? 127 : 126);
+	bb_error_msg_and_die("cannot run %s", cmd[0]);
	}

	/* Have signals kill the child but not self (if possible). */
+	//TODO: just block all sigs? and reenable them in the very end in main?
	interrupt_signal = signal(SIGINT, SIG_IGN);
	quit_signal = signal(SIGQUIT, SIG_IGN);

miscutils/watchdog.c+4 -2

@@ -47,8 +47,10 @@ int watchdog_main(int argc, char **argv)
	bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
	}

-	signal(SIGHUP, watchdog_shutdown);
-	signal(SIGINT, watchdog_shutdown);
+	bb_signals(0
+	+ (1 << SIGHUP)
+	+ (1 << SIGINT)
+	, watchdog_shutdown);

	/* Use known fd # - avoid needing global 'int fd' */
	xmove_fd(xopen(argv[argc - 1], O_WRONLY), 3);

networking/dnsd.c+6 -4

@@ -361,14 +361,16 @@ int dnsd_main(int argc, char **argv)
	dnsentryinit();

	signal(SIGINT, interrupt);
-	/* why? signal(SIGPIPE, SIG_IGN); */
-	signal(SIGHUP, SIG_IGN);
+	bb_signals(0
+	/* why? + (1 << SIGPIPE) */
+	+ (1 << SIGHUP)
	#ifdef SIGTSTP
-	signal(SIGTSTP, SIG_IGN);
+	+ (1 << SIGTSTP)
	#endif
	#ifdef SIGURG
-	signal(SIGURG, SIG_IGN);
+	+ (1 << SIGURG)
	#endif
+	, SIG_IGN);

	lsa = xdotted2sockaddr(listen_interface, port);
	udps = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);

networking/nc_bloaty.c+9 -5

@@ -683,14 +683,18 @@ int nc_main(int argc, char **argv)
	PTR_TO_GLOBALS = xzalloc(sizeof(G));

	/* catch a signal or two for cleanup */
-	signal(SIGINT, catch);
-	signal(SIGQUIT, catch);
-	signal(SIGTERM, catch);
+	bb_signals(0
+	+ (1 << SIGINT)
+	+ (1 << SIGQUIT)
+	+ (1 << SIGTERM)
+	, catch);
	/* and suppress others... */
+	bb_signals(0
	#ifdef SIGURG
-	signal(SIGURG, SIG_IGN);
+	+ (1 << SIGURG)
	#endif
-	signal(SIGPIPE, SIG_IGN); /* important! */
+	+ (1 << SIGPIPE) /* important! */
+	, SIG_IGN);

	proggie = argv;
	while (*++proggie) {

networking/sendmail.c+4 -2

@@ -111,8 +111,10 @@ static void launch_helper(const char **argv)
	_exit(127);
	}
	// parent - check whether child is alive
-	sig_catch(SIGCHLD, signal_handler);
-	sig_catch(SIGALRM, signal_handler);
+	bb_signals_recursive(0
+	+ (1 << SIGCHLD)
+	+ (1 << SIGALRM)
+	, signal_handler);
	signal_handler(SIGCHLD);
	// child seems OK -> parent goes on
	}

networking/slattach.c+6 -4

@@ -175,10 +175,12 @@ int slattach_main(int argc, char **argv)

	/* Trap signals in order to restore tty states upon exit */
	if (!(opt & OPT_e_quit)) {
-	signal(SIGHUP, sig_handler);
-	signal(SIGINT, sig_handler);
-	signal(SIGQUIT, sig_handler);
-	signal(SIGTERM, sig_handler);
+	bb_signals(0
+	+ (1 << SIGHUP)
+	+ (1 << SIGINT)
+	+ (1 << SIGQUIT)
+	+ (1 << SIGTERM)
+	, sig_handler);
	}

	/* Open tty */

networking/telnetd.c+1 -2

@@ -279,8 +279,7 @@ make_new_session(
	setsid();

	/* Restore default signal handling */
-	signal(SIGCHLD, SIG_DFL);
-	signal(SIGPIPE, SIG_DFL);
+	bb_signals((1 << SIGCHLD) + (1 << SIGPIPE), SIG_DFL);

	/* open the child's side of the tty. */
	/* NB: setsid() disconnects from any previous ctty's. Therefore

networking/udhcp/signalpipe.c+5 -3

@@ -42,9 +42,11 @@ void udhcp_sp_setup(void)
	close_on_exec_on(signal_pipe.rd);
	close_on_exec_on(signal_pipe.wr);
	ndelay_on(signal_pipe.wr);
-	signal(SIGUSR1, signal_handler);
-	signal(SIGUSR2, signal_handler);
-	signal(SIGTERM, signal_handler);
+	bb_signals(0
+	+ (1 << SIGUSR1)
+	+ (1 << SIGUSR2)
+	+ (1 << SIGTERM)
+	, signal_handler);
	}

procps/top.c+4 -2

@@ -772,8 +772,10 @@ int top_main(int argc, char **argv)
	/* unbuffered input, turn off echo */
	new_settings.c_lflag &= ~(ISIG \| ICANON \| ECHO \| ECHONL);

-	signal(SIGTERM, sig_catcher);
-	signal(SIGINT, sig_catcher);
+	bb_signals(0
+	+ (1 << SIGTERM)
+	+ (1 << SIGINT)
+	, sig_catcher);
	tcsetattr(0, TCSANOW, (void *) &new_settings);
	atexit(reset_term);
	#endif /* FEATURE_USE_TERMIOS */

runit/runsv.c+6 -4

@@ -345,8 +345,10 @@ static void startservice(struct svdir *s)
	xdup2(logpipe.wr, 1);
	}
	}
-	signal(SIGCHLD, SIG_DFL);
-	signal(SIGTERM, SIG_DFL);
+	bb_signals(0
+	+ (1 << SIGCHLD)
+	+ (1 << SIGTERM)
+	, SIG_DFL);
	sig_unblock(SIGCHLD);
	sig_unblock(SIGTERM);
	execvp(*run, run);
@@ -460,9 +462,9 @@ int runsv_main(int argc, char **argv)
	ndelay_on(selfpipe.wr);

	sig_block(SIGCHLD);
-	sig_catch(SIGCHLD, s_child);
+	bb_signals_recursive(1 << SIGCHLD, s_child);
	sig_block(SIGTERM);
-	sig_catch(SIGTERM, s_term);
+	bb_signals_recursive(1 << SIGTERM, s_term);

	xchdir(dir);
	/* bss: svd[0].pid = 0; */

runit/runsvdir.c+6 -4

@@ -100,8 +100,10 @@ static void runsv(int no, const char *name)
	/* child */
	if (set_pgrp)
	setsid();
-	signal(SIGHUP, SIG_DFL);
-	signal(SIGTERM, SIG_DFL);
+	bb_signals(0
+	+ (1 << SIGHUP)
+	+ (1 << SIGTERM)
+	, SIG_DFL);
	execvp(prog[0], prog);
	fatal2_cannot("start runsv ", name);
	}
@@ -232,8 +234,8 @@ int runsvdir_main(int argc, char **argv)
	bb_show_usage();
	}

-	sig_catch(SIGTERM, s_term);
-	sig_catch(SIGHUP, s_hangup);
+	bb_signals_recursive(1 << SIGTERM, s_term);
+	bb_signals_recursive(1 << SIGHUP, s_hangup);
	svdir = *argv++;
	if (argv && *argv) {
	rplog = *argv;

runit/svlogd.c+9 -7

@@ -222,9 +222,11 @@ static unsigned processorstart(struct logdir *ld)
	int fd;

	/* child */
-	signal(SIGTERM, SIG_DFL);
-	signal(SIGALRM, SIG_DFL);
-	signal(SIGHUP, SIG_DFL);
+	bb_signals(0
+	+ (1 << SIGTERM)
+	+ (1 << SIGALRM)
+	+ (1 << SIGHUP)
+	, SIG_DFL);
	sig_unblock(SIGTERM);
	sig_unblock(SIGALRM);
	sig_unblock(SIGHUP);
@@ -903,10 +905,10 @@ int svlogd_main(int argc, char **argv)
	sigaddset(&blocked_sigset, SIGALRM);
	sigaddset(&blocked_sigset, SIGHUP);
	sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
-	sig_catch(SIGTERM, sig_term_handler);
-	sig_catch(SIGCHLD, sig_child_handler);
-	sig_catch(SIGALRM, sig_alarm_handler);
-	sig_catch(SIGHUP, sig_hangup_handler);
+	bb_signals_recursive(1 << SIGTERM, sig_term_handler);
+	bb_signals_recursive(1 << SIGCHLD, sig_child_handler);
+	bb_signals_recursive(1 << SIGALRM, sig_alarm_handler);
+	bb_signals_recursive(1 << SIGHUP, sig_hangup_handler);

	logdirs_reopen();

shell/hush.c+21 -15

@@ -709,28 +709,34 @@ static void signal_SA_RESTART(int sig, void (*handler)(int))
	/* Signals are grouped, we handle them in batches */
	static void set_fatal_sighandler(void (*handler)(int))
	{
-	signal(SIGILL , handler);
-	signal(SIGTRAP, handler);
-	signal(SIGABRT, handler);
-	signal(SIGFPE , handler);
-	signal(SIGBUS , handler);
-	signal(SIGSEGV, handler);
+	bb_signals(0
+	+ (1 << SIGILL)
+	+ (1 << SIGTRAP)
+	+ (1 << SIGABRT)
+	+ (1 << SIGFPE)
+	+ (1 << SIGBUS)
+	+ (1 << SIGSEGV)
	/* bash 3.2 seems to handle these just like 'fatal' ones */
-	signal(SIGHUP , handler);
-	signal(SIGPIPE, handler);
-	signal(SIGALRM, handler);
+	+ (1 << SIGHUP)
+	+ (1 << SIGPIPE)
+	+ (1 << SIGALRM)
+	, handler);
	}
	static void set_jobctrl_sighandler(void (*handler)(int))
	{
-	signal(SIGTSTP, handler);
-	signal(SIGTTIN, handler);
-	signal(SIGTTOU, handler);
+	bb_signals(0
+	+ (1 << SIGTSTP)
+	+ (1 << SIGTTIN)
+	+ (1 << SIGTTOU)
+	, handler);
	}
	static void set_misc_sighandler(void (*handler)(int))
	{
-	signal(SIGINT , handler);
-	signal(SIGQUIT, handler);
-	signal(SIGTERM, handler);
+	bb_signals(0
+	+ (1 << SIGINT)
+	+ (1 << SIGQUIT)
+	+ (1 << SIGTERM)
+	, handler);
	}
	/* SIGCHLD is special and handled separately */

sysklogd/klogd.c+4 -3

@@ -57,9 +57,10 @@ int klogd_main(int argc, char **argv)
	openlog("kernel", 0, LOG_KERN);

	/* Set up sig handlers */
-	signal(SIGINT, klogd_signal);
-	signal(SIGKILL, klogd_signal);
-	signal(SIGTERM, klogd_signal);
+	bb_signals(0
+	+ (1 << SIGINT)
+	+ (1 << SIGTERM)
+	, klogd_signal);
	signal(SIGHUP, SIG_IGN);

	/* "Open the log. Currently a NOP." */

sysklogd/syslogd.c+5 -3

@@ -540,9 +540,11 @@ static void do_syslogd(void)
	int sock_fd;

	/* Set up signal handlers */
-	signal(SIGINT, quit_signal);
-	signal(SIGTERM, quit_signal);
-	signal(SIGQUIT, quit_signal);
+	bb_signals(0
+	+ (1 << SIGINT)
+	+ (1 << SIGTERM)
+	+ (1 << SIGQUIT)
+	, quit_signal);
	signal(SIGHUP, SIG_IGN);
	/* signal(SIGCHLD, SIG_IGN); - why? */
	#ifdef SYSLOGD_MARK

util-linux/more.c+5 -3

@@ -87,9 +87,11 @@ int more_main(int argc, char **argv)
	new_settings.c_cc[VMIN] = 1;
	new_settings.c_cc[VTIME] = 0;
	setTermSettings(cin_fileno, &new_settings);
-	signal(SIGINT, gotsig);
-	signal(SIGQUIT, gotsig);
-	signal(SIGTERM, gotsig);
+	bb_signals(0
+	+ (1 << SIGINT)
+	+ (1 << SIGQUIT)
+	+ (1 << SIGTERM)
+	, gotsig);
	#endif

	do {