process.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389
  1. /*
  2. * arch/s390/kernel/process.c
  3. *
  4. * S390 version
  5. * Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
  6. * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  7. * Hartmut Penner (hp@de.ibm.com),
  8. * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
  9. *
  10. * Derived from "arch/i386/kernel/process.c"
  11. * Copyright (C) 1995, Linus Torvalds
  12. */
  13. /*
  14. * This file handles the architecture-dependent parts of process handling..
  15. */
  16. #include <linux/compiler.h>
  17. #include <linux/cpu.h>
  18. #include <linux/errno.h>
  19. #include <linux/sched.h>
  20. #include <linux/kernel.h>
  21. #include <linux/mm.h>
  22. #include <linux/smp.h>
  23. #include <linux/smp_lock.h>
  24. #include <linux/stddef.h>
  25. #include <linux/unistd.h>
  26. #include <linux/ptrace.h>
  27. #include <linux/slab.h>
  28. #include <linux/vmalloc.h>
  29. #include <linux/user.h>
  30. #include <linux/a.out.h>
  31. #include <linux/interrupt.h>
  32. #include <linux/delay.h>
  33. #include <linux/reboot.h>
  34. #include <linux/init.h>
  35. #include <linux/module.h>
  36. #include <linux/notifier.h>
  37. #include <asm/uaccess.h>
  38. #include <asm/pgtable.h>
  39. #include <asm/system.h>
  40. #include <asm/io.h>
  41. #include <asm/processor.h>
  42. #include <asm/irq.h>
  43. #include <asm/timer.h>
  44. asmlinkage void ret_from_fork(void) asm ("ret_from_fork");
  45. /*
  46. * Return saved PC of a blocked thread. used in kernel/sched.
  47. * resume in entry.S does not create a new stack frame, it
  48. * just stores the registers %r6-%r15 to the frame given by
  49. * schedule. We want to return the address of the caller of
  50. * schedule, so we have to walk the backchain one time to
  51. * find the frame schedule() store its return address.
  52. */
  53. unsigned long thread_saved_pc(struct task_struct *tsk)
  54. {
  55. struct stack_frame *sf, *low, *high;
  56. if (!tsk || !task_stack_page(tsk))
  57. return 0;
  58. low = task_stack_page(tsk);
  59. high = (struct stack_frame *) task_pt_regs(tsk);
  60. sf = (struct stack_frame *) (tsk->thread.ksp & PSW_ADDR_INSN);
  61. if (sf <= low || sf > high)
  62. return 0;
  63. sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
  64. if (sf <= low || sf > high)
  65. return 0;
  66. return sf->gprs[8];
  67. }
  68. /*
  69. * Need to know about CPUs going idle?
  70. */
  71. static ATOMIC_NOTIFIER_HEAD(idle_chain);
  72. int register_idle_notifier(struct notifier_block *nb)
  73. {
  74. return atomic_notifier_chain_register(&idle_chain, nb);
  75. }
  76. EXPORT_SYMBOL(register_idle_notifier);
  77. int unregister_idle_notifier(struct notifier_block *nb)
  78. {
  79. return atomic_notifier_chain_unregister(&idle_chain, nb);
  80. }
  81. EXPORT_SYMBOL(unregister_idle_notifier);
  82. void do_monitor_call(struct pt_regs *regs, long interruption_code)
  83. {
  84. /* disable monitor call class 0 */
  85. __ctl_clear_bit(8, 15);
  86. atomic_notifier_call_chain(&idle_chain, CPU_NOT_IDLE,
  87. (void *)(long) smp_processor_id());
  88. }
  89. extern void s390_handle_mcck(void);
  90. /*
  91. * The idle loop on a S390...
  92. */
  93. static void default_idle(void)
  94. {
  95. int cpu, rc;
  96. /* CPU is going idle. */
  97. cpu = smp_processor_id();
  98. local_irq_disable();
  99. if (need_resched()) {
  100. local_irq_enable();
  101. return;
  102. }
  103. rc = atomic_notifier_call_chain(&idle_chain,
  104. CPU_IDLE, (void *)(long) cpu);
  105. if (rc != NOTIFY_OK && rc != NOTIFY_DONE)
  106. BUG();
  107. if (rc != NOTIFY_OK) {
  108. local_irq_enable();
  109. return;
  110. }
  111. /* enable monitor call class 0 */
  112. __ctl_set_bit(8, 15);
  113. #ifdef CONFIG_HOTPLUG_CPU
  114. if (cpu_is_offline(cpu)) {
  115. preempt_enable_no_resched();
  116. cpu_die();
  117. }
  118. #endif
  119. local_mcck_disable();
  120. if (test_thread_flag(TIF_MCCK_PENDING)) {
  121. local_mcck_enable();
  122. local_irq_enable();
  123. s390_handle_mcck();
  124. return;
  125. }
  126. trace_hardirqs_on();
  127. /* Wait for external, I/O or machine check interrupt. */
  128. __load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
  129. PSW_MASK_IO | PSW_MASK_EXT);
  130. }
  131. void cpu_idle(void)
  132. {
  133. for (;;) {
  134. while (!need_resched())
  135. default_idle();
  136. preempt_enable_no_resched();
  137. schedule();
  138. preempt_disable();
  139. }
  140. }
  141. void show_regs(struct pt_regs *regs)
  142. {
  143. struct task_struct *tsk = current;
  144. printk("CPU: %d %s\n", task_thread_info(tsk)->cpu, print_tainted());
  145. printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
  146. current->comm, current->pid, (void *) tsk,
  147. (void *) tsk->thread.ksp);
  148. show_registers(regs);
  149. /* Show stack backtrace if pt_regs is from kernel mode */
  150. if (!(regs->psw.mask & PSW_MASK_PSTATE))
  151. show_trace(NULL, (unsigned long *) regs->gprs[15]);
  152. }
  153. extern void kernel_thread_starter(void);
  154. asm(
  155. ".align 4\n"
  156. "kernel_thread_starter:\n"
  157. " la 2,0(10)\n"
  158. " basr 14,9\n"
  159. " la 2,0\n"
  160. " br 11\n");
  161. int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
  162. {
  163. struct pt_regs regs;
  164. memset(&regs, 0, sizeof(regs));
  165. regs.psw.mask = psw_kernel_bits | PSW_MASK_IO | PSW_MASK_EXT;
  166. regs.psw.addr = (unsigned long) kernel_thread_starter | PSW_ADDR_AMODE;
  167. regs.gprs[9] = (unsigned long) fn;
  168. regs.gprs[10] = (unsigned long) arg;
  169. regs.gprs[11] = (unsigned long) do_exit;
  170. regs.orig_gpr2 = -1;
  171. /* Ok, create the new process.. */
  172. return do_fork(flags | CLONE_VM | CLONE_UNTRACED,
  173. 0, &regs, 0, NULL, NULL);
  174. }
  175. /*
  176. * Free current thread data structures etc..
  177. */
  178. void exit_thread(void)
  179. {
  180. }
  181. void flush_thread(void)
  182. {
  183. clear_used_math();
  184. clear_tsk_thread_flag(current, TIF_USEDFPU);
  185. }
  186. void release_thread(struct task_struct *dead_task)
  187. {
  188. }
  189. int copy_thread(int nr, unsigned long clone_flags, unsigned long new_stackp,
  190. unsigned long unused,
  191. struct task_struct * p, struct pt_regs * regs)
  192. {
  193. struct fake_frame
  194. {
  195. struct stack_frame sf;
  196. struct pt_regs childregs;
  197. } *frame;
  198. frame = container_of(task_pt_regs(p), struct fake_frame, childregs);
  199. p->thread.ksp = (unsigned long) frame;
  200. /* Store access registers to kernel stack of new process. */
  201. frame->childregs = *regs;
  202. frame->childregs.gprs[2] = 0; /* child returns 0 on fork. */
  203. frame->childregs.gprs[15] = new_stackp;
  204. frame->sf.back_chain = 0;
  205. /* new return point is ret_from_fork */
  206. frame->sf.gprs[8] = (unsigned long) ret_from_fork;
  207. /* fake return stack for resume(), don't go back to schedule */
  208. frame->sf.gprs[9] = (unsigned long) frame;
  209. /* Save access registers to new thread structure. */
  210. save_access_regs(&p->thread.acrs[0]);
  211. #ifndef CONFIG_64BIT
  212. /*
  213. * save fprs to current->thread.fp_regs to merge them with
  214. * the emulated registers and then copy the result to the child.
  215. */
  216. save_fp_regs(&current->thread.fp_regs);
  217. memcpy(&p->thread.fp_regs, &current->thread.fp_regs,
  218. sizeof(s390_fp_regs));
  219. p->thread.user_seg = __pa((unsigned long) p->mm->pgd) | _SEGMENT_TABLE;
  220. /* Set a new TLS ? */
  221. if (clone_flags & CLONE_SETTLS)
  222. p->thread.acrs[0] = regs->gprs[6];
  223. #else /* CONFIG_64BIT */
  224. /* Save the fpu registers to new thread structure. */
  225. save_fp_regs(&p->thread.fp_regs);
  226. p->thread.user_seg = __pa((unsigned long) p->mm->pgd) | _REGION_TABLE;
  227. /* Set a new TLS ? */
  228. if (clone_flags & CLONE_SETTLS) {
  229. if (test_thread_flag(TIF_31BIT)) {
  230. p->thread.acrs[0] = (unsigned int) regs->gprs[6];
  231. } else {
  232. p->thread.acrs[0] = (unsigned int)(regs->gprs[6] >> 32);
  233. p->thread.acrs[1] = (unsigned int) regs->gprs[6];
  234. }
  235. }
  236. #endif /* CONFIG_64BIT */
  237. /* start new process with ar4 pointing to the correct address space */
  238. p->thread.mm_segment = get_fs();
  239. /* Don't copy debug registers */
  240. memset(&p->thread.per_info,0,sizeof(p->thread.per_info));
  241. return 0;
  242. }
  243. asmlinkage long sys_fork(struct pt_regs regs)
  244. {
  245. return do_fork(SIGCHLD, regs.gprs[15], &regs, 0, NULL, NULL);
  246. }
  247. asmlinkage long sys_clone(struct pt_regs regs)
  248. {
  249. unsigned long clone_flags;
  250. unsigned long newsp;
  251. int __user *parent_tidptr, *child_tidptr;
  252. clone_flags = regs.gprs[3];
  253. newsp = regs.orig_gpr2;
  254. parent_tidptr = (int __user *) regs.gprs[4];
  255. child_tidptr = (int __user *) regs.gprs[5];
  256. if (!newsp)
  257. newsp = regs.gprs[15];
  258. return do_fork(clone_flags, newsp, &regs, 0,
  259. parent_tidptr, child_tidptr);
  260. }
  261. /*
  262. * This is trivial, and on the face of it looks like it
  263. * could equally well be done in user mode.
  264. *
  265. * Not so, for quite unobvious reasons - register pressure.
  266. * In user mode vfork() cannot have a stack frame, and if
  267. * done by calling the "clone()" system call directly, you
  268. * do not have enough call-clobbered registers to hold all
  269. * the information you need.
  270. */
  271. asmlinkage long sys_vfork(struct pt_regs regs)
  272. {
  273. return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
  274. regs.gprs[15], &regs, 0, NULL, NULL);
  275. }
  276. /*
  277. * sys_execve() executes a new program.
  278. */
  279. asmlinkage long sys_execve(struct pt_regs regs)
  280. {
  281. int error;
  282. char * filename;
  283. filename = getname((char __user *) regs.orig_gpr2);
  284. error = PTR_ERR(filename);
  285. if (IS_ERR(filename))
  286. goto out;
  287. error = do_execve(filename, (char __user * __user *) regs.gprs[3],
  288. (char __user * __user *) regs.gprs[4], &regs);
  289. if (error == 0) {
  290. task_lock(current);
  291. current->ptrace &= ~PT_DTRACE;
  292. task_unlock(current);
  293. current->thread.fp_regs.fpc = 0;
  294. if (MACHINE_HAS_IEEE)
  295. asm volatile("sfpc %0,%0" : : "d" (0));
  296. }
  297. putname(filename);
  298. out:
  299. return error;
  300. }
  301. /*
  302. * fill in the FPU structure for a core dump.
  303. */
  304. int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
  305. {
  306. #ifndef CONFIG_64BIT
  307. /*
  308. * save fprs to current->thread.fp_regs to merge them with
  309. * the emulated registers and then copy the result to the dump.
  310. */
  311. save_fp_regs(&current->thread.fp_regs);
  312. memcpy(fpregs, &current->thread.fp_regs, sizeof(s390_fp_regs));
  313. #else /* CONFIG_64BIT */
  314. save_fp_regs(fpregs);
  315. #endif /* CONFIG_64BIT */
  316. return 1;
  317. }
  318. unsigned long get_wchan(struct task_struct *p)
  319. {
  320. struct stack_frame *sf, *low, *high;
  321. unsigned long return_address;
  322. int count;
  323. if (!p || p == current || p->state == TASK_RUNNING || !task_stack_page(p))
  324. return 0;
  325. low = task_stack_page(p);
  326. high = (struct stack_frame *) task_pt_regs(p);
  327. sf = (struct stack_frame *) (p->thread.ksp & PSW_ADDR_INSN);
  328. if (sf <= low || sf > high)
  329. return 0;
  330. for (count = 0; count < 16; count++) {
  331. sf = (struct stack_frame *) (sf->back_chain & PSW_ADDR_INSN);
  332. if (sf <= low || sf > high)
  333. return 0;
  334. return_address = sf->gprs[8] & PSW_ADDR_INSN;
  335. if (!in_sched_functions(return_address))
  336. return return_address;
  337. }
  338. return 0;
  339. }