cpu.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327
  1. /* CPU control.
  2. * (C) 2001, 2002, 2003, 2004 Rusty Russell
  3. *
  4. * This code is licenced under the GPL.
  5. */
  6. #include <linux/proc_fs.h>
  7. #include <linux/smp.h>
  8. #include <linux/init.h>
  9. #include <linux/notifier.h>
  10. #include <linux/sched.h>
  11. #include <linux/unistd.h>
  12. #include <linux/cpu.h>
  13. #include <linux/module.h>
  14. #include <linux/kthread.h>
  15. #include <linux/stop_machine.h>
  16. #include <linux/mutex.h>
  17. /* This protects CPUs going up and down... */
  18. static DEFINE_MUTEX(cpu_add_remove_lock);
  19. static DEFINE_MUTEX(cpu_bitmask_lock);
  20. static __cpuinitdata RAW_NOTIFIER_HEAD(cpu_chain);
  21. /* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
  22. * Should always be manipulated under cpu_add_remove_lock
  23. */
  24. static int cpu_hotplug_disabled;
  25. #ifdef CONFIG_HOTPLUG_CPU
  26. /* Crappy recursive lock-takers in cpufreq! Complain loudly about idiots */
  27. static struct task_struct *recursive;
  28. static int recursive_depth;
  29. void lock_cpu_hotplug(void)
  30. {
  31. struct task_struct *tsk = current;
  32. if (tsk == recursive) {
  33. static int warnings = 10;
  34. if (warnings) {
  35. printk(KERN_ERR "Lukewarm IQ detected in hotplug locking\n");
  36. WARN_ON(1);
  37. warnings--;
  38. }
  39. recursive_depth++;
  40. return;
  41. }
  42. mutex_lock(&cpu_bitmask_lock);
  43. recursive = tsk;
  44. }
  45. EXPORT_SYMBOL_GPL(lock_cpu_hotplug);
  46. void unlock_cpu_hotplug(void)
  47. {
  48. WARN_ON(recursive != current);
  49. if (recursive_depth) {
  50. recursive_depth--;
  51. return;
  52. }
  53. recursive = NULL;
  54. mutex_unlock(&cpu_bitmask_lock);
  55. }
  56. EXPORT_SYMBOL_GPL(unlock_cpu_hotplug);
  57. #endif /* CONFIG_HOTPLUG_CPU */
  58. /* Need to know about CPUs going up/down? */
  59. int __cpuinit register_cpu_notifier(struct notifier_block *nb)
  60. {
  61. int ret;
  62. mutex_lock(&cpu_add_remove_lock);
  63. ret = raw_notifier_chain_register(&cpu_chain, nb);
  64. mutex_unlock(&cpu_add_remove_lock);
  65. return ret;
  66. }
  67. #ifdef CONFIG_HOTPLUG_CPU
  68. EXPORT_SYMBOL(register_cpu_notifier);
  69. void unregister_cpu_notifier(struct notifier_block *nb)
  70. {
  71. mutex_lock(&cpu_add_remove_lock);
  72. raw_notifier_chain_unregister(&cpu_chain, nb);
  73. mutex_unlock(&cpu_add_remove_lock);
  74. }
  75. EXPORT_SYMBOL(unregister_cpu_notifier);
  76. static inline void check_for_tasks(int cpu)
  77. {
  78. struct task_struct *p;
  79. write_lock_irq(&tasklist_lock);
  80. for_each_process(p) {
  81. if (task_cpu(p) == cpu &&
  82. (!cputime_eq(p->utime, cputime_zero) ||
  83. !cputime_eq(p->stime, cputime_zero)))
  84. printk(KERN_WARNING "Task %s (pid = %d) is on cpu %d\
  85. (state = %ld, flags = %lx) \n",
  86. p->comm, p->pid, cpu, p->state, p->flags);
  87. }
  88. write_unlock_irq(&tasklist_lock);
  89. }
  90. /* Take this CPU down. */
  91. static int take_cpu_down(void *unused)
  92. {
  93. int err;
  94. /* Ensure this CPU doesn't handle any more interrupts. */
  95. err = __cpu_disable();
  96. if (err < 0)
  97. return err;
  98. /* Force idle task to run as soon as we yield: it should
  99. immediately notice cpu is offline and die quickly. */
  100. sched_idle_next();
  101. return 0;
  102. }
  103. /* Requires cpu_add_remove_lock to be held */
  104. static int _cpu_down(unsigned int cpu)
  105. {
  106. int err;
  107. struct task_struct *p;
  108. cpumask_t old_allowed, tmp;
  109. if (num_online_cpus() == 1)
  110. return -EBUSY;
  111. if (!cpu_online(cpu))
  112. return -EINVAL;
  113. err = raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE,
  114. (void *)(long)cpu);
  115. if (err == NOTIFY_BAD) {
  116. printk("%s: attempt to take down CPU %u failed\n",
  117. __FUNCTION__, cpu);
  118. return -EINVAL;
  119. }
  120. /* Ensure that we are not runnable on dying cpu */
  121. old_allowed = current->cpus_allowed;
  122. tmp = CPU_MASK_ALL;
  123. cpu_clear(cpu, tmp);
  124. set_cpus_allowed(current, tmp);
  125. mutex_lock(&cpu_bitmask_lock);
  126. p = __stop_machine_run(take_cpu_down, NULL, cpu);
  127. mutex_unlock(&cpu_bitmask_lock);
  128. if (IS_ERR(p) || cpu_online(cpu)) {
  129. /* CPU didn't die: tell everyone. Can't complain. */
  130. if (raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED,
  131. (void *)(long)cpu) == NOTIFY_BAD)
  132. BUG();
  133. if (IS_ERR(p)) {
  134. err = PTR_ERR(p);
  135. goto out_allowed;
  136. }
  137. goto out_thread;
  138. }
  139. /* Wait for it to sleep (leaving idle task). */
  140. while (!idle_cpu(cpu))
  141. yield();
  142. /* This actually kills the CPU. */
  143. __cpu_die(cpu);
  144. /* Move it here so it can run. */
  145. kthread_bind(p, get_cpu());
  146. put_cpu();
  147. /* CPU is completely dead: tell everyone. Too late to complain. */
  148. if (raw_notifier_call_chain(&cpu_chain, CPU_DEAD,
  149. (void *)(long)cpu) == NOTIFY_BAD)
  150. BUG();
  151. check_for_tasks(cpu);
  152. out_thread:
  153. err = kthread_stop(p);
  154. out_allowed:
  155. set_cpus_allowed(current, old_allowed);
  156. return err;
  157. }
  158. int cpu_down(unsigned int cpu)
  159. {
  160. int err = 0;
  161. mutex_lock(&cpu_add_remove_lock);
  162. if (cpu_hotplug_disabled)
  163. err = -EBUSY;
  164. else
  165. err = _cpu_down(cpu);
  166. mutex_unlock(&cpu_add_remove_lock);
  167. return err;
  168. }
  169. #endif /*CONFIG_HOTPLUG_CPU*/
  170. /* Requires cpu_add_remove_lock to be held */
  171. static int __cpuinit _cpu_up(unsigned int cpu)
  172. {
  173. int ret;
  174. void *hcpu = (void *)(long)cpu;
  175. if (cpu_online(cpu) || !cpu_present(cpu))
  176. return -EINVAL;
  177. ret = raw_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE, hcpu);
  178. if (ret == NOTIFY_BAD) {
  179. printk("%s: attempt to bring up CPU %u failed\n",
  180. __FUNCTION__, cpu);
  181. ret = -EINVAL;
  182. goto out_notify;
  183. }
  184. /* Arch-specific enabling code. */
  185. mutex_lock(&cpu_bitmask_lock);
  186. ret = __cpu_up(cpu);
  187. mutex_unlock(&cpu_bitmask_lock);
  188. if (ret != 0)
  189. goto out_notify;
  190. BUG_ON(!cpu_online(cpu));
  191. /* Now call notifier in preparation. */
  192. raw_notifier_call_chain(&cpu_chain, CPU_ONLINE, hcpu);
  193. out_notify:
  194. if (ret != 0)
  195. raw_notifier_call_chain(&cpu_chain,
  196. CPU_UP_CANCELED, hcpu);
  197. return ret;
  198. }
  199. int __cpuinit cpu_up(unsigned int cpu)
  200. {
  201. int err = 0;
  202. mutex_lock(&cpu_add_remove_lock);
  203. if (cpu_hotplug_disabled)
  204. err = -EBUSY;
  205. else
  206. err = _cpu_up(cpu);
  207. mutex_unlock(&cpu_add_remove_lock);
  208. return err;
  209. }
  210. #ifdef CONFIG_SUSPEND_SMP
  211. /* Needed to prevent the microcode driver from requesting firmware in its CPU
  212. * hotplug notifier during the suspend/resume.
  213. */
  214. int suspend_cpu_hotplug;
  215. EXPORT_SYMBOL(suspend_cpu_hotplug);
  216. static cpumask_t frozen_cpus;
  217. int disable_nonboot_cpus(void)
  218. {
  219. int cpu, first_cpu, error = 0;
  220. mutex_lock(&cpu_add_remove_lock);
  221. suspend_cpu_hotplug = 1;
  222. first_cpu = first_cpu(cpu_online_map);
  223. /* We take down all of the non-boot CPUs in one shot to avoid races
  224. * with the userspace trying to use the CPU hotplug at the same time
  225. */
  226. cpus_clear(frozen_cpus);
  227. printk("Disabling non-boot CPUs ...\n");
  228. for_each_online_cpu(cpu) {
  229. if (cpu == first_cpu)
  230. continue;
  231. error = _cpu_down(cpu);
  232. if (!error) {
  233. cpu_set(cpu, frozen_cpus);
  234. printk("CPU%d is down\n", cpu);
  235. } else {
  236. printk(KERN_ERR "Error taking CPU%d down: %d\n",
  237. cpu, error);
  238. break;
  239. }
  240. }
  241. if (!error) {
  242. BUG_ON(num_online_cpus() > 1);
  243. /* Make sure the CPUs won't be enabled by someone else */
  244. cpu_hotplug_disabled = 1;
  245. } else {
  246. printk(KERN_ERR "Non-boot CPUs are not disabled\n");
  247. }
  248. suspend_cpu_hotplug = 0;
  249. mutex_unlock(&cpu_add_remove_lock);
  250. return error;
  251. }
  252. void enable_nonboot_cpus(void)
  253. {
  254. int cpu, error;
  255. /* Allow everyone to use the CPU hotplug again */
  256. mutex_lock(&cpu_add_remove_lock);
  257. cpu_hotplug_disabled = 0;
  258. if (cpus_empty(frozen_cpus))
  259. goto out;
  260. suspend_cpu_hotplug = 1;
  261. printk("Enabling non-boot CPUs ...\n");
  262. for_each_cpu_mask(cpu, frozen_cpus) {
  263. error = _cpu_up(cpu);
  264. if (!error) {
  265. printk("CPU%d is up\n", cpu);
  266. continue;
  267. }
  268. printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
  269. }
  270. cpus_clear(frozen_cpus);
  271. suspend_cpu_hotplug = 0;
  272. out:
  273. mutex_unlock(&cpu_add_remove_lock);
  274. }
  275. #endif