8 files changed, 171 insertions, 64 deletions

diff --git a/init/Kconfig b/init/Kconfig
index 3f42cd66f0f..a30fe085940 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -27,6 +27,9 @@ config IRQ_WORK
         bool
         depends on HAVE_IRQ_WORK
 
+config BUILDTIME_EXTABLE_SORT
+        bool
+
 menu "General setup"
 
 config EXPERIMENTAL
@@ -438,15 +441,6 @@ config PREEMPT_RCU
           This option enables preemptible-RCU code that is common between
           the TREE_PREEMPT_RCU and TINY_PREEMPT_RCU implementations.
 
-config RCU_TRACE
-        bool "Enable tracing for RCU"
-        help
-          This option provides tracing in RCU which presents stats
-          in debugfs for debugging RCU implementation.
-
-          Say Y here if you want to enable RCU tracing
-          Say N if you are unsure.
-
 config RCU_FANOUT
         int "Tree-based hierarchical RCU fanout value"
         range 2 64 if 64BIT
@@ -467,6 +461,33 @@ config RCU_FANOUT
           Select a specific number if testing RCU itself.
           Take the default if unsure.
 
+config RCU_FANOUT_LEAF
+        int "Tree-based hierarchical RCU leaf-level fanout value"
+        range 2 RCU_FANOUT if 64BIT
+        range 2 RCU_FANOUT if !64BIT
+        depends on TREE_RCU || TREE_PREEMPT_RCU
+        default 16
+        help
+          This option controls the leaf-level fanout of hierarchical
+          implementations of RCU, and allows trading off cache misses
+          against lock contention.  Systems that synchronize their
+          scheduling-clock interrupts for energy-efficiency reasons will
+          want the default because the smaller leaf-level fanout keeps
+          lock contention levels acceptably low.  Very large systems
+          (hundreds or thousands of CPUs) will instead want to set this
+          value to the maximum value possible in order to reduce the
+          number of cache misses incurred during RCU's grace-period
+          initialization.  These systems tend to run CPU-bound, and thus
+          are not helped by synchronized interrupts, and thus tend to
+          skew them, which reduces lock contention enough that large
+          leaf-level fanouts work well.
+
+          Select a specific number if testing RCU itself.
+
+          Select the maximum permissible value for large systems.
+
+          Take the default if unsure.
+
 config RCU_FANOUT_EXACT
         bool "Disable tree-based hierarchical RCU auto-balancing"
         depends on TREE_RCU || TREE_PREEMPT_RCU
@@ -524,10 +545,25 @@ config RCU_BOOST_PRIO
         depends on RCU_BOOST
         default 1
         help
-          This option specifies the real-time priority to which preempted
-          RCU readers are to be boosted.  If you are working with CPU-bound
-          real-time applications, you should specify a priority higher then
-          the highest-priority CPU-bound application.
+          This option specifies the real-time priority to which long-term
+          preempted RCU readers are to be boosted.  If you are working
+          with a real-time application that has one or more CPU-bound
+          threads running at a real-time priority level, you should set
+          RCU_BOOST_PRIO to a priority higher then the highest-priority
+          real-time CPU-bound thread.  The default RCU_BOOST_PRIO value
+          of 1 is appropriate in the common case, which is real-time
+          applications that do not have any CPU-bound threads.
+
+          Some real-time applications might not have a single real-time
+          thread that saturates a given CPU, but instead might have
+          multiple real-time threads that, taken together, fully utilize
+          that CPU.  In this case, you should set RCU_BOOST_PRIO to
+          a priority higher than the lowest-priority thread that is
+          conspiring to prevent the CPU from running any non-real-time
+          tasks.  For example, if one thread at priority 10 and another
+          thread at priority 5 are between themselves fully consuming
+          the CPU time on a given CPU, then RCU_BOOST_PRIO should be
+          set to priority 6 or higher.
 
           Specify the real-time priority, or take the default if unsure.
 
@@ -1165,7 +1201,7 @@ menu "Kernel Performance Events And Counters"
 
 config PERF_EVENTS
         bool "Kernel performance events and counters"
-        default y if (PROFILING || PERF_COUNTERS)
+        default y if PROFILING
         depends on HAVE_PERF_EVENTS
         select ANON_INODES
         select IRQ_WORK
@@ -1192,18 +1228,6 @@ config PERF_EVENTS
 
           Say Y if unsure.
 
-config PERF_COUNTERS
-        bool "Kernel performance counters (old config option)"
-        depends on HAVE_PERF_EVENTS
-        help
-          This config has been obsoleted by the PERF_EVENTS
-          config option - please see that one for details.
-
-          It has no effect on the kernel whether you enable
-          it or not, it is a compatibility placeholder.
-
-          Say N if unsure.
-
 config DEBUG_PERF_USE_VMALLOC
         default n
         bool "Debug: use vmalloc to back perf mmap() buffers"
@@ -1423,8 +1447,8 @@ endif # MODULES
 config INIT_ALL_POSSIBLE
         bool
         help
-          Back when each arch used to define their own cpu_online_map and
-          cpu_possible_map, some of them chose to initialize cpu_possible_map
+          Back when each arch used to define their own cpu_online_mask and
+          cpu_possible_mask, some of them chose to initialize cpu_possible_mask
           with all 1s, and others with all 0s.  When they were centralised,
           it was better to provide this option than to break all the archs
           and have several arch maintainers pursuing me down dark alleys.
diff --git a/init/Makefile b/init/Makefile
index 0bf677aa087..7bc47ee31c3 100644
--- a/init/Makefile
+++ b/init/Makefile
@@ -10,6 +10,10 @@ obj-$(CONFIG_BLK_DEV_INITRD)   += initramfs.o
 endif
 obj-$(CONFIG_GENERIC_CALIBRATE_DELAY) += calibrate.o
 
+ifneq ($(CONFIG_ARCH_INIT_TASK),y)
+obj-y                          += init_task.o
+endif
+
 mounts-y                        := do_mounts.o
 mounts-$(CONFIG_BLK_DEV_RAM)    += do_mounts_rd.o
 mounts-$(CONFIG_BLK_DEV_INITRD) += do_mounts_initrd.o
diff --git a/init/calibrate.c b/init/calibrate.c
index 5f117ca9e06..fda0a7b0f06 100644
--- a/init/calibrate.c
+++ b/init/calibrate.c
@@ -267,7 +267,8 @@ void __cpuinit calibrate_delay(void)
 
         if (per_cpu(cpu_loops_per_jiffy, this_cpu)) {
                 lpj = per_cpu(cpu_loops_per_jiffy, this_cpu);
-                pr_info("Calibrating delay loop (skipped) "
+                if (!printed)
+                        pr_info("Calibrating delay loop (skipped) "
                                 "already calibrated this CPU");
         } else if (preset_lpj) {
                 lpj = preset_lpj;
diff --git a/init/do_mounts.c b/init/do_mounts.c
index 2974c8b3b35..42b0707c348 100644
--- a/init/do_mounts.c
+++ b/init/do_mounts.c
@@ -373,8 +373,8 @@ retry:
 #ifdef CONFIG_BLOCK
                 __bdevname(ROOT_DEV, b);
 #endif
-                printk("VFS: Cannot open root device \"%s\" or %s\n",
-                                root_device_name, b);
+                printk("VFS: Cannot open root device \"%s\" or %s: error %d\n",
+                                root_device_name, b, err);
                 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
 
                 printk_all_partitions();
@@ -472,7 +472,7 @@ void __init change_floppy(char *fmt, ...)
 void __init mount_root(void)
 {
 #ifdef CONFIG_ROOT_NFS
-        if (MAJOR(ROOT_DEV) == UNNAMED_MAJOR) {
+        if (ROOT_DEV == Root_NFS) {
                 if (mount_nfs_root())
                         return;
 
diff --git a/init/do_mounts_initrd.c b/init/do_mounts_initrd.c
index 3098a38f3ae..9047330c73e 100644
--- a/init/do_mounts_initrd.c
+++ b/init/do_mounts_initrd.c
@@ -2,7 +2,6 @@
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/minix_fs.h>
-#include <linux/ext2_fs.h>
 #include <linux/romfs_fs.h>
 #include <linux/initrd.h>
 #include <linux/sched.h>
diff --git a/init/do_mounts_rd.c b/init/do_mounts_rd.c
index 887629e24c5..6212586df29 100644
--- a/init/do_mounts_rd.c
+++ b/init/do_mounts_rd.c
@@ -54,20 +54,19 @@ identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
 {
         const int size = 512;
         struct minix_super_block *minixsb;
-        struct ext2_super_block *ext2sb;
         struct romfs_super_block *romfsb;
         struct cramfs_super *cramfsb;
         struct squashfs_super_block *squashfsb;
         int nblocks = -1;
         unsigned char *buf;
         const char *compress_name;
+        unsigned long n;
 
         buf = kmalloc(size, GFP_KERNEL);
         if (!buf)
                 return -ENOMEM;
 
         minixsb = (struct minix_super_block *) buf;
-        ext2sb = (struct ext2_super_block *) buf;
         romfsb = (struct romfs_super_block *) buf;
         cramfsb = (struct cramfs_super *) buf;
         squashfsb = (struct squashfs_super_block *) buf;
@@ -150,12 +149,12 @@ identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
         }
 
         /* Try ext2 */
-        if (ext2sb->s_magic == cpu_to_le16(EXT2_SUPER_MAGIC)) {
+        n = ext2_image_size(buf);
+        if (n) {
                 printk(KERN_NOTICE
                        "RAMDISK: ext2 filesystem found at block %d\n",
                        start_block);
-                nblocks = le32_to_cpu(ext2sb->s_blocks_count) <<
-                        le32_to_cpu(ext2sb->s_log_block_size);
+                nblocks = n;
                 goto done;
         }
 
@@ -178,7 +177,7 @@ int __init rd_load_image(char *from)
         char *buf = NULL;
         unsigned short rotate = 0;
         decompress_fn decompressor = NULL;
-#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
+#if !defined(CONFIG_S390)
         char rotator[4] = { '|' , '/' , '-' , '\\' };
 #endif
 
@@ -264,7 +263,7 @@ int __init rd_load_image(char *from)
                 }
                 sys_read(in_fd, buf, BLOCK_SIZE);
                 sys_write(out_fd, buf, BLOCK_SIZE);
-#if !defined(CONFIG_S390) && !defined(CONFIG_PPC_ISERIES)
+#if !defined(CONFIG_S390)
                 if (!(i % 16)) {
                         printk("%c\b", rotator[rotate & 0x3]);
                         rotate++;
diff --git a/init/init_task.c b/init/init_task.c
new file mode 100644
index 00000000000..8b2f3996b03
--- /dev/null
+++ b/init/init_task.c
@@ -0,0 +1,24 @@
+#include <linux/init_task.h>
+#include <linux/export.h>
+#include <linux/mqueue.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+
+#include <asm/pgtable.h>
+#include <asm/uaccess.h>
+
+static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
+static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
+
+/* Initial task structure */
+struct task_struct init_task = INIT_TASK(init_task);
+EXPORT_SYMBOL(init_task);
+
+/*
+ * Initial thread structure. Alignment of this is handled by a special
+ * linker map entry.
+ */
+union thread_union init_thread_union __init_task_data =
+        { INIT_THREAD_INFO(init_task) };
diff --git a/init/main.c b/init/main.c
index ff49a6dacfb..1ca6b32c482 100644
--- a/init/main.c
+++ b/init/main.c
@@ -87,7 +87,6 @@ extern void mca_init(void);
 extern void sbus_init(void);
 extern void prio_tree_init(void);
 extern void radix_tree_init(void);
-extern void free_initmem(void);
 #ifndef CONFIG_DEBUG_RODATA
 static inline void mark_rodata_ro(void) { }
 #endif
@@ -226,13 +225,9 @@ static int __init loglevel(char *str)
 
 early_param("loglevel", loglevel);
 
-/*
- * Unknown boot options get handed to init, unless they look like
- * unused parameters (modprobe will find them in /proc/cmdline).
- */
-static int __init unknown_bootoption(char *param, char *val)
+/* Change NUL term back to "=", to make "param" the whole string. */
+static int __init repair_env_string(char *param, char *val, const char *unused)
 {
-        /* Change NUL term back to "=", to make "param" the whole string. */
         if (val) {
                 /* param=val or param="val"? */
                 if (val == param+strlen(param)+1)
@@ -244,6 +239,16 @@ static int __init unknown_bootoption(char *param, char *val)
                 } else
                         BUG();
         }
+        return 0;
+}
+
+/*
+ * Unknown boot options get handed to init, unless they look like
+ * unused parameters (modprobe will find them in /proc/cmdline).
+ */
+static int __init unknown_bootoption(char *param, char *val, const char *unused)
+{
+        repair_env_string(param, val, unused);
 
         /* Handle obsolete-style parameters */
         if (obsolete_checksetup(param))
@@ -374,16 +379,13 @@ static noinline void __init_refok rest_init(void)
          * at least once to get things moving:
          */
         init_idle_bootup_task(current);
-        preempt_enable_no_resched();
-        schedule();
-
+        schedule_preempt_disabled();
         /* Call into cpu_idle with preempt disabled */
-        preempt_disable();
         cpu_idle();
 }
 
 /* Check for early params. */
-static int __init do_early_param(char *param, char *val)
+static int __init do_early_param(char *param, char *val, const char *unused)
 {
         const struct obs_kernel_param *p;
 
@@ -403,7 +405,7 @@ static int __init do_early_param(char *param, char *val)
 
 void __init parse_early_options(char *cmdline)
 {
-        parse_args("early options", cmdline, NULL, 0, do_early_param);
+        parse_args("early options", cmdline, NULL, 0, 0, 0, do_early_param);
 }
 
 /* Arch code calls this early on, or if not, just before other parsing. */
@@ -449,8 +451,8 @@ void __init __weak thread_info_cache_init(void)
 static void __init mm_init(void)
 {
         /*
-         * page_cgroup requires countinous pages as memmap
-         * and it's bigger than MAX_ORDER unless SPARSEMEM.
+         * page_cgroup requires contiguous pages,
+         * bigger than MAX_ORDER unless SPARSEMEM.
          */
         page_cgroup_init_flatmem();
         mem_init();
@@ -506,7 +508,7 @@ asmlinkage void __init start_kernel(void)
         parse_early_param();
         parse_args("Booting kernel", static_command_line, __start___param,
                    __stop___param - __start___param,
-                   &unknown_bootoption);
+                   0, 0, &unknown_bootoption);
 
         jump_label_init();
 
@@ -558,9 +560,6 @@ asmlinkage void __init start_kernel(void)
         early_boot_irqs_disabled = false;
         local_irq_enable();
 
-        /* Interrupts are enabled now so all GFP allocations are safe. */
-        gfp_allowed_mask = __GFP_BITS_MASK;
-
         kmem_cache_init_late();
 
         /*
@@ -702,16 +701,69 @@ int __init_or_module do_one_initcall(initcall_t fn)
 }
 
 
-extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
-
-static void __init do_initcalls(void)
+extern initcall_t __initcall_start[];
+extern initcall_t __initcall0_start[];
+extern initcall_t __initcall1_start[];
+extern initcall_t __initcall2_start[];
+extern initcall_t __initcall3_start[];
+extern initcall_t __initcall4_start[];
+extern initcall_t __initcall5_start[];
+extern initcall_t __initcall6_start[];
+extern initcall_t __initcall7_start[];
+extern initcall_t __initcall_end[];
+
+static initcall_t *initcall_levels[] __initdata = {
+        __initcall0_start,
+        __initcall1_start,
+        __initcall2_start,
+        __initcall3_start,
+        __initcall4_start,
+        __initcall5_start,
+        __initcall6_start,
+        __initcall7_start,
+        __initcall_end,
+};
+
+static char *initcall_level_names[] __initdata = {
+        "early",
+        "core",
+        "postcore",
+        "arch",
+        "subsys",
+        "fs",
+        "device",
+        "late",
+};
+
+static void __init do_initcall_level(int level)
 {
+        extern const struct kernel_param __start___param[], __stop___param[];
         initcall_t *fn;
 
-        for (fn = __early_initcall_end; fn < __initcall_end; fn++)
+        strcpy(static_command_line, saved_command_line);
+        parse_args(initcall_level_names[level],
+                   static_command_line, __start___param,
+                   __stop___param - __start___param,
+                   level, level,
+                   &repair_env_string);
+
+        for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
                 do_one_initcall(*fn);
 }
 
+static void __init do_initcalls(void)
+{
+        int level;
+
+        for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++) {
+                pr_info("initlevel:%d=%s, %d registered initcalls\n",
+                        level, initcall_level_names[level],
+                        (int) (initcall_levels[level+1]
+                                - initcall_levels[level]));
+                do_initcall_level(level);
+        }
+}
+
 /*
  * Ok, the machine is now initialized. None of the devices
  * have been touched yet, but the CPU subsystem is up and
@@ -735,7 +787,7 @@ static void __init do_pre_smp_initcalls(void)
 {
         initcall_t *fn;
 
-        for (fn = __initcall_start; fn < __early_initcall_end; fn++)
+        for (fn = __initcall_start; fn < __initcall0_start; fn++)
                 do_one_initcall(*fn);
 }
 
@@ -792,6 +844,10 @@ static int __init kernel_init(void * unused)
          * Wait until kthreadd is all set-up.
          */
         wait_for_completion(&kthreadd_done);
+
+        /* Now the scheduler is fully set up and can do blocking allocations */
+        gfp_allowed_mask = __GFP_BITS_MASK;
+
         /*
          * init can allocate pages on any node
          */