cpu.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339
  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 = %x) \n",
  86. p->comm, p->pid, cpu, p->state, p->flags);
  87. }
  88. write_unlock_irq(&tasklist_lock);
  89. }
  90. struct take_cpu_down_param {
  91. unsigned long mod;
  92. void *hcpu;
  93. };
  94. /* Take this CPU down. */
  95. static int take_cpu_down(void *_param)
  96. {
  97. struct take_cpu_down_param *param = _param;
  98. int err;
  99. raw_notifier_call_chain(&cpu_chain, CPU_DYING | param->mod,
  100. param->hcpu);
  101. /* Ensure this CPU doesn't handle any more interrupts. */
  102. err = __cpu_disable();
  103. if (err < 0)
  104. return err;
  105. /* Force idle task to run as soon as we yield: it should
  106. immediately notice cpu is offline and die quickly. */
  107. sched_idle_next();
  108. return 0;
  109. }
  110. /* Requires cpu_add_remove_lock to be held */
  111. static int _cpu_down(unsigned int cpu, int tasks_frozen)
  112. {
  113. int err, nr_calls = 0;
  114. struct task_struct *p;
  115. cpumask_t old_allowed, tmp;
  116. void *hcpu = (void *)(long)cpu;
  117. unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
  118. struct take_cpu_down_param tcd_param = {
  119. .mod = mod,
  120. .hcpu = hcpu,
  121. };
  122. if (num_online_cpus() == 1)
  123. return -EBUSY;
  124. if (!cpu_online(cpu))
  125. return -EINVAL;
  126. raw_notifier_call_chain(&cpu_chain, CPU_LOCK_ACQUIRE, hcpu);
  127. err = __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE | mod,
  128. hcpu, -1, &nr_calls);
  129. if (err == NOTIFY_BAD) {
  130. nr_calls--;
  131. __raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
  132. hcpu, nr_calls, NULL);
  133. printk("%s: attempt to take down CPU %u failed\n",
  134. __FUNCTION__, cpu);
  135. err = -EINVAL;
  136. goto out_release;
  137. }
  138. /* Ensure that we are not runnable on dying cpu */
  139. old_allowed = current->cpus_allowed;
  140. tmp = CPU_MASK_ALL;
  141. cpu_clear(cpu, tmp);
  142. set_cpus_allowed(current, tmp);
  143. mutex_lock(&cpu_bitmask_lock);
  144. p = __stop_machine_run(take_cpu_down, &tcd_param, cpu);
  145. mutex_unlock(&cpu_bitmask_lock);
  146. if (IS_ERR(p) || cpu_online(cpu)) {
  147. /* CPU didn't die: tell everyone. Can't complain. */
  148. if (raw_notifier_call_chain(&cpu_chain, CPU_DOWN_FAILED | mod,
  149. hcpu) == NOTIFY_BAD)
  150. BUG();
  151. if (IS_ERR(p)) {
  152. err = PTR_ERR(p);
  153. goto out_allowed;
  154. }
  155. goto out_thread;
  156. }
  157. /* Wait for it to sleep (leaving idle task). */
  158. while (!idle_cpu(cpu))
  159. yield();
  160. /* This actually kills the CPU. */
  161. __cpu_die(cpu);
  162. /* CPU is completely dead: tell everyone. Too late to complain. */
  163. if (raw_notifier_call_chain(&cpu_chain, CPU_DEAD | mod,
  164. hcpu) == NOTIFY_BAD)
  165. BUG();
  166. check_for_tasks(cpu);
  167. out_thread:
  168. err = kthread_stop(p);
  169. out_allowed:
  170. set_cpus_allowed(current, old_allowed);
  171. out_release:
  172. raw_notifier_call_chain(&cpu_chain, CPU_LOCK_RELEASE, hcpu);
  173. return err;
  174. }
  175. int cpu_down(unsigned int cpu)
  176. {
  177. int err = 0;
  178. mutex_lock(&cpu_add_remove_lock);
  179. if (cpu_hotplug_disabled)
  180. err = -EBUSY;
  181. else
  182. err = _cpu_down(cpu, 0);
  183. mutex_unlock(&cpu_add_remove_lock);
  184. return err;
  185. }
  186. #endif /*CONFIG_HOTPLUG_CPU*/
  187. /* Requires cpu_add_remove_lock to be held */
  188. static int __cpuinit _cpu_up(unsigned int cpu, int tasks_frozen)
  189. {
  190. int ret, nr_calls = 0;
  191. void *hcpu = (void *)(long)cpu;
  192. unsigned long mod = tasks_frozen ? CPU_TASKS_FROZEN : 0;
  193. if (cpu_online(cpu) || !cpu_present(cpu))
  194. return -EINVAL;
  195. raw_notifier_call_chain(&cpu_chain, CPU_LOCK_ACQUIRE, hcpu);
  196. ret = __raw_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE | mod, hcpu,
  197. -1, &nr_calls);
  198. if (ret == NOTIFY_BAD) {
  199. nr_calls--;
  200. printk("%s: attempt to bring up CPU %u failed\n",
  201. __FUNCTION__, cpu);
  202. ret = -EINVAL;
  203. goto out_notify;
  204. }
  205. /* Arch-specific enabling code. */
  206. mutex_lock(&cpu_bitmask_lock);
  207. ret = __cpu_up(cpu);
  208. mutex_unlock(&cpu_bitmask_lock);
  209. if (ret != 0)
  210. goto out_notify;
  211. BUG_ON(!cpu_online(cpu));
  212. /* Now call notifier in preparation. */
  213. raw_notifier_call_chain(&cpu_chain, CPU_ONLINE | mod, hcpu);
  214. out_notify:
  215. if (ret != 0)
  216. __raw_notifier_call_chain(&cpu_chain,
  217. CPU_UP_CANCELED | mod, hcpu, nr_calls, NULL);
  218. raw_notifier_call_chain(&cpu_chain, CPU_LOCK_RELEASE, hcpu);
  219. return ret;
  220. }
  221. int __cpuinit cpu_up(unsigned int cpu)
  222. {
  223. int err = 0;
  224. mutex_lock(&cpu_add_remove_lock);
  225. if (cpu_hotplug_disabled)
  226. err = -EBUSY;
  227. else
  228. err = _cpu_up(cpu, 0);
  229. mutex_unlock(&cpu_add_remove_lock);
  230. return err;
  231. }
  232. #ifdef CONFIG_PM_SLEEP_SMP
  233. static cpumask_t frozen_cpus;
  234. int disable_nonboot_cpus(void)
  235. {
  236. int cpu, first_cpu, error = 0;
  237. mutex_lock(&cpu_add_remove_lock);
  238. first_cpu = first_cpu(cpu_online_map);
  239. /* We take down all of the non-boot CPUs in one shot to avoid races
  240. * with the userspace trying to use the CPU hotplug at the same time
  241. */
  242. cpus_clear(frozen_cpus);
  243. printk("Disabling non-boot CPUs ...\n");
  244. for_each_online_cpu(cpu) {
  245. if (cpu == first_cpu)
  246. continue;
  247. error = _cpu_down(cpu, 1);
  248. if (!error) {
  249. cpu_set(cpu, frozen_cpus);
  250. printk("CPU%d is down\n", cpu);
  251. } else {
  252. printk(KERN_ERR "Error taking CPU%d down: %d\n",
  253. cpu, error);
  254. break;
  255. }
  256. }
  257. if (!error) {
  258. BUG_ON(num_online_cpus() > 1);
  259. /* Make sure the CPUs won't be enabled by someone else */
  260. cpu_hotplug_disabled = 1;
  261. } else {
  262. printk(KERN_ERR "Non-boot CPUs are not disabled\n");
  263. }
  264. mutex_unlock(&cpu_add_remove_lock);
  265. return error;
  266. }
  267. void enable_nonboot_cpus(void)
  268. {
  269. int cpu, error;
  270. /* Allow everyone to use the CPU hotplug again */
  271. mutex_lock(&cpu_add_remove_lock);
  272. cpu_hotplug_disabled = 0;
  273. if (cpus_empty(frozen_cpus))
  274. goto out;
  275. printk("Enabling non-boot CPUs ...\n");
  276. for_each_cpu_mask(cpu, frozen_cpus) {
  277. error = _cpu_up(cpu, 1);
  278. if (!error) {
  279. printk("CPU%d is up\n", cpu);
  280. continue;
  281. }
  282. printk(KERN_WARNING "Error taking CPU%d up: %d\n", cpu, error);
  283. }
  284. cpus_clear(frozen_cpus);
  285. out:
  286. mutex_unlock(&cpu_add_remove_lock);
  287. }
  288. #endif /* CONFIG_PM_SLEEP_SMP */