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/cpu.h> |
9 | #include <linux/sched.h> |
10 | #include <linux/sched/debug.h> |
11 | #include <linux/sched/task.h> |
12 | #include <linux/sched/task_stack.h> |
13 | #include <linux/types.h> |
14 | #include <linux/module.h> |
15 | #include <linux/tick.h> |
16 | #include <linux/uaccess.h> |
17 | #include <linux/slab.h> |
18 | #include <linux/resume_user_mode.h> |
19 | |
20 | /* |
21 | * Program thread launch. Often defined as a macro in processor.h, |
22 | * but we're shooting for a small footprint and it's not an inner-loop |
23 | * performance-critical operation. |
24 | * |
25 | * The Hexagon ABI specifies that R28 is zero'ed before program launch, |
26 | * so that gets automatically done here. If we ever stop doing that here, |
27 | * we'll probably want to define the ELF_PLAT_INIT macro. |
28 | */ |
29 | void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp) |
30 | { |
31 | /* We want to zero all data-containing registers. Is this overkill? */ |
32 | memset(regs, 0, sizeof(*regs)); |
33 | /* We might want to also zero all Processor registers here */ |
34 | pt_set_usermode(regs); |
35 | pt_set_elr(regs, pc); |
36 | pt_set_rte_sp(regs, sp); |
37 | } |
38 | |
39 | /* |
40 | * Spin, or better still, do a hardware or VM wait instruction |
41 | * If hardware or VM offer wait termination even though interrupts |
42 | * are disabled. |
43 | */ |
44 | void arch_cpu_idle(void) |
45 | { |
46 | __vmwait(); |
47 | /* interrupts wake us up, but irqs are still disabled */ |
48 | } |
49 | |
50 | /* |
51 | * Copy architecture-specific thread state |
52 | */ |
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 | * Some archs flush debug and FPU info here |
117 | */ |
118 | void flush_thread(void) |
119 | { |
120 | } |
121 | |
122 | /* |
123 | * The "wait channel" terminology is archaic, but what we want |
124 | * is an identification of the point at which the scheduler |
125 | * was invoked by a blocked thread. |
126 | */ |
127 | unsigned long __get_wchan(struct task_struct *p) |
128 | { |
129 | unsigned long fp, pc; |
130 | unsigned long stack_page; |
131 | int count = 0; |
132 | |
133 | stack_page = (unsigned long)task_stack_page(task: p); |
134 | fp = ((struct hexagon_switch_stack *)p->thread.switch_sp)->fp; |
135 | do { |
136 | if (fp < (stack_page + sizeof(struct thread_info)) || |
137 | fp >= (THREAD_SIZE - 8 + stack_page)) |
138 | return 0; |
139 | pc = ((unsigned long *)fp)[1]; |
140 | if (!in_sched_functions(addr: pc)) |
141 | return pc; |
142 | fp = *(unsigned long *) fp; |
143 | } while (count++ < 16); |
144 | |
145 | return 0; |
146 | } |
147 | |
148 | /* |
149 | * Called on the exit path of event entry; see vm_entry.S |
150 | * |
151 | * Interrupts will already be disabled. |
152 | * |
153 | * Returns 0 if there's no need to re-check for more work. |
154 | */ |
155 | |
156 | int do_work_pending(struct pt_regs *regs, u32 thread_info_flags); |
157 | int do_work_pending(struct pt_regs *regs, u32 thread_info_flags) |
158 | { |
159 | if (!(thread_info_flags & _TIF_WORK_MASK)) { |
160 | return 0; |
161 | } /* shortcut -- no work to be done */ |
162 | |
163 | local_irq_enable(); |
164 | |
165 | if (thread_info_flags & _TIF_NEED_RESCHED) { |
166 | schedule(); |
167 | return 1; |
168 | } |
169 | |
170 | if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) { |
171 | do_signal(regs); |
172 | return 1; |
173 | } |
174 | |
175 | if (thread_info_flags & _TIF_NOTIFY_RESUME) { |
176 | resume_user_mode_work(regs); |
177 | return 1; |
178 | } |
179 | |
180 | /* Should not even reach here */ |
181 | panic(fmt: "%s: bad thread_info flags 0x%08x\n" , __func__, |
182 | thread_info_flags); |
183 | } |
184 | |