10d1fb0a4SAlex Dewar // SPDX-License-Identifier: GPL-2.0
2995473aeSJeff Dike /*
32eb5f31bSAnton Ivanov * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk})
42eb5f31bSAnton Ivanov * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
5ba180fd4SJeff Dike * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
6995473aeSJeff Dike * Copyright 2003 PathScale, Inc.
7995473aeSJeff Dike */
8995473aeSJeff Dike
9c5d4bb17SJeff Dike #include <linux/stddef.h>
10c5d4bb17SJeff Dike #include <linux/err.h>
11c5d4bb17SJeff Dike #include <linux/hardirq.h>
12c5d4bb17SJeff Dike #include <linux/mm.h>
136613c5e8SAlexey Dobriyan #include <linux/module.h>
14c5d4bb17SJeff Dike #include <linux/personality.h>
15c5d4bb17SJeff Dike #include <linux/proc_fs.h>
16c5d4bb17SJeff Dike #include <linux/ptrace.h>
17c5d4bb17SJeff Dike #include <linux/random.h>
185a0e3ad6STejun Heo #include <linux/slab.h>
19c5d4bb17SJeff Dike #include <linux/sched.h>
20b17b0153SIngo Molnar #include <linux/sched/debug.h>
2129930025SIngo Molnar #include <linux/sched/task.h>
2268db0cf1SIngo Molnar #include <linux/sched/task_stack.h>
236613c5e8SAlexey Dobriyan #include <linux/seq_file.h>
24c5d4bb17SJeff Dike #include <linux/tick.h>
25c5d4bb17SJeff Dike #include <linux/threads.h>
2603248addSEric W. Biederman #include <linux/resume_user_mode.h>
27c5d4bb17SJeff Dike #include <asm/current.h>
28445c5786SAl Viro #include <asm/mmu_context.h>
297c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
3037185b33SAl Viro #include <as-layout.h>
3137185b33SAl Viro #include <kern_util.h>
3237185b33SAl Viro #include <os.h>
3337185b33SAl Viro #include <skas.h>
34dbba7f70SAl Viro #include <registers.h>
35f185063bSJohannes Berg #include <linux/time-internal.h>
36bdbadfccSAl Viro #include <linux/elfcore.h>
37995473aeSJeff Dike
38ba180fd4SJeff Dike /*
39ba180fd4SJeff Dike * This is a per-cpu array. A processor only modifies its entry and it only
40995473aeSJeff Dike * cares about its entry, so it's OK if another processor is modifying its
41995473aeSJeff Dike * entry.
42995473aeSJeff Dike */
43995473aeSJeff Dike struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
44995473aeSJeff Dike
external_pid(void)452dc5802aSKarol Swietlicki static inline int external_pid(void)
46995473aeSJeff Dike {
4777bf4400SJeff Dike /* FIXME: Need to look up userspace_pid by cpu */
48ba180fd4SJeff Dike return userspace_pid[0];
49995473aeSJeff Dike }
50995473aeSJeff Dike
pid_to_processor_id(int pid)51995473aeSJeff Dike int pid_to_processor_id(int pid)
52995473aeSJeff Dike {
53995473aeSJeff Dike int i;
54995473aeSJeff Dike
55995473aeSJeff Dike for (i = 0; i < ncpus; i++) {
566e21aec3SJeff Dike if (cpu_tasks[i].pid == pid)
576e21aec3SJeff Dike return i;
58995473aeSJeff Dike }
596e21aec3SJeff Dike return -1;
60995473aeSJeff Dike }
61995473aeSJeff Dike
free_stack(unsigned long stack,int order)62995473aeSJeff Dike void free_stack(unsigned long stack, int order)
63995473aeSJeff Dike {
64995473aeSJeff Dike free_pages(stack, order);
65995473aeSJeff Dike }
66995473aeSJeff Dike
alloc_stack(int order,int atomic)672fcb4090SJohannes Berg unsigned long alloc_stack(int order, int atomic)
68995473aeSJeff Dike {
692fcb4090SJohannes Berg unsigned long page;
70995473aeSJeff Dike gfp_t flags = GFP_KERNEL;
71995473aeSJeff Dike
72995473aeSJeff Dike if (atomic)
73995473aeSJeff Dike flags = GFP_ATOMIC;
742fcb4090SJohannes Berg page = __get_free_pages(flags, order);
755c8aaceaSJeff Dike
762fcb4090SJohannes Berg return page;
77995473aeSJeff Dike }
78995473aeSJeff Dike
set_current(struct task_struct * task)796e21aec3SJeff Dike static inline void set_current(struct task_struct *task)
80995473aeSJeff Dike {
81995473aeSJeff Dike cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task)
822dc5802aSKarol Swietlicki { external_pid(), task });
83995473aeSJeff Dike }
84995473aeSJeff Dike
85291248fdSKarol Swietlicki extern void arch_switch_to(struct task_struct *to);
8677bf4400SJeff Dike
__switch_to(struct task_struct * from,struct task_struct * to)8776b278edSRichard Weinberger void *__switch_to(struct task_struct *from, struct task_struct *to)
88995473aeSJeff Dike {
89995473aeSJeff Dike to->thread.prev_sched = from;
90995473aeSJeff Dike set_current(to);
91995473aeSJeff Dike
92a1850e9cSRichard Weinberger switch_threads(&from->thread.switch_buf, &to->thread.switch_buf);
93291248fdSKarol Swietlicki arch_switch_to(current);
9477bf4400SJeff Dike
956e21aec3SJeff Dike return current->thread.prev_sched;
96995473aeSJeff Dike }
97995473aeSJeff Dike
interrupt_end(void)98995473aeSJeff Dike void interrupt_end(void)
99995473aeSJeff Dike {
100ccaee5f8SIngo Molnar struct pt_regs *regs = ¤t->thread.regs;
101ccaee5f8SIngo Molnar
1026e21aec3SJeff Dike if (need_resched())
1036e21aec3SJeff Dike schedule();
10409041c92SJens Axboe if (test_thread_flag(TIF_SIGPENDING) ||
10509041c92SJens Axboe test_thread_flag(TIF_NOTIFY_SIGNAL))
106ccaee5f8SIngo Molnar do_signal(regs);
1073c532798SJens Axboe if (test_thread_flag(TIF_NOTIFY_RESUME))
10803248addSEric W. Biederman resume_user_mode_work(regs);
109995473aeSJeff Dike }
110995473aeSJeff Dike
get_current_pid(void)111c2220b2aSAl Viro int get_current_pid(void)
112995473aeSJeff Dike {
113c2220b2aSAl Viro return task_pid_nr(current);
114995473aeSJeff Dike }
115995473aeSJeff Dike
116ba180fd4SJeff Dike /*
117ba180fd4SJeff Dike * This is called magically, by its address being stuffed in a jmp_buf
11877bf4400SJeff Dike * and being longjmp-d to.
11977bf4400SJeff Dike */
new_thread_handler(void)12077bf4400SJeff Dike void new_thread_handler(void)
12177bf4400SJeff Dike {
12277bf4400SJeff Dike int (*fn)(void *), n;
12377bf4400SJeff Dike void *arg;
12477bf4400SJeff Dike
12577bf4400SJeff Dike if (current->thread.prev_sched != NULL)
12677bf4400SJeff Dike schedule_tail(current->thread.prev_sched);
12777bf4400SJeff Dike current->thread.prev_sched = NULL;
12877bf4400SJeff Dike
12977bf4400SJeff Dike fn = current->thread.request.u.thread.proc;
13077bf4400SJeff Dike arg = current->thread.request.u.thread.arg;
13177bf4400SJeff Dike
132ba180fd4SJeff Dike /*
13322e2430dSAl Viro * callback returns only if the kernel thread execs a process
13477bf4400SJeff Dike */
13522e2430dSAl Viro n = fn(arg);
1366f602afdSThomas Meyer userspace(¤t->thread.regs.regs, current_thread_info()->aux_fp_regs);
13777bf4400SJeff Dike }
13877bf4400SJeff Dike
13977bf4400SJeff Dike /* Called magically, see new_thread_handler above */
fork_handler(void)14077bf4400SJeff Dike void fork_handler(void)
14177bf4400SJeff Dike {
14277bf4400SJeff Dike force_flush_all();
14377bf4400SJeff Dike
14477bf4400SJeff Dike schedule_tail(current->thread.prev_sched);
14577bf4400SJeff Dike
146ba180fd4SJeff Dike /*
147ba180fd4SJeff Dike * XXX: if interrupt_end() calls schedule, this call to
14877bf4400SJeff Dike * arch_switch_to isn't needed. We could want to apply this to
149ba180fd4SJeff Dike * improve performance. -bb
150ba180fd4SJeff Dike */
151291248fdSKarol Swietlicki arch_switch_to(current);
15277bf4400SJeff Dike
15377bf4400SJeff Dike current->thread.prev_sched = NULL;
15477bf4400SJeff Dike
1556f602afdSThomas Meyer userspace(¤t->thread.regs.regs, current_thread_info()->aux_fp_regs);
15677bf4400SJeff Dike }
15777bf4400SJeff Dike
copy_thread(struct task_struct * p,const struct kernel_clone_args * args)158c5febea0SEric W. Biederman int copy_thread(struct task_struct * p, const struct kernel_clone_args *args)
159995473aeSJeff Dike {
160c5febea0SEric W. Biederman unsigned long clone_flags = args->flags;
161c5febea0SEric W. Biederman unsigned long sp = args->stack;
162c5febea0SEric W. Biederman unsigned long tls = args->tls;
16377bf4400SJeff Dike void (*handler)(void);
16477bf4400SJeff Dike int ret = 0;
165995473aeSJeff Dike
166995473aeSJeff Dike p->thread = (struct thread_struct) INIT_THREAD;
167995473aeSJeff Dike
1685bd2e97cSEric W. Biederman if (!args->fn) {
1692b067fc9SAl Viro memcpy(&p->thread.regs.regs, current_pt_regs(),
17077bf4400SJeff Dike sizeof(p->thread.regs.regs));
171a3170d2eSAl Viro PT_REGS_SET_SYSCALL_RETURN(&p->thread.regs, 0);
17277bf4400SJeff Dike if (sp != 0)
17318badddaSJeff Dike REGS_SP(p->thread.regs.regs.gp) = sp;
174995473aeSJeff Dike
17577bf4400SJeff Dike handler = fork_handler;
17677bf4400SJeff Dike
17777bf4400SJeff Dike arch_copy_thread(¤t->thread.arch, &p->thread.arch);
178d2ce4e92SAl Viro } else {
179fbfe9c84SIngo van Lil get_safe_registers(p->thread.regs.regs.gp, p->thread.regs.regs.fp);
1805bd2e97cSEric W. Biederman p->thread.request.u.thread.proc = args->fn;
1815bd2e97cSEric W. Biederman p->thread.request.u.thread.arg = args->fn_arg;
18277bf4400SJeff Dike handler = new_thread_handler;
18377bf4400SJeff Dike }
18477bf4400SJeff Dike
18577bf4400SJeff Dike new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
18677bf4400SJeff Dike
1875bd2e97cSEric W. Biederman if (!args->fn) {
188995473aeSJeff Dike clear_flushed_tls(p);
189995473aeSJeff Dike
190995473aeSJeff Dike /*
191995473aeSJeff Dike * Set a new TLS for the child thread?
192995473aeSJeff Dike */
193995473aeSJeff Dike if (clone_flags & CLONE_SETTLS)
194457677c7SAmanieu d'Antras ret = arch_set_tls(p, tls);
19577bf4400SJeff Dike }
196995473aeSJeff Dike
197995473aeSJeff Dike return ret;
198995473aeSJeff Dike }
199995473aeSJeff Dike
initial_thread_cb(void (* proc)(void *),void * arg)200995473aeSJeff Dike void initial_thread_cb(void (*proc)(void *), void *arg)
201995473aeSJeff Dike {
202995473aeSJeff Dike int save_kmalloc_ok = kmalloc_ok;
203995473aeSJeff Dike
204995473aeSJeff Dike kmalloc_ok = 0;
2056aa802ceSJeff Dike initial_thread_cb_skas(proc, arg);
206995473aeSJeff Dike kmalloc_ok = save_kmalloc_ok;
207995473aeSJeff Dike }
208995473aeSJeff Dike
um_idle_sleep(void)209a374b7cbSJohannes Berg void um_idle_sleep(void)
21006503870SJohannes Berg {
21149da38a3SJohannes Berg if (time_travel_mode != TT_MODE_OFF)
21249da38a3SJohannes Berg time_travel_sleep();
21349da38a3SJohannes Berg else
21449da38a3SJohannes Berg os_idle_sleep();
21506503870SJohannes Berg }
21606503870SJohannes Berg
arch_cpu_idle(void)2178198c169SRichard Weinberger void arch_cpu_idle(void)
218995473aeSJeff Dike {
2198198c169SRichard Weinberger cpu_tasks[current_thread_info()->cpu].pid = os_getpid();
22006503870SJohannes Berg um_idle_sleep();
221995473aeSJeff Dike }
222995473aeSJeff Dike
__uml_cant_sleep(void)223*976c46e6SAnton Ivanov int __uml_cant_sleep(void) {
224995473aeSJeff Dike return in_atomic() || irqs_disabled() || in_interrupt();
225995473aeSJeff Dike /* Is in_interrupt() really needed? */
226995473aeSJeff Dike }
227995473aeSJeff Dike
user_context(unsigned long sp)228995473aeSJeff Dike int user_context(unsigned long sp)
229995473aeSJeff Dike {
230995473aeSJeff Dike unsigned long stack;
231995473aeSJeff Dike
232995473aeSJeff Dike stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
233a5a678c8SJeff Dike return stack != (unsigned long) current_thread_info();
234995473aeSJeff Dike }
235995473aeSJeff Dike
236995473aeSJeff Dike extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
237995473aeSJeff Dike
do_uml_exitcalls(void)238995473aeSJeff Dike void do_uml_exitcalls(void)
239995473aeSJeff Dike {
240995473aeSJeff Dike exitcall_t *call;
241995473aeSJeff Dike
242995473aeSJeff Dike call = &__uml_exitcall_end;
243995473aeSJeff Dike while (--call >= &__uml_exitcall_begin)
244995473aeSJeff Dike (*call)();
245995473aeSJeff Dike }
246995473aeSJeff Dike
uml_strdup(const char * string)247c0a9290eSWANG Cong char *uml_strdup(const char *string)
248995473aeSJeff Dike {
249995473aeSJeff Dike return kstrdup(string, GFP_KERNEL);
250995473aeSJeff Dike }
25173395a00SAl Viro EXPORT_SYMBOL(uml_strdup);
252995473aeSJeff Dike
copy_to_user_proc(void __user * to,void * from,int size)253995473aeSJeff Dike int copy_to_user_proc(void __user *to, void *from, int size)
254995473aeSJeff Dike {
2556e21aec3SJeff Dike return copy_to_user(to, from, size);
256995473aeSJeff Dike }
257995473aeSJeff Dike
copy_from_user_proc(void * to,void __user * from,int size)258995473aeSJeff Dike int copy_from_user_proc(void *to, void __user *from, int size)
259995473aeSJeff Dike {
2606e21aec3SJeff Dike return copy_from_user(to, from, size);
261995473aeSJeff Dike }
262995473aeSJeff Dike
clear_user_proc(void __user * buf,int size)263995473aeSJeff Dike int clear_user_proc(void __user *buf, int size)
264995473aeSJeff Dike {
2656e21aec3SJeff Dike return clear_user(buf, size);
266995473aeSJeff Dike }
267995473aeSJeff Dike
268995473aeSJeff Dike static atomic_t using_sysemu = ATOMIC_INIT(0);
269995473aeSJeff Dike int sysemu_supported;
270995473aeSJeff Dike
set_using_sysemu(int value)271995473aeSJeff Dike void set_using_sysemu(int value)
272995473aeSJeff Dike {
273995473aeSJeff Dike if (value > sysemu_supported)
274995473aeSJeff Dike return;
275995473aeSJeff Dike atomic_set(&using_sysemu, value);
276995473aeSJeff Dike }
277995473aeSJeff Dike
get_using_sysemu(void)278995473aeSJeff Dike int get_using_sysemu(void)
279995473aeSJeff Dike {
280995473aeSJeff Dike return atomic_read(&using_sysemu);
281995473aeSJeff Dike }
282995473aeSJeff Dike
sysemu_proc_show(struct seq_file * m,void * v)2836613c5e8SAlexey Dobriyan static int sysemu_proc_show(struct seq_file *m, void *v)
284995473aeSJeff Dike {
2856613c5e8SAlexey Dobriyan seq_printf(m, "%d\n", get_using_sysemu());
2866613c5e8SAlexey Dobriyan return 0;
287995473aeSJeff Dike }
288995473aeSJeff Dike
sysemu_proc_open(struct inode * inode,struct file * file)2896613c5e8SAlexey Dobriyan static int sysemu_proc_open(struct inode *inode, struct file *file)
2906613c5e8SAlexey Dobriyan {
2916613c5e8SAlexey Dobriyan return single_open(file, sysemu_proc_show, NULL);
2926613c5e8SAlexey Dobriyan }
2936613c5e8SAlexey Dobriyan
sysemu_proc_write(struct file * file,const char __user * buf,size_t count,loff_t * pos)2946613c5e8SAlexey Dobriyan static ssize_t sysemu_proc_write(struct file *file, const char __user *buf,
2956613c5e8SAlexey Dobriyan size_t count, loff_t *pos)
296995473aeSJeff Dike {
297995473aeSJeff Dike char tmp[2];
298995473aeSJeff Dike
299995473aeSJeff Dike if (copy_from_user(tmp, buf, 1))
300995473aeSJeff Dike return -EFAULT;
301995473aeSJeff Dike
302995473aeSJeff Dike if (tmp[0] >= '0' && tmp[0] <= '2')
303995473aeSJeff Dike set_using_sysemu(tmp[0] - '0');
304ba180fd4SJeff Dike /* We use the first char, but pretend to write everything */
305ba180fd4SJeff Dike return count;
306995473aeSJeff Dike }
307995473aeSJeff Dike
30897a32539SAlexey Dobriyan static const struct proc_ops sysemu_proc_ops = {
30997a32539SAlexey Dobriyan .proc_open = sysemu_proc_open,
31097a32539SAlexey Dobriyan .proc_read = seq_read,
31197a32539SAlexey Dobriyan .proc_lseek = seq_lseek,
31297a32539SAlexey Dobriyan .proc_release = single_release,
31397a32539SAlexey Dobriyan .proc_write = sysemu_proc_write,
3146613c5e8SAlexey Dobriyan };
3156613c5e8SAlexey Dobriyan
make_proc_sysemu(void)316995473aeSJeff Dike int __init make_proc_sysemu(void)
317995473aeSJeff Dike {
318995473aeSJeff Dike struct proc_dir_entry *ent;
319995473aeSJeff Dike if (!sysemu_supported)
320995473aeSJeff Dike return 0;
321995473aeSJeff Dike
32297a32539SAlexey Dobriyan ent = proc_create("sysemu", 0600, NULL, &sysemu_proc_ops);
323995473aeSJeff Dike
324995473aeSJeff Dike if (ent == NULL)
325995473aeSJeff Dike {
326995473aeSJeff Dike printk(KERN_WARNING "Failed to register /proc/sysemu\n");
3276e21aec3SJeff Dike return 0;
328995473aeSJeff Dike }
329995473aeSJeff Dike
330995473aeSJeff Dike return 0;
331995473aeSJeff Dike }
332995473aeSJeff Dike
333995473aeSJeff Dike late_initcall(make_proc_sysemu);
334995473aeSJeff Dike
singlestepping(void * t)335995473aeSJeff Dike int singlestepping(void * t)
336995473aeSJeff Dike {
337995473aeSJeff Dike struct task_struct *task = t ? t : current;
338995473aeSJeff Dike
339c200e4bbSEric W. Biederman if (!test_thread_flag(TIF_SINGLESTEP))
340ba180fd4SJeff Dike return 0;
341995473aeSJeff Dike
342995473aeSJeff Dike if (task->thread.singlestep_syscall)
343ba180fd4SJeff Dike return 1;
344995473aeSJeff Dike
345995473aeSJeff Dike return 2;
346995473aeSJeff Dike }
347995473aeSJeff Dike
348995473aeSJeff Dike /*
349995473aeSJeff Dike * Only x86 and x86_64 have an arch_align_stack().
350995473aeSJeff Dike * All other arches have "#define arch_align_stack(x) (x)"
351cf7bc58fSDavid Howells * in their asm/exec.h
352995473aeSJeff Dike * As this is included in UML from asm-um/system-generic.h,
353995473aeSJeff Dike * we can use it to behave as the subarch does.
354995473aeSJeff Dike */
355995473aeSJeff Dike #ifndef arch_align_stack
arch_align_stack(unsigned long sp)356995473aeSJeff Dike unsigned long arch_align_stack(unsigned long sp)
357995473aeSJeff Dike {
358995473aeSJeff Dike if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
3598032bf12SJason A. Donenfeld sp -= get_random_u32_below(8192);
360995473aeSJeff Dike return sp & ~0xf;
361995473aeSJeff Dike }
362995473aeSJeff Dike #endif
363c1127465SJeff Dike
__get_wchan(struct task_struct * p)36442a20f86SKees Cook unsigned long __get_wchan(struct task_struct *p)
365c1127465SJeff Dike {
366c1127465SJeff Dike unsigned long stack_page, sp, ip;
367c1127465SJeff Dike bool seen_sched = 0;
368c1127465SJeff Dike
369c1127465SJeff Dike stack_page = (unsigned long) task_stack_page(p);
370c1127465SJeff Dike /* Bail if the process has no kernel stack for some reason */
371c1127465SJeff Dike if (stack_page == 0)
372c1127465SJeff Dike return 0;
373c1127465SJeff Dike
374c1127465SJeff Dike sp = p->thread.switch_buf->JB_SP;
375c1127465SJeff Dike /*
376c1127465SJeff Dike * Bail if the stack pointer is below the bottom of the kernel
377c1127465SJeff Dike * stack for some reason
378c1127465SJeff Dike */
379c1127465SJeff Dike if (sp < stack_page)
380c1127465SJeff Dike return 0;
381c1127465SJeff Dike
382c1127465SJeff Dike while (sp < stack_page + THREAD_SIZE) {
383c1127465SJeff Dike ip = *((unsigned long *) sp);
384c1127465SJeff Dike if (in_sched_functions(ip))
385c1127465SJeff Dike /* Ignore everything until we're above the scheduler */
386c1127465SJeff Dike seen_sched = 1;
387c1127465SJeff Dike else if (kernel_text_address(ip) && seen_sched)
388c1127465SJeff Dike return ip;
389c1127465SJeff Dike
390c1127465SJeff Dike sp += sizeof(unsigned long);
391c1127465SJeff Dike }
392c1127465SJeff Dike
393c1127465SJeff Dike return 0;
394c1127465SJeff Dike }
3958192ab42SJeff Dike
elf_core_copy_task_fpregs(struct task_struct * t,elf_fpregset_t * fpu)396bdbadfccSAl Viro int elf_core_copy_task_fpregs(struct task_struct *t, elf_fpregset_t *fpu)
3978192ab42SJeff Dike {
3988192ab42SJeff Dike int cpu = current_thread_info()->cpu;
3998192ab42SJeff Dike
400a78ff111SEli Cooper return save_i387_registers(userspace_pid[cpu], (unsigned long *) fpu);
4018192ab42SJeff Dike }
4028192ab42SJeff Dike
403