Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk}) * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de) * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) * Copyright 2003 PathScale, Inc. */
#include <linux/stddef.h>#include <linux/err.h>#include <linux/hardirq.h>#include <linux/mm.h>#include <linux/module.h>#include <linux/personality.h>#include <linux/proc_fs.h>#include <linux/ptrace.h>#include <linux/random.h>#include <linux/cpu.h>#include <linux/slab.h>#include <linux/sched.h>#include <linux/sched/debug.h>#include <linux/sched/task.h>#include <linux/sched/task_stack.h>#include <linux/seq_file.h>#include <linux/tick.h>#include <linux/threads.h>#include <linux/resume_user_mode.h>#include <asm/current.h>#include <asm/mmu_context.h>#include <asm/switch_to.h>#include <asm/exec.h>#include <linux/uaccess.h>#include <as-layout.h>#include <kern_util.h>#include <os.h>#include <skas.h>#include <registers.h>#include <linux/time-internal.h>#include <linux/elfcore.h>
/* * This is a per-cpu array. A processor only modifies its entry and it only * cares about its entry, so it's OK if another processor is modifying its * entry. */struct task_struct *cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = &init_task,};EXPORT_SYMBOL(cpu_tasks);
void free_stack(unsigned long stack, int order){ free_pages(stack, order);}
unsigned long alloc_stack(int order, int atomic){ unsigned long page; gfp_t flags = GFP_KERNEL;
if (atomic) flags = GFP_ATOMIC; page = __get_free_pages(flags, order);
return page;}
static inline void set_current(struct task_struct *task){ cpu_tasks[task_thread_info(task)->cpu] = task;}
struct task_struct *__switch_to(struct task_struct *from, struct task_struct *to){ to->thread.prev_sched = from; set_current(to);
switch_threads(&from->thread.switch_buf, &to->thread.switch_buf); arch_switch_to(current);
return current->thread.prev_sched;}
void interrupt_end(void){ struct pt_regs *regs = ¤t->thread.regs; unsigned long thread_flags;
thread_flags = read_thread_flags(); while (thread_flags & _TIF_WORK_MASK) { if (thread_flags & _TIF_NEED_RESCHED) schedule(); if (thread_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) do_signal(regs); if (thread_flags & _TIF_NOTIFY_RESUME) resume_user_mode_work(regs); thread_flags = read_thread_flags(); }}
int get_current_pid(void){ return task_pid_nr(current);}
/* * This is called magically, by its address being stuffed in a jmp_buf * and being longjmp-d to. */void new_thread_handler(void){ int (*fn)(void *); void *arg;
if (current->thread.prev_sched != NULL) schedule_tail(current->thread.prev_sched); current->thread.prev_sched = NULL;
fn = current->thread.request.thread.proc; arg = current->thread.request.thread.arg;
/* * callback returns only if the kernel thread execs a process */ fn(arg); userspace(¤t->thread.regs.regs);}
/* Called magically, see new_thread_handler above */static void fork_handler(void){ schedule_tail(current->thread.prev_sched);
/* * XXX: if interrupt_end() calls schedule, this call to * arch_switch_to isn't needed. We could want to apply this to * improve performance. -bb */ arch_switch_to(current);
current->thread.prev_sched = NULL;
userspace(¤t->thread.regs.regs);}
int copy_thread(struct task_struct * p, const struct kernel_clone_args *args){ u64 clone_flags = args->flags; unsigned long sp = args->stack; unsigned long tls = args->tls; void (*handler)(void); int ret = 0;
p->thread = (struct thread_struct) INIT_THREAD;
if (!args->fn) { memcpy(&p->thread.regs.regs, current_pt_regs(), sizeof(p->thread.regs.regs)); PT_REGS_SET_SYSCALL_RETURN(&p->thread.regs, 0); if (sp != 0) REGS_SP(p->thread.regs.regs.gp) = sp;
handler = fork_handler;
arch_copy_thread(¤t->thread.arch, &p->thread.arch); } else { get_safe_registers(p->thread.regs.regs.gp, p->thread.regs.regs.fp); p->thread.request.thread.proc = args->fn; p->thread.request.thread.arg = args->fn_arg; handler = new_thread_handler; }
new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
if (!args->fn) { clear_flushed_tls(p);
/* * Set a new TLS for the child thread? */ if (clone_flags & CLONE_SETTLS) ret = arch_set_tls(p, tls); }
return ret;}
void initial_thread_cb(void (*proc)(void *), void *arg){ initial_thread_cb_skas(proc, arg);}
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src){ /* init_task is not dynamically sized (missing FPU state) */ if (unlikely(src == &init_task)) { memcpy(dst, src, sizeof(init_task)); memset((void *)dst + sizeof(init_task), 0, arch_task_struct_size - sizeof(init_task)); } else { memcpy(dst, src, arch_task_struct_size); }
return 0;}
void um_idle_sleep(void){ if (time_travel_mode != TT_MODE_OFF) time_travel_sleep(); else os_idle_sleep();}
void arch_cpu_idle(void){ um_idle_sleep();}
void arch_cpu_idle_prepare(void){ os_idle_prepare();}
int __uml_cant_sleep(void) { return in_atomic() || irqs_disabled() || in_interrupt(); /* Is in_interrupt() really needed? */}
int uml_need_resched(void){ return need_resched();}
extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
void do_uml_exitcalls(void){ exitcall_t *call;
call = &__uml_exitcall_end; while (--call >= &__uml_exitcall_begin) (*call)();}
char *uml_strdup(const char *string){ return kstrdup(string, GFP_KERNEL);}EXPORT_SYMBOL(uml_strdup);
int copy_from_user_proc(void *to, void __user *from, int size){ return copy_from_user(to, from, size);}
int singlestepping(void){ return test_thread_flag(TIF_SINGLESTEP);}
/* * Only x86 and x86_64 have an arch_align_stack(). * All other arches have "#define arch_align_stack(x) (x)" * in their asm/exec.h * As this is included in UML from asm-um/system-generic.h, * we can use it to behave as the subarch does. */#ifndef arch_align_stackunsigned long arch_align_stack(unsigned long sp){ if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space) sp -= get_random_u32_below(8192); return sp & ~0xf;}#endif
unsigned long __get_wchan(struct task_struct *p){ unsigned long stack_page, sp, ip; bool seen_sched = 0;
stack_page = (unsigned long) task_stack_page(p); /* Bail if the process has no kernel stack for some reason */ if (stack_page == 0) return 0;
sp = p->thread.switch_buf->JB_SP; /* * Bail if the stack pointer is below the bottom of the kernel * stack for some reason */ if (sp < stack_page) return 0;
while (sp < stack_page + THREAD_SIZE) { ip = *((unsigned long *) sp); if (in_sched_functions(ip)) /* Ignore everything until we're above the scheduler */ seen_sched = 1; else if (kernel_text_address(ip) && seen_sched) return ip;
sp += sizeof(unsigned long); }
return 0;}