]>
Commit | Line | Data |
---|---|---|
4b30f965 RK |
1 | /* |
2 | * Process creation support for Hexagon | |
3 | * | |
e1858b2a | 4 | * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved. |
4b30f965 RK |
5 | * |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 and | |
8 | * only version 2 as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
18 | * 02110-1301, USA. | |
19 | */ | |
20 | ||
21 | #include <linux/sched.h> | |
b17b0153 | 22 | #include <linux/sched/debug.h> |
4b30f965 RK |
23 | #include <linux/types.h> |
24 | #include <linux/module.h> | |
25 | #include <linux/tick.h> | |
26 | #include <linux/uaccess.h> | |
27 | #include <linux/slab.h> | |
a11e67c2 | 28 | #include <linux/tracehook.h> |
4b30f965 | 29 | |
4b30f965 RK |
30 | /* |
31 | * Program thread launch. Often defined as a macro in processor.h, | |
32 | * but we're shooting for a small footprint and it's not an inner-loop | |
33 | * performance-critical operation. | |
34 | * | |
35 | * The Hexagon ABI specifies that R28 is zero'ed before program launch, | |
36 | * so that gets automatically done here. If we ever stop doing that here, | |
37 | * we'll probably want to define the ELF_PLAT_INIT macro. | |
38 | */ | |
39 | void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp) | |
40 | { | |
4b30f965 RK |
41 | /* We want to zero all data-containing registers. Is this overkill? */ |
42 | memset(regs, 0, sizeof(*regs)); | |
43 | /* We might want to also zero all Processor registers here */ | |
44 | pt_set_usermode(regs); | |
45 | pt_set_elr(regs, pc); | |
46 | pt_set_rte_sp(regs, sp); | |
47 | } | |
48 | ||
49 | /* | |
50 | * Spin, or better still, do a hardware or VM wait instruction | |
51 | * If hardware or VM offer wait termination even though interrupts | |
52 | * are disabled. | |
53 | */ | |
4e0fcc56 | 54 | void arch_cpu_idle(void) |
4b30f965 RK |
55 | { |
56 | __vmwait(); | |
4e0fcc56 TG |
57 | /* interrupts wake us up, but irqs are still disabled */ |
58 | local_irq_enable(); | |
4b30f965 RK |
59 | } |
60 | ||
61 | /* | |
62 | * Return saved PC of a blocked thread | |
63 | */ | |
64 | unsigned long thread_saved_pc(struct task_struct *tsk) | |
65 | { | |
66 | return 0; | |
67 | } | |
68 | ||
69 | /* | |
70 | * Copy architecture-specific thread state | |
71 | */ | |
72 | int copy_thread(unsigned long clone_flags, unsigned long usp, | |
afa86fc4 | 73 | unsigned long arg, struct task_struct *p) |
4b30f965 RK |
74 | { |
75 | struct thread_info *ti = task_thread_info(p); | |
76 | struct hexagon_switch_stack *ss; | |
77 | struct pt_regs *childregs; | |
78 | asmlinkage void ret_from_fork(void); | |
79 | ||
80 | childregs = (struct pt_regs *) (((unsigned long) ti + THREAD_SIZE) - | |
81 | sizeof(*childregs)); | |
82 | ||
4b30f965 RK |
83 | ti->regs = childregs; |
84 | ||
85 | /* | |
86 | * Establish kernel stack pointer and initial PC for new thread | |
99521855 AV |
87 | * Note that unlike the usual situation, we do not copy the |
88 | * parent's callee-saved here; those are in pt_regs and whatever | |
89 | * we leave here will be overridden on return to userland. | |
4b30f965 RK |
90 | */ |
91 | ss = (struct hexagon_switch_stack *) ((unsigned long) childregs - | |
92 | sizeof(*ss)); | |
93 | ss->lr = (unsigned long)ret_from_fork; | |
94 | p->thread.switch_sp = ss; | |
99521855 AV |
95 | if (unlikely(p->flags & PF_KTHREAD)) { |
96 | memset(childregs, 0, sizeof(struct pt_regs)); | |
97 | /* r24 <- fn, r25 <- arg */ | |
0d3ab450 RK |
98 | ss->r24 = usp; |
99 | ss->r25 = arg; | |
99521855 AV |
100 | pt_set_kmode(childregs); |
101 | return 0; | |
4b30f965 | 102 | } |
f01aceac | 103 | memcpy(childregs, current_pt_regs(), sizeof(*childregs)); |
99521855 AV |
104 | ss->r2524 = 0; |
105 | ||
f01aceac AV |
106 | if (usp) |
107 | pt_set_rte_sp(childregs, usp); | |
99521855 AV |
108 | |
109 | /* Child sees zero return value */ | |
110 | childregs->r00 = 0; | |
111 | ||
112 | /* | |
113 | * The clone syscall has the C signature: | |
114 | * int [r0] clone(int flags [r0], | |
115 | * void *child_frame [r1], | |
116 | * void *parent_tid [r2], | |
117 | * void *child_tid [r3], | |
118 | * void *thread_control_block [r4]); | |
119 | * ugp is used to provide TLS support. | |
120 | */ | |
121 | if (clone_flags & CLONE_SETTLS) | |
122 | childregs->ugp = childregs->r04; | |
4b30f965 RK |
123 | |
124 | /* | |
99521855 AV |
125 | * Parent sees new pid -- not necessary, not even possible at |
126 | * this point in the fork process | |
127 | * Might also want to set things like ti->addr_limit | |
4b30f965 | 128 | */ |
4b30f965 RK |
129 | |
130 | return 0; | |
131 | } | |
132 | ||
133 | /* | |
134 | * Release any architecture-specific resources locked by thread | |
135 | */ | |
136 | void release_thread(struct task_struct *dead_task) | |
137 | { | |
138 | } | |
139 | ||
4b30f965 RK |
140 | /* |
141 | * Some archs flush debug and FPU info here | |
142 | */ | |
143 | void flush_thread(void) | |
144 | { | |
145 | } | |
146 | ||
147 | /* | |
148 | * The "wait channel" terminology is archaic, but what we want | |
149 | * is an identification of the point at which the scheduler | |
150 | * was invoked by a blocked thread. | |
151 | */ | |
152 | unsigned long get_wchan(struct task_struct *p) | |
153 | { | |
154 | unsigned long fp, pc; | |
155 | unsigned long stack_page; | |
156 | int count = 0; | |
157 | if (!p || p == current || p->state == TASK_RUNNING) | |
158 | return 0; | |
159 | ||
160 | stack_page = (unsigned long)task_stack_page(p); | |
161 | fp = ((struct hexagon_switch_stack *)p->thread.switch_sp)->fp; | |
162 | do { | |
163 | if (fp < (stack_page + sizeof(struct thread_info)) || | |
164 | fp >= (THREAD_SIZE - 8 + stack_page)) | |
165 | return 0; | |
166 | pc = ((unsigned long *)fp)[1]; | |
167 | if (!in_sched_functions(pc)) | |
168 | return pc; | |
169 | fp = *(unsigned long *) fp; | |
170 | } while (count++ < 16); | |
171 | ||
172 | return 0; | |
173 | } | |
174 | ||
4b30f965 RK |
175 | /* |
176 | * Required placeholder. | |
177 | */ | |
178 | int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu) | |
179 | { | |
180 | return 0; | |
181 | } | |
a11e67c2 RK |
182 | |
183 | ||
184 | /* | |
185 | * Called on the exit path of event entry; see vm_entry.S | |
186 | * | |
187 | * Interrupts will already be disabled. | |
188 | * | |
189 | * Returns 0 if there's no need to re-check for more work. | |
190 | */ | |
191 | ||
192 | int do_work_pending(struct pt_regs *regs, u32 thread_info_flags) | |
193 | { | |
f8722a4d | 194 | if (!(thread_info_flags & _TIF_WORK_MASK)) { |
a11e67c2 RK |
195 | return 0; |
196 | } /* shortcut -- no work to be done */ | |
197 | ||
198 | local_irq_enable(); | |
199 | ||
200 | if (thread_info_flags & _TIF_NEED_RESCHED) { | |
201 | schedule(); | |
202 | return 1; | |
203 | } | |
204 | ||
205 | if (thread_info_flags & _TIF_SIGPENDING) { | |
206 | do_signal(regs); | |
207 | return 1; | |
208 | } | |
209 | ||
210 | if (thread_info_flags & _TIF_NOTIFY_RESUME) { | |
211 | clear_thread_flag(TIF_NOTIFY_RESUME); | |
212 | tracehook_notify_resume(regs); | |
c710f590 | 213 | return 1; |
a11e67c2 RK |
214 | } |
215 | ||
216 | /* Should not even reach here */ | |
217 | panic("%s: bad thread_info flags 0x%08x\n", __func__, | |
218 | thread_info_flags); | |
219 | } |