]>
Commit | Line | Data |
---|---|---|
08dbd0f8 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
4b30f965 RK |
2 | /* |
3 | * Process creation support for Hexagon | |
4 | * | |
e1858b2a | 5 | * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved. |
4b30f965 RK |
6 | */ |
7 | ||
8 | #include <linux/sched.h> | |
b17b0153 | 9 | #include <linux/sched/debug.h> |
29930025 | 10 | #include <linux/sched/task.h> |
68db0cf1 | 11 | #include <linux/sched/task_stack.h> |
4b30f965 RK |
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> | |
a11e67c2 | 17 | #include <linux/tracehook.h> |
4b30f965 | 18 | |
4b30f965 RK |
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 | */ | |
28 | void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp) | |
29 | { | |
4b30f965 RK |
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 | */ | |
4e0fcc56 | 43 | void arch_cpu_idle(void) |
4b30f965 RK |
44 | { |
45 | __vmwait(); | |
4e0fcc56 TG |
46 | /* interrupts wake us up, but irqs are still disabled */ |
47 | local_irq_enable(); | |
4b30f965 RK |
48 | } |
49 | ||
4b30f965 RK |
50 | /* |
51 | * Copy architecture-specific thread state | |
52 | */ | |
714acdbd CB |
53 | int copy_thread(unsigned long clone_flags, unsigned long usp, unsigned long arg, |
54 | struct task_struct *p, unsigned long tls) | |
4b30f965 RK |
55 | { |
56 | struct thread_info *ti = task_thread_info(p); | |
57 | struct hexagon_switch_stack *ss; | |
58 | struct pt_regs *childregs; | |
59 | asmlinkage void ret_from_fork(void); | |
60 | ||
61 | childregs = (struct pt_regs *) (((unsigned long) ti + THREAD_SIZE) - | |
62 | sizeof(*childregs)); | |
63 | ||
4b30f965 RK |
64 | ti->regs = childregs; |
65 | ||
66 | /* | |
67 | * Establish kernel stack pointer and initial PC for new thread | |
99521855 AV |
68 | * Note that unlike the usual situation, we do not copy the |
69 | * parent's callee-saved here; those are in pt_regs and whatever | |
70 | * we leave here will be overridden on return to userland. | |
4b30f965 RK |
71 | */ |
72 | ss = (struct hexagon_switch_stack *) ((unsigned long) childregs - | |
73 | sizeof(*ss)); | |
74 | ss->lr = (unsigned long)ret_from_fork; | |
75 | p->thread.switch_sp = ss; | |
99521855 AV |
76 | if (unlikely(p->flags & PF_KTHREAD)) { |
77 | memset(childregs, 0, sizeof(struct pt_regs)); | |
78 | /* r24 <- fn, r25 <- arg */ | |
0d3ab450 RK |
79 | ss->r24 = usp; |
80 | ss->r25 = arg; | |
99521855 AV |
81 | pt_set_kmode(childregs); |
82 | return 0; | |
4b30f965 | 83 | } |
f01aceac | 84 | memcpy(childregs, current_pt_regs(), sizeof(*childregs)); |
99521855 AV |
85 | ss->r2524 = 0; |
86 | ||
f01aceac AV |
87 | if (usp) |
88 | pt_set_rte_sp(childregs, usp); | |
99521855 AV |
89 | |
90 | /* Child sees zero return value */ | |
91 | childregs->r00 = 0; | |
92 | ||
93 | /* | |
94 | * The clone syscall has the C signature: | |
95 | * int [r0] clone(int flags [r0], | |
96 | * void *child_frame [r1], | |
97 | * void *parent_tid [r2], | |
98 | * void *child_tid [r3], | |
99 | * void *thread_control_block [r4]); | |
100 | * ugp is used to provide TLS support. | |
101 | */ | |
102 | if (clone_flags & CLONE_SETTLS) | |
643d48b8 | 103 | childregs->ugp = tls; |
4b30f965 RK |
104 | |
105 | /* | |
99521855 AV |
106 | * Parent sees new pid -- not necessary, not even possible at |
107 | * this point in the fork process | |
108 | * Might also want to set things like ti->addr_limit | |
4b30f965 | 109 | */ |
4b30f965 RK |
110 | |
111 | return 0; | |
112 | } | |
113 | ||
114 | /* | |
115 | * Release any architecture-specific resources locked by thread | |
116 | */ | |
117 | void release_thread(struct task_struct *dead_task) | |
118 | { | |
119 | } | |
120 | ||
4b30f965 RK |
121 | /* |
122 | * Some archs flush debug and FPU info here | |
123 | */ | |
124 | void flush_thread(void) | |
125 | { | |
126 | } | |
127 | ||
128 | /* | |
129 | * The "wait channel" terminology is archaic, but what we want | |
130 | * is an identification of the point at which the scheduler | |
131 | * was invoked by a blocked thread. | |
132 | */ | |
133 | unsigned long get_wchan(struct task_struct *p) | |
134 | { | |
135 | unsigned long fp, pc; | |
136 | unsigned long stack_page; | |
137 | int count = 0; | |
138 | if (!p || p == current || p->state == TASK_RUNNING) | |
139 | return 0; | |
140 | ||
141 | stack_page = (unsigned long)task_stack_page(p); | |
142 | fp = ((struct hexagon_switch_stack *)p->thread.switch_sp)->fp; | |
143 | do { | |
144 | if (fp < (stack_page + sizeof(struct thread_info)) || | |
145 | fp >= (THREAD_SIZE - 8 + stack_page)) | |
146 | return 0; | |
147 | pc = ((unsigned long *)fp)[1]; | |
148 | if (!in_sched_functions(pc)) | |
149 | return pc; | |
150 | fp = *(unsigned long *) fp; | |
151 | } while (count++ < 16); | |
152 | ||
153 | return 0; | |
154 | } | |
155 | ||
a11e67c2 RK |
156 | /* |
157 | * Called on the exit path of event entry; see vm_entry.S | |
158 | * | |
159 | * Interrupts will already be disabled. | |
160 | * | |
161 | * Returns 0 if there's no need to re-check for more work. | |
162 | */ | |
163 | ||
164 | int do_work_pending(struct pt_regs *regs, u32 thread_info_flags) | |
165 | { | |
f8722a4d | 166 | if (!(thread_info_flags & _TIF_WORK_MASK)) { |
a11e67c2 RK |
167 | return 0; |
168 | } /* shortcut -- no work to be done */ | |
169 | ||
170 | local_irq_enable(); | |
171 | ||
172 | if (thread_info_flags & _TIF_NEED_RESCHED) { | |
173 | schedule(); | |
174 | return 1; | |
175 | } | |
176 | ||
177 | if (thread_info_flags & _TIF_SIGPENDING) { | |
178 | do_signal(regs); | |
179 | return 1; | |
180 | } | |
181 | ||
182 | if (thread_info_flags & _TIF_NOTIFY_RESUME) { | |
183 | clear_thread_flag(TIF_NOTIFY_RESUME); | |
184 | tracehook_notify_resume(regs); | |
c710f590 | 185 | return 1; |
a11e67c2 RK |
186 | } |
187 | ||
188 | /* Should not even reach here */ | |
189 | panic("%s: bad thread_info flags 0x%08x\n", __func__, | |
190 | thread_info_flags); | |
191 | } |