|
|
|
|
@@ -538,64 +538,56 @@ asmlinkage long sparc_do_fork(unsigned long clone_flags,
|
|
|
|
|
* Child --> %o0 == parents pid, %o1 == 1
|
|
|
|
|
*/
|
|
|
|
|
int copy_thread(unsigned long clone_flags, unsigned long sp,
|
|
|
|
|
unsigned long unused,
|
|
|
|
|
unsigned long arg,
|
|
|
|
|
struct task_struct *p, struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
struct thread_info *t = task_thread_info(p);
|
|
|
|
|
struct sparc_stackf *parent_sf;
|
|
|
|
|
unsigned long child_stack_sz;
|
|
|
|
|
char *child_trap_frame;
|
|
|
|
|
int kernel_thread;
|
|
|
|
|
|
|
|
|
|
kernel_thread = (regs->tstate & TSTATE_PRIV) ? 1 : 0;
|
|
|
|
|
parent_sf = ((struct sparc_stackf *) regs) - 1;
|
|
|
|
|
|
|
|
|
|
/* Calculate offset to stack_frame & pt_regs */
|
|
|
|
|
child_stack_sz = ((STACKFRAME_SZ + TRACEREG_SZ) +
|
|
|
|
|
(kernel_thread ? STACKFRAME_SZ : 0));
|
|
|
|
|
child_stack_sz = (STACKFRAME_SZ + TRACEREG_SZ);
|
|
|
|
|
child_trap_frame = (task_stack_page(p) +
|
|
|
|
|
(THREAD_SIZE - child_stack_sz));
|
|
|
|
|
memcpy(child_trap_frame, parent_sf, child_stack_sz);
|
|
|
|
|
|
|
|
|
|
__thread_flag_byte_ptr(t)[TI_FLAG_BYTE_CWP] =
|
|
|
|
|
(regs->tstate + 1) & TSTATE_CWP;
|
|
|
|
|
t->new_child = 1;
|
|
|
|
|
t->ksp = ((unsigned long) child_trap_frame) - STACK_BIAS;
|
|
|
|
|
t->kregs = (struct pt_regs *) (child_trap_frame +
|
|
|
|
|
sizeof(struct sparc_stackf));
|
|
|
|
|
t->fpsaved[0] = 0;
|
|
|
|
|
|
|
|
|
|
if (kernel_thread) {
|
|
|
|
|
struct sparc_stackf *child_sf = (struct sparc_stackf *)
|
|
|
|
|
(child_trap_frame + (STACKFRAME_SZ + TRACEREG_SZ));
|
|
|
|
|
|
|
|
|
|
/* Zero terminate the stack backtrace. */
|
|
|
|
|
child_sf->fp = NULL;
|
|
|
|
|
t->kregs->u_regs[UREG_FP] =
|
|
|
|
|
((unsigned long) child_sf) - STACK_BIAS;
|
|
|
|
|
|
|
|
|
|
if (unlikely(p->flags & PF_KTHREAD)) {
|
|
|
|
|
memset(child_trap_frame, 0, child_stack_sz);
|
|
|
|
|
__thread_flag_byte_ptr(t)[TI_FLAG_BYTE_CWP] =
|
|
|
|
|
(current_pt_regs()->tstate + 1) & TSTATE_CWP;
|
|
|
|
|
t->current_ds = ASI_P;
|
|
|
|
|
t->kregs->u_regs[UREG_G6] = (unsigned long) t;
|
|
|
|
|
t->kregs->u_regs[UREG_G4] = (unsigned long) t->task;
|
|
|
|
|
} else {
|
|
|
|
|
if (t->flags & _TIF_32BIT) {
|
|
|
|
|
sp &= 0x00000000ffffffffUL;
|
|
|
|
|
regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
|
|
|
|
|
}
|
|
|
|
|
t->kregs->u_regs[UREG_FP] = sp;
|
|
|
|
|
t->current_ds = ASI_AIUS;
|
|
|
|
|
if (sp != regs->u_regs[UREG_FP]) {
|
|
|
|
|
unsigned long csp;
|
|
|
|
|
|
|
|
|
|
csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
|
|
|
|
|
if (!csp)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
t->kregs->u_regs[UREG_FP] = csp;
|
|
|
|
|
}
|
|
|
|
|
if (t->utraps)
|
|
|
|
|
t->utraps[0]++;
|
|
|
|
|
t->kregs->u_regs[UREG_G1] = sp; /* function */
|
|
|
|
|
t->kregs->u_regs[UREG_G2] = arg;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parent_sf = ((struct sparc_stackf *) regs) - 1;
|
|
|
|
|
memcpy(child_trap_frame, parent_sf, child_stack_sz);
|
|
|
|
|
if (t->flags & _TIF_32BIT) {
|
|
|
|
|
sp &= 0x00000000ffffffffUL;
|
|
|
|
|
regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
|
|
|
|
|
}
|
|
|
|
|
t->kregs->u_regs[UREG_FP] = sp;
|
|
|
|
|
__thread_flag_byte_ptr(t)[TI_FLAG_BYTE_CWP] =
|
|
|
|
|
(regs->tstate + 1) & TSTATE_CWP;
|
|
|
|
|
t->current_ds = ASI_AIUS;
|
|
|
|
|
if (sp != regs->u_regs[UREG_FP]) {
|
|
|
|
|
unsigned long csp;
|
|
|
|
|
|
|
|
|
|
csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
|
|
|
|
|
if (!csp)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
t->kregs->u_regs[UREG_FP] = csp;
|
|
|
|
|
}
|
|
|
|
|
if (t->utraps)
|
|
|
|
|
t->utraps[0]++;
|
|
|
|
|
|
|
|
|
|
/* Set the return value for the child. */
|
|
|
|
|
t->kregs->u_regs[UREG_I0] = current->pid;
|
|
|
|
|
t->kregs->u_regs[UREG_I1] = 1;
|
|
|
|
|
@@ -609,45 +601,6 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This is the mechanism for creating a new kernel thread.
|
|
|
|
|
*
|
|
|
|
|
* NOTE! Only a kernel-only process(ie the swapper or direct descendants
|
|
|
|
|
* who haven't done an "execve()") should use this: it will work within
|
|
|
|
|
* a system call from a "real" process, but the process memory space will
|
|
|
|
|
* not be freed until both the parent and the child have exited.
|
|
|
|
|
*/
|
|
|
|
|
pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
|
|
|
|
|
{
|
|
|
|
|
long retval;
|
|
|
|
|
|
|
|
|
|
/* If the parent runs before fn(arg) is called by the child,
|
|
|
|
|
* the input registers of this function can be clobbered.
|
|
|
|
|
* So we stash 'fn' and 'arg' into global registers which
|
|
|
|
|
* will not be modified by the parent.
|
|
|
|
|
*/
|
|
|
|
|
__asm__ __volatile__("mov %4, %%g2\n\t" /* Save FN into global */
|
|
|
|
|
"mov %5, %%g3\n\t" /* Save ARG into global */
|
|
|
|
|
"mov %1, %%g1\n\t" /* Clone syscall nr. */
|
|
|
|
|
"mov %2, %%o0\n\t" /* Clone flags. */
|
|
|
|
|
"mov 0, %%o1\n\t" /* usp arg == 0 */
|
|
|
|
|
"t 0x6d\n\t" /* Linux/Sparc clone(). */
|
|
|
|
|
"brz,a,pn %%o1, 1f\n\t" /* Parent, just return. */
|
|
|
|
|
" mov %%o0, %0\n\t"
|
|
|
|
|
"jmpl %%g2, %%o7\n\t" /* Call the function. */
|
|
|
|
|
" mov %%g3, %%o0\n\t" /* Set arg in delay. */
|
|
|
|
|
"mov %3, %%g1\n\t"
|
|
|
|
|
"t 0x6d\n\t" /* Linux/Sparc exit(). */
|
|
|
|
|
/* Notreached by child. */
|
|
|
|
|
"1:" :
|
|
|
|
|
"=r" (retval) :
|
|
|
|
|
"i" (__NR_clone), "r" (flags | CLONE_VM | CLONE_UNTRACED),
|
|
|
|
|
"i" (__NR_exit), "r" (fn), "r" (arg) :
|
|
|
|
|
"g1", "g2", "g3", "o0", "o1", "memory", "cc");
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(kernel_thread);
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
union {
|
|
|
|
|
unsigned int pr_regs[32];
|
|
|
|
|
|
Al Viro