Re: 2.6.8-rc3-mm1

From: William Lee Irwin III (wli_at_holomorphy.com)
Date: 08/06/04

  • Next message: Jean-Luc Cooke: "Re: [PATCH]" 
    Date:	Thu, 5 Aug 2004 21:24:20 -0700
To: Andrew Morton <akpm@osdl.org>, linux-kernel@vger.kernel.org

    On Thu, Aug 05, 2004 at 08:34:48PM -0700, William Lee Irwin III wrote:
    > It appears that init_idle() and fork_by_hand() could be combined into
    > a single method that calls init_idle() on behalf of the caller, which
    > would amount to something like:
    > task_t * __init fork_idle(int cpu)
    [...]

    Atop the full 2.6.8-rc3-mm1 series:

    $ diffstat tmp/fork_idle.patch
     arch/alpha/kernel/smp.c | 14 +-------------
     arch/i386/kernel/smpboot.c | 20 +-------------------
     arch/i386/mach-voyager/voyager_smp.c | 18 +-----------------
     arch/ia64/kernel/smpboot.c | 27 ++++++---------------------
     arch/mips/kernel/smp.c | 18 +-----------------
     arch/parisc/kernel/smp.c | 23 +----------------------
     arch/ppc/kernel/smp.c | 7 +------
     arch/ppc64/kernel/smp.c | 10 +---------
     arch/s390/kernel/smp.c | 11 +----------
     arch/sh/kernel/smp.c | 7 +------
     arch/sparc/kernel/sun4d_smp.c | 11 +----------
     arch/sparc64/kernel/smp.c | 9 +--------
     arch/um/kernel/smp.c | 4 +---
     arch/x86_64/kernel/smpboot.c | 18 +-----------------
     include/linux/sched.h | 2 +-
     init/main.c | 9 ---------
     kernel/fork.c | 16 +++++++++++++++-
     kernel/sched.c | 8 ++++++++
     18 files changed, 43 insertions(+), 189 deletions(-)

    Index: mm1-2.6.8-rc3/arch/alpha/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/alpha/kernel/smp.c 2004-08-05 05:30:43.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/alpha/kernel/smp.c 2004-08-05 20:42:56.581904632 -0700
    @@ -412,15 +412,6 @@
             return 0;
     }
     
    -static struct task_struct * __init
    -fork_by_hand(void)
    -{
    - /* Don't care about the contents of regs since we'll never
    - reschedule the forked task. */
    - struct pt_regs regs;
    - return copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    -}
    -
     /*
      * Bring one cpu online.
      */
    @@ -436,13 +427,10 @@
                the other task-y sort of data structures set up like we
                wish. We can't use kernel_thread since we must avoid
                rescheduling the child. */
    - idle = fork_by_hand();
    + idle = fork_idle(cpuid);
             if (IS_ERR(idle))
                     panic("failed fork for CPU %d", cpuid);
     
    - init_idle(idle, cpuid);
    - unhash_process(idle);
    -
             DBGS(("smp_boot_one_cpu: CPU %d state 0x%lx flags 0x%lx\n",
                   cpuid, idle->state, idle->flags));
     
    Index: mm1-2.6.8-rc3/arch/i386/kernel/smpboot.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/i386/kernel/smpboot.c 2004-08-05 05:30:43.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/i386/kernel/smpboot.c 2004-08-05 20:43:33.993217248 -0700
    @@ -502,16 +502,6 @@
             unsigned short ss;
     } stack_start;
     
    -static struct task_struct * __init fork_by_hand(void)
    -{
    - struct pt_regs regs;
    - /*
    - * don't care about the eip and regs settings since
    - * we'll never reschedule the forked task.
    - */
    - return copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    -}
    -
     #ifdef CONFIG_NUMA
     
     /* which logical CPUs are on which nodes */
    @@ -807,18 +797,10 @@
              * We can't use kernel_thread since we must avoid to
              * reschedule the child.
              */
    - idle = fork_by_hand();
    + idle = fork_idle(cpu);
             if (IS_ERR(idle))
                     panic("failed fork for CPU %d", cpu);
    -
    - /* Make this the idle thread */
    - init_idle(idle, cpu);
    -
             idle->thread.eip = (unsigned long) start_secondary;
    -
    - /* Remove it from the pidhash */
    - unhash_process(idle);
    -
             /* start_eip had better be page-aligned! */
             start_eip = setup_trampoline();
     
    Index: mm1-2.6.8-rc3/arch/i386/mach-voyager/voyager_smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/i386/mach-voyager/voyager_smp.c 2004-08-05 05:30:43.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/i386/mach-voyager/voyager_smp.c 2004-08-05 20:51:52.557423968 -0700
    @@ -523,15 +523,6 @@
             return cpu_idle();
     }
     
    -static struct task_struct * __init
    -fork_by_hand(void)
    -{
    - struct pt_regs regs;
    - /* don't care about the eip and regs settings since we'll
    - * never reschedule the forked task. */
    - return copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    -}
    -
     
     /* Routine to kick start the given CPU and wait for it to report ready
      * (or timeout in startup). When this routine returns, the requested
    @@ -587,17 +578,10 @@
             hijack_source.idt.Segment = (start_phys_address >> 4) & 0xFFFF;
     
             cpucount++;
    - idle = fork_by_hand();
    + idle = fork_idle(cpu);
             if(IS_ERR(idle))
                     panic("failed fork for CPU%d", cpu);
    -
    - /* Make this the idle thread */
    - init_idle(idle, cpu);
    -
             idle->thread.eip = (unsigned long) start_secondary;
    -
    - /* Remove it from the pidhash */
    - unhash_process(idle);
             /* init_tasks (in sched.c) is indexed logically */
             stack_start.esp = (void *) idle->thread.esp;
     
    Index: mm1-2.6.8-rc3/arch/ia64/kernel/smpboot.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/ia64/kernel/smpboot.c 2004-08-05 05:30:37.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/ia64/kernel/smpboot.c 2004-08-05 20:48:49.420265048 -0700
    @@ -356,19 +356,10 @@
             return cpu_idle();
     }
     
    -static struct task_struct * __devinit
    -fork_by_hand (void)
    -{
    - /*
    - * Don't care about the IP and regs settings since we'll never reschedule the
    - * forked task.
    - */
    - return copy_process(CLONE_VM|CLONE_IDLETASK, 0, 0, 0, NULL, NULL);
    -}
    -
     struct create_idle {
             struct task_struct *idle;
             struct completion done;
    + int cpu;
     };
     
     void
    @@ -376,7 +367,7 @@
     {
             struct create_idle *c_idle = _c_idle;
     
    - c_idle->idle = fork_by_hand();
    + c_idle->idle = fork_idle(c_idle->cpu);
             complete(&c_idle->done);
     }
     
    @@ -384,10 +375,11 @@
     do_boot_cpu (int sapicid, int cpu)
     {
             int timeout;
    - struct create_idle c_idle;
    + struct create_idle c_idle = {
    + .cpu = cpu,
    + .done = COMPLETION_INITIALIZER(c_idle.done),
    + };
             DECLARE_WORK(work, do_fork_idle, &c_idle);
    -
    - init_completion(&c_idle.done);
             /*
              * We can't use kernel_thread since we must avoid to reschedule the child.
              */
    @@ -400,13 +392,6 @@
     
             if (IS_ERR(c_idle.idle))
                     panic("failed fork for CPU %d", cpu);
    -
    - /* Make this the idle thread */
    - init_idle(c_idle.idle, cpu);
    -
    - /* Remove it from the pidhash */
    - unhash_process(c_idle.idle);
    -
             task_for_booting_cpu = c_idle.idle;
     
             Dprintk("Sending wakeup vector %lu to AP 0x%x/0x%x.\n", ap_wakeup_vector, cpu, sapicid);
    Index: mm1-2.6.8-rc3/arch/mips/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/mips/kernel/smp.c 2004-08-05 05:30:36.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/mips/kernel/smp.c 2004-08-05 20:50:52.425565400 -0700
    @@ -254,16 +254,6 @@
             cpu_set(0, cpu_callin_map);
     }
     
    -static struct task_struct * __init fork_by_hand(void)
    -{
    - struct pt_regs regs;
    - /*
    - * don't care about the eip and regs settings since
    - * we'll never reschedule the forked task.
    - */
    - return copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    -}
    -
     /*
      * Startup the CPU with this logical number
      */
    @@ -275,16 +265,10 @@
              * The following code is purely to make sure
              * Linux can schedule processes on this slave.
              */
    - idle = fork_by_hand();
    + idle = fork_idle(cpu);
             if (IS_ERR(idle))
                     panic("failed fork for CPU %d\n", cpu);
     
    - /* Make this the idle thread */
    - init_idle(idle, cpu);
    -
    - /* Remove it from the pidhash */
    - unhash_process(idle);
    -
             prom_boot_secondary(cpu, idle);
     
             /* XXXKW timeout */
    Index: mm1-2.6.8-rc3/arch/parisc/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/parisc/kernel/smp.c 2004-08-05 05:30:36.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/parisc/kernel/smp.c 2004-08-05 20:45:09.552690000 -0700
    @@ -504,24 +504,6 @@
     
     #if 0
     /*
    - * Create the idle task for a new Slave CPU. DO NOT use kernel_thread()
    - * because that could end up calling schedule(). If it did, the new idle
    - * task could get scheduled before we had a chance to remove it from the
    - * run-queue...
    - */
    -static struct task_struct *fork_by_hand(void)
    -{
    - struct pt_regs regs;
    -
    - /*
    - * don't care about the regs settings since
    - * we'll never reschedule the forked task.
    - */
    - return copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    -}
    -
    -
    -/*
      * Bring one cpu online.
      */
     int __init smp_boot_one_cpu(int cpuid, int cpunum)
    @@ -539,12 +521,9 @@
              * Sheesh . . .
              */
     
    - idle = fork_by_hand();
    + idle = fork_idle(cpunum);
             if (IS_ERR(idle))
                     panic("SMP: fork failed for CPU:%d", cpuid);
    -
    - init_idle(idle, cpunum);
    - unhash_process(idle);
             idle->thread_info->cpu = cpunum;
     
             /* Let _start know what logical CPU we're booting
    Index: mm1-2.6.8-rc3/arch/ppc/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/ppc/kernel/smp.c 2004-08-05 05:30:36.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/ppc/kernel/smp.c 2004-08-05 20:51:11.882607480 -0700
    @@ -364,20 +364,15 @@
     
     int __cpu_up(unsigned int cpu)
     {
    - struct pt_regs regs;
             struct task_struct *p;
             char buf[32];
             int c;
     
             /* create a process for the processor */
             /* only regs.msr is actually used, and 0 is OK for it */
    - memset(&regs, 0, sizeof(struct pt_regs));
    - p = copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    + p = fork_idle(cpu);
             if (IS_ERR(p))
                     panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
    - init_idle(p, cpu);
    - unhash_process(p);
    -
             secondary_ti = p->thread_info;
             p->thread_info->cpu = cpu;
     
    Index: mm1-2.6.8-rc3/arch/ppc64/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/ppc64/kernel/smp.c 2004-08-05 05:30:37.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/ppc64/kernel/smp.c 2004-08-05 20:45:36.135648776 -0700
    @@ -800,20 +800,12 @@
     
     static void __init smp_create_idle(unsigned int cpu)
     {
    - struct pt_regs regs;
             struct task_struct *p;
     
             /* create a process for the processor */
    - /* only regs.msr is actually used, and 0 is OK for it */
    - memset(&regs, 0, sizeof(struct pt_regs));
    - p = copy_process(CLONE_VM | CLONE_IDLETASK,
    - 0, &regs, 0, NULL, NULL);
    + p = fork_idle(cpu);
             if (IS_ERR(p))
                     panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
    -
    - init_idle(p, cpu);
    - unhash_process(p);
    -
             paca[cpu].__current = p;
             current_set[cpu] = p->thread_info;
     }
    Index: mm1-2.6.8-rc3/arch/s390/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/s390/kernel/smp.c 2004-08-05 05:30:36.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/s390/kernel/smp.c 2004-08-05 20:44:04.400594624 -0700
    @@ -562,24 +562,15 @@
     
     static void __init smp_create_idle(unsigned int cpu)
     {
    - struct pt_regs regs;
             struct task_struct *p;
     
             /*
              * don't care about the psw and regs settings since we'll never
              * reschedule the forked task.
              */
    - memset(&regs, 0, sizeof(struct pt_regs));
    - p = copy_process(CLONE_VM | CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    + p = fork_idle(cpu);
             if (IS_ERR(p))
                     panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
    -
    - /* Make this the idle thread */
    - init_idle(p, cpu);
    -
    - /* Remove it from the pidhash */
    - unhash_process(p);
    -
             current_set[cpu] = p;
     }
     
    Index: mm1-2.6.8-rc3/arch/sh/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/sh/kernel/smp.c 2004-08-05 05:30:36.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/sh/kernel/smp.c 2004-08-05 20:50:24.947742664 -0700
    @@ -98,17 +98,12 @@
     int __cpu_up(unsigned int cpu)
     {
             struct task_struct *tsk;
    - struct pt_regs regs;
     
    - memset(&regs, 0, sizeof(struct pt_regs));
    - tsk = copy_process(CLONE_VM | CLONE_IDLETASK, 0, &regs, 0, 0, 0);
    + tsk = fork_idle(cpu);
     
             if (IS_ERR(tsk))
                     panic("Failed forking idle task for cpu %d\n", cpu);
             
    - init_idle(tsk, cpu);
    - unhash_process(tsk);
    -
             tsk->thread_info->cpu = cpu;
     
             cpu_set(cpu, cpu_online_map);
    Index: mm1-2.6.8-rc3/arch/sparc/kernel/sun4d_smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/sparc/kernel/sun4d_smp.c 2004-08-05 05:30:44.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/sparc/kernel/sun4d_smp.c 2004-08-05 20:42:08.015287880 -0700
    @@ -201,18 +201,9 @@
                             int no;
     
                             /* Cook up an idler for this guy. */
    - kernel_thread(NULL, NULL, CLONE_IDLETASK);
    -
    + p = fork_idle(p, cpu);
                             cpucount++;
    -
    - p = prev_task(&init_task);
    -
    - init_idle(p, i);
    -
                             current_set[i] = p->thread_info;
    -
    - unhash_process(p);
    -
                             for (no = 0; !cpu_find_by_instance(no, NULL, &mid)
                                          && mid != i; no++) ;
     
    Index: mm1-2.6.8-rc3/arch/sparc64/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/sparc64/kernel/smp.c 2004-08-05 05:30:43.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/sparc64/kernel/smp.c 2004-08-05 20:41:23.502054920 -0700
    @@ -302,14 +302,7 @@
             struct task_struct *p;
             int timeout, ret, cpu_node;
     
    - kernel_thread(NULL, NULL, CLONE_IDLETASK);
    -
    - p = prev_task(&init_task);
    -
    - init_idle(p, cpu);
    -
    - unhash_process(p);
    -
    + p = fork_idle(cpu);
             callin_flag = 0;
             cpu_new_thread = p->thread_info;
             cpu_set(cpu, cpu_callout_map);
    Index: mm1-2.6.8-rc3/arch/um/kernel/smp.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/um/kernel/smp.c 2004-08-05 05:30:39.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/um/kernel/smp.c 2004-08-05 20:49:33.637543000 -0700
    @@ -105,8 +105,7 @@
     
             current->thread.request.u.thread.proc = idle_proc;
             current->thread.request.u.thread.arg = (void *) cpu;
    - new_task = copy_process(CLONE_VM | CLONE_IDLETASK, 0, NULL, 0, NULL,
    - NULL);
    + new_task = fork_idle(cpu);
             if(IS_ERR(new_task))
                     panic("copy_process failed in idle_thread, error = %ld",
                           PTR_ERR(new_task));
    @@ -118,7 +117,6 @@
             CHOOSE_MODE(os_write_file(new_task->thread.mode.tt.switch_pipe[1], &c,
                               sizeof(c)),
                         ({ panic("skas mode doesn't support SMP"); }));
    - wake_up_forked_process(new_task);
             return(new_task);
     }
     
    Index: mm1-2.6.8-rc3/arch/x86_64/kernel/smpboot.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/arch/x86_64/kernel/smpboot.c 2004-08-05 05:30:36.000000000 -0700
    +++ mm1-2.6.8-rc3/arch/x86_64/kernel/smpboot.c 2004-08-05 20:44:34.780976104 -0700
    @@ -392,16 +392,6 @@
     extern volatile unsigned long init_rsp;
     extern void (*initial_code)(void);
     
    -static struct task_struct * __init fork_by_hand(void)
    -{
    - struct pt_regs regs;
    - /*
    - * don't care about the eip and regs settings since
    - * we'll never reschedule the forked task.
    - */
    - return copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    -}
    -
     #if APIC_DEBUG
     static inline void inquire_remote_apic(int apicid)
     {
    @@ -575,17 +565,11 @@
              * We can't use kernel_thread since we must avoid to
              * reschedule the child.
              */
    - idle = fork_by_hand();
    + idle = fork_idle(cpu);
             if (IS_ERR(idle))
                     panic("failed fork for CPU %d", cpu);
             x86_cpu_to_apicid[cpu] = apicid;
     
    - /* Make this the idle thread */
    - init_idle(idle,cpu);
    -
    - /* Remove it from the pidhash */
    - unhash_process(idle);
    -
             cpu_pda[cpu].pcurrent = idle;
     
             start_rip = setup_trampoline();
    Index: mm1-2.6.8-rc3/include/linux/sched.h
    ===================================================================
    --- mm1-2.6.8-rc3.orig/include/linux/sched.h 2004-08-05 05:30:44.000000000 -0700
    +++ mm1-2.6.8-rc3/include/linux/sched.h 2004-08-05 20:34:52.309525224 -0700
    @@ -968,7 +968,7 @@
     
     extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
     extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
    -extern struct task_struct * copy_process(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
    +task_t *fork_idle(int);
     
     #ifdef CONFIG_SMP
     extern void wait_task_inactive(task_t * p);
    Index: mm1-2.6.8-rc3/init/main.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/init/main.c 2004-08-05 05:30:44.000000000 -0700
    +++ mm1-2.6.8-rc3/init/main.c 2004-08-05 20:37:56.806477424 -0700
    @@ -495,15 +495,6 @@
              * time - but meanwhile we still have a functioning scheduler.
              */
             sched_init();
    -
    - /*
    - * Make us the idle thread. Technically, schedule() should not be
    - * called from this thread, however somewhere below it might be,
    - * but because we are the idle thread, we just pick up running again
    - * when this runqueue becomes "idle".
    - */
    - init_idle(current, smp_processor_id());
    -
             build_all_zonelists();
             page_alloc_init();
             trap_init();
    Index: mm1-2.6.8-rc3/kernel/fork.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/kernel/fork.c 2004-08-05 05:30:44.000000000 -0700
    +++ mm1-2.6.8-rc3/kernel/fork.c 2004-08-05 20:37:17.587439624 -0700
    @@ -881,7 +881,7 @@
      * parts of the process environment (as per the clone
      * flags). The actual kick-off is left to the caller.
      */
    -struct task_struct *copy_process(unsigned long clone_flags,
    +static task_t *copy_process(unsigned long clone_flags,
                                      unsigned long stack_start,
                                      struct pt_regs *regs,
                                      unsigned long stack_size,
    @@ -1181,6 +1181,20 @@
             goto fork_out;
     }
     
    +task_t * __init fork_idle(int cpu)
    +{
    + task_t *task;
    + struct pt_regs regs;
    +
    + memset(&regs, 0, sizeof(struct pt_regs));
    + task = copy_process(CLONE_VM|CLONE_IDLETASK, 0, &regs, 0, NULL, NULL);
    + if (!task)
    + return ERR_PTR(-ENOMEM);
    + init_idle(task, cpu);
    + unhash_process(task);
    + return task;
    +}
    +
     static inline int fork_traceflag (unsigned clone_flags)
     {
             if (clone_flags & (CLONE_UNTRACED | CLONE_IDLETASK))
    Index: mm1-2.6.8-rc3/kernel/sched.c
    ===================================================================
    --- mm1-2.6.8-rc3.orig/kernel/sched.c 2004-08-05 05:30:43.000000000 -0700
    +++ mm1-2.6.8-rc3/kernel/sched.c 2004-08-05 20:38:07.266887200 -0700
    @@ -4391,6 +4391,14 @@
              */
             atomic_inc(&init_mm.mm_count);
             enter_lazy_tlb(&init_mm, current);
    +
    + /*
    + * Make us the idle thread. Technically, schedule() should not be
    + * called from this thread, however somewhere below it might be,
    + * but because we are the idle thread, we just pick up running again
    + * when this runqueue becomes "idle".
    + */
    + init_idle(current, smp_processor_id());
     }
     
     #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  • Next message: Jean-Luc Cooke: "Re: [PATCH]"

    Relevant Pages