lkml.org 
[lkml]   [2007]   [Apr]   [29]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    SubjectRe: [PATCH -mm] Allow selective freezing of the system for different events
    Date
    Hi,

    Sorry for the delay.

    On Saturday, 28 April 2007 03:34, Gautham R Shenoy wrote:
    > This patch
    > * Provides an interface to selectively freeze the system for different events.
    > * Allows tasks to exempt themselves or other tasks from specific freeze
    > events.
    > * Allow nesting of freezer calls. For eg:
    >
    > freeze_processes(EVENT_A);
    > /* Do something with respect to event A */
    > .
    > .
    > .
    > freeze_processes(EVENT_B);
    > /* Do something with respect to event B */
    > .
    > .
    > .
    > thaw_processes(EVENT_B);
    > .
    > .
    > .
    > thaw_processes(EVENT_B);
    >
    > This type of behaviour would be required when cpu hotplug would start
    > using the process freezer, where EVENT_A would be SUSPEND and EVENT_B
    > would be HOTPLUG_CPU.
    >
    > This patch applies on the top of 2.6.21-rc7-mm2 + Rafael's freezer
    > changes from http://lkml.org/lkml/2007/4/27/302.
    >
    > Signed-off-by: Gautham R Shenoy <ego@in.ibm.com>
    > ---
    > arch/i386/kernel/apm.c | 2 -
    > drivers/block/loop.c | 2 -
    > drivers/char/apm-emulation.c | 6 +--
    > drivers/ieee1394/ieee1394_core.c | 2 -
    > drivers/md/md.c | 2 -
    > drivers/mmc/card/queue.c | 2 -
    > drivers/mtd/mtd_blkdevs.c | 2 -
    > drivers/scsi/libsas/sas_scsi_host.c | 2 -
    > drivers/scsi/scsi_error.c | 2 -
    > drivers/usb/storage/usb.c | 2 -
    > include/linux/freezer.h | 44 +++++++++++++++++++-----
    > kernel/freezer.c | 64 ++++++++++++++++++++++++++++++------
    > kernel/kprobes.c | 4 +-
    > kernel/kthread.c | 2 -
    > kernel/power/disk.c | 4 +-
    > kernel/power/main.c | 8 ++--
    > kernel/power/user.c | 6 +--
    > kernel/rcutorture.c | 4 +-
    > kernel/sched.c | 2 -
    > kernel/softirq.c | 2 -
    > kernel/softlockup.c | 2 -
    > kernel/workqueue.c | 2 -
    > 22 files changed, 119 insertions(+), 49 deletions(-)
    >
    > Index: linux-2.6.21-rc7/include/linux/freezer.h
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/include/linux/freezer.h
    > +++ linux-2.6.21-rc7/include/linux/freezer.h
    > @@ -4,17 +4,27 @@
    >
    > #ifdef CONFIG_FREEZER
    >
    > +
    > /*
    > * Per task flags used by the freezer
    > *
    > * They should not be referred to directly outside of this file.
    > */
    > -#define TFF_NOFREEZE 0 /* task should not be frozen */
    > +#define TFF_FE_SUSPEND 0 /* Do not freeze task for software suspend */
    > +#define TFF_FE_KPROBES 1 /* Do not freeze task for kprobes */
    > #define TFF_FREEZE 8 /* task should go to the refrigerator ASAP */
    > #define TFF_SKIP 9 /* do not count this task as freezable */
    > #define TFF_FROZEN 10 /* task is frozen */
    >
    > /*
    > + * Codes of different events which use the freezer
    > + * These are the only flags that can be referred outside this file
    > + */
    > +#define FE_SUSPEND (1 << TFF_FE_SUSPEND) /* Software Suspend */
    > +#define FE_KPROBES (1 << TFF_FE_KPROBES) /* Kprobes */
    > +#define FE_ALL (FE_SUSPEND | FE_KPROBES) /* All events using freezer */
    > +
    > +/*
    > * Check if a process has been frozen
    > */
    > static inline int frozen(struct task_struct *p)
    > @@ -57,19 +67,29 @@ static inline void clear_freeze_flag(str
    > }
    >
    > /*
    > - * Check if the task wants to be exempted from freezing
    > + * Check if the task wants to be exempted from freezing for
    > + * freeze_event.
    > */
    > -static inline int freezer_should_exempt(struct task_struct *p)
    > +static inline int freezer_should_exempt(struct task_struct *p,
    > + unsigned long freeze_event)
    > {
    > - return test_bit(TFF_NOFREEZE, &p->freezer_flags);
    > + return p->freezer_flags & freeze_event;
    > }
    >
    > /*
    > * Tell the freezer to exempt this task from freezing
    > + * for events in freeze_event_mask.
    > */
    > -static inline void freezer_exempt(struct task_struct *p)

    I, personally, would introduce

    static inline void freezer_exempt_event(struct task_struct *p,
    unsigned long freeze_event_mask)
    {
    atomic_set_mask(freeze_event_mask, &p->freezer_flags);
    }

    and then

    static inline void freezer_exempt(struct task_struct *p)
    {
    freezer_exempt_event(p, FE_ALL);
    }

    The patch would be shorter. ;-)

    [In that case I'd probably rename freezer_should_exempt() to
    freezer_should_exempt_event(), for symmetry.]

    > +static inline void freezer_exempt(struct task_struct *p,
    > + unsigned long freeze_event_mask)
    > +{
    > + atomic_set_mask(freeze_event_mask, &p->freezer_flags);
    > +}
    > +
    > +/* Returns the mask of the events for which this process is freezeable */
    > +static inline unsigned long freezeable_event_mask(struct task_struct *p)
    > {
    > - set_bit(TFF_NOFREEZE, &p->freezer_flags);
    > + return ~p->freezer_flags & FE_ALL;
    > }
    >
    > /*
    > @@ -96,8 +116,8 @@ static inline int thaw_process(struct ta
    > }
    >
    > extern void refrigerator(void);
    > -extern int freeze_processes(void);
    > -extern void thaw_processes(void);
    > +extern int freeze_processes(unsigned long freeze_event);
    > +extern void thaw_processes(unsigned long freeze_event);
    >
    > static inline int try_to_freeze(void)
    > {
    > @@ -160,11 +180,15 @@ static inline int freezing(struct task_s
    > static inline void freeze(struct task_struct *p) { BUG(); }
    > static inline int freezer_should_exempt(struct task_struct *p) { return 0; }
    > static inline void freezer_exempt(struct task_struct *p) {}
    > +static inline unsigned long freezeable_event_mask(struct task_struct *p)
    > +{
    > + return 0;
    > +}
    > static inline int thaw_process(struct task_struct *p) { return 1; }
    >
    > static inline void refrigerator(void) {}
    > -static inline int freeze_processes(void) { BUG(); return 0; }
    > -static inline void thaw_processes(void) {}
    > +static inline int freeze_processes(unsigned long) { BUG(); return 0; }
    > +static inline void thaw_processes(unsigned long) {}
    >
    > static inline int try_to_freeze(void) { return 0; }
    >
    > Index: linux-2.6.21-rc7/kernel/freezer.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/freezer.c
    > +++ linux-2.6.21-rc7/kernel/freezer.c
    > @@ -23,21 +23,44 @@
    > #define FREEZER_KERNEL_THREADS 0
    > #define FREEZER_USER_SPACE 1
    >
    > +static DEFINE_MUTEX(freezer_mutex);
    > +/* Mask of the events for which the system is currently frozen */
    > +unsigned long system_frozen_event_mask;
    > +/* The event for which the freeze request has been raised */
    > +unsigned long current_freezer_event;
    > +
    > static inline int freezeable(struct task_struct * p)
    > {
    > if ((p == current) ||
    > - freezer_should_exempt(p) ||
    > + freezer_should_exempt(p, current_freezer_event) ||
    > (p->exit_state != 0))
    > return 0;
    > return 1;
    > }
    >
    > +/* Returns the mask of events for which p is currently frozen */
    > +static inline unsigned long process_frozen_event_mask(struct task_struct *p)
    > +{
    > + return (freezeable_event_mask(p) & system_frozen_event_mask);
    > +}
    > +
    > +static inline int thawable(struct task_struct *p)
    > +{
    > + if (!freezeable(p))
    > + return 0;
    > +
    > + /* Thaw p iff it is frozen for current_freezer_event alone */
    > + if (process_frozen_event_mask(p) & ~current_freezer_event)
    > + return 0;
    > +
    > + return 1;

    I would do

    return !(process_frozen_event_mask(p) & ~current_freezer_event);

    > +}
    > /*
    > * freezing is complete, mark current process as frozen
    > */
    > static inline void frozen_process(void)
    > {
    > - if (!unlikely(freezer_should_exempt(current))) {
    > + if (!unlikely(freezer_should_exempt(current, current_freezer_event))) {
    > set_frozen_flag(current);
    > wmb();
    > }
    > @@ -185,26 +208,39 @@ static unsigned int try_to_freeze_tasks(
    > /**
    > * freeze_processes - tell processes to enter the refrigerator
    > *
    > + * @freeze_event : Event that's requesting the services
    > + * of the process freezer to freeze the system
    > + *
    > * Returns 0 on success, or the number of processes that didn't freeze,
    > * although they were told to.
    > */
    > -int freeze_processes(void)
    > +int freeze_processes(unsigned long freeze_event)
    > {
    > - unsigned int nr_unfrozen;
    > + unsigned int nr_unfrozen = 0;
    > +
    > + mutex_lock(&freezer_mutex);
    > + if (system_frozen_event_mask & freeze_event)
    > + goto out;
    > +
    > + current_freezer_event = freeze_event;
    >
    > printk("Stopping tasks ... ");
    > nr_unfrozen = try_to_freeze_tasks(FREEZER_USER_SPACE);
    > if (nr_unfrozen)
    > - return nr_unfrozen;
    > + goto out;
    >
    > sys_sync();
    > nr_unfrozen = try_to_freeze_tasks(FREEZER_KERNEL_THREADS);
    > if (nr_unfrozen)
    > - return nr_unfrozen;
    > + goto out;
    >
    > + system_frozen_event_mask |= current_freezer_event;
    > printk("done.\n");
    > BUG_ON(in_atomic());

    The BUG_ON() is still valid if tasks are already frozen for this event.

    > - return 0;
    > +out:
    > + current_freezer_event = 0;
    > + mutex_unlock(&freezer_mutex);
    > + return nr_unfrozen;
    > }
    >
    > static void thaw_tasks(int thaw_user_space)
    > @@ -213,7 +249,7 @@ static void thaw_tasks(int thaw_user_spa
    >
    > read_lock(&tasklist_lock);
    > do_each_thread(g, p) {
    > - if (!freezeable(p))
    > + if (!thawable(p))
    > continue;
    >
    > if (is_user_space(p) == !thaw_user_space)
    > @@ -224,13 +260,23 @@ static void thaw_tasks(int thaw_user_spa
    > read_unlock(&tasklist_lock);
    > }
    >
    > -void thaw_processes(void)
    > +void thaw_processes(unsigned long thaw_event)
    > {
    > + mutex_lock(&freezer_mutex);
    > + if (!(system_frozen_event_mask & thaw_event)) {
    > + WARN_ON(1);

    Hmm, I wouldn't use the WARN_ON() here. There's nothing wrong in calling
    this twice in a row as long as we do the sanity checking. There's even one
    case in which that may be convenient, actually.

    > + goto out;
    > + }
    > + current_freezer_event = thaw_event;
    > printk("Restarting tasks ... ");
    > thaw_tasks(FREEZER_KERNEL_THREADS);
    > thaw_tasks(FREEZER_USER_SPACE);
    > + system_frozen_event_mask &= ~current_freezer_event;
    > schedule();
    > printk("done.\n");
    > +out:
    > + current_freezer_event = 0;
    > + mutex_unlock(&freezer_mutex);
    > }
    >
    > EXPORT_SYMBOL(refrigerator);
    > Index: linux-2.6.21-rc7/arch/i386/kernel/apm.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/arch/i386/kernel/apm.c
    > +++ linux-2.6.21-rc7/arch/i386/kernel/apm.c
    > @@ -2313,7 +2313,7 @@ static int __init apm_init(void)
    > remove_proc_entry("apm", NULL);
    > return err;
    > }
    > - freezer_exempt(kapmd_task);
    > + freezer_exempt(kapmd_task, FE_ALL);
    > wake_up_process(kapmd_task);
    >
    > if (num_online_cpus() > 1 && !smp ) {
    > Index: linux-2.6.21-rc7/drivers/block/loop.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/block/loop.c
    > +++ linux-2.6.21-rc7/drivers/block/loop.c
    > @@ -582,7 +582,7 @@ static int loop_thread(void *data)
    > * hence, it mustn't be stopped at all
    > * because it could be indirectly used during suspension
    > */
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > set_user_nice(current, -20);
    >
    > Index: linux-2.6.21-rc7/drivers/char/apm-emulation.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/char/apm-emulation.c
    > +++ linux-2.6.21-rc7/drivers/char/apm-emulation.c
    > @@ -336,7 +336,7 @@ apm_ioctl(struct inode * inode, struct f
    > * threads.
    > */
    > flags = current->flags;
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > wait_event(apm_suspend_waitqueue,
    > as->suspend_state == SUSPEND_DONE);
    > @@ -372,7 +372,7 @@ apm_ioctl(struct inode * inode, struct f
    > * threads.
    > */
    > flags = current->flags;
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > wait_event_interruptible(apm_suspend_waitqueue,
    > as->suspend_state == SUSPEND_DONE);
    > @@ -601,7 +601,7 @@ static int __init apm_init(void)
    > kapmd_tsk = NULL;
    > return ret;
    > }
    > - freezer_exempt(kapmd_tsk);
    > + freezer_exempt(kapmd_tsk, FE_ALL);
    > wake_up_process(kapmd_tsk);
    >
    > #ifdef CONFIG_PROC_FS
    > Index: linux-2.6.21-rc7/drivers/ieee1394/ieee1394_core.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/ieee1394/ieee1394_core.c
    > +++ linux-2.6.21-rc7/drivers/ieee1394/ieee1394_core.c
    > @@ -1134,7 +1134,7 @@ static int hpsbpkt_thread(void *__hi)
    > struct list_head tmp;
    > int may_schedule;
    >
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > while (!kthread_should_stop()) {
    >
    > Index: linux-2.6.21-rc7/drivers/md/md.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/md/md.c
    > +++ linux-2.6.21-rc7/drivers/md/md.c
    > @@ -4541,7 +4541,7 @@ static int md_thread(void * arg)
    > * many dirty RAID5 blocks.
    > */
    >
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    > while (!kthread_should_stop()) {
    >
    > /* We need to wait INTERRUPTIBLE so that
    > Index: linux-2.6.21-rc7/drivers/mmc/card/queue.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/mmc/card/queue.c
    > +++ linux-2.6.21-rc7/drivers/mmc/card/queue.c
    > @@ -67,7 +67,7 @@ static int mmc_queue_thread(void *d)
    > * the process freezing. We handle suspension ourselves.
    > */
    > current->flags |= PF_MEMALLOC;
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > down(&mq->thread_sem);
    > do {
    > Index: linux-2.6.21-rc7/drivers/mtd/mtd_blkdevs.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/mtd/mtd_blkdevs.c
    > +++ linux-2.6.21-rc7/drivers/mtd/mtd_blkdevs.c
    > @@ -82,7 +82,7 @@ static int mtd_blktrans_thread(void *arg
    >
    > /* we might get involved when memory gets low, so use PF_MEMALLOC */
    > current->flags |= PF_MEMALLOC;
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > spin_lock_irq(rq->queue_lock);
    > while (!kthread_should_stop()) {
    > Index: linux-2.6.21-rc7/drivers/scsi/libsas/sas_scsi_host.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/scsi/libsas/sas_scsi_host.c
    > +++ linux-2.6.21-rc7/drivers/scsi/libsas/sas_scsi_host.c
    > @@ -871,7 +871,7 @@ static int sas_queue_thread(void *_sas_h
    > struct sas_ha_struct *sas_ha = _sas_ha;
    > struct scsi_core *core = &sas_ha->core;
    >
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > complete(&queue_th_comp);
    >
    > Index: linux-2.6.21-rc7/drivers/scsi/scsi_error.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/scsi/scsi_error.c
    > +++ linux-2.6.21-rc7/drivers/scsi/scsi_error.c
    > @@ -1536,7 +1536,7 @@ int scsi_error_handler(void *data)
    > {
    > struct Scsi_Host *shost = data;
    >
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > /*
    > * We use TASK_INTERRUPTIBLE so that the thread is not
    > Index: linux-2.6.21-rc7/drivers/usb/storage/usb.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/drivers/usb/storage/usb.c
    > +++ linux-2.6.21-rc7/drivers/usb/storage/usb.c
    > @@ -301,7 +301,7 @@ static int usb_stor_control_thread(void
    > struct us_data *us = (struct us_data *)__us;
    > struct Scsi_Host *host = us_to_host(us);
    >
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > for(;;) {
    > try_to_freeze();
    > Index: linux-2.6.21-rc7/kernel/kthread.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/kthread.c
    > +++ linux-2.6.21-rc7/kernel/kthread.c
    > @@ -233,7 +233,7 @@ int kthreadd(void *unused)
    > /* Setup a clean context for our children to inherit. */
    > kthreadd_setup();
    >
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > for (;;) {
    > set_current_state(TASK_INTERRUPTIBLE);
    > Index: linux-2.6.21-rc7/kernel/rcutorture.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/rcutorture.c
    > +++ linux-2.6.21-rc7/kernel/rcutorture.c
    > @@ -559,7 +559,7 @@ rcu_torture_fakewriter(void *arg)
    >
    > VERBOSE_PRINTK_STRING("rcu_torture_fakewriter task started");
    > set_user_nice(current, 19);
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > do {
    > schedule_timeout_uninterruptible(1 + rcu_random(&rand)%10);
    > @@ -590,7 +590,7 @@ rcu_torture_reader(void *arg)
    >
    > VERBOSE_PRINTK_STRING("rcu_torture_reader task started");
    > set_user_nice(current, 19);
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > do {
    > idx = cur_ops->readlock();
    > Index: linux-2.6.21-rc7/kernel/sched.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/sched.c
    > +++ linux-2.6.21-rc7/kernel/sched.c
    > @@ -5478,7 +5478,7 @@ migration_call(struct notifier_block *nf
    > p = kthread_create(migration_thread, hcpu, "migration/%d",cpu);
    > if (IS_ERR(p))
    > return NOTIFY_BAD;
    > - freezer_exempt(p);
    > + freezer_exempt(p, FE_ALL);
    > kthread_bind(p, cpu);
    > /* Must be high prio: stop_machine expects to yield to it. */
    > rq = task_rq_lock(p, &flags);
    > Index: linux-2.6.21-rc7/kernel/softirq.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/softirq.c
    > +++ linux-2.6.21-rc7/kernel/softirq.c
    > @@ -490,7 +490,7 @@ void __init softirq_init(void)
    > static int ksoftirqd(void * __bind_cpu)
    > {
    > set_user_nice(current, 15);
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > set_current_state(TASK_INTERRUPTIBLE);
    >
    > Index: linux-2.6.21-rc7/kernel/softlockup.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/softlockup.c
    > +++ linux-2.6.21-rc7/kernel/softlockup.c
    > @@ -117,7 +117,7 @@ static int watchdog(void * __bind_cpu)
    > struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
    >
    > sched_setscheduler(current, SCHED_FIFO, &param);
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > /* initialize timestamp */
    > touch_softlockup_watchdog();
    > Index: linux-2.6.21-rc7/kernel/workqueue.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/workqueue.c
    > +++ linux-2.6.21-rc7/kernel/workqueue.c
    > @@ -291,7 +291,7 @@ static int worker_thread(void *__cwq)
    > DEFINE_WAIT(wait);
    >
    > if (!cwq->wq->freezeable)
    > - freezer_exempt(current);
    > + freezer_exempt(current, FE_ALL);
    >
    > for (;;) {
    > prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);
    > Index: linux-2.6.21-rc7/kernel/kprobes.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/kprobes.c
    > +++ linux-2.6.21-rc7/kernel/kprobes.c
    > @@ -109,7 +109,7 @@ static int __kprobes check_safety(void)
    > {
    > int ret = 0;
    > #ifdef CONFIG_PREEMPT
    > - ret = freeze_processes();
    > + ret = freeze_processes(FE_KPROBES);
    > if (ret == 0) {
    > struct task_struct *p, *q;
    > do_each_thread(p, q) {
    > @@ -122,7 +122,7 @@ static int __kprobes check_safety(void)
    > } while_each_thread(p, q);
    > }
    > loop_end:
    > - thaw_processes();
    > + thaw_processes(FE_KPROBES);
    > #else
    > synchronize_sched();
    > #endif
    > Index: linux-2.6.21-rc7/kernel/power/disk.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/power/disk.c
    > +++ linux-2.6.21-rc7/kernel/power/disk.c
    > @@ -103,7 +103,7 @@ static inline void platform_finish(void)
    >
    > static void unprepare_processes(void)
    > {
    > - thaw_processes();
    > + thaw_processes(FE_SUSPEND);
    > pm_restore_console();
    > }
    >
    > @@ -112,7 +112,7 @@ static int prepare_processes(void)
    > int error = 0;
    >
    > pm_prepare_console();
    > - if (freeze_processes()) {
    > + if (freeze_processes(FE_SUSPEND)) {
    > error = -EBUSY;
    > unprepare_processes();
    > }
    > Index: linux-2.6.21-rc7/kernel/power/main.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/power/main.c
    > +++ linux-2.6.21-rc7/kernel/power/main.c
    > @@ -90,9 +90,9 @@ static int suspend_prepare(suspend_state
    > if (error)
    > goto Finish;
    >
    > - if (freeze_processes()) {
    > + if (freeze_processes(FE_SUSPEND)) {
    > error = -EAGAIN;
    > - thaw_processes();
    > + thaw_processes(FE_SUSPEND);
    > goto Finish;
    > }
    >
    > @@ -133,7 +133,7 @@ static int suspend_prepare(suspend_state
    > resume_console();
    > Thaw:
    > suspend_notifier_call_chain(SUSPEND_THAW_PREPARE);
    > - thaw_processes();
    > + thaw_processes(FE_SUSPEND);
    > Finish:
    > pm_restore_console();
    > suspend_notifier_call_chain(SUSPEND_FINISHED);
    > @@ -185,7 +185,7 @@ static void suspend_finish(suspend_state
    > device_resume();
    > resume_console();
    > suspend_notifier_call_chain(SUSPEND_THAW_PREPARE);
    > - thaw_processes();
    > + thaw_processes(FE_SUSPEND);
    > pm_restore_console();
    > suspend_notifier_call_chain(SUSPEND_FINISHED);
    > }
    > Index: linux-2.6.21-rc7/kernel/power/user.c
    > ===================================================================
    > --- linux-2.6.21-rc7.orig/kernel/power/user.c
    > +++ linux-2.6.21-rc7/kernel/power/user.c
    > @@ -81,7 +81,7 @@ static void snapshot_unfreeze(struct sna
    > return;
    >
    > mutex_lock(&pm_mutex);
    > - thaw_processes();
    > + thaw_processes(FE_SUSPEND);
    > suspend_notifier_call_chain(SUSPEND_FINISHED);
    > mutex_unlock(&pm_mutex);
    > data->frozen = 0;
    > @@ -257,8 +257,8 @@ static int snapshot_ioctl(struct inode *
    > if (error)
    > break;
    >
    > - if (freeze_processes()) {
    > - thaw_processes();
    > + if (freeze_processes(FE_SUSPEND)) {
    > + thaw_processes(FE_SUSPEND);
    > suspend_notifier_call_chain(SUSPEND_FINISHED);
    > error = -EBUSY;
    > }
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2007-04-29 19:51    [W:3.487 / U:0.252 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site