1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk})
4 * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
5 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
6 * Copyright 2003 PathScale, Inc.
7 */
8
9 #include <linux/stddef.h>
10 #include <linux/err.h>
11 #include <linux/hardirq.h>
12 #include <linux/mm.h>
13 #include <linux/module.h>
14 #include <linux/personality.h>
15 #include <linux/proc_fs.h>
16 #include <linux/ptrace.h>
17 #include <linux/random.h>
18 #include <linux/cpu.h>
19 #include <linux/slab.h>
20 #include <linux/sched.h>
21 #include <linux/sched/debug.h>
22 #include <linux/sched/task.h>
23 #include <linux/sched/task_stack.h>
24 #include <linux/seq_file.h>
25 #include <linux/tick.h>
26 #include <linux/threads.h>
27 #include <linux/resume_user_mode.h>
28 #include <asm/current.h>
29 #include <asm/mmu_context.h>
30 #include <asm/switch_to.h>
31 #include <asm/exec.h>
32 #include <linux/uaccess.h>
33 #include <as-layout.h>
34 #include <kern_util.h>
35 #include <os.h>
36 #include <skas.h>
37 #include <registers.h>
38 #include <linux/time-internal.h>
39 #include <linux/elfcore.h>
40
41 /*
42 * This is a per-cpu array. A processor only modifies its entry and it only
43 * cares about its entry, so it's OK if another processor is modifying its
44 * entry.
45 */
46 struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { NULL } };
47
48 void free_stack(unsigned long stack, int order)
49 {
50 free_pages(stack, order);
51 }
52
53 unsigned long alloc_stack(int order, int atomic)
54 {
55 unsigned long page;
56 gfp_t flags = GFP_KERNEL;
57
58 if (atomic)
59 flags = GFP_ATOMIC;
60 page = __get_free_pages(flags, order);
61
62 return page;
63 }
64
65 static inline void set_current(struct task_struct *task)
66 {
67 cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task) { task });
68 }
69
70 struct task_struct *__switch_to(struct task_struct *from, struct task_struct *to)
71 {
72 to->thread.prev_sched = from;
73 set_current(to);
74
75 switch_threads(&from->thread.switch_buf, &to->thread.switch_buf);
76 arch_switch_to(current);
77
78 return current->thread.prev_sched;
79 }
80
81 void interrupt_end(void)
82 {
83 struct pt_regs *regs = ¤t->thread.regs;
84
85 if (need_resched())
86 schedule();
87 if (test_thread_flag(TIF_SIGPENDING) ||
88 test_thread_flag(TIF_NOTIFY_SIGNAL))
89 do_signal(regs);
90 if (test_thread_flag(TIF_NOTIFY_RESUME))
91 resume_user_mode_work(regs);
92 }
93
94 int get_current_pid(void)
95 {
96 return task_pid_nr(current);
97 }
98
99 /*
100 * This is called magically, by its address being stuffed in a jmp_buf
101 * and being longjmp-d to.
102 */
103 void new_thread_handler(void)
104 {
105 int (*fn)(void *);
106 void *arg;
107
108 if (current->thread.prev_sched != NULL)
109 schedule_tail(current->thread.prev_sched);
110 current->thread.prev_sched = NULL;
111
112 fn = current->thread.request.u.thread.proc;
113 arg = current->thread.request.u.thread.arg;
114
115 /*
116 * callback returns only if the kernel thread execs a process
117 */
118 fn(arg);
119 userspace(¤t->thread.regs.regs, current_thread_info()->aux_fp_regs);
120 }
121
122 /* Called magically, see new_thread_handler above */
123 static void fork_handler(void)
124 {
125 schedule_tail(current->thread.prev_sched);
126
127 /*
128 * XXX: if interrupt_end() calls schedule, this call to
129 * arch_switch_to isn't needed. We could want to apply this to
130 * improve performance. -bb
131 */
132 arch_switch_to(current);
133
134 current->thread.prev_sched = NULL;
135
136 userspace(¤t->thread.regs.regs, current_thread_info()->aux_fp_regs);
137 }
138
139 int copy_thread(struct task_struct * p, const struct kernel_clone_args *args)
140 {
141 unsigned long clone_flags = args->flags;
142 unsigned long sp = args->stack;
143 unsigned long tls = args->tls;
144 void (*handler)(void);
145 int ret = 0;
146
147 p->thread = (struct thread_struct) INIT_THREAD;
148
149 if (!args->fn) {
150 memcpy(&p->thread.regs.regs, current_pt_regs(),
151 sizeof(p->thread.regs.regs));
152 PT_REGS_SET_SYSCALL_RETURN(&p->thread.regs, 0);
153 if (sp != 0)
154 REGS_SP(p->thread.regs.regs.gp) = sp;
155
156 handler = fork_handler;
157
158 arch_copy_thread(¤t->thread.arch, &p->thread.arch);
159 } else {
160 get_safe_registers(p->thread.regs.regs.gp, p->thread.regs.regs.fp);
161 p->thread.request.u.thread.proc = args->fn;
162 p->thread.request.u.thread.arg = args->fn_arg;
163 handler = new_thread_handler;
164 }
165
166 new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
167
168 if (!args->fn) {
169 clear_flushed_tls(p);
170
171 /*
172 * Set a new TLS for the child thread?
173 */
174 if (clone_flags & CLONE_SETTLS)
175 ret = arch_set_tls(p, tls);
176 }
177
178 return ret;
179 }
180
181 void initial_thread_cb(void (*proc)(void *), void *arg)
182 {
183 int save_kmalloc_ok = kmalloc_ok;
184
185 kmalloc_ok = 0;
186 initial_thread_cb_skas(proc, arg);
187 kmalloc_ok = save_kmalloc_ok;
188 }
189
190 void um_idle_sleep(void)
191 {
192 if (time_travel_mode != TT_MODE_OFF)
193 time_travel_sleep();
194 else
195 os_idle_sleep();
196 }
197
198 void arch_cpu_idle(void)
199 {
200 um_idle_sleep();
201 }
202
203 int __uml_cant_sleep(void) {
204 return in_atomic() || irqs_disabled() || in_interrupt();
205 /* Is in_interrupt() really needed? */
206 }
207
208 int user_context(unsigned long sp)
209 {
210 unsigned long stack;
211
212 stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
213 return stack != (unsigned long) current_thread_info();
214 }
215
216 extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
217
218 void do_uml_exitcalls(void)
219 {
220 exitcall_t *call;
221
222 call = &__uml_exitcall_end;
223 while (--call >= &__uml_exitcall_begin)
224 (*call)();
225 }
226
227 char *uml_strdup(const char *string)
228 {
229 return kstrdup(string, GFP_KERNEL);
230 }
231 EXPORT_SYMBOL(uml_strdup);
232
233 int copy_from_user_proc(void *to, void __user *from, int size)
234 {
235 return copy_from_user(to, from, size);
236 }
237
238 int singlestepping(void)
239 {
240 return test_thread_flag(TIF_SINGLESTEP);
241 }
242
243 /*
244 * Only x86 and x86_64 have an arch_align_stack().
245 * All other arches have "#define arch_align_stack(x) (x)"
246 * in their asm/exec.h
247 * As this is included in UML from asm-um/system-generic.h,
248 * we can use it to behave as the subarch does.
249 */
250 #ifndef arch_align_stack
251 unsigned long arch_align_stack(unsigned long sp)
252 {
253 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
254 sp -= get_random_u32_below(8192);
255 return sp & ~0xf;
256 }
257 #endif
258
259 unsigned long __get_wchan(struct task_struct *p)
260 {
261 unsigned long stack_page, sp, ip;
262 bool seen_sched = 0;
263
264 stack_page = (unsigned long) task_stack_page(p);
265 /* Bail if the process has no kernel stack for some reason */
266 if (stack_page == 0)
267 return 0;
268
269 sp = p->thread.switch_buf->JB_SP;
270 /*
271 * Bail if the stack pointer is below the bottom of the kernel
272 * stack for some reason
273 */
274 if (sp < stack_page)
275 return 0;
276
277 while (sp < stack_page + THREAD_SIZE) {
278 ip = *((unsigned long *) sp);
279 if (in_sched_functions(ip))
280 /* Ignore everything until we're above the scheduler */
281 seen_sched = 1;
282 else if (kernel_text_address(ip) && seen_sched)
283 return ip;
284
285 sp += sizeof(unsigned long);
286 }
287
288 return 0;
289 }
290
291 int elf_core_copy_task_fpregs(struct task_struct *t, elf_fpregset_t *fpu)
292 {
293 int cpu = current_thread_info()->cpu;
294
295 return save_i387_registers(userspace_pid[cpu], (unsigned long *) fpu);
296 }
297
298
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.