process.c 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369
  1. /* process.c: FRV specific parts of process handling
  2. *
  3. * Copyright (C) 2003-5 Red Hat, Inc. All Rights Reserved.
  4. * Written by David Howells (dhowells@redhat.com)
  5. * - Derived from arch/m68k/kernel/process.c
  6. *
  7. * This program is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU General Public License
  9. * as published by the Free Software Foundation; either version
  10. * 2 of the License, or (at your option) any later version.
  11. */
  12. #include <linux/errno.h>
  13. #include <linux/sched.h>
  14. #include <linux/kernel.h>
  15. #include <linux/mm.h>
  16. #include <linux/smp.h>
  17. #include <linux/smp_lock.h>
  18. #include <linux/stddef.h>
  19. #include <linux/unistd.h>
  20. #include <linux/ptrace.h>
  21. #include <linux/slab.h>
  22. #include <linux/user.h>
  23. #include <linux/elf.h>
  24. #include <linux/reboot.h>
  25. #include <linux/interrupt.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/system.h>
  28. #include <asm/setup.h>
  29. #include <asm/pgtable.h>
  30. #include <asm/gdb-stub.h>
  31. #include <asm/mb-regs.h>
  32. #include "local.h"
  33. asmlinkage void ret_from_fork(void);
  34. #include <asm/pgalloc.h>
  35. struct task_struct *alloc_task_struct(void)
  36. {
  37. struct task_struct *p = kmalloc(THREAD_SIZE, GFP_KERNEL);
  38. if (p)
  39. atomic_set((atomic_t *)(p+1), 1);
  40. return p;
  41. }
  42. void free_task_struct(struct task_struct *p)
  43. {
  44. if (atomic_dec_and_test((atomic_t *)(p+1)))
  45. kfree(p);
  46. }
  47. static void core_sleep_idle(void)
  48. {
  49. #ifdef LED_DEBUG_SLEEP
  50. /* Show that we're sleeping... */
  51. __set_LEDS(0x55aa);
  52. #endif
  53. frv_cpu_core_sleep();
  54. #ifdef LED_DEBUG_SLEEP
  55. /* ... and that we woke up */
  56. __set_LEDS(0);
  57. #endif
  58. mb();
  59. }
  60. void (*idle)(void) = core_sleep_idle;
  61. /*
  62. * The idle thread. There's no useful work to be
  63. * done, so just try to conserve power and have a
  64. * low exit latency (ie sit in a loop waiting for
  65. * somebody to say that they'd like to reschedule)
  66. */
  67. void cpu_idle(void)
  68. {
  69. int cpu = smp_processor_id();
  70. /* endless idle loop with no priority at all */
  71. while (1) {
  72. while (!need_resched()) {
  73. irq_stat[cpu].idle_timestamp = jiffies;
  74. if (!frv_dma_inprogress && idle)
  75. idle();
  76. }
  77. preempt_enable_no_resched();
  78. schedule();
  79. preempt_disable();
  80. }
  81. }
  82. void machine_restart(char * __unused)
  83. {
  84. unsigned long reset_addr;
  85. #ifdef CONFIG_GDBSTUB
  86. gdbstub_exit(0);
  87. #endif
  88. if (PSR_IMPLE(__get_PSR()) == PSR_IMPLE_FR551)
  89. reset_addr = 0xfefff500;
  90. else
  91. reset_addr = 0xfeff0500;
  92. /* Software reset. */
  93. asm volatile(" dcef @(gr0,gr0),1 ! membar !"
  94. " sti %1,@(%0,0) !"
  95. " nop ! nop ! nop ! nop ! nop ! "
  96. " nop ! nop ! nop ! nop ! nop ! "
  97. " nop ! nop ! nop ! nop ! nop ! "
  98. " nop ! nop ! nop ! nop ! nop ! "
  99. : : "r" (reset_addr), "r" (1) );
  100. for (;;)
  101. ;
  102. }
  103. void machine_halt(void)
  104. {
  105. #ifdef CONFIG_GDBSTUB
  106. gdbstub_exit(0);
  107. #endif
  108. for (;;);
  109. }
  110. void machine_power_off(void)
  111. {
  112. #ifdef CONFIG_GDBSTUB
  113. gdbstub_exit(0);
  114. #endif
  115. for (;;);
  116. }
  117. void flush_thread(void)
  118. {
  119. #if 0 //ndef NO_FPU
  120. unsigned long zero = 0;
  121. #endif
  122. set_fs(USER_DS);
  123. }
  124. inline unsigned long user_stack(const struct pt_regs *regs)
  125. {
  126. while (regs->next_frame)
  127. regs = regs->next_frame;
  128. return user_mode(regs) ? regs->sp : 0;
  129. }
  130. asmlinkage int sys_fork(void)
  131. {
  132. #ifndef CONFIG_MMU
  133. /* fork almost works, enough to trick you into looking elsewhere:-( */
  134. return -EINVAL;
  135. #else
  136. return do_fork(SIGCHLD, user_stack(__frame), __frame, 0, NULL, NULL);
  137. #endif
  138. }
  139. asmlinkage int sys_vfork(void)
  140. {
  141. return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, user_stack(__frame), __frame, 0,
  142. NULL, NULL);
  143. }
  144. /*****************************************************************************/
  145. /*
  146. * clone a process
  147. * - tlsptr is retrieved by copy_thread()
  148. */
  149. asmlinkage int sys_clone(unsigned long clone_flags, unsigned long newsp,
  150. int __user *parent_tidptr, int __user *child_tidptr,
  151. int __user *tlsptr)
  152. {
  153. if (!newsp)
  154. newsp = user_stack(__frame);
  155. return do_fork(clone_flags, newsp, __frame, 0, parent_tidptr, child_tidptr);
  156. } /* end sys_clone() */
  157. /*****************************************************************************/
  158. /*
  159. * This gets called before we allocate a new thread and copy
  160. * the current task into it.
  161. */
  162. void prepare_to_copy(struct task_struct *tsk)
  163. {
  164. //unlazy_fpu(tsk);
  165. } /* end prepare_to_copy() */
  166. /*****************************************************************************/
  167. /*
  168. * set up the kernel stack and exception frames for a new process
  169. */
  170. int copy_thread(int nr, unsigned long clone_flags,
  171. unsigned long usp, unsigned long topstk,
  172. struct task_struct *p, struct pt_regs *regs)
  173. {
  174. struct pt_regs *childregs0, *childregs, *regs0;
  175. regs0 = __kernel_frame0_ptr;
  176. childregs0 = (struct pt_regs *)
  177. (task_stack_page(p) + THREAD_SIZE - USER_CONTEXT_SIZE);
  178. childregs = childregs0;
  179. /* set up the userspace frame (the only place that the USP is stored) */
  180. *childregs0 = *regs0;
  181. childregs0->gr8 = 0;
  182. childregs0->sp = usp;
  183. childregs0->next_frame = NULL;
  184. /* set up the return kernel frame if called from kernel_thread() */
  185. if (regs != regs0) {
  186. childregs--;
  187. *childregs = *regs;
  188. childregs->sp = (unsigned long) childregs0;
  189. childregs->next_frame = childregs0;
  190. childregs->gr15 = (unsigned long) task_thread_info(p);
  191. childregs->gr29 = (unsigned long) p;
  192. }
  193. p->set_child_tid = p->clear_child_tid = NULL;
  194. p->thread.frame = childregs;
  195. p->thread.curr = p;
  196. p->thread.sp = (unsigned long) childregs;
  197. p->thread.fp = 0;
  198. p->thread.lr = 0;
  199. p->thread.pc = (unsigned long) ret_from_fork;
  200. p->thread.frame0 = childregs0;
  201. /* the new TLS pointer is passed in as arg #5 to sys_clone() */
  202. if (clone_flags & CLONE_SETTLS)
  203. childregs->gr29 = childregs->gr12;
  204. save_user_regs(p->thread.user);
  205. return 0;
  206. } /* end copy_thread() */
  207. /*
  208. * sys_execve() executes a new program.
  209. */
  210. asmlinkage int sys_execve(char __user *name, char __user * __user *argv, char __user * __user *envp)
  211. {
  212. int error;
  213. char * filename;
  214. lock_kernel();
  215. filename = getname(name);
  216. error = PTR_ERR(filename);
  217. if (IS_ERR(filename))
  218. goto out;
  219. error = do_execve(filename, argv, envp, __frame);
  220. putname(filename);
  221. out:
  222. unlock_kernel();
  223. return error;
  224. }
  225. unsigned long get_wchan(struct task_struct *p)
  226. {
  227. struct pt_regs *regs0;
  228. unsigned long fp, pc;
  229. unsigned long stack_limit;
  230. int count = 0;
  231. if (!p || p == current || p->state == TASK_RUNNING)
  232. return 0;
  233. stack_limit = (unsigned long) (p + 1);
  234. fp = p->thread.fp;
  235. regs0 = p->thread.frame0;
  236. do {
  237. if (fp < stack_limit || fp >= (unsigned long) regs0 || fp & 3)
  238. return 0;
  239. pc = ((unsigned long *) fp)[2];
  240. /* FIXME: This depends on the order of these functions. */
  241. if (!in_sched_functions(pc))
  242. return pc;
  243. fp = *(unsigned long *) fp;
  244. } while (count++ < 16);
  245. return 0;
  246. }
  247. unsigned long thread_saved_pc(struct task_struct *tsk)
  248. {
  249. /* Check whether the thread is blocked in resume() */
  250. if (in_sched_functions(tsk->thread.pc))
  251. return ((unsigned long *)tsk->thread.fp)[2];
  252. else
  253. return tsk->thread.pc;
  254. }
  255. int elf_check_arch(const struct elf32_hdr *hdr)
  256. {
  257. unsigned long hsr0 = __get_HSR(0);
  258. unsigned long psr = __get_PSR();
  259. if (hdr->e_machine != EM_FRV)
  260. return 0;
  261. switch (hdr->e_flags & EF_FRV_GPR_MASK) {
  262. case EF_FRV_GPR64:
  263. if ((hsr0 & HSR0_GRN) == HSR0_GRN_32)
  264. return 0;
  265. case EF_FRV_GPR32:
  266. case 0:
  267. break;
  268. default:
  269. return 0;
  270. }
  271. switch (hdr->e_flags & EF_FRV_FPR_MASK) {
  272. case EF_FRV_FPR64:
  273. if ((hsr0 & HSR0_FRN) == HSR0_FRN_32)
  274. return 0;
  275. case EF_FRV_FPR32:
  276. case EF_FRV_FPR_NONE:
  277. case 0:
  278. break;
  279. default:
  280. return 0;
  281. }
  282. if ((hdr->e_flags & EF_FRV_MULADD) == EF_FRV_MULADD)
  283. if (PSR_IMPLE(psr) != PSR_IMPLE_FR405 &&
  284. PSR_IMPLE(psr) != PSR_IMPLE_FR451)
  285. return 0;
  286. switch (hdr->e_flags & EF_FRV_CPU_MASK) {
  287. case EF_FRV_CPU_GENERIC:
  288. break;
  289. case EF_FRV_CPU_FR300:
  290. case EF_FRV_CPU_SIMPLE:
  291. case EF_FRV_CPU_TOMCAT:
  292. default:
  293. return 0;
  294. case EF_FRV_CPU_FR400:
  295. if (PSR_IMPLE(psr) != PSR_IMPLE_FR401 &&
  296. PSR_IMPLE(psr) != PSR_IMPLE_FR405 &&
  297. PSR_IMPLE(psr) != PSR_IMPLE_FR451 &&
  298. PSR_IMPLE(psr) != PSR_IMPLE_FR551)
  299. return 0;
  300. break;
  301. case EF_FRV_CPU_FR450:
  302. if (PSR_IMPLE(psr) != PSR_IMPLE_FR451)
  303. return 0;
  304. break;
  305. case EF_FRV_CPU_FR500:
  306. if (PSR_IMPLE(psr) != PSR_IMPLE_FR501)
  307. return 0;
  308. break;
  309. case EF_FRV_CPU_FR550:
  310. if (PSR_IMPLE(psr) != PSR_IMPLE_FR551)
  311. return 0;
  312. break;
  313. }
  314. return 1;
  315. }