1 /* 2 * drivers/power/process.c - Functions for starting/stopping processes on 3 * suspend transitions. 4 * 5 * Originally from swsusp. 6 */ 7 8 9 #undef DEBUG 10 11 #include <linux/smp_lock.h> 12 #include <linux/interrupt.h> 13 #include <linux/suspend.h> 14 #include <linux/module.h> 15 #include <linux/syscalls.h> 16 #include <linux/freezer.h> 17 18 /* 19 * Timeout for stopping processes 20 */ 21 #define TIMEOUT (20 * HZ) 22 23 24 static inline int freezeable(struct task_struct * p) 25 { 26 if ((p == current) || 27 (p->flags & PF_NOFREEZE) || 28 (p->exit_state == EXIT_ZOMBIE) || 29 (p->exit_state == EXIT_DEAD) || 30 (p->state == TASK_STOPPED)) 31 return 0; 32 return 1; 33 } 34 35 /* Refrigerator is place where frozen processes are stored :-). */ 36 void refrigerator(void) 37 { 38 /* Hmm, should we be allowed to suspend when there are realtime 39 processes around? */ 40 long save; 41 save = current->state; 42 pr_debug("%s entered refrigerator\n", current->comm); 43 printk("="); 44 45 frozen_process(current); 46 spin_lock_irq(¤t->sighand->siglock); 47 recalc_sigpending(); /* We sent fake signal, clean it up */ 48 spin_unlock_irq(¤t->sighand->siglock); 49 50 while (frozen(current)) { 51 current->state = TASK_UNINTERRUPTIBLE; 52 schedule(); 53 } 54 pr_debug("%s left refrigerator\n", current->comm); 55 current->state = save; 56 } 57 58 static inline void freeze_process(struct task_struct *p) 59 { 60 unsigned long flags; 61 62 if (!freezing(p)) { 63 freeze(p); 64 spin_lock_irqsave(&p->sighand->siglock, flags); 65 signal_wake_up(p, 0); 66 spin_unlock_irqrestore(&p->sighand->siglock, flags); 67 } 68 } 69 70 static void cancel_freezing(struct task_struct *p) 71 { 72 unsigned long flags; 73 74 if (freezing(p)) { 75 pr_debug(" clean up: %s\n", p->comm); 76 do_not_freeze(p); 77 spin_lock_irqsave(&p->sighand->siglock, flags); 78 recalc_sigpending_tsk(p); 79 spin_unlock_irqrestore(&p->sighand->siglock, flags); 80 } 81 } 82 83 /* 0 = success, else # of processes that we failed to stop */ 84 int freeze_processes(void) 85 { 86 int todo, nr_user, user_frozen; 87 unsigned long start_time; 88 struct task_struct *g, *p; 89 90 printk( "Stopping tasks: " ); 91 start_time = jiffies; 92 user_frozen = 0; 93 do { 94 nr_user = todo = 0; 95 read_lock(&tasklist_lock); 96 do_each_thread(g, p) { 97 if (!freezeable(p)) 98 continue; 99 if (frozen(p)) 100 continue; 101 if (p->state == TASK_TRACED && frozen(p->parent)) { 102 cancel_freezing(p); 103 continue; 104 } 105 if (p->mm && !(p->flags & PF_BORROWED_MM)) { 106 /* The task is a user-space one. 107 * Freeze it unless there's a vfork completion 108 * pending 109 */ 110 if (!p->vfork_done) 111 freeze_process(p); 112 nr_user++; 113 } else { 114 /* Freeze only if the user space is frozen */ 115 if (user_frozen) 116 freeze_process(p); 117 todo++; 118 } 119 } while_each_thread(g, p); 120 read_unlock(&tasklist_lock); 121 todo += nr_user; 122 if (!user_frozen && !nr_user) { 123 sys_sync(); 124 start_time = jiffies; 125 } 126 user_frozen = !nr_user; 127 yield(); /* Yield is okay here */ 128 if (todo && time_after(jiffies, start_time + TIMEOUT)) 129 break; 130 } while(todo); 131 132 /* This does not unfreeze processes that are already frozen 133 * (we have slightly ugly calling convention in that respect, 134 * and caller must call thaw_processes() if something fails), 135 * but it cleans up leftover PF_FREEZE requests. 136 */ 137 if (todo) { 138 printk( "\n" ); 139 printk(KERN_ERR " stopping tasks timed out " 140 "after %d seconds (%d tasks remaining):\n", 141 TIMEOUT / HZ, todo); 142 read_lock(&tasklist_lock); 143 do_each_thread(g, p) { 144 if (freezeable(p) && !frozen(p)) 145 printk(KERN_ERR " %s\n", p->comm); 146 cancel_freezing(p); 147 } while_each_thread(g, p); 148 read_unlock(&tasklist_lock); 149 return todo; 150 } 151 152 printk( "|\n" ); 153 BUG_ON(in_atomic()); 154 return 0; 155 } 156 157 void thaw_processes(void) 158 { 159 struct task_struct *g, *p; 160 161 printk( "Restarting tasks..." ); 162 read_lock(&tasklist_lock); 163 do_each_thread(g, p) { 164 if (!freezeable(p)) 165 continue; 166 if (!thaw_process(p)) 167 printk(KERN_INFO " Strange, %s not stopped\n", p->comm ); 168 } while_each_thread(g, p); 169 170 read_unlock(&tasklist_lock); 171 schedule(); 172 printk( " done\n" ); 173 } 174 175 EXPORT_SYMBOL(refrigerator); 176