1
2
3
4
5
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/tracehook.h>
18
19
20
21
22
23
24
25
26
27
28void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp)
29{
30
31 memset(regs, 0, sizeof(*regs));
32
33 pt_set_usermode(regs);
34 pt_set_elr(regs, pc);
35 pt_set_rte_sp(regs, sp);
36}
37
38
39
40
41
42
43void arch_cpu_idle(void)
44{
45 __vmwait();
46
47 raw_local_irq_enable();
48}
49
50
51
52
53int copy_thread(unsigned long clone_flags, unsigned long usp, unsigned long arg,
54 struct task_struct *p, unsigned long tls)
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
64 ti->regs = childregs;
65
66
67
68
69
70
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;
76 if (unlikely(p->flags & (PF_KTHREAD | PF_IO_WORKER))) {
77 memset(childregs, 0, sizeof(struct pt_regs));
78
79 ss->r24 = usp;
80 ss->r25 = arg;
81 pt_set_kmode(childregs);
82 return 0;
83 }
84 memcpy(childregs, current_pt_regs(), sizeof(*childregs));
85 ss->r2524 = 0;
86
87 if (usp)
88 pt_set_rte_sp(childregs, usp);
89
90
91 childregs->r00 = 0;
92
93
94
95
96
97
98
99
100
101
102 if (clone_flags & CLONE_SETTLS)
103 childregs->ugp = tls;
104
105
106
107
108
109
110
111 return 0;
112}
113
114
115
116
117void release_thread(struct task_struct *dead_task)
118{
119}
120
121
122
123
124void flush_thread(void)
125{
126}
127
128
129
130
131
132
133unsigned 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 || task_is_running(p))
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
156
157
158
159
160
161
162
163
164int do_work_pending(struct pt_regs *regs, u32 thread_info_flags)
165{
166 if (!(thread_info_flags & _TIF_WORK_MASK)) {
167 return 0;
168 }
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 | _TIF_NOTIFY_SIGNAL)) {
178 do_signal(regs);
179 return 1;
180 }
181
182 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
183 tracehook_notify_resume(regs);
184 return 1;
185 }
186
187
188 panic("%s: bad thread_info flags 0x%08x\n", __func__,
189 thread_info_flags);
190}
191