Merge branch 'topic/pcsp-fix' into topic/misc

6 files changed, 160 insertions, 54 deletions

diff --git a/init/Kconfig b/init/Kconfig
index c11da38837e5..f763762d544a 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -299,6 +299,13 @@ config CGROUP_NS
           for instance virtual servers and checkpoint/restart
           jobs.
 
+config CGROUP_FREEZER
+        bool "control group freezer subsystem"
+        depends on CGROUPS
+        help
+          Provides a way to freeze and unfreeze all tasks in a
+          cgroup.
+
 config CGROUP_DEVICE
         bool "Device controller for cgroups"
         depends on CGROUPS && EXPERIMENTAL
@@ -347,7 +354,7 @@ config RT_GROUP_SCHED
           setting below. If enabled, it will also make it impossible to
           schedule realtime tasks for non-root users until you allocate
           realtime bandwidth for them.
-          See Documentation/sched-rt-group.txt for more information.
+          See Documentation/scheduler/sched-rt-group.txt for more information.
 
 choice
         depends on GROUP_SCHED
@@ -394,16 +401,20 @@ config CGROUP_MEM_RES_CTLR
         depends on CGROUPS && RESOURCE_COUNTERS
         select MM_OWNER
         help
-          Provides a memory resource controller that manages both page cache and
-          RSS memory.
+          Provides a memory resource controller that manages both anonymous
+          memory and page cache. (See Documentation/controllers/memory.txt)
 
           Note that setting this option increases fixed memory overhead
-          associated with each page of memory in the system by 4/8 bytes
-          and also increases cache misses because struct page on many 64bit
-          systems will not fit into a single cache line anymore.
+          associated with each page of memory in the system. By this,
+          20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
+          usage tracking struct at boot. Total amount of this is printed out
+          at boot.
 
           Only enable when you're ok with these trade offs and really
-          sure you need the memory resource controller.
+          sure you need the memory resource controller. Even when you enable
+          this, you can set "cgroup_disable=memory" at your boot option to
+          disable memory resource controller and you can avoid overheads.
+          (and lose benefits of memory resource contoller)
 
           This config option also selects MM_OWNER config option, which
           could in turn add some fork/exit overhead.
@@ -713,6 +724,14 @@ config SHMEM
           option replaces shmem and tmpfs with the much simpler ramfs code,
           which may be appropriate on small systems without swap.
 
+config AIO
+        bool "Enable AIO support" if EMBEDDED
+        default y
+        help
+          This option enables POSIX asynchronous I/O which may by used
+          by some high performance threaded applications. Disabling
+          this option saves about 7k.
+
 config VM_EVENT_COUNTERS
         default y
         bool "Enable VM event counters for /proc/vmstat" if EMBEDDED
@@ -722,6 +741,15 @@ config VM_EVENT_COUNTERS
           on EMBEDDED systems.  /proc/vmstat will only show page counts
           if VM event counters are disabled.
 
+config PCI_QUIRKS
+        default y
+        bool "Enable PCI quirk workarounds" if EMBEDDED
+        depends on PCI
+        help
+          This enables workarounds for various PCI chipset
+          bugs/quirks. Disable this only if your target machine is
+          unaffected by PCI quirks.
+
 config SLUB_DEBUG
         default y
         bool "Enable SLUB debugging support" if EMBEDDED
@@ -743,8 +771,7 @@ config SLAB
         help
           The regular slab allocator that is established and known to work
           well in all environments. It organizes cache hot objects in
-          per cpu and per node queues. SLAB is the default choice for
-          a slab allocator.
+          per cpu and per node queues.
 
 config SLUB
         bool "SLUB (Unqueued Allocator)"
@@ -753,7 +780,8 @@ config SLUB
            instead of managing queues of cached objects (SLAB approach).
            Per cpu caching is realized using slabs of objects instead
            of queues of objects. SLUB can use memory efficiently
-           and has enhanced diagnostics.
+           and has enhanced diagnostics. SLUB is the default choice for
+           a slab allocator.
 
 config SLOB
         depends on EMBEDDED
@@ -771,6 +799,13 @@ config PROFILING
           Say Y here to enable the extended profiling support mechanisms used
           by profilers such as OProfile.
 
+#
+# Place an empty function call at each tracepoint site. Can be
+# dynamically changed for a probe function.
+#
+config TRACEPOINTS
+        bool
+
 config MARKERS
         bool "Activate markers"
         help
@@ -779,16 +814,6 @@ config MARKERS
 
 source "arch/Kconfig"
 
-config PROC_PAGE_MONITOR
-        default y
-        depends on PROC_FS && MMU
-        bool "Enable /proc page monitoring" if EMBEDDED
-        help
-          Various /proc files exist to monitor process memory utilization:
-          /proc/pid/smaps, /proc/pid/clear_refs, /proc/pid/pagemap,
-          /proc/kpagecount, and /proc/kpageflags. Disabling these
-          interfaces will reduce the size of the kernel by approximately 4kb.
-
 endmenu         # General setup
 
 config HAVE_GENERIC_DMA_COHERENT
diff --git a/init/do_mounts.c b/init/do_mounts.c
index 3715feb8446d..d055b1914c3d 100644
--- a/init/do_mounts.c
+++ b/init/do_mounts.c
@@ -263,6 +263,10 @@ retry:
                 printk("Please append a correct \"root=\" boot option; here are the available partitions:\n");
 
                 printk_all_partitions();
+#ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
+                printk("DEBUG_BLOCK_EXT_DEVT is enabled, you need to specify "
+                       "explicit textual name for \"root=\" boot option.\n");
+#endif
                 panic("VFS: Unable to mount root fs on %s", b);
         }
 
diff --git a/init/do_mounts_md.c b/init/do_mounts_md.c
index 693d24694a6c..d6da5cdd3c38 100644
--- a/init/do_mounts_md.c
+++ b/init/do_mounts_md.c
@@ -1,4 +1,4 @@
-
+#include <linux/delay.h>
 #include <linux/raid/md.h>
 
 #include "do_mounts.h"
@@ -12,7 +12,12 @@
  * The code for that is here.
  */
 
-static int __initdata raid_noautodetect, raid_autopart;
+#ifdef CONFIG_MD_AUTODETECT
+static int __initdata raid_noautodetect;
+#else
+static int __initdata raid_noautodetect=1;
+#endif
+static int __initdata raid_autopart;
 
 static struct {
         int minor;
@@ -252,6 +257,8 @@ static int __init raid_setup(char *str)
 
                 if (!strncmp(str, "noautodetect", wlen))
                         raid_noautodetect = 1;
+                if (!strncmp(str, "autodetect", wlen))
+                        raid_noautodetect = 0;
                 if (strncmp(str, "partitionable", wlen)==0)
                         raid_autopart = 1;
                 if (strncmp(str, "part", wlen)==0)
@@ -264,17 +271,32 @@ static int __init raid_setup(char *str)
 __setup("raid=", raid_setup);
 __setup("md=", md_setup);
 
+static void autodetect_raid(void)
+{
+        int fd;
+
+        /*
+         * Since we don't want to detect and use half a raid array, we need to
+         * wait for the known devices to complete their probing
+         */
+        printk(KERN_INFO "md: Waiting for all devices to be available before autodetect\n");
+        printk(KERN_INFO "md: If you don't use raid, use raid=noautodetect\n");
+        while (driver_probe_done() < 0)
+                msleep(100);
+        fd = sys_open("/dev/md0", 0, 0);
+        if (fd >= 0) {
+                sys_ioctl(fd, RAID_AUTORUN, raid_autopart);
+                sys_close(fd);
+        }
+}
+
 void __init md_run_setup(void)
 {
         create_dev("/dev/md0", MKDEV(MD_MAJOR, 0));
+
         if (raid_noautodetect)
-                printk(KERN_INFO "md: Skipping autodetection of RAID arrays. (raid=noautodetect)\n");
-        else {
-                int fd = sys_open("/dev/md0", 0, 0);
-                if (fd >= 0) {
-                        sys_ioctl(fd, RAID_AUTORUN, raid_autopart);
-                        sys_close(fd);
-                }
-        }
+                printk(KERN_INFO "md: Skipping autodetection of RAID arrays. (raid=autodetect will force)\n");
+        else
+                autodetect_raid();
         md_setup_drive();
 }
diff --git a/init/do_mounts_rd.c b/init/do_mounts_rd.c
index fedef93b586f..a7c748fa977a 100644
--- a/init/do_mounts_rd.c
+++ b/init/do_mounts_rd.c
@@ -71,7 +71,7 @@ identify_ramdisk_image(int fd, int start_block)
         sys_read(fd, buf, size);
 
         /*
-         * If it matches the gzip magic numbers, return -1
+         * If it matches the gzip magic numbers, return 0
          */
         if (buf[0] == 037 && ((buf[1] == 0213) || (buf[1] == 0236))) {
                 printk(KERN_NOTICE
diff --git a/init/initramfs.c b/init/initramfs.c
index 644fc01ad5f0..4f5ba75aaa7c 100644
--- a/init/initramfs.c
+++ b/init/initramfs.c
@@ -6,6 +6,7 @@
 #include <linux/delay.h>
 #include <linux/string.h>
 #include <linux/syscalls.h>
+#include <linux/utime.h>
 
 static __initdata char *message;
 static void __init error(char *x)
@@ -72,6 +73,49 @@ static void __init free_hash(void)
         }
 }
 
+static long __init do_utime(char __user *filename, time_t mtime)
+{
+        struct timespec t[2];
+
+        t[0].tv_sec = mtime;
+        t[0].tv_nsec = 0;
+        t[1].tv_sec = mtime;
+        t[1].tv_nsec = 0;
+
+        return do_utimes(AT_FDCWD, filename, t, AT_SYMLINK_NOFOLLOW);
+}
+
+static __initdata LIST_HEAD(dir_list);
+struct dir_entry {
+        struct list_head list;
+        char *name;
+        time_t mtime;
+};
+
+static void __init dir_add(const char *name, time_t mtime)
+{
+        struct dir_entry *de = kmalloc(sizeof(struct dir_entry), GFP_KERNEL);
+        if (!de)
+                panic("can't allocate dir_entry buffer");
+        INIT_LIST_HEAD(&de->list);
+        de->name = kstrdup(name, GFP_KERNEL);
+        de->mtime = mtime;
+        list_add(&de->list, &dir_list);
+}
+
+static void __init dir_utime(void)
+{
+        struct dir_entry *de, *tmp;
+        list_for_each_entry_safe(de, tmp, &dir_list, list) {
+                list_del(&de->list);
+                do_utime(de->name, de->mtime);
+                kfree(de->name);
+                kfree(de);
+        }
+}
+
+static __initdata time_t mtime;
+
 /* cpio header parsing */
 
 static __initdata unsigned long ino, major, minor, nlink;
@@ -97,6 +141,7 @@ static void __init parse_header(char *s)
         uid = parsed[2];
         gid = parsed[3];
         nlink = parsed[4];
+        mtime = parsed[5];
         body_len = parsed[6];
         major = parsed[7];
         minor = parsed[8];
@@ -130,6 +175,7 @@ static inline void __init eat(unsigned n)
         count -= n;
 }
 
+static __initdata char *vcollected;
 static __initdata char *collected;
 static __initdata int remains;
 static __initdata char *collect;
@@ -271,6 +317,7 @@ static int __init do_name(void)
                         if (wfd >= 0) {
                                 sys_fchown(wfd, uid, gid);
                                 sys_fchmod(wfd, mode);
+                                vcollected = kstrdup(collected, GFP_KERNEL);
                                 state = CopyFile;
                         }
                 }
@@ -278,12 +325,14 @@ static int __init do_name(void)
                 sys_mkdir(collected, mode);
                 sys_chown(collected, uid, gid);
                 sys_chmod(collected, mode);
+                dir_add(collected, mtime);
         } else if (S_ISBLK(mode) || S_ISCHR(mode) ||
                    S_ISFIFO(mode) || S_ISSOCK(mode)) {
                 if (maybe_link() == 0) {
                         sys_mknod(collected, mode, rdev);
                         sys_chown(collected, uid, gid);
                         sys_chmod(collected, mode);
+                        do_utime(collected, mtime);
                 }
         }
         return 0;
@@ -294,6 +343,8 @@ static int __init do_copy(void)
         if (count >= body_len) {
                 sys_write(wfd, victim, body_len);
                 sys_close(wfd);
+                do_utime(vcollected, mtime);
+                kfree(vcollected);
                 eat(body_len);
                 state = SkipIt;
                 return 0;
@@ -311,6 +362,7 @@ static int __init do_symlink(void)
         clean_path(collected, 0);
         sys_symlink(collected + N_ALIGN(name_len), collected);
         sys_lchown(collected, uid, gid);
+        do_utime(collected, mtime);
         state = SkipIt;
         next_state = Reset;
         return 0;
@@ -466,6 +518,7 @@ static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)
                 buf += inptr;
                 len -= inptr;
         }
+        dir_utime();
         kfree(window);
         kfree(name_buf);
         kfree(symlink_buf);
diff --git a/init/main.c b/init/main.c
index 3820323c4c84..7e117a231af1 100644
--- a/init/main.c
+++ b/init/main.c
@@ -27,6 +27,7 @@
 #include <linux/gfp.h>
 #include <linux/percpu.h>
 #include <linux/kmod.h>
+#include <linux/vmalloc.h>
 #include <linux/kernel_stat.h>
 #include <linux/start_kernel.h>
 #include <linux/security.h>
@@ -51,6 +52,7 @@
 #include <linux/key.h>
 #include <linux/unwind.h>
 #include <linux/buffer_head.h>
+#include <linux/page_cgroup.h>
 #include <linux/debug_locks.h>
 #include <linux/debugobjects.h>
 #include <linux/lockdep.h>
@@ -60,6 +62,7 @@
 #include <linux/sched.h>
 #include <linux/signal.h>
 #include <linux/idr.h>
+#include <linux/ftrace.h>
 
 #include <asm/io.h>
 #include <asm/bugs.h>
@@ -642,8 +645,10 @@ asmlinkage void __init start_kernel(void)
                 initrd_start = 0;
         }
 #endif
+        vmalloc_init();
         vfs_caches_init_early();
         cpuset_init_early();
+        page_cgroup_init();
         mem_init();
         enable_debug_pagealloc();
         cpu_hotplug_init();
@@ -667,7 +672,6 @@ asmlinkage void __init start_kernel(void)
         fork_init(num_physpages);
         proc_caches_init();
         buffer_init();
-        unnamed_dev_init();
         key_init();
         security_init();
         vfs_caches_init(num_physpages);
@@ -687,46 +691,43 @@ asmlinkage void __init start_kernel(void)
 
         acpi_early_init(); /* before LAPIC and SMP init */
 
+        ftrace_init();
+
         /* Do the rest non-__init'ed, we're now alive */
         rest_init();
 }
 
 static int initcall_debug;
-
-static int __init initcall_debug_setup(char *str)
-{
-        initcall_debug = 1;
-        return 1;
-}
-__setup("initcall_debug", initcall_debug_setup);
+core_param(initcall_debug, initcall_debug, bool, 0644);
 
 int do_one_initcall(initcall_t fn)
 {
         int count = preempt_count();
-        ktime_t t0, t1, delta;
+        ktime_t delta;
         char msgbuf[64];
-        int result;
+        struct boot_trace it;
 
         if (initcall_debug) {
-                printk("calling  %pF\n", fn);
-                t0 = ktime_get();
+                it.caller = task_pid_nr(current);
+                printk("calling  %pF @ %i\n", fn, it.caller);
+                it.calltime = ktime_get();
         }
 
-        result = fn();
+        it.result = fn();
 
         if (initcall_debug) {
-                t1 = ktime_get();
-                delta = ktime_sub(t1, t0);
-
-                printk("initcall %pF returned %d after %Ld msecs\n",
-                        fn, result,
-                        (unsigned long long) delta.tv64 >> 20);
+                it.rettime = ktime_get();
+                delta = ktime_sub(it.rettime, it.calltime);
+                it.duration = (unsigned long long) delta.tv64 >> 10;
+                printk("initcall %pF returned %d after %Ld usecs\n", fn,
+                        it.result, it.duration);
+                trace_boot(&it, fn);
         }
 
         msgbuf[0] = 0;
 
-        if (result && result != -ENODEV && initcall_debug)
-                sprintf(msgbuf, "error code %d ", result);
+        if (it.result && it.result != -ENODEV && initcall_debug)
+                sprintf(msgbuf, "error code %d ", it.result);
 
         if (preempt_count() != count) {
                 strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
@@ -740,7 +741,7 @@ int do_one_initcall(initcall_t fn)
                 printk("initcall %pF returned with %s\n", fn, msgbuf);
         }
 
-        return result;
+        return it.result;
 }
 
 
@@ -767,7 +768,6 @@ static void __init do_initcalls(void)
 static void __init do_basic_setup(void)
 {
         rcu_init_sched(); /* needed by module_init stage. */
-        /* drivers will send hotplug events */
         init_workqueues();
         usermodehelper_init();
         driver_init();
@@ -855,6 +855,7 @@ static int __init kernel_init(void * unused)
         smp_prepare_cpus(setup_max_cpus);
 
         do_pre_smp_initcalls();
+        start_boot_trace();
 
         smp_init();
         sched_init_smp();
@@ -881,6 +882,7 @@ static int __init kernel_init(void * unused)
          * we're essentially up and running. Get rid of the
          * initmem segments and start the user-mode stuff..
          */
+        stop_boot_trace();
         init_post();
         return 0;
 }