aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--Documentation/power/freezing-of-tasks.txt160
-rw-r--r--Documentation/power/kernel_threads.txt40
-rw-r--r--Documentation/power/swsusp.txt18
-rw-r--r--arch/i386/kernel/apm.c2
-rw-r--r--arch/i386/kernel/io_apic.c1
-rw-r--r--drivers/block/loop.c8
-rw-r--r--drivers/block/pktcdvd.c1
-rw-r--r--drivers/char/apm-emulation.c12
-rw-r--r--drivers/char/hvc_console.c1
-rw-r--r--drivers/edac/edac_mc.c1
-rw-r--r--drivers/ieee1394/ieee1394_core.c3
-rw-r--r--drivers/ieee1394/nodemgr.c1
-rw-r--r--drivers/input/gameport/gameport.c1
-rw-r--r--drivers/input/serio/serio.c1
-rw-r--r--drivers/input/touchscreen/ucb1400_ts.c1
-rw-r--r--drivers/macintosh/therm_adt746x.c1
-rw-r--r--drivers/macintosh/windfarm_core.c1
-rw-r--r--drivers/md/md.c1
-rw-r--r--drivers/media/dvb/dvb-core/dvb_frontend.c1
-rw-r--r--drivers/media/video/cx88/cx88-tvaudio.c1
-rw-r--r--drivers/media/video/msp3400-kthreads.c6
-rw-r--r--drivers/media/video/tvaudio.c2
-rw-r--r--drivers/media/video/video-buf-dvb.c1
-rw-r--r--drivers/media/video/vivi.c1
-rw-r--r--drivers/mfd/ucb1x00-ts.c1
-rw-r--r--drivers/mmc/card/queue.c7
-rw-r--r--drivers/mtd/mtd_blkdevs.c3
-rw-r--r--drivers/mtd/ubi/wl.c1
-rw-r--r--drivers/net/wireless/airo.c3
-rw-r--r--drivers/net/wireless/libertas/main.c1
-rw-r--r--drivers/pcmcia/cs.c1
-rw-r--r--drivers/pnp/pnpbios/core.c1
-rw-r--r--drivers/scsi/libsas/sas_scsi_host.c3
-rw-r--r--drivers/scsi/scsi_error.c3
-rw-r--r--drivers/usb/atm/ueagle-atm.c1
-rw-r--r--drivers/usb/core/hub.c1
-rw-r--r--drivers/usb/gadget/file_storage.c3
-rw-r--r--drivers/usb/storage/usb.c3
-rw-r--r--drivers/video/ps3fb.c1
-rw-r--r--drivers/w1/w1.c1
-rw-r--r--fs/cifs/cifsfs.c1
-rw-r--r--fs/cifs/connect.c1
-rw-r--r--fs/jffs2/background.c1
-rw-r--r--fs/lockd/svc.c2
-rw-r--r--fs/nfs/callback.c2
-rw-r--r--fs/nfsd/nfssvc.c2
-rw-r--r--fs/xfs/linux-2.6/xfs_super.c1
-rw-r--r--include/linux/freezer.h14
-rw-r--r--init/do_mounts_initrd.c7
-rw-r--r--kernel/audit.c1
-rw-r--r--kernel/exit.c6
-rw-r--r--kernel/fork.c2
-rw-r--r--kernel/rcutorture.c4
-rw-r--r--kernel/rtmutex-tester.c1
-rw-r--r--kernel/sched.c3
-rw-r--r--kernel/softirq.c3
-rw-r--r--kernel/softlockup.c2
-rw-r--r--kernel/workqueue.c4
-rw-r--r--mm/pdflush.c1
-rw-r--r--mm/vmscan.c1
-rw-r--r--net/bluetooth/bnep/core.c2
-rw-r--r--net/bluetooth/cmtp/core.c2
-rw-r--r--net/bluetooth/hidp/core.c2
-rw-r--r--net/bluetooth/rfcomm/core.c2
-rw-r--r--net/core/pktgen.c2
65 files changed, 256 insertions, 113 deletions
diff --git a/Documentation/power/freezing-of-tasks.txt b/Documentation/power/freezing-of-tasks.txt
new file mode 100644
index 000000000000..af1a282c71a3
--- /dev/null
+++ b/Documentation/power/freezing-of-tasks.txt
@@ -0,0 +1,160 @@
1Freezing of tasks
2 (C) 2007 Rafael J. Wysocki <rjw@sisk.pl>, GPL
3
4I. What is the freezing of tasks?
5
6The freezing of tasks is a mechanism by which user space processes and some
7kernel threads are controlled during hibernation or system-wide suspend (on some
8architectures).
9
10II. How does it work?
11
12There are four per-task flags used for that, PF_NOFREEZE, PF_FROZEN, TIF_FREEZE
13and PF_FREEZER_SKIP (the last one is auxiliary). The tasks that have
14PF_NOFREEZE unset (all user space processes and some kernel threads) are
15regarded as 'freezable' and treated in a special way before the system enters a
16suspend state as well as before a hibernation image is created (in what follows
17we only consider hibernation, but the description also applies to suspend).
18
19Namely, as the first step of the hibernation procedure the function
20freeze_processes() (defined in kernel/power/process.c) is called. It executes
21try_to_freeze_tasks() that sets TIF_FREEZE for all of the freezable tasks and
22sends a fake signal to each of them. A task that receives such a signal and has
23TIF_FREEZE set, should react to it by calling the refrigerator() function
24(defined in kernel/power/process.c), which sets the task's PF_FROZEN flag,
25changes its state to TASK_UNINTERRUPTIBLE and makes it loop until PF_FROZEN is
26cleared for it. Then, we say that the task is 'frozen' and therefore the set of
27functions handling this mechanism is called 'the freezer' (these functions are
28defined in kernel/power/process.c and include/linux/freezer.h). User space
29processes are generally frozen before kernel threads.
30
31It is not recommended to call refrigerator() directly. Instead, it is
32recommended to use the try_to_freeze() function (defined in
33include/linux/freezer.h), that checks the task's TIF_FREEZE flag and makes the
34task enter refrigerator() if the flag is set.
35
36For user space processes try_to_freeze() is called automatically from the
37signal-handling code, but the freezable kernel threads need to call it
38explicitly in suitable places. The code to do this may look like the following:
39
40 do {
41 hub_events();
42 wait_event_interruptible(khubd_wait,
43 !list_empty(&hub_event_list));
44 try_to_freeze();
45 } while (!signal_pending(current));
46
47(from drivers/usb/core/hub.c::hub_thread()).
48
49If a freezable kernel thread fails to call try_to_freeze() after the freezer has
50set TIF_FREEZE for it, the freezing of tasks will fail and the entire
51hibernation operation will be cancelled. For this reason, freezable kernel
52threads must call try_to_freeze() somewhere.
53
54After the system memory state has been restored from a hibernation image and
55devices have been reinitialized, the function thaw_processes() is called in
56order to clear the PF_FROZEN flag for each frozen task. Then, the tasks that
57have been frozen leave refrigerator() and continue running.
58
59III. Which kernel threads are freezable?
60
61Kernel threads are not freezable by default. However, a kernel thread may clear
62PF_NOFREEZE for itself by calling set_freezable() (the resetting of PF_NOFREEZE
63directly is strongly discouraged). From this point it is regarded as freezable
64and must call try_to_freeze() in a suitable place.
65
66IV. Why do we do that?
67
68Generally speaking, there is a couple of reasons to use the freezing of tasks:
69
701. The principal reason is to prevent filesystems from being damaged after
71hibernation. At the moment we have no simple means of checkpointing
72filesystems, so if there are any modifications made to filesystem data and/or
73metadata on disks, we cannot bring them back to the state from before the
74modifications. At the same time each hibernation image contains some
75filesystem-related information that must be consistent with the state of the
76on-disk data and metadata after the system memory state has been restored from
77the image (otherwise the filesystems will be damaged in a nasty way, usually
78making them almost impossible to repair). We therefore freeze tasks that might
79cause the on-disk filesystems' data and metadata to be modified after the
80hibernation image has been created and before the system is finally powered off.
81The majority of these are user space processes, but if any of the kernel threads
82may cause something like this to happen, they have to be freezable.
83
842. The second reason is to prevent user space processes and some kernel threads
85from interfering with the suspending and resuming of devices. A user space
86process running on a second CPU while we are suspending devices may, for
87example, be troublesome and without the freezing of tasks we would need some
88safeguards against race conditions that might occur in such a case.
89
90Although Linus Torvalds doesn't like the freezing of tasks, he said this in one
91of the discussions on LKML (http://lkml.org/lkml/2007/4/27/608):
92
93"RJW:> Why we freeze tasks at all or why we freeze kernel threads?
94
95Linus: In many ways, 'at all'.
96
97I _do_ realize the IO request queue issues, and that we cannot actually do
98s2ram with some devices in the middle of a DMA. So we want to be able to
99avoid *that*, there's no question about that. And I suspect that stopping
100user threads and then waiting for a sync is practically one of the easier
101ways to do so.
102
103So in practice, the 'at all' may become a 'why freeze kernel threads?' and
104freezing user threads I don't find really objectionable."
105
106Still, there are kernel threads that may want to be freezable. For example, if
107a kernel that belongs to a device driver accesses the device directly, it in
108principle needs to know when the device is suspended, so that it doesn't try to
109access it at that time. However, if the kernel thread is freezable, it will be
110frozen before the driver's .suspend() callback is executed and it will be
111thawed after the driver's .resume() callback has run, so it won't be accessing
112the device while it's suspended.
113
1143. Another reason for freezing tasks is to prevent user space processes from
115realizing that hibernation (or suspend) operation takes place. Ideally, user
116space processes should not notice that such a system-wide operation has occurred
117and should continue running without any problems after the restore (or resume
118from suspend). Unfortunately, in the most general case this is quite difficult
119to achieve without the freezing of tasks. Consider, for example, a process
120that depends on all CPUs being online while it's running. Since we need to
121disable nonboot CPUs during the hibernation, if this process is not frozen, it
122may notice that the number of CPUs has changed and may start to work incorrectly
123because of that.
124
125V. Are there any problems related to the freezing of tasks?
126
127Yes, there are.
128
129First of all, the freezing of kernel threads may be tricky if they depend one
130on another. For example, if kernel thread A waits for a completion (in the
131TASK_UNINTERRUPTIBLE state) that needs to be done by freezable kernel thread B
132and B is frozen in the meantime, then A will be blocked until B is thawed, which
133may be undesirable. That's why kernel threads are not freezable by default.
134
135Second, there are the following two problems related to the freezing of user
136space processes:
1371. Putting processes into an uninterruptible sleep distorts the load average.
1382. Now that we have FUSE, plus the framework for doing device drivers in
139userspace, it gets even more complicated because some userspace processes are
140now doing the sorts of things that kernel threads do
141(https://lists.linux-foundation.org/pipermail/linux-pm/2007-May/012309.html).
142
143The problem 1. seems to be fixable, although it hasn't been fixed so far. The
144other one is more serious, but it seems that we can work around it by using
145hibernation (and suspend) notifiers (in that case, though, we won't be able to
146avoid the realization by the user space processes that the hibernation is taking
147place).
148
149There are also problems that the freezing of tasks tends to expose, although
150they are not directly related to it. For example, if request_firmware() is
151called from a device driver's .resume() routine, it will timeout and eventually
152fail, because the user land process that should respond to the request is frozen
153at this point. So, seemingly, the failure is due to the freezing of tasks.
154Suppose, however, that the firmware file is located on a filesystem accessible
155only through another device that hasn't been resumed yet. In that case,
156request_firmware() will fail regardless of whether or not the freezing of tasks
157is used. Consequently, the problem is not really related to the freezing of
158tasks, since it generally exists anyway. [The solution to this particular
159problem is to keep the firmware in memory after it's loaded for the first time
160and upload if from memory to the device whenever necessary.]
diff --git a/Documentation/power/kernel_threads.txt b/Documentation/power/kernel_threads.txt
deleted file mode 100644
index fb57784986b1..000000000000
--- a/Documentation/power/kernel_threads.txt
+++ /dev/null
@@ -1,40 +0,0 @@
1KERNEL THREADS
2
3
4Freezer
5
6Upon entering a suspended state the system will freeze all
7tasks. This is done by delivering pseudosignals. This affects
8kernel threads, too. To successfully freeze a kernel thread
9the thread has to check for the pseudosignal and enter the
10refrigerator. Code to do this looks like this:
11
12 do {
13 hub_events();
14 wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list));
15 try_to_freeze();
16 } while (!signal_pending(current));
17
18from drivers/usb/core/hub.c::hub_thread()
19
20
21The Unfreezable
22
23Some kernel threads however, must not be frozen. The kernel must
24be able to finish pending IO operations and later on be able to
25write the memory image to disk. Kernel threads needed to do IO
26must stay awake. Such threads must mark themselves unfreezable
27like this:
28
29 /*
30 * This thread doesn't need any user-level access,
31 * so get rid of all our resources.
32 */
33 daemonize("usb-storage");
34
35 current->flags |= PF_NOFREEZE;
36
37from drivers/usb/storage/usb.c::usb_stor_control_thread()
38
39Such drivers are themselves responsible for staying quiet during
40the actual snapshotting.
diff --git a/Documentation/power/swsusp.txt b/Documentation/power/swsusp.txt
index 152b510d1bbb..aea7e9209667 100644
--- a/Documentation/power/swsusp.txt
+++ b/Documentation/power/swsusp.txt
@@ -140,21 +140,11 @@ should be sent to the mailing list available through the suspend2
140website, and not to the Linux Kernel Mailing List. We are working 140website, and not to the Linux Kernel Mailing List. We are working
141toward merging suspend2 into the mainline kernel. 141toward merging suspend2 into the mainline kernel.
142 142
143Q: A kernel thread must voluntarily freeze itself (call 'refrigerator'). 143Q: What is the freezing of tasks and why are we using it?
144I found some kernel threads that don't do it, and they don't freeze
145so the system can't sleep. Is this a known behavior?
146
147A: All such kernel threads need to be fixed, one by one. Select the
148place where the thread is safe to be frozen (no kernel semaphores
149should be held at that point and it must be safe to sleep there), and
150add:
151
152 try_to_freeze();
153
154If the thread is needed for writing the image to storage, you should
155instead set the PF_NOFREEZE process flag when creating the thread (and
156be very careful).
157 144
145A: The freezing of tasks is a mechanism by which user space processes and some
146kernel threads are controlled during hibernation or system-wide suspend (on some
147architectures). See freezing-of-tasks.txt for details.
158 148
159Q: What is the difference between "platform" and "shutdown"? 149Q: What is the difference between "platform" and "shutdown"?
160 150
diff --git a/arch/i386/kernel/apm.c b/arch/i386/kernel/apm.c
index 4112afe712b9..47001d50a083 100644
--- a/arch/i386/kernel/apm.c
+++ b/arch/i386/kernel/apm.c
@@ -222,6 +222,7 @@
222#include <linux/capability.h> 222#include <linux/capability.h>
223#include <linux/device.h> 223#include <linux/device.h>
224#include <linux/kernel.h> 224#include <linux/kernel.h>
225#include <linux/freezer.h>
225#include <linux/smp.h> 226#include <linux/smp.h>
226#include <linux/dmi.h> 227#include <linux/dmi.h>
227#include <linux/suspend.h> 228#include <linux/suspend.h>
@@ -2311,7 +2312,6 @@ static int __init apm_init(void)
2311 remove_proc_entry("apm", NULL); 2312 remove_proc_entry("apm", NULL);
2312 return err; 2313 return err;
2313 } 2314 }
2314 kapmd_task->flags |= PF_NOFREEZE;
2315 wake_up_process(kapmd_task); 2315 wake_up_process(kapmd_task);
2316 2316
2317 if (num_online_cpus() > 1 && !smp ) { 2317 if (num_online_cpus() > 1 && !smp ) {
diff --git a/arch/i386/kernel/io_apic.c b/arch/i386/kernel/io_apic.c
index 7f8b7af2b95f..21db8f56c9a1 100644
--- a/arch/i386/kernel/io_apic.c
+++ b/arch/i386/kernel/io_apic.c
@@ -667,6 +667,7 @@ static int balanced_irq(void *unused)
667 set_pending_irq(i, cpumask_of_cpu(0)); 667 set_pending_irq(i, cpumask_of_cpu(0));
668 } 668 }
669 669
670 set_freezable();
670 for ( ; ; ) { 671 for ( ; ; ) {
671 time_remaining = schedule_timeout_interruptible(time_remaining); 672 time_remaining = schedule_timeout_interruptible(time_remaining);
672 try_to_freeze(); 673 try_to_freeze();
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 4503290da407..06eaa11cbc2f 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -68,6 +68,7 @@
68#include <linux/loop.h> 68#include <linux/loop.h>
69#include <linux/compat.h> 69#include <linux/compat.h>
70#include <linux/suspend.h> 70#include <linux/suspend.h>
71#include <linux/freezer.h>
71#include <linux/writeback.h> 72#include <linux/writeback.h>
72#include <linux/buffer_head.h> /* for invalidate_bdev() */ 73#include <linux/buffer_head.h> /* for invalidate_bdev() */
73#include <linux/completion.h> 74#include <linux/completion.h>
@@ -600,13 +601,6 @@ static int loop_thread(void *data)
600 struct loop_device *lo = data; 601 struct loop_device *lo = data;
601 struct bio *bio; 602 struct bio *bio;
602 603
603 /*
604 * loop can be used in an encrypted device,
605 * hence, it mustn't be stopped at all
606 * because it could be indirectly used during suspension
607 */
608 current->flags |= PF_NOFREEZE;
609
610 set_user_nice(current, -20); 604 set_user_nice(current, -20);
611 605
612 while (!kthread_should_stop() || lo->lo_bio) { 606 while (!kthread_should_stop() || lo->lo_bio) {
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 7c294a40002e..31be33e4f119 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -1593,6 +1593,7 @@ static int kcdrwd(void *foobar)
1593 long min_sleep_time, residue; 1593 long min_sleep_time, residue;
1594 1594
1595 set_user_nice(current, -20); 1595 set_user_nice(current, -20);
1596 set_freezable();
1596 1597
1597 for (;;) { 1598 for (;;) {
1598 DECLARE_WAITQUEUE(wait, current); 1599 DECLARE_WAITQUEUE(wait, current);
diff --git a/drivers/char/apm-emulation.c b/drivers/char/apm-emulation.c
index 179c7a3b6e75..ec116df919d9 100644
--- a/drivers/char/apm-emulation.c
+++ b/drivers/char/apm-emulation.c
@@ -20,6 +20,7 @@
20#include <linux/sched.h> 20#include <linux/sched.h>
21#include <linux/pm.h> 21#include <linux/pm.h>
22#include <linux/apm-emulation.h> 22#include <linux/apm-emulation.h>
23#include <linux/freezer.h>
23#include <linux/device.h> 24#include <linux/device.h>
24#include <linux/kernel.h> 25#include <linux/kernel.h>
25#include <linux/list.h> 26#include <linux/list.h>
@@ -329,13 +330,8 @@ apm_ioctl(struct inode * inode, struct file *filp, u_int cmd, u_long arg)
329 /* 330 /*
330 * Wait for the suspend/resume to complete. If there 331 * Wait for the suspend/resume to complete. If there
331 * are pending acknowledges, we wait here for them. 332 * are pending acknowledges, we wait here for them.
332 *
333 * Note: we need to ensure that the PM subsystem does
334 * not kick us out of the wait when it suspends the
335 * threads.
336 */ 333 */
337 flags = current->flags; 334 flags = current->flags;
338 current->flags |= PF_NOFREEZE;
339 335
340 wait_event(apm_suspend_waitqueue, 336 wait_event(apm_suspend_waitqueue,
341 as->suspend_state == SUSPEND_DONE); 337 as->suspend_state == SUSPEND_DONE);
@@ -365,13 +361,8 @@ apm_ioctl(struct inode * inode, struct file *filp, u_int cmd, u_long arg)
365 /* 361 /*
366 * Wait for the suspend/resume to complete. If there 362 * Wait for the suspend/resume to complete. If there
367 * are pending acknowledges, we wait here for them. 363 * are pending acknowledges, we wait here for them.
368 *
369 * Note: we need to ensure that the PM subsystem does
370 * not kick us out of the wait when it suspends the
371 * threads.
372 */ 364 */
373 flags = current->flags; 365 flags = current->flags;
374 current->flags |= PF_NOFREEZE;
375 366
376 wait_event_interruptible(apm_suspend_waitqueue, 367 wait_event_interruptible(apm_suspend_waitqueue,
377 as->suspend_state == SUSPEND_DONE); 368 as->suspend_state == SUSPEND_DONE);
@@ -598,7 +589,6 @@ static int __init apm_init(void)
598 kapmd_tsk = NULL; 589 kapmd_tsk = NULL;
599 return ret; 590 return ret;
600 } 591 }
601 kapmd_tsk->flags |= PF_NOFREEZE;
602 wake_up_process(kapmd_tsk); 592 wake_up_process(kapmd_tsk);
603 593
604#ifdef CONFIG_PROC_FS 594#ifdef CONFIG_PROC_FS
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index b3ab42e0dd4a..83c1151ec7a2 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -679,6 +679,7 @@ static int khvcd(void *unused)
679 int poll_mask; 679 int poll_mask;
680 struct hvc_struct *hp; 680 struct hvc_struct *hp;
681 681
682 set_freezable();
682 __set_current_state(TASK_RUNNING); 683 __set_current_state(TASK_RUNNING);
683 do { 684 do {
684 poll_mask = 0; 685 poll_mask = 0;
diff --git a/drivers/edac/edac_mc.c b/drivers/edac/edac_mc.c
index 7b622300d0e5..804875de5801 100644
--- a/drivers/edac/edac_mc.c
+++ b/drivers/edac/edac_mc.c
@@ -1906,6 +1906,7 @@ static void do_edac_check(void)
1906 1906
1907static int edac_kernel_thread(void *arg) 1907static int edac_kernel_thread(void *arg)
1908{ 1908{
1909 set_freezable();
1909 while (!kthread_should_stop()) { 1910 while (!kthread_should_stop()) {
1910 do_edac_check(); 1911 do_edac_check();
1911 1912
diff --git a/drivers/ieee1394/ieee1394_core.c b/drivers/ieee1394/ieee1394_core.c
index 0fc8c6e559e4..ee45259573c8 100644
--- a/drivers/ieee1394/ieee1394_core.c
+++ b/drivers/ieee1394/ieee1394_core.c
@@ -30,6 +30,7 @@
30#include <linux/moduleparam.h> 30#include <linux/moduleparam.h>
31#include <linux/bitops.h> 31#include <linux/bitops.h>
32#include <linux/kdev_t.h> 32#include <linux/kdev_t.h>
33#include <linux/freezer.h>
33#include <linux/suspend.h> 34#include <linux/suspend.h>
34#include <linux/kthread.h> 35#include <linux/kthread.h>
35#include <linux/preempt.h> 36#include <linux/preempt.h>
@@ -1128,8 +1129,6 @@ static int hpsbpkt_thread(void *__hi)
1128 struct list_head tmp; 1129 struct list_head tmp;
1129 int may_schedule; 1130 int may_schedule;
1130 1131
1131 current->flags |= PF_NOFREEZE;
1132
1133 while (!kthread_should_stop()) { 1132 while (!kthread_should_stop()) {
1134 1133
1135 INIT_LIST_HEAD(&tmp); 1134 INIT_LIST_HEAD(&tmp);
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 51a12062ed36..2ffd53461db6 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -1699,6 +1699,7 @@ static int nodemgr_host_thread(void *__hi)
1699 unsigned int g, generation = 0; 1699 unsigned int g, generation = 0;
1700 int i, reset_cycles = 0; 1700 int i, reset_cycles = 0;
1701 1701
1702 set_freezable();
1702 /* Setup our device-model entries */ 1703 /* Setup our device-model entries */
1703 nodemgr_create_host_dev_files(host); 1704 nodemgr_create_host_dev_files(host);
1704 1705
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c
index bd686a2a517d..20896d5e5f0e 100644
--- a/drivers/input/gameport/gameport.c
+++ b/drivers/input/gameport/gameport.c
@@ -445,6 +445,7 @@ static struct gameport *gameport_get_pending_child(struct gameport *parent)
445 445
446static int gameport_thread(void *nothing) 446static int gameport_thread(void *nothing)
447{ 447{
448 set_freezable();
448 do { 449 do {
449 gameport_handle_event(); 450 gameport_handle_event();
450 wait_event_interruptible(gameport_wait, 451 wait_event_interruptible(gameport_wait,
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index a8f3bc1dff22..372ca4931194 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -384,6 +384,7 @@ static struct serio *serio_get_pending_child(struct serio *parent)
384 384
385static int serio_thread(void *nothing) 385static int serio_thread(void *nothing)
386{ 386{
387 set_freezable();
387 do { 388 do {
388 serio_handle_event(); 389 serio_handle_event();
389 wait_event_interruptible(serio_wait, 390 wait_event_interruptible(serio_wait,
diff --git a/drivers/input/touchscreen/ucb1400_ts.c b/drivers/input/touchscreen/ucb1400_ts.c
index f0cbcdb008ed..36f944019158 100644
--- a/drivers/input/touchscreen/ucb1400_ts.c
+++ b/drivers/input/touchscreen/ucb1400_ts.c
@@ -292,6 +292,7 @@ static int ucb1400_ts_thread(void *_ucb)
292 292
293 sched_setscheduler(tsk, SCHED_FIFO, &param); 293 sched_setscheduler(tsk, SCHED_FIFO, &param);
294 294
295 set_freezable();
295 while (!kthread_should_stop()) { 296 while (!kthread_should_stop()) {
296 unsigned int x, y, p; 297 unsigned int x, y, p;
297 long timeout; 298 long timeout;
diff --git a/drivers/macintosh/therm_adt746x.c b/drivers/macintosh/therm_adt746x.c
index bd55e6ab99fc..f25685b9b7cf 100644
--- a/drivers/macintosh/therm_adt746x.c
+++ b/drivers/macintosh/therm_adt746x.c
@@ -335,6 +335,7 @@ static int monitor_task(void *arg)
335{ 335{
336 struct thermostat* th = arg; 336 struct thermostat* th = arg;
337 337
338 set_freezable();
338 while(!kthread_should_stop()) { 339 while(!kthread_should_stop()) {
339 try_to_freeze(); 340 try_to_freeze();
340 msleep_interruptible(2000); 341 msleep_interruptible(2000);
diff --git a/drivers/macintosh/windfarm_core.c b/drivers/macintosh/windfarm_core.c
index 4fcb245ba184..e18d265d5d33 100644
--- a/drivers/macintosh/windfarm_core.c
+++ b/drivers/macintosh/windfarm_core.c
@@ -92,6 +92,7 @@ static int wf_thread_func(void *data)
92 92
93 DBG("wf: thread started\n"); 93 DBG("wf: thread started\n");
94 94
95 set_freezable();
95 while(!kthread_should_stop()) { 96 while(!kthread_should_stop()) {
96 if (time_after_eq(jiffies, next)) { 97 if (time_after_eq(jiffies, next)) {
97 wf_notify(WF_EVENT_TICK, NULL); 98 wf_notify(WF_EVENT_TICK, NULL);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 33beaa7da085..9aefc4a023df 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -4642,7 +4642,6 @@ static int md_thread(void * arg)
4642 * many dirty RAID5 blocks. 4642 * many dirty RAID5 blocks.
4643 */ 4643 */
4644 4644
4645 current->flags |= PF_NOFREEZE;
4646 allow_signal(SIGKILL); 4645 allow_signal(SIGKILL);
4647 while (!kthread_should_stop()) { 4646 while (!kthread_should_stop()) {
4648 4647
diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.c b/drivers/media/dvb/dvb-core/dvb_frontend.c
index f4e4ca2dcade..b6c7f6610ec5 100644
--- a/drivers/media/dvb/dvb-core/dvb_frontend.c
+++ b/drivers/media/dvb/dvb-core/dvb_frontend.c
@@ -523,6 +523,7 @@ static int dvb_frontend_thread(void *data)
523 523
524 dvb_frontend_init(fe); 524 dvb_frontend_init(fe);
525 525
526 set_freezable();
526 while (1) { 527 while (1) {
527 up(&fepriv->sem); /* is locked when we enter the thread... */ 528 up(&fepriv->sem); /* is locked when we enter the thread... */
528restart: 529restart:
diff --git a/drivers/media/video/cx88/cx88-tvaudio.c b/drivers/media/video/cx88/cx88-tvaudio.c
index 259ea08e784f..1cc2d286a1cb 100644
--- a/drivers/media/video/cx88/cx88-tvaudio.c
+++ b/drivers/media/video/cx88/cx88-tvaudio.c
@@ -906,6 +906,7 @@ int cx88_audio_thread(void *data)
906 u32 mode = 0; 906 u32 mode = 0;
907 907
908 dprintk("cx88: tvaudio thread started\n"); 908 dprintk("cx88: tvaudio thread started\n");
909 set_freezable();
909 for (;;) { 910 for (;;) {
910 msleep_interruptible(1000); 911 msleep_interruptible(1000);
911 if (kthread_should_stop()) 912 if (kthread_should_stop())
diff --git a/drivers/media/video/msp3400-kthreads.c b/drivers/media/video/msp3400-kthreads.c
index e1821eb82fb5..d5ee2629121e 100644
--- a/drivers/media/video/msp3400-kthreads.c
+++ b/drivers/media/video/msp3400-kthreads.c
@@ -23,6 +23,7 @@
23#include <linux/module.h> 23#include <linux/module.h>
24#include <linux/slab.h> 24#include <linux/slab.h>
25#include <linux/i2c.h> 25#include <linux/i2c.h>
26#include <linux/freezer.h>
26#include <linux/videodev.h> 27#include <linux/videodev.h>
27#include <linux/videodev2.h> 28#include <linux/videodev2.h>
28#include <media/v4l2-common.h> 29#include <media/v4l2-common.h>
@@ -468,6 +469,7 @@ int msp3400c_thread(void *data)
468 469
469 470
470 v4l_dbg(1, msp_debug, client, "msp3400 daemon started\n"); 471 v4l_dbg(1, msp_debug, client, "msp3400 daemon started\n");
472 set_freezable();
471 for (;;) { 473 for (;;) {
472 v4l_dbg(2, msp_debug, client, "msp3400 thread: sleep\n"); 474 v4l_dbg(2, msp_debug, client, "msp3400 thread: sleep\n");
473 msp_sleep(state, -1); 475 msp_sleep(state, -1);
@@ -646,7 +648,7 @@ int msp3410d_thread(void *data)
646 int val, i, std, count; 648 int val, i, std, count;
647 649
648 v4l_dbg(1, msp_debug, client, "msp3410 daemon started\n"); 650 v4l_dbg(1, msp_debug, client, "msp3410 daemon started\n");
649 651 set_freezable();
650 for (;;) { 652 for (;;) {
651 v4l_dbg(2, msp_debug, client, "msp3410 thread: sleep\n"); 653 v4l_dbg(2, msp_debug, client, "msp3410 thread: sleep\n");
652 msp_sleep(state,-1); 654 msp_sleep(state,-1);
@@ -940,7 +942,7 @@ int msp34xxg_thread(void *data)
940 int val, i; 942 int val, i;
941 943
942 v4l_dbg(1, msp_debug, client, "msp34xxg daemon started\n"); 944 v4l_dbg(1, msp_debug, client, "msp34xxg daemon started\n");
943 945 set_freezable();
944 for (;;) { 946 for (;;) {
945 v4l_dbg(2, msp_debug, client, "msp34xxg thread: sleep\n"); 947 v4l_dbg(2, msp_debug, client, "msp34xxg thread: sleep\n");
946 msp_sleep(state, -1); 948 msp_sleep(state, -1);
diff --git a/drivers/media/video/tvaudio.c b/drivers/media/video/tvaudio.c
index c9bf9dbc2ea3..9da338dc4f3b 100644
--- a/drivers/media/video/tvaudio.c
+++ b/drivers/media/video/tvaudio.c
@@ -271,7 +271,7 @@ static int chip_thread(void *data)
271 struct CHIPDESC *desc = chiplist + chip->type; 271 struct CHIPDESC *desc = chiplist + chip->type;
272 272
273 v4l_dbg(1, debug, &chip->c, "%s: thread started\n", chip->c.name); 273 v4l_dbg(1, debug, &chip->c, "%s: thread started\n", chip->c.name);
274 274 set_freezable();
275 for (;;) { 275 for (;;) {
276 set_current_state(TASK_INTERRUPTIBLE); 276 set_current_state(TASK_INTERRUPTIBLE);
277 if (!kthread_should_stop()) 277 if (!kthread_should_stop())
diff --git a/drivers/media/video/video-buf-dvb.c b/drivers/media/video/video-buf-dvb.c
index fcc5467e7636..e617925ba31e 100644
--- a/drivers/media/video/video-buf-dvb.c
+++ b/drivers/media/video/video-buf-dvb.c
@@ -47,6 +47,7 @@ static int videobuf_dvb_thread(void *data)
47 int err; 47 int err;
48 48
49 dprintk("dvb thread started\n"); 49 dprintk("dvb thread started\n");
50 set_freezable();
50 videobuf_read_start(&dvb->dvbq); 51 videobuf_read_start(&dvb->dvbq);
51 52
52 for (;;) { 53 for (;;) {
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index f7e1d1910374..3ef4d0159c33 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -573,6 +573,7 @@ static int vivi_thread(void *data)
573 dprintk(1,"thread started\n"); 573 dprintk(1,"thread started\n");
574 574
575 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT); 575 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT);
576 set_freezable();
576 577
577 for (;;) { 578 for (;;) {
578 vivi_sleep(dma_q); 579 vivi_sleep(dma_q);
diff --git a/drivers/mfd/ucb1x00-ts.c b/drivers/mfd/ucb1x00-ts.c
index 38e815a2e871..fdbaa776f249 100644
--- a/drivers/mfd/ucb1x00-ts.c
+++ b/drivers/mfd/ucb1x00-ts.c
@@ -209,6 +209,7 @@ static int ucb1x00_thread(void *_ts)
209 DECLARE_WAITQUEUE(wait, tsk); 209 DECLARE_WAITQUEUE(wait, tsk);
210 int valid = 0; 210 int valid = 0;
211 211
212 set_freezable();
212 add_wait_queue(&ts->irq_wait, &wait); 213 add_wait_queue(&ts->irq_wait, &wait);
213 while (!kthread_should_stop()) { 214 while (!kthread_should_stop()) {
214 unsigned int x, y, p; 215 unsigned int x, y, p;
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 4fb2089dc690..b53dac8d1b69 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -11,6 +11,7 @@
11 */ 11 */
12#include <linux/module.h> 12#include <linux/module.h>
13#include <linux/blkdev.h> 13#include <linux/blkdev.h>
14#include <linux/freezer.h>
14#include <linux/kthread.h> 15#include <linux/kthread.h>
15 16
16#include <linux/mmc/card.h> 17#include <linux/mmc/card.h>
@@ -44,11 +45,7 @@ static int mmc_queue_thread(void *d)
44 struct mmc_queue *mq = d; 45 struct mmc_queue *mq = d;
45 struct request_queue *q = mq->queue; 46 struct request_queue *q = mq->queue;
46 47
47 /* 48 current->flags |= PF_MEMALLOC;
48 * Set iothread to ensure that we aren't put to sleep by
49 * the process freezing. We handle suspension ourselves.
50 */
51 current->flags |= PF_MEMALLOC|PF_NOFREEZE;
52 49
53 down(&mq->thread_sem); 50 down(&mq->thread_sem);
54 do { 51 do {
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 51bc7e2f1f22..ef89780eb9d6 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -16,6 +16,7 @@
16#include <linux/mtd/mtd.h> 16#include <linux/mtd/mtd.h>
17#include <linux/blkdev.h> 17#include <linux/blkdev.h>
18#include <linux/blkpg.h> 18#include <linux/blkpg.h>
19#include <linux/freezer.h>
19#include <linux/spinlock.h> 20#include <linux/spinlock.h>
20#include <linux/hdreg.h> 21#include <linux/hdreg.h>
21#include <linux/init.h> 22#include <linux/init.h>
@@ -80,7 +81,7 @@ static int mtd_blktrans_thread(void *arg)
80 struct request_queue *rq = tr->blkcore_priv->rq; 81 struct request_queue *rq = tr->blkcore_priv->rq;
81 82
82 /* we might get involved when memory gets low, so use PF_MEMALLOC */ 83 /* we might get involved when memory gets low, so use PF_MEMALLOC */
83 current->flags |= PF_MEMALLOC | PF_NOFREEZE; 84 current->flags |= PF_MEMALLOC;
84 85
85 spin_lock_irq(rq->queue_lock); 86 spin_lock_irq(rq->queue_lock);
86 while (!kthread_should_stop()) { 87 while (!kthread_should_stop()) {
diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c
index 9ecaf77eca9e..ab2174a56bc2 100644
--- a/drivers/mtd/ubi/wl.c
+++ b/drivers/mtd/ubi/wl.c
@@ -1346,6 +1346,7 @@ static int ubi_thread(void *u)
1346 ubi_msg("background thread \"%s\" started, PID %d", 1346 ubi_msg("background thread \"%s\" started, PID %d",
1347 ubi->bgt_name, current->pid); 1347 ubi->bgt_name, current->pid);
1348 1348
1349 set_freezable();
1349 for (;;) { 1350 for (;;) {
1350 int err; 1351 int err;
1351 1352
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index 1c54908fdc4c..ee1cc14db389 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -3086,7 +3086,8 @@ static int airo_thread(void *data) {
3086 struct net_device *dev = data; 3086 struct net_device *dev = data;
3087 struct airo_info *ai = dev->priv; 3087 struct airo_info *ai = dev->priv;
3088 int locked; 3088 int locked;
3089 3089
3090 set_freezable();
3090 while(1) { 3091 while(1) {
3091 /* make swsusp happy with our thread */ 3092 /* make swsusp happy with our thread */
3092 try_to_freeze(); 3093 try_to_freeze();
diff --git a/drivers/net/wireless/libertas/main.c b/drivers/net/wireless/libertas/main.c
index 4a59306a3f05..9f366242c392 100644
--- a/drivers/net/wireless/libertas/main.c
+++ b/drivers/net/wireless/libertas/main.c
@@ -613,6 +613,7 @@ static int wlan_service_main_thread(void *data)
613 613
614 init_waitqueue_entry(&wait, current); 614 init_waitqueue_entry(&wait, current);
615 615
616 set_freezable();
616 for (;;) { 617 for (;;) {
617 lbs_deb_thread( "main-thread 111: intcounter=%d " 618 lbs_deb_thread( "main-thread 111: intcounter=%d "
618 "currenttxskb=%p dnld_sent=%d\n", 619 "currenttxskb=%p dnld_sent=%d\n",
diff --git a/drivers/pcmcia/cs.c b/drivers/pcmcia/cs.c
index 50cad3a59a6c..7c93a108f9b8 100644
--- a/drivers/pcmcia/cs.c
+++ b/drivers/pcmcia/cs.c
@@ -651,6 +651,7 @@ static int pccardd(void *__skt)
651 add_wait_queue(&skt->thread_wait, &wait); 651 add_wait_queue(&skt->thread_wait, &wait);
652 complete(&skt->thread_done); 652 complete(&skt->thread_done);
653 653
654 set_freezable();
654 for (;;) { 655 for (;;) {
655 unsigned long flags; 656 unsigned long flags;
656 unsigned int events; 657 unsigned int events;
diff --git a/drivers/pnp/pnpbios/core.c b/drivers/pnp/pnpbios/core.c
index 3a201b77b963..03baf1c64a2e 100644
--- a/drivers/pnp/pnpbios/core.c
+++ b/drivers/pnp/pnpbios/core.c
@@ -160,6 +160,7 @@ static int pnp_dock_thread(void * unused)
160{ 160{
161 static struct pnp_docking_station_info now; 161 static struct pnp_docking_station_info now;
162 int docked = -1, d = 0; 162 int docked = -1, d = 0;
163 set_freezable();
163 while (!unloading) 164 while (!unloading)
164 { 165 {
165 int status; 166 int status;
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index d70ddfda93fc..9c5342e7a69c 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -40,6 +40,7 @@
40 40
41#include <linux/err.h> 41#include <linux/err.h>
42#include <linux/blkdev.h> 42#include <linux/blkdev.h>
43#include <linux/freezer.h>
43#include <linux/scatterlist.h> 44#include <linux/scatterlist.h>
44 45
45/* ---------- SCSI Host glue ---------- */ 46/* ---------- SCSI Host glue ---------- */
@@ -868,8 +869,6 @@ static int sas_queue_thread(void *_sas_ha)
868{ 869{
869 struct sas_ha_struct *sas_ha = _sas_ha; 870 struct sas_ha_struct *sas_ha = _sas_ha;
870 871
871 current->flags |= PF_NOFREEZE;
872
873 while (1) { 872 while (1) {
874 set_current_state(TASK_INTERRUPTIBLE); 873 set_current_state(TASK_INTERRUPTIBLE);
875 schedule(); 874 schedule();
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 9adb64ac054c..8a525abda30f 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -19,6 +19,7 @@
19#include <linux/timer.h> 19#include <linux/timer.h>
20#include <linux/string.h> 20#include <linux/string.h>
21#include <linux/kernel.h> 21#include <linux/kernel.h>
22#include <linux/freezer.h>
22#include <linux/kthread.h> 23#include <linux/kthread.h>
23#include <linux/interrupt.h> 24#include <linux/interrupt.h>
24#include <linux/blkdev.h> 25#include <linux/blkdev.h>
@@ -1516,8 +1517,6 @@ int scsi_error_handler(void *data)
1516{ 1517{
1517 struct Scsi_Host *shost = data; 1518 struct Scsi_Host *shost = data;
1518 1519
1519 current->flags |= PF_NOFREEZE;
1520
1521 /* 1520 /*
1522 * We use TASK_INTERRUPTIBLE so that the thread is not 1521 * We use TASK_INTERRUPTIBLE so that the thread is not
1523 * counted against the load average as a running process. 1522 * counted against the load average as a running process.
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index 4973e147bc79..8f046659b4e9 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -1168,6 +1168,7 @@ static int uea_kthread(void *data)
1168 struct uea_softc *sc = data; 1168 struct uea_softc *sc = data;
1169 int ret = -EAGAIN; 1169 int ret = -EAGAIN;
1170 1170
1171 set_freezable();
1171 uea_enters(INS_TO_USBDEV(sc)); 1172 uea_enters(INS_TO_USBDEV(sc));
1172 while (!kthread_should_stop()) { 1173 while (!kthread_should_stop()) {
1173 if (ret < 0 || sc->reset) 1174 if (ret < 0 || sc->reset)
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 50e79010401c..fd74c50b1804 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -2728,6 +2728,7 @@ loop:
2728 2728
2729static int hub_thread(void *__unused) 2729static int hub_thread(void *__unused)
2730{ 2730{
2731 set_freezable();
2731 do { 2732 do {
2732 hub_events(); 2733 hub_events();
2733 wait_event_interruptible(khubd_wait, 2734 wait_event_interruptible(khubd_wait,
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 8712ef987179..be7a1bd2823b 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -3434,6 +3434,9 @@ static int fsg_main_thread(void *fsg_)
3434 allow_signal(SIGKILL); 3434 allow_signal(SIGKILL);
3435 allow_signal(SIGUSR1); 3435 allow_signal(SIGUSR1);
3436 3436
3437 /* Allow the thread to be frozen */
3438 set_freezable();
3439
3437 /* Arrange for userspace references to be interpreted as kernel 3440 /* Arrange for userspace references to be interpreted as kernel
3438 * pointers. That way we can pass a kernel pointer to a routine 3441 * pointers. That way we can pass a kernel pointer to a routine
3439 * that expects a __user pointer and it will work okay. */ 3442 * that expects a __user pointer and it will work okay. */
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index bef8bcd9bd98..28842d208bb0 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -311,8 +311,6 @@ static int usb_stor_control_thread(void * __us)
311 struct Scsi_Host *host = us_to_host(us); 311 struct Scsi_Host *host = us_to_host(us);
312 int autopm_rc; 312 int autopm_rc;
313 313
314 current->flags |= PF_NOFREEZE;
315
316 for(;;) { 314 for(;;) {
317 US_DEBUGP("*** thread sleeping.\n"); 315 US_DEBUGP("*** thread sleeping.\n");
318 if(down_interruptible(&us->sema)) 316 if(down_interruptible(&us->sema))
@@ -920,6 +918,7 @@ static int usb_stor_scan_thread(void * __us)
920 printk(KERN_DEBUG 918 printk(KERN_DEBUG
921 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 919 "usb-storage: device found at %d\n", us->pusb_dev->devnum);
922 920
921 set_freezable();
923 /* Wait for the timeout to expire or for a disconnect */ 922 /* Wait for the timeout to expire or for a disconnect */
924 if (delay_use > 0) { 923 if (delay_use > 0) {
925 printk(KERN_DEBUG "usb-storage: waiting for device " 924 printk(KERN_DEBUG "usb-storage: waiting for device "
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 08b7ffbbbbd8..3972aa8cf859 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -812,6 +812,7 @@ static int ps3fb_ioctl(struct fb_info *info, unsigned int cmd,
812 812
813static int ps3fbd(void *arg) 813static int ps3fbd(void *arg)
814{ 814{
815 set_freezable();
815 while (!kthread_should_stop()) { 816 while (!kthread_should_stop()) {
816 try_to_freeze(); 817 try_to_freeze();
817 set_current_state(TASK_INTERRUPTIBLE); 818 set_current_state(TASK_INTERRUPTIBLE);
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index f5c5b760ed7b..c6332108f1c5 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -805,6 +805,7 @@ static int w1_control(void *data)
805 struct w1_master *dev, *n; 805 struct w1_master *dev, *n;
806 int have_to_wait = 0; 806 int have_to_wait = 0;
807 807
808 set_freezable();
808 while (!kthread_should_stop() || have_to_wait) { 809 while (!kthread_should_stop() || have_to_wait) {
809 have_to_wait = 0; 810 have_to_wait = 0;
810 811
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 8b0cbf4a4ad0..bd0f2f2353ce 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -849,6 +849,7 @@ static int cifs_oplock_thread(void * dummyarg)
849 __u16 netfid; 849 __u16 netfid;
850 int rc; 850 int rc;
851 851
852 set_freezable();
852 do { 853 do {
853 if (try_to_freeze()) 854 if (try_to_freeze())
854 continue; 855 continue;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index f4e92661b223..0a1b8bd1dfcb 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -363,6 +363,7 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
363 GFP_KERNEL); 363 GFP_KERNEL);
364 } 364 }
365 365
366 set_freezable();
366 while (!kthread_should_stop()) { 367 while (!kthread_should_stop()) {
367 if (try_to_freeze()) 368 if (try_to_freeze())
368 continue; 369 continue;
diff --git a/fs/jffs2/background.c b/fs/jffs2/background.c
index 0c82dfcfd246..143c5530caf3 100644
--- a/fs/jffs2/background.c
+++ b/fs/jffs2/background.c
@@ -81,6 +81,7 @@ static int jffs2_garbage_collect_thread(void *_c)
81 81
82 set_user_nice(current, 10); 82 set_user_nice(current, 10);
83 83
84 set_freezable();
84 for (;;) { 85 for (;;) {
85 allow_signal(SIGHUP); 86 allow_signal(SIGHUP);
86 87
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 26809325469c..9fcdef50aad6 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -25,6 +25,7 @@
25#include <linux/smp.h> 25#include <linux/smp.h>
26#include <linux/smp_lock.h> 26#include <linux/smp_lock.h>
27#include <linux/mutex.h> 27#include <linux/mutex.h>
28#include <linux/freezer.h>
28 29
29#include <linux/sunrpc/types.h> 30#include <linux/sunrpc/types.h>
30#include <linux/sunrpc/stats.h> 31#include <linux/sunrpc/stats.h>
@@ -119,6 +120,7 @@ lockd(struct svc_rqst *rqstp)
119 complete(&lockd_start_done); 120 complete(&lockd_start_done);
120 121
121 daemonize("lockd"); 122 daemonize("lockd");
123 set_freezable();
122 124
123 /* Process request with signals blocked, but allow SIGKILL. */ 125 /* Process request with signals blocked, but allow SIGKILL. */
124 allow_signal(SIGKILL); 126 allow_signal(SIGKILL);
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 75f309c8741a..a796be5051bf 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -14,6 +14,7 @@
14#include <linux/sunrpc/svcsock.h> 14#include <linux/sunrpc/svcsock.h>
15#include <linux/nfs_fs.h> 15#include <linux/nfs_fs.h>
16#include <linux/mutex.h> 16#include <linux/mutex.h>
17#include <linux/freezer.h>
17 18
18#include <net/inet_sock.h> 19#include <net/inet_sock.h>
19 20
@@ -67,6 +68,7 @@ static void nfs_callback_svc(struct svc_rqst *rqstp)
67 daemonize("nfsv4-svc"); 68 daemonize("nfsv4-svc");
68 /* Process request with signals blocked, but allow SIGKILL. */ 69 /* Process request with signals blocked, but allow SIGKILL. */
69 allow_signal(SIGKILL); 70 allow_signal(SIGKILL);
71 set_freezable();
70 72
71 complete(&nfs_callback_info.started); 73 complete(&nfs_callback_info.started);
72 74
diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index ff55950efb43..5c8192bcbced 100644
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -19,6 +19,7 @@
19#include <linux/slab.h> 19#include <linux/slab.h>
20#include <linux/smp.h> 20#include <linux/smp.h>
21#include <linux/smp_lock.h> 21#include <linux/smp_lock.h>
22#include <linux/freezer.h>
22#include <linux/fs_struct.h> 23#include <linux/fs_struct.h>
23 24
24#include <linux/sunrpc/types.h> 25#include <linux/sunrpc/types.h>
@@ -432,6 +433,7 @@ nfsd(struct svc_rqst *rqstp)
432 * dirty pages. 433 * dirty pages.
433 */ 434 */
434 current->flags |= PF_LESS_THROTTLE; 435 current->flags |= PF_LESS_THROTTLE;
436 set_freezable();
435 437
436 /* 438 /*
437 * The main request loop 439 * The main request loop
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 06894cf00b12..4528f9a3f304 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -562,6 +562,7 @@ xfssyncd(
562 bhv_vfs_sync_work_t *work, *n; 562 bhv_vfs_sync_work_t *work, *n;
563 LIST_HEAD (tmp); 563 LIST_HEAD (tmp);
564 564
565 set_freezable();
565 timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10); 566 timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
566 for (;;) { 567 for (;;) {
567 timeleft = schedule_timeout_interruptible(timeleft); 568 timeleft = schedule_timeout_interruptible(timeleft);
diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index 4631086f5060..2d38b1a74662 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -1,5 +1,8 @@
1/* Freezer declarations */ 1/* Freezer declarations */
2 2
3#ifndef FREEZER_H_INCLUDED
4#define FREEZER_H_INCLUDED
5
3#include <linux/sched.h> 6#include <linux/sched.h>
4 7
5#ifdef CONFIG_PM 8#ifdef CONFIG_PM
@@ -115,6 +118,14 @@ static inline int freezer_should_skip(struct task_struct *p)
115 return !!(p->flags & PF_FREEZER_SKIP); 118 return !!(p->flags & PF_FREEZER_SKIP);
116} 119}
117 120
121/*
122 * Tell the freezer that the current task should be frozen by it
123 */
124static inline void set_freezable(void)
125{
126 current->flags &= ~PF_NOFREEZE;
127}
128
118#else 129#else
119static inline int frozen(struct task_struct *p) { return 0; } 130static inline int frozen(struct task_struct *p) { return 0; }
120static inline int freezing(struct task_struct *p) { return 0; } 131static inline int freezing(struct task_struct *p) { return 0; }
@@ -130,4 +141,7 @@ static inline int try_to_freeze(void) { return 0; }
130static inline void freezer_do_not_count(void) {} 141static inline void freezer_do_not_count(void) {}
131static inline void freezer_count(void) {} 142static inline void freezer_count(void) {}
132static inline int freezer_should_skip(struct task_struct *p) { return 0; } 143static inline int freezer_should_skip(struct task_struct *p) { return 0; }
144static inline void set_freezable(void) {}
133#endif 145#endif
146
147#endif /* FREEZER_H_INCLUDED */
diff --git a/init/do_mounts_initrd.c b/init/do_mounts_initrd.c
index b222ce9e1c8b..a6b4c0c08e13 100644
--- a/init/do_mounts_initrd.c
+++ b/init/do_mounts_initrd.c
@@ -56,12 +56,9 @@ static void __init handle_initrd(void)
56 sys_chroot("."); 56 sys_chroot(".");
57 57
58 pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD); 58 pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);
59 if (pid > 0) { 59 if (pid > 0)
60 while (pid != sys_wait4(-1, NULL, 0, NULL)) { 60 while (pid != sys_wait4(-1, NULL, 0, NULL))
61 try_to_freeze();
62 yield(); 61 yield();
63 }
64 }
65 62
66 /* move initrd to rootfs' /old */ 63 /* move initrd to rootfs' /old */
67 sys_fchdir(old_fd); 64 sys_fchdir(old_fd);
diff --git a/kernel/audit.c b/kernel/audit.c
index 5ce8851facf7..eb0f9165b401 100644
--- a/kernel/audit.c
+++ b/kernel/audit.c
@@ -392,6 +392,7 @@ static int kauditd_thread(void *dummy)
392{ 392{
393 struct sk_buff *skb; 393 struct sk_buff *skb;
394 394
395 set_freezable();
395 while (!kthread_should_stop()) { 396 while (!kthread_should_stop()) {
396 skb = skb_dequeue(&audit_skb_queue); 397 skb = skb_dequeue(&audit_skb_queue);
397 wake_up(&audit_backlog_wait); 398 wake_up(&audit_backlog_wait);
diff --git a/kernel/exit.c b/kernel/exit.c
index 57626692cd90..e8af8d0c2483 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -31,6 +31,7 @@
31#include <linux/mempolicy.h> 31#include <linux/mempolicy.h>
32#include <linux/taskstats_kern.h> 32#include <linux/taskstats_kern.h>
33#include <linux/delayacct.h> 33#include <linux/delayacct.h>
34#include <linux/freezer.h>
34#include <linux/cpuset.h> 35#include <linux/cpuset.h>
35#include <linux/syscalls.h> 36#include <linux/syscalls.h>
36#include <linux/signal.h> 37#include <linux/signal.h>
@@ -387,6 +388,11 @@ void daemonize(const char *name, ...)
387 * they would be locked into memory. 388 * they would be locked into memory.
388 */ 389 */
389 exit_mm(current); 390 exit_mm(current);
391 /*
392 * We don't want to have TIF_FREEZE set if the system-wide hibernation
393 * or suspend transition begins right now.
394 */
395 current->flags |= PF_NOFREEZE;
390 396
391 set_special_pids(1, 1); 397 set_special_pids(1, 1);
392 proc_clear_tty(current); 398 proc_clear_tty(current);
diff --git a/kernel/fork.c b/kernel/fork.c
index 7c5c5888e00a..ba39bdb2a7b8 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -923,7 +923,7 @@ static inline void copy_flags(unsigned long clone_flags, struct task_struct *p)
923{ 923{
924 unsigned long new_flags = p->flags; 924 unsigned long new_flags = p->flags;
925 925
926 new_flags &= ~(PF_SUPERPRIV | PF_NOFREEZE); 926 new_flags &= ~PF_SUPERPRIV;
927 new_flags |= PF_FORKNOEXEC; 927 new_flags |= PF_FORKNOEXEC;
928 if (!(clone_flags & CLONE_PTRACE)) 928 if (!(clone_flags & CLONE_PTRACE))
929 p->ptrace = 0; 929 p->ptrace = 0;
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index 55ba82a85a66..ddff33247785 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -40,6 +40,7 @@
40#include <linux/moduleparam.h> 40#include <linux/moduleparam.h>
41#include <linux/percpu.h> 41#include <linux/percpu.h>
42#include <linux/notifier.h> 42#include <linux/notifier.h>
43#include <linux/freezer.h>
43#include <linux/cpu.h> 44#include <linux/cpu.h>
44#include <linux/random.h> 45#include <linux/random.h>
45#include <linux/delay.h> 46#include <linux/delay.h>
@@ -518,7 +519,6 @@ rcu_torture_writer(void *arg)
518 519
519 VERBOSE_PRINTK_STRING("rcu_torture_writer task started"); 520 VERBOSE_PRINTK_STRING("rcu_torture_writer task started");
520 set_user_nice(current, 19); 521 set_user_nice(current, 19);
521 current->flags |= PF_NOFREEZE;
522 522
523 do { 523 do {
524 schedule_timeout_uninterruptible(1); 524 schedule_timeout_uninterruptible(1);
@@ -558,7 +558,6 @@ rcu_torture_fakewriter(void *arg)
558 558
559 VERBOSE_PRINTK_STRING("rcu_torture_fakewriter task started"); 559 VERBOSE_PRINTK_STRING("rcu_torture_fakewriter task started");
560 set_user_nice(current, 19); 560 set_user_nice(current, 19);
561 current->flags |= PF_NOFREEZE;
562 561
563 do { 562 do {
564 schedule_timeout_uninterruptible(1 + rcu_random(&rand)%10); 563 schedule_timeout_uninterruptible(1 + rcu_random(&rand)%10);
@@ -589,7 +588,6 @@ rcu_torture_reader(void *arg)
589 588
590 VERBOSE_PRINTK_STRING("rcu_torture_reader task started"); 589 VERBOSE_PRINTK_STRING("rcu_torture_reader task started");
591 set_user_nice(current, 19); 590 set_user_nice(current, 19);
592 current->flags |= PF_NOFREEZE;
593 591
594 do { 592 do {
595 idx = cur_ops->readlock(); 593 idx = cur_ops->readlock();
diff --git a/kernel/rtmutex-tester.c b/kernel/rtmutex-tester.c
index 015fc633c96c..e3055ba69159 100644
--- a/kernel/rtmutex-tester.c
+++ b/kernel/rtmutex-tester.c
@@ -260,6 +260,7 @@ static int test_func(void *data)
260 int ret; 260 int ret;
261 261
262 current->flags |= PF_MUTEX_TESTER; 262 current->flags |= PF_MUTEX_TESTER;
263 set_freezable();
263 allow_signal(SIGHUP); 264 allow_signal(SIGHUP);
264 265
265 for(;;) { 266 for(;;) {
diff --git a/kernel/sched.c b/kernel/sched.c
index 1c8076676eb1..cb31fb4a1379 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4912,8 +4912,6 @@ static int migration_thread(void *data)
4912 struct migration_req *req; 4912 struct migration_req *req;
4913 struct list_head *head; 4913 struct list_head *head;
4914 4914
4915 try_to_freeze();
4916
4917 spin_lock_irq(&rq->lock); 4915 spin_lock_irq(&rq->lock);
4918 4916
4919 if (cpu_is_offline(cpu)) { 4917 if (cpu_is_offline(cpu)) {
@@ -5147,7 +5145,6 @@ migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
5147 p = kthread_create(migration_thread, hcpu, "migration/%d", cpu); 5145 p = kthread_create(migration_thread, hcpu, "migration/%d", cpu);
5148 if (IS_ERR(p)) 5146 if (IS_ERR(p))
5149 return NOTIFY_BAD; 5147 return NOTIFY_BAD;
5150 p->flags |= PF_NOFREEZE;
5151 kthread_bind(p, cpu); 5148 kthread_bind(p, cpu);
5152 /* Must be high prio: stop_machine expects to yield to it. */ 5149 /* Must be high prio: stop_machine expects to yield to it. */
5153 rq = task_rq_lock(p, &flags); 5150 rq = task_rq_lock(p, &flags);
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 8de267790166..0f546ddea43d 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -14,6 +14,7 @@
14#include <linux/notifier.h> 14#include <linux/notifier.h>
15#include <linux/percpu.h> 15#include <linux/percpu.h>
16#include <linux/cpu.h> 16#include <linux/cpu.h>
17#include <linux/freezer.h>
17#include <linux/kthread.h> 18#include <linux/kthread.h>
18#include <linux/rcupdate.h> 19#include <linux/rcupdate.h>
19#include <linux/smp.h> 20#include <linux/smp.h>
@@ -488,8 +489,6 @@ void __init softirq_init(void)
488 489
489static int ksoftirqd(void * __bind_cpu) 490static int ksoftirqd(void * __bind_cpu)
490{ 491{
491 current->flags |= PF_NOFREEZE;
492
493 set_current_state(TASK_INTERRUPTIBLE); 492 set_current_state(TASK_INTERRUPTIBLE);
494 493
495 while (!kthread_should_stop()) { 494 while (!kthread_should_stop()) {
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index 0131e296ffb4..708d4882c0c3 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -10,6 +10,7 @@
10#include <linux/cpu.h> 10#include <linux/cpu.h>
11#include <linux/init.h> 11#include <linux/init.h>
12#include <linux/delay.h> 12#include <linux/delay.h>
13#include <linux/freezer.h>
13#include <linux/kthread.h> 14#include <linux/kthread.h>
14#include <linux/notifier.h> 15#include <linux/notifier.h>
15#include <linux/module.h> 16#include <linux/module.h>
@@ -116,7 +117,6 @@ static int watchdog(void * __bind_cpu)
116 struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 }; 117 struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
117 118
118 sched_setscheduler(current, SCHED_FIFO, &param); 119 sched_setscheduler(current, SCHED_FIFO, &param);
119 current->flags |= PF_NOFREEZE;
120 120
121 /* initialize timestamp */ 121 /* initialize timestamp */
122 touch_softlockup_watchdog(); 122 touch_softlockup_watchdog();
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index d7d3fa3072e5..1935302cc645 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -282,8 +282,8 @@ static int worker_thread(void *__cwq)
282 struct cpu_workqueue_struct *cwq = __cwq; 282 struct cpu_workqueue_struct *cwq = __cwq;
283 DEFINE_WAIT(wait); 283 DEFINE_WAIT(wait);
284 284
285 if (!cwq->wq->freezeable) 285 if (cwq->wq->freezeable)
286 current->flags |= PF_NOFREEZE; 286 set_freezable();
287 287
288 set_user_nice(current, -5); 288 set_user_nice(current, -5);
289 289
diff --git a/mm/pdflush.c b/mm/pdflush.c
index 8ce0900dc95c..8f6ee073c0e3 100644
--- a/mm/pdflush.c
+++ b/mm/pdflush.c
@@ -92,6 +92,7 @@ struct pdflush_work {
92static int __pdflush(struct pdflush_work *my_work) 92static int __pdflush(struct pdflush_work *my_work)
93{ 93{
94 current->flags |= PF_FLUSHER | PF_SWAPWRITE; 94 current->flags |= PF_FLUSHER | PF_SWAPWRITE;
95 set_freezable();
95 my_work->fn = NULL; 96 my_work->fn = NULL;
96 my_work->who = current; 97 my_work->who = current;
97 INIT_LIST_HEAD(&my_work->list); 98 INIT_LIST_HEAD(&my_work->list);
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 2225b7c9df85..d419e10e3daa 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1421,6 +1421,7 @@ static int kswapd(void *p)
1421 * trying to free the first piece of memory in the first place). 1421 * trying to free the first piece of memory in the first place).
1422 */ 1422 */
1423 tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD; 1423 tsk->flags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
1424 set_freezable();
1424 1425
1425 order = 0; 1426 order = 0;
1426 for ( ; ; ) { 1427 for ( ; ; ) {
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c
index 1c8f4a0c5f43..1f78c3e336d8 100644
--- a/net/bluetooth/bnep/core.c
+++ b/net/bluetooth/bnep/core.c
@@ -36,6 +36,7 @@
36#include <linux/signal.h> 36#include <linux/signal.h>
37#include <linux/init.h> 37#include <linux/init.h>
38#include <linux/wait.h> 38#include <linux/wait.h>
39#include <linux/freezer.h>
39#include <linux/errno.h> 40#include <linux/errno.h>
40#include <linux/net.h> 41#include <linux/net.h>
41#include <net/sock.h> 42#include <net/sock.h>
@@ -474,7 +475,6 @@ static int bnep_session(void *arg)
474 475
475 daemonize("kbnepd %s", dev->name); 476 daemonize("kbnepd %s", dev->name);
476 set_user_nice(current, -15); 477 set_user_nice(current, -15);
477 current->flags |= PF_NOFREEZE;
478 478
479 init_waitqueue_entry(&wait, current); 479 init_waitqueue_entry(&wait, current);
480 add_wait_queue(sk->sk_sleep, &wait); 480 add_wait_queue(sk->sk_sleep, &wait);
diff --git a/net/bluetooth/cmtp/core.c b/net/bluetooth/cmtp/core.c
index 66bef1ccee2a..ca60a4517fd3 100644
--- a/net/bluetooth/cmtp/core.c
+++ b/net/bluetooth/cmtp/core.c
@@ -29,6 +29,7 @@
29#include <linux/slab.h> 29#include <linux/slab.h>
30#include <linux/poll.h> 30#include <linux/poll.h>
31#include <linux/fcntl.h> 31#include <linux/fcntl.h>
32#include <linux/freezer.h>
32#include <linux/skbuff.h> 33#include <linux/skbuff.h>
33#include <linux/socket.h> 34#include <linux/socket.h>
34#include <linux/ioctl.h> 35#include <linux/ioctl.h>
@@ -287,7 +288,6 @@ static int cmtp_session(void *arg)
287 288
288 daemonize("kcmtpd_ctr_%d", session->num); 289 daemonize("kcmtpd_ctr_%d", session->num);
289 set_user_nice(current, -15); 290 set_user_nice(current, -15);
290 current->flags |= PF_NOFREEZE;
291 291
292 init_waitqueue_entry(&wait, current); 292 init_waitqueue_entry(&wait, current);
293 add_wait_queue(sk->sk_sleep, &wait); 293 add_wait_queue(sk->sk_sleep, &wait);
diff --git a/net/bluetooth/hidp/core.c b/net/bluetooth/hidp/core.c
index 450eb0244bbf..64d89ca28847 100644
--- a/net/bluetooth/hidp/core.c
+++ b/net/bluetooth/hidp/core.c
@@ -28,6 +28,7 @@
28#include <linux/sched.h> 28#include <linux/sched.h>
29#include <linux/slab.h> 29#include <linux/slab.h>
30#include <linux/poll.h> 30#include <linux/poll.h>
31#include <linux/freezer.h>
31#include <linux/fcntl.h> 32#include <linux/fcntl.h>
32#include <linux/skbuff.h> 33#include <linux/skbuff.h>
33#include <linux/socket.h> 34#include <linux/socket.h>
@@ -547,7 +548,6 @@ static int hidp_session(void *arg)
547 548
548 daemonize("khidpd_%04x%04x", vendor, product); 549 daemonize("khidpd_%04x%04x", vendor, product);
549 set_user_nice(current, -15); 550 set_user_nice(current, -15);
550 current->flags |= PF_NOFREEZE;
551 551
552 init_waitqueue_entry(&ctrl_wait, current); 552 init_waitqueue_entry(&ctrl_wait, current);
553 init_waitqueue_entry(&intr_wait, current); 553 init_waitqueue_entry(&intr_wait, current);
diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index 52e04df323ea..bb7220770f2c 100644
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -33,6 +33,7 @@
33#include <linux/sched.h> 33#include <linux/sched.h>
34#include <linux/signal.h> 34#include <linux/signal.h>
35#include <linux/init.h> 35#include <linux/init.h>
36#include <linux/freezer.h>
36#include <linux/wait.h> 37#include <linux/wait.h>
37#include <linux/device.h> 38#include <linux/device.h>
38#include <linux/net.h> 39#include <linux/net.h>
@@ -1940,7 +1941,6 @@ static int rfcomm_run(void *unused)
1940 1941
1941 daemonize("krfcommd"); 1942 daemonize("krfcommd");
1942 set_user_nice(current, -10); 1943 set_user_nice(current, -10);
1943 current->flags |= PF_NOFREEZE;
1944 1944
1945 BT_DBG(""); 1945 BT_DBG("");
1946 1946
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 75215331b045..bca787fdbc51 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -3465,6 +3465,8 @@ static int pktgen_thread_worker(void *arg)
3465 3465
3466 set_current_state(TASK_INTERRUPTIBLE); 3466 set_current_state(TASK_INTERRUPTIBLE);
3467 3467
3468 set_freezable();
3469
3468 while (!kthread_should_stop()) { 3470 while (!kthread_should_stop()) {
3469 pkt_dev = next_to_run(t); 3471 pkt_dev = next_to_run(t);
3470 3472