patch-2.2.4 linux/arch/sparc/kernel/process.c

• Lines: 96
• Date: Sun Mar 21 18:37:56 1999
• Orig file: v2.2.3/linux/arch/sparc/kernel/process.c
• Orig date: Mon Oct 5 13:13:37 1998

diff -u --recursive --new-file v2.2.3/linux/arch/sparc/kernel/process.c linux/arch/sparc/kernel/process.c
@@ -1,4 +1,4 @@
-/*  $Id: process.c,v 1.126 1998/09/21 05:05:18 jj Exp $
+/*  $Id: process.c,v 1.132 1999/03/22 02:12:13 davem Exp $
  *  linux/arch/sparc/kernel/process.c
  *
  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
@@ -62,7 +62,7 @@
 
 	/* endless idle loop with no priority at all */
 	current->priority = 0;
-	current->counter = 0;
+	current->counter = -100;
 	for (;;) {
 		if (ARCH_SUN4C_SUN4) {
 			static int count = HZ;
@@ -108,13 +108,15 @@
 /* This is being executed in task 0 'user space'. */
 int cpu_idle(void *unused)
 {
+	/* endless idle loop with no priority at all */
 	current->priority = 0;
+	current->counter = -100;
 	while(1) {
-		check_pgt_cache();
- 		run_task_queue(&tq_scheduler);
- 		/* endless idle loop with no priority at all */
-		current->counter = 0;
-		schedule();
+		if(current->need_resched) {
+			schedule();
+			check_pgt_cache();
+		}
+		barrier(); /* or else gcc optimizes... */
 	}
 }
 
@@ -440,10 +442,17 @@
 	size = ((unsigned long)src->fp) - ((unsigned long)src);
 	sp = (struct sparc_stackf *)(((unsigned long)dst) - size); 
 
+	/* do_fork() grabs the parent semaphore, we must release it
+	 * temporarily so we can build the child clone stack frame
+	 * without deadlocking.
+	 */
+	up(&current->mm->mmap_sem);
 	if (copy_to_user(sp, src, size))
-		return 0;
-	if (put_user(dst, &sp->fp))
-		return 0;
+		sp = (struct sparc_stackf *) 0;
+	else if (put_user(dst, &sp->fp))
+		sp = (struct sparc_stackf *) 0;
+	down(&current->mm->mmap_sem);
+
 	return sp;
 }
 
@@ -657,4 +666,38 @@
 out:
 	unlock_kernel();
 	return error;
+}
+
+/*
+ * 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 free'd until both the parent and the child have exited.
+ */
+pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
+{
+	long retval;
+
+	__asm__ __volatile("mov %4, %%g2\n\t"    /* Set aside fn ptr... */
+			   "mov %5, %%g3\n\t"    /* and arg. */
+			   "mov %1, %%g1\n\t"
+			   "mov %2, %%o0\n\t"    /* Clone flags. */
+			   "mov 0, %%o1\n\t"     /* usp arg == 0 */
+			   "t 0x10\n\t"          /* Linux/Sparc clone(). */
+			   "cmp %%o1, 0\n\t"
+			   "be 1f\n\t"           /* The parent, just return. */
+			   " nop\n\t"            /* Delay slot. */
+			   "jmpl %%g2, %%o7\n\t" /* Call the function. */
+			   " mov %%g3, %%o0\n\t" /* Get back the arg in delay. */
+			   "mov %3, %%g1\n\t"
+			   "t 0x10\n\t"          /* Linux/Sparc exit(). */
+			   /* Notreached by child. */
+			   "1: mov %%o0, %0\n\t" :
+			   "=r" (retval) :
+			   "i" (__NR_clone), "r" (flags | CLONE_VM),
+			   "i" (__NR_exit),  "r" (fn), "r" (arg) :
+			   "g1", "g2", "g3", "o0", "o1", "memory", "cc");
+	return retval;
 }