1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Process creation support for Hexagon
4 *
5 * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
6 */
7
8 #include <linux/sched.h>
9 #include <linux/sched/debug.h>
10 #include <linux/sched/task.h>
11 #include <linux/sched/task_stack.h>
12 #include <linux/types.h>
13 #include <linux/module.h>
14 #include <linux/tick.h>
15 #include <linux/uaccess.h>
16 #include <linux/slab.h>
17 #include <linux/resume_user_mode.h>
18
19 /*
20 * Program thread launch. Often defined as a macro in processor.h,
21 * but we're shooting for a small footprint and it's not an inner-loop
22 * performance-critical operation.
23 *
24 * The Hexagon ABI specifies that R28 is zero'ed before program launch,
25 * so that gets automatically done here. If we ever stop doing that here,
26 * we'll probably want to define the ELF_PLAT_INIT macro.
27 */
start_thread(struct pt_regs * regs,unsigned long pc,unsigned long sp)28 void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp)
29 {
30 /* We want to zero all data-containing registers. Is this overkill? */
31 memset(regs, 0, sizeof(*regs));
32 /* We might want to also zero all Processor registers here */
33 pt_set_usermode(regs);
34 pt_set_elr(regs, pc);
35 pt_set_rte_sp(regs, sp);
36 }
37
38 /*
39 * Spin, or better still, do a hardware or VM wait instruction
40 * If hardware or VM offer wait termination even though interrupts
41 * are disabled.
42 */
arch_cpu_idle(void)43 void arch_cpu_idle(void)
44 {
45 __vmwait();
46 /* interrupts wake us up, but irqs are still disabled */
47 raw_local_irq_enable();
48 }
49
50 /*
51 * Copy architecture-specific thread state
52 */
copy_thread(struct task_struct * p,const struct kernel_clone_args * args)53 int copy_thread(struct task_struct *p, const struct kernel_clone_args *args)
54 {
55 unsigned long clone_flags = args->flags;
56 unsigned long usp = args->stack;
57 unsigned long tls = args->tls;
58 struct thread_info *ti = task_thread_info(p);
59 struct hexagon_switch_stack *ss;
60 struct pt_regs *childregs;
61 asmlinkage void ret_from_fork(void);
62
63 childregs = (struct pt_regs *) (((unsigned long) ti + THREAD_SIZE) -
64 sizeof(*childregs));
65
66 ti->regs = childregs;
67
68 /*
69 * Establish kernel stack pointer and initial PC for new thread
70 * Note that unlike the usual situation, we do not copy the
71 * parent's callee-saved here; those are in pt_regs and whatever
72 * we leave here will be overridden on return to userland.
73 */
74 ss = (struct hexagon_switch_stack *) ((unsigned long) childregs -
75 sizeof(*ss));
76 ss->lr = (unsigned long)ret_from_fork;
77 p->thread.switch_sp = ss;
78 if (unlikely(args->fn)) {
79 memset(childregs, 0, sizeof(struct pt_regs));
80 /* r24 <- fn, r25 <- arg */
81 ss->r24 = (unsigned long)args->fn;
82 ss->r25 = (unsigned long)args->fn_arg;
83 pt_set_kmode(childregs);
84 return 0;
85 }
86 memcpy(childregs, current_pt_regs(), sizeof(*childregs));
87 ss->r2524 = 0;
88
89 if (usp)
90 pt_set_rte_sp(childregs, usp);
91
92 /* Child sees zero return value */
93 childregs->r00 = 0;
94
95 /*
96 * The clone syscall has the C signature:
97 * int [r0] clone(int flags [r0],
98 * void *child_frame [r1],
99 * void *parent_tid [r2],
100 * void *child_tid [r3],
101 * void *thread_control_block [r4]);
102 * ugp is used to provide TLS support.
103 */
104 if (clone_flags & CLONE_SETTLS)
105 childregs->ugp = tls;
106
107 /*
108 * Parent sees new pid -- not necessary, not even possible at
109 * this point in the fork process
110 */
111
112 return 0;
113 }
114
115 /*
116 * Release any architecture-specific resources locked by thread
117 */
release_thread(struct task_struct * dead_task)118 void release_thread(struct task_struct *dead_task)
119 {
120 }
121
122 /*
123 * Some archs flush debug and FPU info here
124 */
flush_thread(void)125 void flush_thread(void)
126 {
127 }
128
129 /*
130 * The "wait channel" terminology is archaic, but what we want
131 * is an identification of the point at which the scheduler
132 * was invoked by a blocked thread.
133 */
__get_wchan(struct task_struct * p)134 unsigned long __get_wchan(struct task_struct *p)
135 {
136 unsigned long fp, pc;
137 unsigned long stack_page;
138 int count = 0;
139
140 stack_page = (unsigned long)task_stack_page(p);
141 fp = ((struct hexagon_switch_stack *)p->thread.switch_sp)->fp;
142 do {
143 if (fp < (stack_page + sizeof(struct thread_info)) ||
144 fp >= (THREAD_SIZE - 8 + stack_page))
145 return 0;
146 pc = ((unsigned long *)fp)[1];
147 if (!in_sched_functions(pc))
148 return pc;
149 fp = *(unsigned long *) fp;
150 } while (count++ < 16);
151
152 return 0;
153 }
154
155 /*
156 * Called on the exit path of event entry; see vm_entry.S
157 *
158 * Interrupts will already be disabled.
159 *
160 * Returns 0 if there's no need to re-check for more work.
161 */
162
do_work_pending(struct pt_regs * regs,u32 thread_info_flags)163 int do_work_pending(struct pt_regs *regs, u32 thread_info_flags)
164 {
165 if (!(thread_info_flags & _TIF_WORK_MASK)) {
166 return 0;
167 } /* shortcut -- no work to be done */
168
169 local_irq_enable();
170
171 if (thread_info_flags & _TIF_NEED_RESCHED) {
172 schedule();
173 return 1;
174 }
175
176 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) {
177 do_signal(regs);
178 return 1;
179 }
180
181 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
182 resume_user_mode_work(regs);
183 return 1;
184 }
185
186 /* Should not even reach here */
187 panic("%s: bad thread_info flags 0x%08x\n", __func__,
188 thread_info_flags);
189 }
190