process.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2009 Sunplus Core Technology Co., Ltd.
  4. * Chen Liqin <liqin.chen@sunplusct.com>
  5. * Lennox Wu <lennox.wu@sunplusct.com>
  6. * Copyright (C) 2012 Regents of the University of California
  7. * Copyright (C) 2017 SiFive
  8. */
  9. #include <linux/cpu.h>
  10. #include <linux/kernel.h>
  11. #include <linux/sched.h>
  12. #include <linux/sched/task_stack.h>
  13. #include <linux/tick.h>
  14. #include <linux/ptrace.h>
  15. #include <linux/uaccess.h>
  16. #include <uapi/linux/elf.h>
  17. #include <asm/unistd.h>
  18. #include <asm/processor.h>
  19. #include <asm/compat.h>
  20. #include <asm/csr.h>
  21. #include <asm/string.h>
  22. #include <asm/switch_to.h>
  23. #include <asm/thread_info.h>
  24. register unsigned long gp_in_global __asm__("gp");
  25. #ifdef CONFIG_STACKPROTECTOR
  26. #include <linux/stackprotector.h>
  27. unsigned long __stack_chk_guard __read_mostly;
  28. EXPORT_SYMBOL(__stack_chk_guard);
  29. #endif
  30. extern asmlinkage void ret_from_fork(void);
  31. extern asmlinkage void ret_from_kernel_thread(void);
  32. void arch_cpu_idle(void)
  33. {
  34. wait_for_interrupt();
  35. raw_local_irq_enable();
  36. }
  37. void show_regs(struct pt_regs *regs)
  38. {
  39. show_regs_print_info(KERN_DEFAULT);
  40. if (!user_mode(regs)) {
  41. pr_cont("epc : %pS\n", (void *)regs->epc);
  42. pr_cont(" ra : %pS\n", (void *)regs->ra);
  43. }
  44. pr_cont("epc: " REG_FMT " ra : " REG_FMT " sp : " REG_FMT "\n",
  45. regs->epc, regs->ra, regs->sp);
  46. pr_cont(" gp : " REG_FMT " tp : " REG_FMT " t0 : " REG_FMT "\n",
  47. regs->gp, regs->tp, regs->t0);
  48. pr_cont(" t1 : " REG_FMT " t2 : " REG_FMT " s0 : " REG_FMT "\n",
  49. regs->t1, regs->t2, regs->s0);
  50. pr_cont(" s1 : " REG_FMT " a0 : " REG_FMT " a1 : " REG_FMT "\n",
  51. regs->s1, regs->a0, regs->a1);
  52. pr_cont(" a2 : " REG_FMT " a3 : " REG_FMT " a4 : " REG_FMT "\n",
  53. regs->a2, regs->a3, regs->a4);
  54. pr_cont(" a5 : " REG_FMT " a6 : " REG_FMT " a7 : " REG_FMT "\n",
  55. regs->a5, regs->a6, regs->a7);
  56. pr_cont(" s2 : " REG_FMT " s3 : " REG_FMT " s4 : " REG_FMT "\n",
  57. regs->s2, regs->s3, regs->s4);
  58. pr_cont(" s5 : " REG_FMT " s6 : " REG_FMT " s7 : " REG_FMT "\n",
  59. regs->s5, regs->s6, regs->s7);
  60. pr_cont(" s8 : " REG_FMT " s9 : " REG_FMT " s10: " REG_FMT "\n",
  61. regs->s8, regs->s9, regs->s10);
  62. pr_cont(" s11: " REG_FMT " t3 : " REG_FMT " t4 : " REG_FMT "\n",
  63. regs->s11, regs->t3, regs->t4);
  64. pr_cont(" t5 : " REG_FMT " t6 : " REG_FMT "\n",
  65. regs->t5, regs->t6);
  66. pr_cont("status: " REG_FMT " badaddr: " REG_FMT " cause: " REG_FMT "\n",
  67. regs->status, regs->badaddr, regs->cause);
  68. }
  69. void start_thread(struct pt_regs *regs, unsigned long pc,
  70. unsigned long sp)
  71. {
  72. regs->status = SR_PIE;
  73. if (has_fpu) {
  74. regs->status |= SR_FS_INITIAL;
  75. /*
  76. * Restore the initial value to the FP register
  77. * before starting the user program.
  78. */
  79. fstate_restore(current, regs);
  80. }
  81. if (has_vector) {
  82. regs->status |= SR_VS_INITIAL;
  83. vstate_restore(current, regs);
  84. }
  85. regs->epc = pc;
  86. regs->sp = sp;
  87. #ifdef CONFIG_COMPAT
  88. regs->status &= ~SR_UXL;
  89. if (is_compat_task())
  90. regs->status |= SR_UXL_32;
  91. else
  92. regs->status |= SR_UXL_64;
  93. #endif
  94. }
  95. void flush_thread(void)
  96. {
  97. #ifdef CONFIG_FPU
  98. /*
  99. * Reset FPU state and context
  100. * frm: round to nearest, ties to even (IEEE default)
  101. * fflags: accrued exceptions cleared
  102. */
  103. fstate_off(current, task_pt_regs(current));
  104. memset(&current->thread.fstate, 0, sizeof(current->thread.fstate));
  105. #endif
  106. }
  107. int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
  108. {
  109. fstate_save(src, task_pt_regs(src));
  110. *dst = *src;
  111. return 0;
  112. }
  113. int copy_thread(unsigned long clone_flags, unsigned long usp, unsigned long arg,
  114. struct task_struct *p, unsigned long tls)
  115. {
  116. struct pt_regs *childregs = task_pt_regs(p);
  117. /* p->thread holds context to be restored by __switch_to() */
  118. if (unlikely(p->flags & PF_KTHREAD)) {
  119. /* Kernel thread */
  120. memset(childregs, 0, sizeof(struct pt_regs));
  121. childregs->gp = gp_in_global;
  122. /* Supervisor/Machine, irqs on: */
  123. childregs->status = SR_PP | SR_PIE;
  124. p->thread.ra = (unsigned long)ret_from_kernel_thread;
  125. p->thread.s[0] = usp; /* fn */
  126. p->thread.s[1] = arg;
  127. } else {
  128. *childregs = *(current_pt_regs());
  129. if (usp) /* User fork */
  130. childregs->sp = usp;
  131. if (clone_flags & CLONE_SETTLS)
  132. childregs->tp = tls;
  133. childregs->a0 = 0; /* Return value of fork() */
  134. p->thread.ra = (unsigned long)ret_from_fork;
  135. }
  136. p->thread.sp = (unsigned long)childregs; /* kernel sp */
  137. return 0;
  138. }