process.c 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * PARISC Architecture-dependent parts of process handling
  4. * based on the work for i386
  5. *
  6. * Copyright (C) 1999-2003 Matthew Wilcox <willy at parisc-linux.org>
  7. * Copyright (C) 2000 Martin K Petersen <mkp at mkp.net>
  8. * Copyright (C) 2000 John Marvin <jsm at parisc-linux.org>
  9. * Copyright (C) 2000 David Huggins-Daines <dhd with pobox.org>
  10. * Copyright (C) 2000-2003 Paul Bame <bame at parisc-linux.org>
  11. * Copyright (C) 2000 Philipp Rumpf <prumpf with tux.org>
  12. * Copyright (C) 2000 David Kennedy <dkennedy with linuxcare.com>
  13. * Copyright (C) 2000 Richard Hirst <rhirst with parisc-linux.org>
  14. * Copyright (C) 2000 Grant Grundler <grundler with parisc-linux.org>
  15. * Copyright (C) 2001 Alan Modra <amodra at parisc-linux.org>
  16. * Copyright (C) 2001-2002 Ryan Bradetich <rbrad at parisc-linux.org>
  17. * Copyright (C) 2001-2014 Helge Deller <deller@gmx.de>
  18. * Copyright (C) 2002 Randolph Chung <tausq with parisc-linux.org>
  19. */
  20. #include <stdarg.h>
  21. #include <linux/elf.h>
  22. #include <linux/errno.h>
  23. #include <linux/kernel.h>
  24. #include <linux/mm.h>
  25. #include <linux/fs.h>
  26. #include <linux/cpu.h>
  27. #include <linux/module.h>
  28. #include <linux/personality.h>
  29. #include <linux/ptrace.h>
  30. #include <linux/sched.h>
  31. #include <linux/sched/debug.h>
  32. #include <linux/sched/task.h>
  33. #include <linux/sched/task_stack.h>
  34. #include <linux/slab.h>
  35. #include <linux/stddef.h>
  36. #include <linux/unistd.h>
  37. #include <linux/kallsyms.h>
  38. #include <linux/uaccess.h>
  39. #include <linux/rcupdate.h>
  40. #include <linux/random.h>
  41. #include <linux/nmi.h>
  42. #include <asm/io.h>
  43. #include <asm/asm-offsets.h>
  44. #include <asm/assembly.h>
  45. #include <asm/pdc.h>
  46. #include <asm/pdc_chassis.h>
  47. #include <asm/unwind.h>
  48. #include <asm/sections.h>
  49. #define COMMAND_GLOBAL F_EXTEND(0xfffe0030)
  50. #define CMD_RESET 5 /* reset any module */
  51. /*
  52. ** The Wright Brothers and Gecko systems have a H/W problem
  53. ** (Lasi...'nuf said) may cause a broadcast reset to lockup
  54. ** the system. An HVERSION dependent PDC call was developed
  55. ** to perform a "safe", platform specific broadcast reset instead
  56. ** of kludging up all the code.
  57. **
  58. ** Older machines which do not implement PDC_BROADCAST_RESET will
  59. ** return (with an error) and the regular broadcast reset can be
  60. ** issued. Obviously, if the PDC does implement PDC_BROADCAST_RESET
  61. ** the PDC call will not return (the system will be reset).
  62. */
  63. void machine_restart(char *cmd)
  64. {
  65. #ifdef FASTBOOT_SELFTEST_SUPPORT
  66. /*
  67. ** If user has modified the Firmware Selftest Bitmap,
  68. ** run the tests specified in the bitmap after the
  69. ** system is rebooted w/PDC_DO_RESET.
  70. **
  71. ** ftc_bitmap = 0x1AUL "Skip destructive memory tests"
  72. **
  73. ** Using "directed resets" at each processor with the MEM_TOC
  74. ** vector cleared will also avoid running destructive
  75. ** memory self tests. (Not implemented yet)
  76. */
  77. if (ftc_bitmap) {
  78. pdc_do_firm_test_reset(ftc_bitmap);
  79. }
  80. #endif
  81. /* set up a new led state on systems shipped with a LED State panel */
  82. pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
  83. /* "Normal" system reset */
  84. pdc_do_reset();
  85. /* Nope...box should reset with just CMD_RESET now */
  86. gsc_writel(CMD_RESET, COMMAND_GLOBAL);
  87. /* Wait for RESET to lay us to rest. */
  88. while (1) ;
  89. }
  90. void (*chassis_power_off)(void);
  91. /*
  92. * This routine is called from sys_reboot to actually turn off the
  93. * machine
  94. */
  95. void machine_power_off(void)
  96. {
  97. /* If there is a registered power off handler, call it. */
  98. if (chassis_power_off)
  99. chassis_power_off();
  100. /* Put the soft power button back under hardware control.
  101. * If the user had already pressed the power button, the
  102. * following call will immediately power off. */
  103. pdc_soft_power_button(0);
  104. pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
  105. /* ipmi_poweroff may have been installed. */
  106. if (pm_power_off)
  107. pm_power_off();
  108. /* It seems we have no way to power the system off via
  109. * software. The user has to press the button himself. */
  110. printk(KERN_EMERG "System shut down completed.\n"
  111. "Please power this system off now.");
  112. /* prevent soft lockup/stalled CPU messages for endless loop. */
  113. rcu_sysrq_start();
  114. lockup_detector_soft_poweroff();
  115. for (;;);
  116. }
  117. void (*pm_power_off)(void);
  118. EXPORT_SYMBOL(pm_power_off);
  119. void machine_halt(void)
  120. {
  121. machine_power_off();
  122. }
  123. void flush_thread(void)
  124. {
  125. /* Only needs to handle fpu stuff or perf monitors.
  126. ** REVISIT: several arches implement a "lazy fpu state".
  127. */
  128. }
  129. void release_thread(struct task_struct *dead_task)
  130. {
  131. }
  132. /*
  133. * Idle thread support
  134. *
  135. * Detect when running on QEMU with SeaBIOS PDC Firmware and let
  136. * QEMU idle the host too.
  137. */
  138. int running_on_qemu __ro_after_init;
  139. EXPORT_SYMBOL(running_on_qemu);
  140. void __cpuidle arch_cpu_idle_dead(void)
  141. {
  142. /* nop on real hardware, qemu will offline CPU. */
  143. asm volatile("or %%r31,%%r31,%%r31\n":::);
  144. }
  145. void __cpuidle arch_cpu_idle(void)
  146. {
  147. raw_local_irq_enable();
  148. /* nop on real hardware, qemu will idle sleep. */
  149. asm volatile("or %%r10,%%r10,%%r10\n":::);
  150. }
  151. static int __init parisc_idle_init(void)
  152. {
  153. if (!running_on_qemu)
  154. cpu_idle_poll_ctrl(1);
  155. return 0;
  156. }
  157. arch_initcall(parisc_idle_init);
  158. /*
  159. * Copy architecture-specific thread state
  160. */
  161. int
  162. copy_thread(unsigned long clone_flags, unsigned long usp,
  163. unsigned long kthread_arg, struct task_struct *p, unsigned long tls)
  164. {
  165. struct pt_regs *cregs = &(p->thread.regs);
  166. void *stack = task_stack_page(p);
  167. /* We have to use void * instead of a function pointer, because
  168. * function pointers aren't a pointer to the function on 64-bit.
  169. * Make them const so the compiler knows they live in .text */
  170. extern void * const ret_from_kernel_thread;
  171. extern void * const child_return;
  172. if (unlikely(p->flags & PF_KTHREAD)) {
  173. /* kernel thread */
  174. memset(cregs, 0, sizeof(struct pt_regs));
  175. if (!usp) /* idle thread */
  176. return 0;
  177. /* Must exit via ret_from_kernel_thread in order
  178. * to call schedule_tail()
  179. */
  180. cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
  181. cregs->kpc = (unsigned long) &ret_from_kernel_thread;
  182. /*
  183. * Copy function and argument to be called from
  184. * ret_from_kernel_thread.
  185. */
  186. #ifdef CONFIG_64BIT
  187. cregs->gr[27] = ((unsigned long *)usp)[3];
  188. cregs->gr[26] = ((unsigned long *)usp)[2];
  189. #else
  190. cregs->gr[26] = usp;
  191. #endif
  192. cregs->gr[25] = kthread_arg;
  193. } else {
  194. /* user thread */
  195. /* usp must be word aligned. This also prevents users from
  196. * passing in the value 1 (which is the signal for a special
  197. * return for a kernel thread) */
  198. if (usp) {
  199. usp = ALIGN(usp, 4);
  200. if (likely(usp))
  201. cregs->gr[30] = usp;
  202. }
  203. cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN + FRAME_SIZE;
  204. cregs->kpc = (unsigned long) &child_return;
  205. /* Setup thread TLS area */
  206. if (clone_flags & CLONE_SETTLS)
  207. cregs->cr27 = tls;
  208. }
  209. return 0;
  210. }
  211. unsigned long
  212. get_wchan(struct task_struct *p)
  213. {
  214. struct unwind_frame_info info;
  215. unsigned long ip;
  216. int count = 0;
  217. if (!p || p == current || p->state == TASK_RUNNING)
  218. return 0;
  219. /*
  220. * These bracket the sleeping functions..
  221. */
  222. unwind_frame_init_from_blocked_task(&info, p);
  223. do {
  224. if (unwind_once(&info) < 0)
  225. return 0;
  226. ip = info.ip;
  227. if (!in_sched_functions(ip))
  228. return ip;
  229. } while (count++ < MAX_UNWIND_ENTRIES);
  230. return 0;
  231. }
  232. #ifdef CONFIG_64BIT
  233. void *dereference_function_descriptor(void *ptr)
  234. {
  235. Elf64_Fdesc *desc = ptr;
  236. void *p;
  237. if (!get_kernel_nofault(p, (void *)&desc->addr))
  238. ptr = p;
  239. return ptr;
  240. }
  241. void *dereference_kernel_function_descriptor(void *ptr)
  242. {
  243. if (ptr < (void *)__start_opd ||
  244. ptr >= (void *)__end_opd)
  245. return ptr;
  246. return dereference_function_descriptor(ptr);
  247. }
  248. #endif
  249. static inline unsigned long brk_rnd(void)
  250. {
  251. return (get_random_int() & BRK_RND_MASK) << PAGE_SHIFT;
  252. }
  253. unsigned long arch_randomize_brk(struct mm_struct *mm)
  254. {
  255. unsigned long ret = PAGE_ALIGN(mm->brk + brk_rnd());
  256. if (ret < mm->brk)
  257. return mm->brk;
  258. return ret;
  259. }