Sanitize kernel daemon signal handling and process naming.

Add a name argument to daemonize() (va_arg) to avoid all the
kernel threads having to duplicate the name setting over and
over again.

Make daemonize() disable all signals by default, and add a
"allow_signal()" function to let daemons say they explicitly
want to support a signal.

Make flush_signal() take the signal lock, so that callers do
not need to.

66 files changed, 133 insertions, 352 deletions

diff --git a/arch/arm/kernel/ecard.c b/arch/arm/kernel/ecard.c
index 2ce63481432b..6028ec3cf670 100644
--- a/arch/arm/kernel/ecard.c
+++ b/arch/arm/kernel/ecard.c
@@ -290,14 +290,7 @@ ecard_task(void * unused)
 {
 	struct task_struct *tsk = current;
 
-	/*
-	 * We don't want /any/ signals, not even SIGKILL
-	 */
-	sigfillset(&tsk->blocked);
-	sigemptyset(&tsk->pending.signal);
-	recalc_sigpending();
-	strcpy(tsk->comm, "kecardd");
-	daemonize();
+	daemonize("kecardd");
 
 	/*
 	 * Allocate a mm.  We're not a lazy-TLB kernel task since we need
diff --git a/arch/i386/kernel/apm.c b/arch/i386/kernel/apm.c
index 1f5a243376b7..86a426bbb9ac 100644
--- a/arch/i386/kernel/apm.c
+++ b/arch/i386/kernel/apm.c
@@ -1742,9 +1742,8 @@ static int apm(void *unused)
 
 	kapmd_running = 1;
 
-	daemonize();
+	daemonize("kapmd");
 
-	strcpy(current->comm, "kapmd");
 	current->flags |= PF_IOTHREAD;
 	sigfillset(&current->blocked);
 
diff --git a/arch/i386/kernel/io_apic.c b/arch/i386/kernel/io_apic.c
index 0e32adb7b0d6..319b80d13be3 100644
--- a/arch/i386/kernel/io_apic.c
+++ b/arch/i386/kernel/io_apic.c
@@ -510,9 +510,8 @@ int balanced_irq(void *unused)
 	int i;
 	unsigned long prev_balance_time = jiffies;
 	long time_remaining = balanced_irq_interval;
-	daemonize();
-	sigfillset(&current->blocked);
-	sprintf(current->comm, "kirqd");
+
+	daemonize("kirqd");
 	
 	/* push everything to CPU 0 to give us a starting point.  */
 	for (i = 0 ; i < NR_IRQS ; i++)
diff --git a/arch/i386/mach-voyager/voyager_thread.c b/arch/i386/mach-voyager/voyager_thread.c
index 70fdedf6cd37..c82afd309f4b 100644
--- a/arch/i386/mach-voyager/voyager_thread.c
+++ b/arch/i386/mach-voyager/voyager_thread.c
@@ -137,13 +137,12 @@ thread(void *unused)
 	kvoyagerd_running = 1;
 
 	reparent_to_init();
-	daemonize();
+	daemonize(THREAD_NAME);
 
 	set_timeout = 0;
 
 	init_timer(&wakeup_timer);
 
-	strcpy(current->comm, THREAD_NAME);
 	sigfillset(&current->blocked);
 	current->tty = NULL;	/* get rid of controlling tty */
 
diff --git a/arch/ppc64/kernel/rtasd.c b/arch/ppc64/kernel/rtasd.c
index 8edbb142d1c5..106620bc27d1 100644
--- a/arch/ppc64/kernel/rtasd.c
+++ b/arch/ppc64/kernel/rtasd.c
@@ -211,9 +211,7 @@ static int rtasd(void *unused)
 
 	DEBUG("will sleep for %d jiffies\n", (HZ*60/rtas_event_scan_rate) / 2);
 
-	daemonize();
-	sigfillset(&current->blocked);
-	sprintf(current->comm, "rtasd");
+	daemonize("rtasd");
 
 #if 0
 	/* Rusty unreal time task */
diff --git a/arch/sparc64/kernel/power.c b/arch/sparc64/kernel/power.c
index 042bb08bbb21..390e7ef19149 100644
--- a/arch/sparc64/kernel/power.c
+++ b/arch/sparc64/kernel/power.c
@@ -65,14 +65,11 @@ static int powerd(void *__unused)
 	static char *envp[] = { "HOME=/", "TERM=linux", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
 	char *argv[] = { "/sbin/shutdown", "-h", "now", NULL };
 
-	daemonize();
-	sprintf(current->comm, "powerd");
+	daemonize("powerd");
 
 again:
 	while (button_pressed == 0) {
-		spin_lock_irq(&current->sighand->siglock);
 		flush_signals(current);
-		spin_unlock_irq(&current->sighand->siglock);
 		interruptible_sleep_on(&powerd_wait);
 	}
 
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 71ae15a0c6fd..85636a00c3c6 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -577,18 +577,12 @@ static int loop_thread(void *data)
 	struct loop_device *lo = data;
 	struct bio *bio;
 
-	daemonize();
+	daemonize("loop%d", lo->lo_number);
 
-	sprintf(current->comm, "loop%d", lo->lo_number);
 	current->flags |= PF_IOTHREAD;	/* loop can be used in an encrypted device
 					   hence, it mustn't be stopped at all because it could
 					   be indirectly used during suspension */
 
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	flush_signals(current);
-	spin_unlock_irq(&current->sighand->siglock);
-
 	set_user_nice(current, -20);
 
 	lo->lo_state = Lo_bound;
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index b3fe12431691..fb2ee72e6db2 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -233,9 +233,7 @@ int khvcd(void *unused)
 {
 	int i;
 
-	daemonize();
-	strcpy(current->comm, "khvcd");
-	sigfillset(&current->blocked);
+	daemonize("khvcd");
 
 	for (;;) {
 		if (!cpus_in_xmon) {
diff --git a/drivers/hotplug/cpci_hotplug_core.c b/drivers/hotplug/cpci_hotplug_core.c
index 0b109d2aa9cc..e8981f780b62 100644
--- a/drivers/hotplug/cpci_hotplug_core.c
+++ b/drivers/hotplug/cpci_hotplug_core.c
@@ -622,8 +622,7 @@ event_thread(void *data)
 	struct list_head *tmp;
 
 	lock_kernel();
-	daemonize();
-	strcpy(current->comm, "cpci_hp_eventd");
+	daemonize("cpci_hp_eventd");
 	unlock_kernel();
 
 	dbg("%s - event thread started", __FUNCTION__);
@@ -682,8 +681,7 @@ poll_thread(void *data)
 	struct list_head *tmp;
 
 	lock_kernel();
-	daemonize();
-	strcpy(current->comm, "cpci_hp_polld");
+	daemonize("cpci_hp_polld");
 	unlock_kernel();
 
 	while(1) {
diff --git a/drivers/hotplug/cpqphp_ctrl.c b/drivers/hotplug/cpqphp_ctrl.c
index deb229539165..b9a8432487f4 100644
--- a/drivers/hotplug/cpqphp_ctrl.c
+++ b/drivers/hotplug/cpqphp_ctrl.c
@@ -1709,10 +1709,7 @@ static int event_thread(void* data)
 {
 	struct controller *ctrl;
 	lock_kernel();
-	daemonize();
-	
-	//  New name
-	strcpy(current->comm, "phpd_event");
+	daemonize("phpd_event");
 	
 	unlock_kernel();
 
diff --git a/drivers/hotplug/ibmphp_hpc.c b/drivers/hotplug/ibmphp_hpc.c
index ae959809e8a8..0bc95c57056b 100644
--- a/drivers/hotplug/ibmphp_hpc.c
+++ b/drivers/hotplug/ibmphp_hpc.c
@@ -1125,13 +1125,9 @@ static int process_changeinlatch (u8 old, u8 new, struct controller *ctrl)
 static int hpc_poll_thread (void *data)
 {
 	debug ("%s - Entry\n", __FUNCTION__);
-	lock_kernel ();
-	daemonize ();
 
-	//  New name
-	strcpy (current->comm, "hpc_poll");
-
-	unlock_kernel ();
+	daemonize("hpc_poll");
+	allow_signal(SIGKILL);
 
 	poll_hpc ();
 
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 0f5440f9966b..b0ad6ca47ec1 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -1216,10 +1216,9 @@ static int nodemgr_host_thread(void *__hi)
 	struct host_info *hi = (struct host_info *)__hi;
 
 	/* No userlevel access needed */
-	daemonize();
+	daemonize("knodemgrd");
+	allow_signal(SIGTERM);
 
-	strcpy(current->comm, "knodemgrd");
-	
 	/* Sit and wait for a signal to probe the nodes on the bus. This
 	 * happens when we get a bus reset. */
 	while (!down_interruptible(&hi->reset_sem) &&
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index da245d5c13ab..bf29f0becf61 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -105,8 +105,8 @@ void serio_handle_events(void)
 static int serio_thread(void *nothing)
 {
 	lock_kernel();
-	daemonize();
-	strcpy(current->comm, "kseriod");
+	daemonize("kseriod");
+	allow_signal(SIGTERM);
 
 	do {
 		serio_handle_events();
diff --git a/drivers/isdn/hardware/eicon/i4lididrv.c b/drivers/isdn/hardware/eicon/i4lididrv.c
index 38cf7c984607..b3be96a6d625 100644
--- a/drivers/isdn/hardware/eicon/i4lididrv.c
+++ b/drivers/isdn/hardware/eicon/i4lididrv.c
@@ -326,10 +326,7 @@ divad_thread(void * data)
     if(!(atomic_read(&thread_running)))
       break;
     if(signal_pending(current)) {
-         /* we may want to do something on signals here */
-         spin_lock_irq(&current->sigmask_lock);
          flush_signals(current);
-         spin_unlock_irq(&current->sigmask_lock);
     } else {
          run_task_queue(&tq_divad);
     }
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 6e994acf13b6..a5a983fdbede 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -244,12 +244,13 @@ static int adb_scan_bus(void)
 static int
 adb_probe_task(void *x)
 {
+	sigset_t blocked;
+
 	strcpy(current->comm, "kadbprobe");
-	
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
+
+	sigfillset(&blocked);
+	sicprocmask(SIG_BLOCK, &blocked, NULL);	
 	flush_signals(current);
-	spin_unlock_irq(&current->sighand->siglock);
 
 	printk(KERN_INFO "adb: starting probe task...\n");
 	do_adb_reset_bus();
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 9f1d5d0878e5..3f4f379b0bc3 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2444,9 +2444,7 @@ static struct block_device_operations md_fops =
 
 static inline void flush_curr_signals(void)
 {
-	spin_lock(&current->sighand->siglock);
 	flush_signals(current);
-	spin_unlock(&current->sighand->siglock);
 }
 
 int md_thread(void * arg)
@@ -2459,12 +2457,10 @@ int md_thread(void * arg)
 	 * Detach thread
 	 */
 
-	daemonize();
+	daemonize(thread->name);
 
-	sprintf(current->comm, thread->name);
 	current->exit_signal = SIGCHLD;
-	siginitsetinv(&current->blocked, sigmask(SIGKILL));
-	flush_curr_signals();
+	allow_signal(SIGKILL);
 	thread->tsk = current;
 
 	/*
diff --git a/drivers/media/dvb/av7110/av7110.c b/drivers/media/dvb/av7110/av7110.c
index f0178c18e0e5..9a1dc9f5ea7d 100644
--- a/drivers/media/dvb/av7110/av7110.c
+++ b/drivers/media/dvb/av7110/av7110.c
@@ -349,13 +349,13 @@ static int arm_thread(void *data)
     
 	lock_kernel();
 #if 0
-	daemonize();
+	daemonize("arm_mon");
 #else
         exit_mm(current);
         current->session=current->pgrp=1;
-#endif
 	sigfillset(&current->blocked);
 	strcpy(current->comm, "arm_mon");
+#endif
 	av7110->arm_thread = current;
 	unlock_kernel();
 
diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.c b/drivers/media/dvb/dvb-core/dvb_frontend.c
index 344621653fea..2c18162a6665 100644
--- a/drivers/media/dvb/dvb-core/dvb_frontend.c
+++ b/drivers/media/dvb/dvb-core/dvb_frontend.c
@@ -482,9 +482,7 @@ int dvb_frontend_thread (void *data)
 	dprintk ("%s\n", __FUNCTION__);
 
 	lock_kernel ();
-	daemonize ();
-	sigfillset (&current->blocked);
-	strncpy (current->comm, "kdvb-fe", sizeof (current->comm));
+	daemonize("kdvb-fe");
 	fe->thread = current;
 	unlock_kernel ();
 
diff --git a/drivers/media/video/msp3400.c b/drivers/media/video/msp3400.c
index bdae961c265b..d91d04f97f4f 100644
--- a/drivers/media/video/msp3400.c
+++ b/drivers/media/video/msp3400.c
@@ -755,9 +755,7 @@ static int msp3400c_thread(void *data)
 	lock_kernel();
 #endif
 	
-	daemonize();
-	sigfillset(&current->blocked);
-	strcpy(current->comm,"msp3400");
+	daemonize("msp3400");
 
 	msp->thread = current;
 
@@ -1011,9 +1009,7 @@ static int msp3410d_thread(void *data)
 	lock_kernel();
 #endif
     
-	daemonize();
-	sigfillset(&current->blocked);
-	strcpy(current->comm,"msp3410 [auto]");
+	daemonize("msp3410 [auto]");
 
 	msp->thread = current;
 
diff --git a/drivers/media/video/saa7134/saa7134-tvaudio.c b/drivers/media/video/saa7134/saa7134-tvaudio.c
index 89e53cc5ace5..11949b018afc 100644
--- a/drivers/media/video/saa7134/saa7134-tvaudio.c
+++ b/drivers/media/video/saa7134/saa7134-tvaudio.c
@@ -393,9 +393,7 @@ static int tvaudio_thread(void *data)
 	int i,max,carrier,audio;
 
 	lock_kernel();
-	daemonize();
-	sigfillset(&current->blocked);
-	sprintf(current->comm, "%s", dev->name);
+	daemonize("%s", dev->name);
 	dev->thread.task = current;
 	unlock_kernel();
 	if (dev->thread.notify != NULL)
diff --git a/drivers/media/video/tvaudio.c b/drivers/media/video/tvaudio.c
index b46752742a60..b077e42ef792 100644
--- a/drivers/media/video/tvaudio.c
+++ b/drivers/media/video/tvaudio.c
@@ -272,9 +272,7 @@ static int chip_thread(void *data)
 #ifdef CONFIG_SMP
 	lock_kernel();
 #endif
-	daemonize();
-	sigfillset(&current->blocked);
-	strcpy(current->comm,chip->c.name);
+	daemonize("%s", chip->c.name);
 	chip->thread = current;
 #ifdef CONFIG_SMP
 	unlock_kernel();
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 05406290dde8..61fe2369e8f4 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -629,11 +629,9 @@ static int i2ob_evt(void *dummy)
 		u8 data[16];
 		} *evt_local;
 
-	lock_kernel();
-	daemonize();
-	unlock_kernel();
+	daemonize("i2oblock");
+	allow_signal(SIGKILL);
 
-	strcpy(current->comm, "i2oblock");
 	evt_running = 1;
 
 	while(1)
diff --git a/drivers/message/i2o/i2o_core.c b/drivers/message/i2o/i2o_core.c
index d4f15436a380..93ce837e421c 100644
--- a/drivers/message/i2o/i2o_core.c
+++ b/drivers/message/i2o/i2o_core.c
@@ -879,11 +879,9 @@ static int i2o_core_evt(void *reply_data)
 	struct i2o_controller *c = NULL;
 	unsigned long flags;
 
-	lock_kernel();
-	daemonize();
-	unlock_kernel();
+	daemonize("i2oevtd");
+	allow_signal(SIGKILL);
 
-	strcpy(current->comm, "i2oevtd");
 	evt_running = 1;
 
 	while(1)
@@ -1047,15 +1045,10 @@ static int i2o_dyn_lct(void *foo)
 	int found = 0;
 	int entries;
 	void *tmp;
-	char name[16];
 
-	lock_kernel();
-	daemonize();
-	unlock_kernel();
+	daemonize("iop%d_lctd", c->unit);
+	allow_signal(SIGKILL);
 
-	sprintf(name, "iop%d_lctd", c->unit);
-	strcpy(current->comm, name);	
-	
 	c->lct_running = 1;
 
 	while(1)
diff --git a/drivers/mtd/devices/blkmtd.c b/drivers/mtd/devices/blkmtd.c
index 7d738397f667..9b2438f01e5e 100644
--- a/drivers/mtd/devices/blkmtd.c
+++ b/drivers/mtd/devices/blkmtd.c
@@ -303,12 +303,7 @@ static int write_queue_task(void *data)
 
   DECLARE_WAITQUEUE(wait, tsk);
   DEBUG(1, "blkmtd: writetask: starting (pid = %d)\n", tsk->pid);
-  daemonize();
-  strcpy(tsk->comm, "blkmtdd");
-  spin_lock_irq(&tsk->sighand->siglock);
-  sigfillset(&tsk->blocked);
-  recalc_sigpending();
-  spin_unlock_irq(&tsk->sighand->siglock);
+  daemonize("blkmtdd");
 
   if(alloc_kiovec(1, &iobuf)) {
     printk("blkmtd: write_queue_task cant allocate kiobuf\n");
diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index 0aec2e6709e7..af065e4af4cf 100644
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -452,12 +452,7 @@ int mtdblock_thread(void *dummy)
 
 	/* we might get involved when memory gets low, so use PF_MEMALLOC */
 	tsk->flags |= PF_MEMALLOC;
-	strcpy(tsk->comm, "mtdblockd");
-	spin_lock_irq(&tsk->sighand->siglock);
-	sigfillset(&tsk->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&tsk->sighand->siglock);
-	daemonize();
+	daemonize("mtdblockd");
 
 	while (!leaving) {
 		add_wait_queue(&thr_wq, &wait);
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index e1e8d997983e..084ff5219678 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -1588,14 +1588,8 @@ static int rtl8139_thread (void *data)
 	struct rtl8139_private *tp = dev->priv;
 	unsigned long timeout;
 
-	daemonize();
-	spin_lock_irq(&current->sighand->siglock);
-	sigemptyset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
-	strncpy (current->comm, dev->name, sizeof(current->comm) - 1);
-	current->comm[sizeof(current->comm) - 1] = '\0';
+	daemonize("%s", dev->name);
+	allow_signal(SIGKILL);
 
 	while (1) {
 		timeout = next_tick;
@@ -1604,9 +1598,7 @@ static int rtl8139_thread (void *data)
 		} while (!signal_pending (current) && (timeout > 0));
 
 		if (signal_pending (current)) {
-			spin_lock_irq(&current->sighand->siglock);
 			flush_signals(current);
-			spin_unlock_irq(&current->sighand->siglock);
 		}
 
 		if (tp->time_to_die)
diff --git a/drivers/net/irda/sir_kthread.c b/drivers/net/irda/sir_kthread.c
index 3f2a538981d9..cf292968b241 100644
--- a/drivers/net/irda/sir_kthread.c
+++ b/drivers/net/irda/sir_kthread.c
@@ -113,13 +113,7 @@ static int irda_thread(void *startup)
 {
 	DECLARE_WAITQUEUE(wait, current);
 
-	daemonize();
-	strcpy(current->comm, "kIrDAd");
-
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	daemonize("kIrDAd");
 
 	set_fs(KERNEL_DS);
 
diff --git a/drivers/pnp/pnpbios/core.c b/drivers/pnp/pnpbios/core.c
index d9e2092dbbb9..82944c33a021 100644
--- a/drivers/pnp/pnpbios/core.c
+++ b/drivers/pnp/pnpbios/core.c
@@ -615,8 +615,8 @@ static int pnp_dock_thread(void * unused)
 {
 	static struct pnp_docking_station_info now;
 	int docked = -1, d = 0;
-	daemonize();
-	strcpy(current->comm, "kpnpbiosd");
+	daemonize("kpnpbiosd");
+	allow_signal(SIGKILL);
 	while(!unloading && !signal_pending(current))
 	{
 		int status;
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index 97e4bb6a40ff..3386baf5f604 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -908,7 +908,7 @@ lcs_fix_multicast_list(void *data)
 
 	card = (struct lcs_card *) data;
 
-	daemonize();
+	daemonize("fixipm");
 	LCS_DBF_TEXT(5, trace, "fixipm");
 	spin_lock(&card->lock);
 	list_for_each_safe(l, n, &card->ipm_list) {
@@ -1370,7 +1370,7 @@ lcs_lgw_startlan_thread(void *data)
 	struct lcs_card *card;
 
 	card = (struct lcs_card *) data;
-	daemonize();
+	daemonize("lgwstpln");
 	LCS_DBF_TEXT(4, trace, "lgwstpln");
 	if (card->dev)
 		netif_stop_queue(card->dev);
@@ -1397,7 +1397,7 @@ lcs_lgw_startup_thread(void *data)
 	struct lcs_card *card;
 
 	card = (struct lcs_card *) data;
-	daemonize();
+	daemonize("lgwstpln");
 	LCS_DBF_TEXT(4, trace, "lgwstpln");
 	if (card->dev)
 		netif_stop_queue(card->dev);
@@ -1436,7 +1436,7 @@ lcs_lgw_stoplan_thread(void *data)
 	struct lcs_card *card;
 
 	card = (struct lcs_card *) data;
-	daemonize();
+	daemonize("lgwstop");
 	LCS_DBF_TEXT(4, trace, "lgwstop");
 	if (card->dev)
 		netif_stop_queue(card->dev);
diff --git a/drivers/sbus/char/bbc_envctrl.c b/drivers/sbus/char/bbc_envctrl.c
index a5ac67cc498f..d0a545010b1e 100644
--- a/drivers/sbus/char/bbc_envctrl.c
+++ b/drivers/sbus/char/bbc_envctrl.c
@@ -457,8 +457,8 @@ static struct task_struct *kenvctrld_task;
 
 static int kenvctrld(void *__unused)
 {
-	daemonize();
-	strcpy(current->comm, "kenvctrld");
+	daemonize("kenvctrld");
+	allow_signal(SIGKILL);
 	kenvctrld_task = current;
 
 	printk(KERN_INFO "bbc_envctrl: kenvctrld starting...\n");
diff --git a/drivers/sbus/char/envctrl.c b/drivers/sbus/char/envctrl.c
index f953eaf73d32..bf97d2efafa5 100644
--- a/drivers/sbus/char/envctrl.c
+++ b/drivers/sbus/char/envctrl.c
@@ -1016,8 +1016,9 @@ static int kenvctrld(void *__unused)
 
 	poll_interval = 5 * HZ; /* TODO env_mon_interval */
 
-	daemonize();
-	strcpy(current->comm, "kenvctrld");
+	daemonize("kenvctrld");
+	allow_signal(SIGKILL);
+
 	kenvctrld_task = current;
 
 	printk(KERN_INFO "envctrl: %s starting...\n", current->comm);
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 55c36b8bed90..d5e9408cebd7 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -816,8 +816,8 @@ int aac_command_thread(struct aac_dev * dev)
 	 *	Set up the name that will appear in 'ps'
 	 *	stored in  task_struct.comm[16].
 	 */
-	sprintf(current->comm, "aacraid");
-	daemonize();
+	daemonize("aacraid");
+	allow_signal(SIGKILL);
 	/*
 	 *	Let the DPC know it has a place to send the AIF's to.
 	 */
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index a397ed69b47a..7b03b6e1f15a 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -2854,8 +2854,7 @@ ahd_linux_dv_thread(void *data)
 	 * Complete thread creation.
 	 */
 	lock_kernel();
-	daemonize();
-	sprintf(current->comm, "ahd_dv_%d", ahd->unit);
+	daemonize("ahd_dv_%d", ahd->unit);
 	unlock_kernel();
 
 	while (1) {
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index a12ad53ec289..bff5a2eabb1b 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -2355,16 +2355,10 @@ ahc_linux_dv_thread(void *data)
 #endif
 
 	/*
-	 * Don't care about any signals.
-	 */
-	siginitsetinv(&current->blocked, 0);
-
-	/*
 	 * Complete thread creation.
 	 */
 	lock_kernel();
-	daemonize();
-	sprintf(current->comm, "ahc_dv_%d", ahc->unit);
+	daemonize("ahc_dv_%d", ahc->unit);
 	unlock_kernel();
 
 	while (1) {
diff --git a/drivers/scsi/cpqfcTSworker.c b/drivers/scsi/cpqfcTSworker.c
index 7bec5d1091f7..a45c448dc40b 100644
--- a/drivers/scsi/cpqfcTSworker.c
+++ b/drivers/scsi/cpqfcTSworker.c
@@ -165,15 +165,10 @@ void cpqfcTSWorkerThread( void *host)
   ENTER("WorkerThread");
 
   lock_kernel();
-  daemonize();
+  daemonize("cpqfcTS_wt_%d", HostAdapter->host_no);
   siginitsetinv(&current->blocked, SHUTDOWN_SIGS);
 
 
-  /*
-   * Set the name of this process.
-   */
-  sprintf(current->comm, "cpqfcTS_wt_%d", HostAdapter->host_no);
-
   cpqfcHBAdata->fcQueReady = &fcQueReady;  // primary wait point
   cpqfcHBAdata->TYOBcomplete = &fcTYOBcomplete;
   cpqfcHBAdata->TachFrozen = &TachFrozen;
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index c0bb52aaa3bd..7f8d47677aff 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1579,24 +1579,14 @@ void scsi_error_handler(void *data)
 	int rtn;
 	DECLARE_MUTEX_LOCKED(sem);
 
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
 	lock_kernel();
 
 	/*
 	 *    Flush resources
 	 */
 
-	daemonize();
-
-	/*
-	 * Set the name of this process.
-	 */
+	daemonize("scsi_eh_%d", shost->host_no);
 
-	sprintf(current->comm, "scsi_eh_%d", shost->host_no);
 	current->flags |= PF_IOTHREAD;
 
 	shost->eh_wait = &sem;
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index f23744d8749b..ba2713a23e24 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -1083,10 +1083,8 @@ static int usb_hub_thread(void *__hub)
 	 * so get rid of all our resources
 	 */
 
-	daemonize();
-
-	/* Setup a nice name */
-	strcpy(current->comm, "khubd");
+	daemonize("khubd");
+	allow_signal(SIGKILL);
 
 	/* Send me a signal to get me die (for debugging) */
 	do {
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index e4a98569d058..4c2b6de50c91 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -298,18 +298,9 @@ static int usb_stor_control_thread(void * __us)
 	 * This thread doesn't need any user-level access,
 	 * so get rid of all our resources..
 	 */
-	daemonize();
+	daemonize("usb-storage");
 
-	/* avoid getting signals */
-	spin_lock_irq(&current->sighand->siglock);
-	flush_signals(current);
 	current->flags |= PF_IOTHREAD;
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
-	/* set our name for identification purposes */
-	sprintf(current->comm, "usb-storage");
 
 	unlock_kernel();
 
diff --git a/fs/afs/cmservice.c b/fs/afs/cmservice.c
index 99960d002026..e5e839741803 100644
--- a/fs/afs/cmservice.c
+++ b/fs/afs/cmservice.c
@@ -120,18 +120,10 @@ static int kafscmd(void *arg)
 	int die;
 
 	printk("kAFS: Started kafscmd %d\n",current->pid);
-	strcpy(current->comm,"kafscmd");
-
-	daemonize();
+	daemonize("kafscmd");
 
 	complete(&kafscmd_alive);
 
-	/* only certain signals are of interest */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked,0);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
 	/* loop around looking for things to attend to */
 	do {
 		if (list_empty(&kafscmd_attention_list)) {
diff --git a/fs/afs/kafsasyncd.c b/fs/afs/kafsasyncd.c
index e546a6da5015..9ac95adeff33 100644
--- a/fs/afs/kafsasyncd.c
+++ b/fs/afs/kafsasyncd.c
@@ -94,18 +94,11 @@ static int kafsasyncd(void *arg)
 	kafsasyncd_task = current;
 
 	printk("kAFS: Started kafsasyncd %d\n",current->pid);
-	strcpy(current->comm,"kafsasyncd");
 
-	daemonize();
+	daemonize("kafsasyncd");
 
 	complete(&kafsasyncd_alive);
 
-	/* only certain signals are of interest */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked,0);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
 	/* loop around looking for things to attend to */
 	do {
 		set_current_state(TASK_INTERRUPTIBLE);
diff --git a/fs/afs/kafstimod.c b/fs/afs/kafstimod.c
index 2b0f5a9d84e9..d2f66184eb08 100644
--- a/fs/afs/kafstimod.c
+++ b/fs/afs/kafstimod.c
@@ -71,18 +71,11 @@ static int kafstimod(void *arg)
 	afs_timer_t *timer;
 
 	printk("kAFS: Started kafstimod %d\n",current->pid);
-	strcpy(current->comm,"kafstimod");
 
-	daemonize();
+	daemonize("kafstimod");
 
 	complete(&kafstimod_alive);
 
-	/* only certain signals are of interest */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked,0);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
 	/* loop around looking for things to attend to */
  loop:
 	set_current_state(TASK_INTERRUPTIBLE);
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index afb2c3844b05..64327cc0e054 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -95,7 +95,8 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
 	struct mid_q_entry *mid_entry;
 	char *temp;
 
-	daemonize();
+	daemonize("cifsd");
+	allow_signal(SIGKILL);
 
 	server->tsk = current;	/* save process info to wake at shutdown */
 	cFYI(1, ("\nDemultiplex PID: %d", current->pid));
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index 3a8be07f8c7e..eb23953d7251 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -202,14 +202,9 @@ int kjournald(void *arg)
 
 	current_journal = journal;
 
-	lock_kernel();
-	daemonize();
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	daemonize("kjournald");
 
-	sprintf(current->comm, "kjournald");
+	lock_kernel();
 
 	/* Set up an interval timer which can be used to trigger a
            commit wakeup after the commit interval expires */
diff --git a/fs/jffs2/background.c b/fs/jffs2/background.c
index 9d3df991fca0..c63568931e15 100644
--- a/fs/jffs2/background.c
+++ b/fs/jffs2/background.c
@@ -82,13 +82,11 @@ static int jffs2_garbage_collect_thread(void *_c)
 {
 	struct jffs2_sb_info *c = _c;
 
-	daemonize();
+	daemonize("jffs2_gcd_mtd%d", c->mtd->index);
 
 	c->gc_task = current;
 	up(&c->gc_thread_start);
 
-	sprintf(current->comm, "jffs2_gcd_mtd%d", c->mtd->index);
-
 	set_user_nice(current, 10);
 
 	for (;;) {
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 360139794557..b76e1f3ff16d 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -2132,17 +2132,7 @@ int jfsIOWait(void *arg)
 {
 	struct lbuf *bp;
 
-	lock_kernel();
-
-	daemonize();
-	strcpy(current->comm, "jfsIO");
-
-	unlock_kernel();
-
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	daemonize("jfsIO");
 
 	complete(&jfsIOwait);
 
diff --git a/fs/jfs/jfs_txnmgr.c b/fs/jfs/jfs_txnmgr.c
index 6af148d0387c..f86efd5f14c7 100644
--- a/fs/jfs/jfs_txnmgr.c
+++ b/fs/jfs/jfs_txnmgr.c
@@ -2771,20 +2771,10 @@ int jfs_lazycommit(void *arg)
 	struct tblock *tblk;
 	unsigned long flags;
 
-	lock_kernel();
-
-	daemonize();
-	strcpy(current->comm, "jfsCommit");
-
-	unlock_kernel();
+	daemonize("jfsCommit");
 
 	jfsCommitTask = current;
 
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
 	LAZY_LOCK_INIT();
 	TxAnchor.unlock_queue = TxAnchor.unlock_tail = 0;
 
@@ -2978,17 +2968,7 @@ int jfs_sync(void *arg)
 	int rc;
 	tid_t tid;
 
-	lock_kernel();
-
-	daemonize();
-	strcpy(current->comm, "jfsSync");
-
-	unlock_kernel();
-
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	daemonize("jfsSync");
 
 	complete(&jfsIOwait);
 
diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index c5110c48422b..6f3f77110ead 100644
--- a/fs/lockd/clntlock.c
+++ b/fs/lockd/clntlock.c
@@ -201,10 +201,8 @@ reclaimer(void *ptr)
 	struct file_lock *fl;
 	struct inode *inode;
 
-	daemonize();
-	snprintf(current->comm, sizeof(current->comm),
-		 "%s-reclaim",
-		 host->h_name);
+	daemonize("%s-reclaim", host->h_name);
+	allow_signal(SIGKILL);
 
 	/* This one ensures that our parent doesn't terminate while the
 	 * reclaim is in progress */
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index a0cafbdfbb0a..052e5518a7e3 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -97,14 +97,10 @@ lockd(struct svc_rqst *rqstp)
 	nlmsvc_pid = current->pid;
 	up(&lockd_start);
 
-	daemonize();
-	sprintf(current->comm, "lockd");
+	daemonize("lockd");
 
-	/* Process request with signals blocked.  */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked, sigmask(SIGKILL));
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	/* Process request with signals blocked, but allow SIGKILL.  */
+	allow_signal(SIGKILL);
 
 	/* kick rpciod */
 	rpciod_up();
@@ -126,9 +122,7 @@ lockd(struct svc_rqst *rqstp)
 	{
 		long timeout = MAX_SCHEDULE_TIMEOUT;
 		if (signalled()) {
-			spin_lock_irq(&current->sighand->siglock);
 			flush_signals(current);
-			spin_unlock_irq(&current->sighand->siglock);
 			if (nlmsvc_ops) {
 				nlmsvc_invalidate_all();
 				grace_period_expire = set_grace_period();
diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index 369c2ce897f4..3678715c34f1 100644
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -173,8 +173,7 @@ nfsd(struct svc_rqst *rqstp)
 	/* Lock module and set up kernel thread */
 	MOD_INC_USE_COUNT;
 	lock_kernel();
-	daemonize();
-	sprintf(current->comm, "nfsd");
+	daemonize("nfsd");
 	current->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
 
 	siginitsetinv(&shutdown_mask, SHUTDOWN_SIGS);
diff --git a/fs/smbfs/smbiod.c b/fs/smbfs/smbiod.c
index 41d5bbd8a334..f09ce74b8763 100644
--- a/fs/smbfs/smbiod.c
+++ b/fs/smbfs/smbiod.c
@@ -283,14 +283,9 @@ out:
 static int smbiod(void *unused)
 {
 	MOD_INC_USE_COUNT;
-	daemonize();
+	daemonize("smbiod");
 
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked, sigmask(SIGKILL));
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
-	strcpy(current->comm, "smbiod");
+	allow_signal(SIGKILL);
 
 	VERBOSE("SMB Kernel thread starting (%d) ...\n", current->pid);
 
diff --git a/fs/xfs/pagebuf/page_buf.c b/fs/xfs/pagebuf/page_buf.c
index d6b027eb2022..5663f6d4b430 100644
--- a/fs/xfs/pagebuf/page_buf.c
+++ b/fs/xfs/pagebuf/page_buf.c
@@ -1578,15 +1578,8 @@ pagebuf_daemon(
 		TIMER_INITIALIZER((timeout_fn)pagebuf_daemon_wakeup, 0, 0);
 
 	/*  Set up the thread  */
-	daemonize();
+	daemonize("pagebufd");
 
-	/* Avoid signals */
-	spin_lock_irq(&current->sighand->siglock);
-	sigfillset(&current->blocked);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
-	strcpy(current->comm, "pagebufd");
 	current->flags |= PF_MEMALLOC;
 
 	INIT_LIST_HEAD(&tmp);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index b99d2eb57a82..5432eb4765fc 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -616,7 +616,8 @@ extern void __exit_sighand(struct task_struct *);
 extern NORET_TYPE void do_group_exit(int);
 
 extern void reparent_to_init(void);
-extern void daemonize(void);
+extern void daemonize(const char *, ...);
+extern int allow_signal(int);
 extern task_t *child_reaper;
 
 extern int do_execve(char *, char **, char **, struct pt_regs *);
diff --git a/kernel/exit.c b/kernel/exit.c
index de34ed9091f5..acab23a650cc 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -278,14 +278,36 @@ void set_special_pids(pid_t session, pid_t pgrp)
 }
 
 /*
+ * Let kernel threads use this to say that they
+ * allow a certain signal (since daemonize() will
+ * have disabled all of them by default).
+ */
+int allow_signal(int sig)
+{
+	if (sig < 1 || sig > _NSIG)
+		return -EINVAL;
+
+	spin_lock_irq(&current->sighand->siglock);
+	sigdelset(&current->blocked, sig);
+	recalc_sigpending();
+	spin_unlock_irq(&current->sighand->siglock);
+	return 0;
+}
+	
+
+/*
  *	Put all the gunge required to become a kernel thread without
  *	attached user resources in one place where it belongs.
  */
 
-void daemonize(void)
+void daemonize(const char *name, ...)
 {
+	va_list args;
 	struct fs_struct *fs;
+	sigset_t blocked;
 
+	va_start(args, name);
+	vsnprintf(current->comm, sizeof(current->comm), name, args);
 
 	/*
 	 * If we were started as result of loading a module, close all of the
@@ -297,6 +319,11 @@ void daemonize(void)
 	set_special_pids(1, 1);
 	current->tty = NULL;
 
+	/* Block and flush all signals */
+	sigfillset(&blocked);
+	sigprocmask(SIG_BLOCK, &blocked, NULL);
+	flush_signals(current);
+
 	/* Become as one with the init task */
 
 	exit_fs(current);	/* current->fs->count--; */
diff --git a/kernel/kmod.c b/kernel/kmod.c
index 257634f94652..15dacc2e6bd8 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -110,10 +110,10 @@ int exec_usermodehelper(char *program_path, char *argv[], char *envp[])
 	   as the super user right after the execve fails if you time
 	   the signal just right.
 	*/
-	spin_lock_irq(&curtask->sighand->siglock);
-	sigemptyset(&curtask->blocked);
 	flush_signals(curtask);
 	flush_signal_handlers(curtask);
+	spin_lock_irq(&curtask->sighand->siglock);
+	sigemptyset(&curtask->blocked);
 	recalc_sigpending();
 	spin_unlock_irq(&curtask->sighand->siglock);
 
diff --git a/kernel/sched.c b/kernel/sched.c
index a501326ed2dc..1981a92ab129 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -2246,8 +2246,7 @@ static int migration_thread(void * data)
 	runqueue_t *rq;
 	int ret;
 
-	daemonize();
-	sigfillset(&current->blocked);
+	daemonize("migration/%d", cpu);
 	set_fs(KERNEL_DS);
 
 	/*
@@ -2261,8 +2260,6 @@ static int migration_thread(void * data)
 	rq = this_rq();
 	rq->migration_thread = current;
 
-	sprintf(current->comm, "migration/%d", smp_processor_id());
-
 	for (;;) {
 		runqueue_t *rq_src, *rq_dest;
 		struct list_head *head;
diff --git a/kernel/signal.c b/kernel/signal.c
index b43102e63a8d..abd41adee495 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -256,8 +256,13 @@ static void flush_sigqueue(struct sigpending *queue)
 void
 flush_signals(struct task_struct *t)
 {
+	unsigned long flags;
+
+	spin_lock_irqsave(&t->sighand->siglock, flags);
 	clear_tsk_thread_flag(t,TIF_SIGPENDING);
 	flush_sigqueue(&t->pending);
+	flush_sigqueue(&t->signal->shared_pending);
+	spin_unlock_irqrestore(&t->sighand->siglock, flags);
 }
 
 /*
@@ -1580,7 +1585,6 @@ long do_no_restart_syscall(struct restart_block *param)
 	return -EINTR;
 }
 
-
 /*
  * We don't need to get the kernel lock - this is all local to this
  * particular thread.. (and that's good, because this is _heavily_
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 59fb7acb0ee1..57048481e7f3 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -300,18 +300,15 @@ static int ksoftirqd(void * __bind_cpu)
 {
 	int cpu = (int) (long) __bind_cpu;
 
-	daemonize();
+	daemonize("ksoftirqd/%d", cpu);
 	set_user_nice(current, 19);
 	current->flags |= PF_IOTHREAD;
-	sigfillset(&current->blocked);
 
 	/* Migrate to the right CPU */
 	set_cpus_allowed(current, 1UL << cpu);
 	if (smp_processor_id() != cpu)
 		BUG();
 
-	sprintf(current->comm, "ksoftirqd/%d", cpu);
-
 	__set_current_state(TASK_INTERRUPTIBLE);
 	mb();
 
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 8fd97c6764a4..5e9a520cfd77 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -172,19 +172,14 @@ static int worker_thread(void *__startup)
 	DECLARE_WAITQUEUE(wait, current);
 	struct k_sigaction sa;
 
-	daemonize();
-	sprintf(current->comm, "%s/%d", startup->name, cpu);
+	daemonize("%s/%d", startup->name, cpu);
+	allow_signal(SIGCHLD);
 	current->flags |= PF_IOTHREAD;
 	cwq->thread = current;
 
 	set_user_nice(current, -10);
 	set_cpus_allowed(current, 1UL << cpu);
 
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked, sigmask(SIGCHLD));
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
 	complete(&startup->done);
 
 	/* Install a handler so SIGCLD is delivered */
@@ -213,10 +208,7 @@ static int worker_thread(void *__startup)
 				/* SIGCHLD - auto-reaping */ ;
 
 			/* zap all other signals */
-			spin_lock_irq(&current->sighand->siglock);
 			flush_signals(current);
-			recalc_sigpending();
-			spin_unlock_irq(&current->sighand->siglock);
 		}
 	}
 	remove_wait_queue(&cwq->more_work, &wait);
diff --git a/mm/pdflush.c b/mm/pdflush.c
index c38ad46c58c7..b1375644c519 100644
--- a/mm/pdflush.c
+++ b/mm/pdflush.c
@@ -86,14 +86,7 @@ struct pdflush_work {
 
 static int __pdflush(struct pdflush_work *my_work)
 {
-	daemonize();
-	strcpy(current->comm, "pdflush");
-
-	/* interruptible sleep, so block all signals */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked, 0);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	daemonize("pdflush");
 
 	current->flags |= PF_FLUSHER;
 	my_work->fn = NULL;
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 4b40c5483268..995ea273b5df 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -928,10 +928,8 @@ int kswapd(void *p)
 	struct task_struct *tsk = current;
 	DEFINE_WAIT(wait);
 
-	daemonize();
+	daemonize("kswapd%d", pgdat->node_id);
 	set_cpus_allowed(tsk, node_to_cpumask(pgdat->node_id));
-	sprintf(tsk->comm, "kswapd%d", pgdat->node_id);
-	sigfillset(&tsk->blocked);
 	
 	/*
 	 * Tell the memory management that we're a "memory allocator",
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c
index e15d2603b59f..e72ccd2a69bd 100644
--- a/net/bluetooth/bnep/core.c
+++ b/net/bluetooth/bnep/core.c
@@ -478,13 +478,9 @@ static int bnep_session(void *arg)
 
 	BT_DBG("");
 
-        daemonize();
+        daemonize("kbnepd %s", dev->name);
 	set_user_nice(current, -15);
 	current->flags |= PF_IOTHREAD;
-        sigfillset(&current->blocked);
-	flush_signals(current);
-
-        sprintf(current->comm, "kbnepd %s", dev->name);
 
         set_fs(KERNEL_DS);
 
diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index ca4d8295078c..9798603a4e61 100644
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -1705,13 +1705,9 @@ static int rfcomm_run(void *unused)
 
 	atomic_inc(&running);
 
-	daemonize();
+	daemonize("krfcommd");
 	set_user_nice(current, -10);
 	current->flags |= PF_IOTHREAD;
-	sigfillset(&current->blocked);
-	flush_signals(current);
-
-	sprintf(current->comm, "krfcommd");
 
 	set_fs(KERNEL_DS);
 
diff --git a/net/rxrpc/krxiod.c b/net/rxrpc/krxiod.c
index ae9987d6155f..3eba905e00e4 100644
--- a/net/rxrpc/krxiod.c
+++ b/net/rxrpc/krxiod.c
@@ -42,15 +42,8 @@ static int rxrpc_krxiod(void *arg)
 	DECLARE_WAITQUEUE(krxiod,current);
 
 	printk("Started krxiod %d\n",current->pid);
-	strcpy(current->comm,"krxiod");
 
-	daemonize();
-
-	/* only certain signals are of interest */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked,0);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	daemonize("krxiod");
 
 	/* loop around waiting for work to do */
 	do {
diff --git a/net/rxrpc/krxsecd.c b/net/rxrpc/krxsecd.c
index 39f4eac9f224..e5498ab73c8e 100644
--- a/net/rxrpc/krxsecd.c
+++ b/net/rxrpc/krxsecd.c
@@ -54,15 +54,8 @@ static int rxrpc_krxsecd(void *arg)
 	int die;
 
 	printk("Started krxsecd %d\n",current->pid);
-	strcpy(current->comm,"krxsecd");
 
-	daemonize();
-
-	/* only certain signals are of interest */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked,0);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
+	daemonize("krxsecd");
 
 	/* loop around waiting for work to do */
 	do {
diff --git a/net/rxrpc/krxtimod.c b/net/rxrpc/krxtimod.c
index c6df1edf38ff..415366ed7983 100644
--- a/net/rxrpc/krxtimod.c
+++ b/net/rxrpc/krxtimod.c
@@ -70,18 +70,11 @@ static int krxtimod(void *arg)
 	rxrpc_timer_t *timer;
 
 	printk("Started krxtimod %d\n",current->pid);
-	strcpy(current->comm,"krxtimod");
 
-	daemonize();
+	daemonize("krxtimod");
 
 	complete(&krxtimod_alive);
 
-	/* only certain signals are of interest */
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked,0);
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
 	/* loop around looking for things to attend to */
  loop:
 	set_current_state(TASK_INTERRUPTIBLE);
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index c8e5364ed1ea..b36d08d5e71f 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -962,14 +962,8 @@ rpciod(void *ptr)
 	rpciod_pid = current->pid;
 	up(&rpciod_running);
 
-	daemonize();
-
-	spin_lock_irq(&current->sighand->siglock);
-	siginitsetinv(&current->blocked, sigmask(SIGKILL));
-	recalc_sigpending();
-	spin_unlock_irq(&current->sighand->siglock);
-
-	strcpy(current->comm, "rpciod");
+	daemonize("rpciod");
+	allow_signal(SIGKILL);
 
 	dprintk("RPC: rpciod starting (pid %d)\n", rpciod_pid);
 	while (rpciod_users) {