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 <[EMAIL PROTECTED]> > --- > 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, ¶m); > - 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 [EMAIL PROTECTED] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
