// SPDX-License-Identifier: GPL-2.0 /* * This file handles the architecture independent parts of process handling.. */ #include <linux/compat.h>#include <linux/errno.h>#include <linux/kernel.h>#include <linux/ptrace.h>#include <linux/sched.h>#include <linux/sched/task.h>#include <linux/sched/task_stack.h>#include <linux/signal.h>#include <linux/syscalls.h> #include "kernel.h" asmlinkage long sparc_fork(struct pt_regs *regs){	unsigned long orig_i1;	long ret;	struct kernel_clone_args args = {		.exit_signal	= SIGCHLD,	}; 	synchronize_user_stack(); 	orig_i1 = regs->u_regs[UREG_I1];	/* Reuse the parent's stack for the child. */	args.stack = regs->u_regs[UREG_FP]; 	ret = kernel_clone(&args); 	/* If we get an error and potentially restart the system	 * call, we're screwed because copy_thread() clobbered	 * the parent's %o1.  So detect that case and restore it	 * here.	 */	if ((unsigned long)ret >= -ERESTART_RESTARTBLOCK)		regs->u_regs[UREG_I1] = orig_i1; 	return ret;} asmlinkage long sparc_vfork(struct pt_regs *regs){	unsigned long orig_i1;	long ret;	struct kernel_clone_args args = {		.flags		= CLONE_VFORK | CLONE_VM,		.exit_signal	= SIGCHLD,	}; 	synchronize_user_stack(); 	orig_i1 = regs->u_regs[UREG_I1];	/* Reuse the parent's stack for the child. */	args.stack = regs->u_regs[UREG_FP]; 	ret = kernel_clone(&args); 	/* If we get an error and potentially restart the system	 * call, we're screwed because copy_thread() clobbered	 * the parent's %o1.  So detect that case and restore it	 * here.	 */	if ((unsigned long)ret >= -ERESTART_RESTARTBLOCK)		regs->u_regs[UREG_I1] = orig_i1; 	return ret;} asmlinkage long sparc_clone(struct pt_regs *regs){	unsigned long orig_i1;	unsigned int flags;	long ret;	struct kernel_clone_args args = {0}; 	synchronize_user_stack(); 	orig_i1 = regs->u_regs[UREG_I1];	flags = lower_32_bits(regs->u_regs[UREG_I0]);	args.flags		= (flags & ~CSIGNAL);	args.exit_signal	= (flags & CSIGNAL);	args.tls		= regs->u_regs[UREG_I3]; #ifdef CONFIG_COMPAT	if (test_thread_flag(TIF_32BIT)) {		args.pidfd	= compat_ptr(regs->u_regs[UREG_I2]);		args.child_tid	= compat_ptr(regs->u_regs[UREG_I4]);		args.parent_tid	= compat_ptr(regs->u_regs[UREG_I2]);	} else#endif	{		args.pidfd	= (int __user *)regs->u_regs[UREG_I2];		args.child_tid	= (int __user *)regs->u_regs[UREG_I4];		args.parent_tid	= (int __user *)regs->u_regs[UREG_I2];	} 	/* Did userspace give setup a separate stack for the child or are we	 * reusing the parent's?	 */	if (regs->u_regs[UREG_I1])		args.stack = regs->u_regs[UREG_I1];	else		args.stack = regs->u_regs[UREG_FP]; 	ret = kernel_clone(&args); 	/* If we get an error and potentially restart the system	 * call, we're screwed because copy_thread() clobbered	 * the parent's %o1.  So detect that case and restore it	 * here.	 */	if ((unsigned long)ret >= -ERESTART_RESTARTBLOCK)		regs->u_regs[UREG_I1] = orig_i1; 	return ret;} asmlinkage long sparc_clone3(struct pt_regs *regs){	unsigned long sz;	struct clone_args __user *cl_args; 	synchronize_user_stack(); 	cl_args = (struct clone_args __user *)regs->u_regs[UREG_I0];	sz = regs->u_regs[UREG_I1]; 	return sys_clone3(cl_args, sz);}