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