Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

9 files changed, 527 insertions, 321 deletions

diff --git a/init/Kconfig b/init/Kconfig
index 2de5b1cbadd9..412c21b00d51 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -19,7 +19,13 @@ config DEFCONFIG_LIST
 config CONSTRUCTORS
         bool
         depends on !UML
-        default y
+
+config HAVE_IRQ_WORK
+        bool
+
+config IRQ_WORK
+        bool
+        depends on HAVE_IRQ_WORK
 
 menu "General setup"
 
@@ -62,11 +68,6 @@ config BROKEN_ON_SMP
         depends on BROKEN || !SMP
         default y
 
-config LOCK_KERNEL
-        bool
-        depends on SMP || PREEMPT
-        default y
-
 config INIT_ENV_ARG_LIMIT
         int
         default 32 if !UML
@@ -123,13 +124,16 @@ config HAVE_KERNEL_BZIP2
 config HAVE_KERNEL_LZMA
         bool
 
+config HAVE_KERNEL_XZ
+        bool
+
 config HAVE_KERNEL_LZO
         bool
 
 choice
         prompt "Kernel compression mode"
         default KERNEL_GZIP
-        depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA || HAVE_KERNEL_LZO
+        depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA || HAVE_KERNEL_XZ || HAVE_KERNEL_LZO
         help
           The linux kernel is a kind of self-extracting executable.
           Several compression algorithms are available, which differ
@@ -174,16 +178,40 @@ config KERNEL_LZMA
           two. Compression is slowest.  The kernel size is about 33%
           smaller with LZMA in comparison to gzip.
 
+config KERNEL_XZ
+        bool "XZ"
+        depends on HAVE_KERNEL_XZ
+        help
+          XZ uses the LZMA2 algorithm and instruction set specific
+          BCJ filters which can improve compression ratio of executable
+          code. The size of the kernel is about 30% smaller with XZ in
+          comparison to gzip. On architectures for which there is a BCJ
+          filter (i386, x86_64, ARM, IA-64, PowerPC, and SPARC), XZ
+          will create a few percent smaller kernel than plain LZMA.
+
+          The speed is about the same as with LZMA: The decompression
+          speed of XZ is better than that of bzip2 but worse than gzip
+          and LZO. Compression is slow.
+
 config KERNEL_LZO
         bool "LZO"
         depends on HAVE_KERNEL_LZO
         help
           Its compression ratio is the poorest among the 4. The kernel
-          size is about about 10% bigger than gzip; however its speed
+          size is about 10% bigger than gzip; however its speed
           (both compression and decompression) is the fastest.
 
 endchoice
 
+config DEFAULT_HOSTNAME
+        string "Default hostname"
+        default "(none)"
+        help
+          This option determines the default system hostname before userspace
+          calls sethostname(2). The kernel traditionally uses "(none)" here,
+          but you may wish to use a different default here to make a minimal
+          system more usable with less configuration.
+
 config SWAP
         bool "Support for paging of anonymous memory (swap)"
         depends on MMU && BLOCK
@@ -262,6 +290,18 @@ config BSD_PROCESS_ACCT_V3
           for processing it. A preliminary version of these tools is available
           at <http://www.gnu.org/software/acct/>.
 
+config FHANDLE
+        bool "open by fhandle syscalls"
+        select EXPORTFS
+        help
+          If you say Y here, a user level program will be able to map
+          file names to handle and then later use the handle for
+          different file system operations. This is useful in implementing
+          userspace file servers, which now track files using handles instead
+          of names. The handle would remain the same even if file names
+          get renamed. Enables open_by_handle_at(2) and name_to_handle_at(2)
+          syscalls.
+
 config TASKSTATS
         bool "Export task/process statistics through netlink (EXPERIMENTAL)"
         depends on NET
@@ -332,6 +372,8 @@ config AUDIT_TREE
         depends on AUDITSYSCALL
         select FSNOTIFY
 
+source "kernel/irq/Kconfig"
+
 menu "RCU Subsystem"
 
 choice
@@ -340,6 +382,7 @@ choice
 
 config TREE_RCU
         bool "Tree-based hierarchical RCU"
+        depends on !PREEMPT && SMP
         help
           This option selects the RCU implementation that is
           designed for very large SMP system with hundreds or
@@ -347,7 +390,7 @@ config TREE_RCU
           smaller systems.
 
 config TREE_PREEMPT_RCU
-        bool "Preemptable tree-based hierarchical RCU"
+        bool "Preemptible tree-based hierarchical RCU"
         depends on PREEMPT
         help
           This option selects the RCU implementation that is
@@ -365,11 +408,24 @@ config TINY_RCU
           is not required.  This option greatly reduces the
           memory footprint of RCU.
 
+config TINY_PREEMPT_RCU
+        bool "Preemptible UP-only small-memory-footprint RCU"
+        depends on !SMP && PREEMPT
+        help
+          This option selects the RCU implementation that is designed
+          for real-time UP systems.  This option greatly reduces the
+          memory footprint of RCU.
+
 endchoice
 
+config PREEMPT_RCU
+        def_bool ( TREE_PREEMPT_RCU || TINY_PREEMPT_RCU )
+        help
+          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"
-        depends on TREE_RCU || TREE_PREEMPT_RCU
         help
           This option provides tracing in RCU which presents stats
           in debugfs for debugging RCU implementation.
@@ -387,9 +443,12 @@ config RCU_FANOUT
         help
           This option controls the fanout of hierarchical implementations
           of RCU, allowing RCU to work efficiently on machines with
-          large numbers of CPUs.  This value must be at least the cube
-          root of NR_CPUS, which allows NR_CPUS up to 32,768 for 32-bit
-          systems and up to 262,144 for 64-bit systems.
+          large numbers of CPUs.  This value must be at least the fourth
+          root of NR_CPUS, which allows NR_CPUS to be insanely large.
+          The default value of RCU_FANOUT should be used for production
+          systems, but if you are stress-testing the RCU implementation
+          itself, small RCU_FANOUT values allow you to test large-system
+          code paths on small(er) systems.
 
           Select a specific number if testing RCU itself.
           Take the default if unsure.
@@ -432,6 +491,45 @@ config TREE_RCU_TRACE
           TREE_PREEMPT_RCU implementations, permitting Makefile to
           trivially select kernel/rcutree_trace.c.
 
+config RCU_BOOST
+        bool "Enable RCU priority boosting"
+        depends on RT_MUTEXES && PREEMPT_RCU
+        default n
+        help
+          This option boosts the priority of preempted RCU readers that
+          block the current preemptible RCU grace period for too long.
+          This option also prevents heavy loads from blocking RCU
+          callback invocation for all flavors of RCU.
+
+          Say Y here if you are working with real-time apps or heavy loads
+          Say N here if you are unsure.
+
+config RCU_BOOST_PRIO
+        int "Real-time priority to boost RCU readers to"
+        range 1 99
+        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.
+
+          Specify the real-time priority, or take the default if unsure.
+
+config RCU_BOOST_DELAY
+        int "Milliseconds to delay boosting after RCU grace-period start"
+        range 0 3000
+        depends on RCU_BOOST
+        default 500
+        help
+          This option specifies the time to wait after the beginning of
+          a given grace period before priority-boosting preempted RCU
+          readers blocking that grace period.  Note that any RCU reader
+          blocking an expedited RCU grace period is boosted immediately.
+
+          Accept the default if unsure.
+
 endmenu # "RCU Subsystem"
 
 config IKCONFIG
@@ -491,7 +589,6 @@ if CGROUPS
 
 config CGROUP_DEBUG
         bool "Example debug cgroup subsystem"
-        depends on CGROUPS
         default n
         help
           This option enables a simple cgroup subsystem that
@@ -500,32 +597,20 @@ config CGROUP_DEBUG
 
           Say N if unsure.
 
-config CGROUP_NS
-        bool "Namespace cgroup subsystem"
-        depends on CGROUPS
-        help
-          Provides a simple namespace cgroup subsystem to
-          provide hierarchical naming of sets of namespaces,
-          for instance virtual servers and checkpoint/restart
-          jobs.
-
 config CGROUP_FREEZER
         bool "Freezer cgroup 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
         help
           Provides a cgroup implementing whitelists for devices which
           a process in the cgroup can mknod or open.
 
 config CPUSETS
         bool "Cpuset support"
-        depends on CGROUPS
         help
           This option will let you create and manage CPUSETs which
           allow dynamically partitioning a system into sets of CPUs and
@@ -541,7 +626,6 @@ config PROC_PID_CPUSET
 
 config CGROUP_CPUACCT
         bool "Simple CPU accounting cgroup subsystem"
-        depends on CGROUPS
         help
           Provides a simple Resource Controller for monitoring the
           total CPU consumed by the tasks in a cgroup.
@@ -551,11 +635,10 @@ config RESOURCE_COUNTERS
         help
           This option enables controller independent resource accounting
           infrastructure that works with cgroups.
-        depends on CGROUPS
 
 config CGROUP_MEM_RES_CTLR
         bool "Memory Resource Controller for Control Groups"
-        depends on CGROUPS && RESOURCE_COUNTERS
+        depends on RESOURCE_COUNTERS
         select MM_OWNER
         help
           Provides a memory resource controller that manages both anonymous
@@ -593,10 +676,33 @@ config CGROUP_MEM_RES_CTLR_SWAP
           if boot option "noswapaccount" is set, swap will not be accounted.
           Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
           size is 4096bytes, 512k per 1Gbytes of swap.
+config CGROUP_MEM_RES_CTLR_SWAP_ENABLED
+        bool "Memory Resource Controller Swap Extension enabled by default"
+        depends on CGROUP_MEM_RES_CTLR_SWAP
+        default y
+        help
+          Memory Resource Controller Swap Extension comes with its price in
+          a bigger memory consumption. General purpose distribution kernels
+          which want to enable the feature but keep it disabled by default
+          and let the user enable it by swapaccount boot command line
+          parameter should have this option unselected.
+          For those who want to have the feature enabled by default should
+          select this option (if, for some reason, they need to disable it
+          then noswapaccount does the trick).
+
+config CGROUP_PERF
+        bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
+        depends on PERF_EVENTS && CGROUPS
+        help
+          This option extends the per-cpu mode to restrict monitoring to
+          threads which belong to the cgroup specified and run on the
+          designated cpu.
+
+          Say N if unsure.
 
 menuconfig CGROUP_SCHED
         bool "Group CPU scheduler"
-        depends on EXPERIMENTAL && CGROUPS
+        depends on EXPERIMENTAL
         default n
         help
           This feature lets CPU scheduler recognize task groups and control CPU
@@ -625,7 +731,7 @@ endif #CGROUP_SCHED
 
 config BLK_CGROUP
         tristate "Block IO controller"
-        depends on CGROUPS && BLOCK
+        depends on BLOCK
         default n
         ---help---
         Generic block IO controller cgroup interface. This is the common
@@ -634,11 +740,14 @@ config BLK_CGROUP
 
         Currently, CFQ IO scheduler uses it to recognize task groups and
         control disk bandwidth allocation (proportional time slice allocation)
-        to such task groups.
+        to such task groups. It is also used by bio throttling logic in
+        block layer to implement upper limit in IO rates on a device.
 
         This option only enables generic Block IO controller infrastructure.
-        One needs to also enable actual IO controlling logic in CFQ for it
-        to take effect. (CONFIG_CFQ_GROUP_IOSCHED=y).
+        One needs to also enable actual IO controlling logic/policy. For
+        enabling proportional weight division of disk bandwidth in CFQ, set
+        CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
+        CONFIG_BLK_DEV_THROTTLING=y.
 
         See Documentation/cgroups/blkio-controller.txt for more information.
 
@@ -652,107 +761,124 @@ config DEBUG_BLK_CGROUP
 
 endif # CGROUPS
 
-config MM_OWNER
-        bool
-
-config SYSFS_DEPRECATED
-        bool
-
-config SYSFS_DEPRECATED_V2
-        bool "enable deprecated sysfs features to support old userspace tools"
-        depends on SYSFS
-        default n
-        select SYSFS_DEPRECATED
-        help
-          This option switches the layout of sysfs to the deprecated
-          version. Do not use it on recent distributions.
-
-          The current sysfs layout features a unified device tree at
-          /sys/devices/, which is able to express a hierarchy between
-          class devices. If the deprecated option is set to Y, the
-          unified device tree is split into a bus device tree at
-          /sys/devices/ and several individual class device trees at
-          /sys/class/. The class and bus devices will be connected by
-          "<subsystem>:<name>" and the "device" links. The "block"
-          class devices, will not show up in /sys/class/block/. Some
-          subsystems will suppress the creation of some devices which
-          depend on the unified device tree.
-
-          This option is not a pure compatibility option that can
-          be safely enabled on newer distributions. It will change the
-          layout of sysfs to the non-extensible deprecated version,
-          and disable some features, which can not be exported without
-          confusing older userspace tools. Since 2007/2008 all major
-          distributions do not enable this option, and ship no tools which
-          depend on the deprecated layout or this option.
-
-          If you are using a new kernel on an older distribution, or use
-          older userspace tools, you might need to say Y here. Do not say Y,
-          if the original kernel, that came with your distribution, has
-          this option set to N.
-
-config RELAY
-        bool "Kernel->user space relay support (formerly relayfs)"
-        help
-          This option enables support for relay interface support in
-          certain file systems (such as debugfs).
-          It is designed to provide an efficient mechanism for tools and
-          facilities to relay large amounts of data from kernel space to
-          user space.
-
-          If unsure, say N.
-
-config NAMESPACES
-        bool "Namespaces support" if EMBEDDED
-        default !EMBEDDED
+menuconfig NAMESPACES
+        bool "Namespaces support" if EXPERT
+        default !EXPERT
         help
           Provides the way to make tasks work with different objects using
           the same id. For example same IPC id may refer to different objects
           or same user id or pid may refer to different tasks when used in
           different namespaces.
 
+if NAMESPACES
+
 config UTS_NS
         bool "UTS namespace"
-        depends on NAMESPACES
+        default y
         help
           In this namespace tasks see different info provided with the
           uname() system call
 
 config IPC_NS
         bool "IPC namespace"
-        depends on NAMESPACES && (SYSVIPC || POSIX_MQUEUE)
+        depends on (SYSVIPC || POSIX_MQUEUE)
+        default y
         help
           In this namespace tasks work with IPC ids which correspond to
           different IPC objects in different namespaces.
 
 config USER_NS
         bool "User namespace (EXPERIMENTAL)"
-        depends on NAMESPACES && EXPERIMENTAL
+        depends on EXPERIMENTAL
+        default y
         help
           This allows containers, i.e. vservers, to use user namespaces
           to provide different user info for different servers.
           If unsure, say N.
 
 config PID_NS
-        bool "PID Namespaces (EXPERIMENTAL)"
-        default n
-        depends on NAMESPACES && EXPERIMENTAL
+        bool "PID Namespaces"
+        default y
         help
           Support process id namespaces.  This allows having multiple
           processes with the same pid as long as they are in different
           pid namespaces.  This is a building block of containers.
 
-          Unless you want to work with an experimental feature
-          say N here.
-
 config NET_NS
         bool "Network namespace"
-        default n
-        depends on NAMESPACES && EXPERIMENTAL && NET
+        depends on NET
+        default y
         help
           Allow user space to create what appear to be multiple instances
           of the network stack.
 
+endif # NAMESPACES
+
+config SCHED_AUTOGROUP
+        bool "Automatic process group scheduling"
+        select EVENTFD
+        select CGROUPS
+        select CGROUP_SCHED
+        select FAIR_GROUP_SCHED
+        help
+          This option optimizes the scheduler for common desktop workloads by
+          automatically creating and populating task groups.  This separation
+          of workloads isolates aggressive CPU burners (like build jobs) from
+          desktop applications.  Task group autogeneration is currently based
+          upon task session.
+
+config MM_OWNER
+        bool
+
+config SYSFS_DEPRECATED
+        bool "Enable deprecated sysfs features to support old userspace tools"
+        depends on SYSFS
+        default n
+        help
+          This option adds code that switches the layout of the "block" class
+          devices, to not show up in /sys/class/block/, but only in
+          /sys/block/.
+
+          This switch is only active when the sysfs.deprecated=1 boot option is
+          passed or the SYSFS_DEPRECATED_V2 option is set.
+
+          This option allows new kernels to run on old distributions and tools,
+          which might get confused by /sys/class/block/. Since 2007/2008 all
+          major distributions and tools handle this just fine.
+
+          Recent distributions and userspace tools after 2009/2010 depend on
+          the existence of /sys/class/block/, and will not work with this
+          option enabled.
+
+          Only if you are using a new kernel on an old distribution, you might
+          need to say Y here.
+
+config SYSFS_DEPRECATED_V2
+        bool "Enable deprecated sysfs features by default"
+        default n
+        depends on SYSFS
+        depends on SYSFS_DEPRECATED
+        help
+          Enable deprecated sysfs by default.
+
+          See the CONFIG_SYSFS_DEPRECATED option for more details about this
+          option.
+
+          Only if you are using a new kernel on an old distribution, you might
+          need to say Y here. Even then, odds are you would not need it
+          enabled, you can always pass the boot option if absolutely necessary.
+
+config RELAY
+        bool "Kernel->user space relay support (formerly relayfs)"
+        help
+          This option enables support for relay interface support in
+          certain file systems (such as debugfs).
+          It is designed to provide an efficient mechanism for tools and
+          facilities to relay large amounts of data from kernel space to
+          user space.
+
+          If unsure, say N.
+
 config BLK_DEV_INITRD
         bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support"
         depends on BROKEN || !FRV
@@ -777,7 +903,6 @@ endif
 
 config CC_OPTIMIZE_FOR_SIZE
         bool "Optimize for size"
-        default y
         help
           Enabling this option will pass "-Os" instead of "-O2" to gcc
           resulting in a smaller kernel.
@@ -790,8 +915,8 @@ config SYSCTL
 config ANON_INODES
         bool
 
-menuconfig EMBEDDED
-        bool "Configure standard kernel features (for small systems)"
+menuconfig EXPERT
+        bool "Configure standard kernel features (expert users)"
         help
           This option allows certain base kernel options and settings
           to be disabled or tweaked. This is for specialized
@@ -799,14 +924,14 @@ menuconfig EMBEDDED
           Only use this if you really know what you are doing.
 
 config UID16
-        bool "Enable 16-bit UID system calls" if EMBEDDED
+        bool "Enable 16-bit UID system calls" if EXPERT
         depends on ARM || BLACKFIN || CRIS || FRV || H8300 || X86_32 || M68K || (S390 && !64BIT) || SUPERH || SPARC32 || (SPARC64 && COMPAT) || UML || (X86_64 && IA32_EMULATION)
         default y
         help
           This enables the legacy 16-bit UID syscall wrappers.
 
 config SYSCTL_SYSCALL
-        bool "Sysctl syscall support" if EMBEDDED
+        bool "Sysctl syscall support" if EXPERT
         depends on PROC_SYSCTL
         default y
         select SYSCTL
@@ -823,7 +948,7 @@ config SYSCTL_SYSCALL
           If unsure say Y here.
 
 config KALLSYMS
-         bool "Load all symbols for debugging/ksymoops" if EMBEDDED
+         bool "Load all symbols for debugging/ksymoops" if EXPERT
          default y
          help
            Say Y here to let the kernel print out symbolic crash information and
@@ -834,27 +959,21 @@ config KALLSYMS_ALL
         bool "Include all symbols in kallsyms"
         depends on DEBUG_KERNEL && KALLSYMS
         help
-           Normally kallsyms only contains the symbols of functions, for nicer
-           OOPS messages.  Some debuggers can use kallsyms for other
-           symbols too: say Y here to include all symbols, if you need them 
-           and you don't care about adding 300k to the size of your kernel.
+           Normally kallsyms only contains the symbols of functions for nicer
+           OOPS messages and backtraces (i.e., symbols from the text and inittext
+           sections). This is sufficient for most cases. And only in very rare
+           cases (e.g., when a debugger is used) all symbols are required (e.g.,
+           names of variables from the data sections, etc).
 
-           Say N.
-
-config KALLSYMS_EXTRA_PASS
-        bool "Do an extra kallsyms pass"
-        depends on KALLSYMS
-        help
-           If kallsyms is not working correctly, the build will fail with
-           inconsistent kallsyms data.  If that occurs, log a bug report and
-           turn on KALLSYMS_EXTRA_PASS which should result in a stable build.
-           Always say N here unless you find a bug in kallsyms, which must be
-           reported.  KALLSYMS_EXTRA_PASS is only a temporary workaround while
-           you wait for kallsyms to be fixed.
+           This option makes sure that all symbols are loaded into the kernel
+           image (i.e., symbols from all sections) in cost of increased kernel
+           size (depending on the kernel configuration, it may be 300KiB or
+           something like this).
 
+           Say N unless you really need all symbols.
 
 config HOTPLUG
-        bool "Support for hot-pluggable devices" if EMBEDDED
+        bool "Support for hot-pluggable devices" if EXPERT
         default y
         help
           This option is provided for the case where no hotplug or uevent
@@ -864,7 +983,7 @@ config HOTPLUG
 
 config PRINTK
         default y
-        bool "Enable support for printk" if EMBEDDED
+        bool "Enable support for printk" if EXPERT
         help
           This option enables normal printk support. Removing it
           eliminates most of the message strings from the kernel image
@@ -873,7 +992,7 @@ config PRINTK
           strongly discouraged.
 
 config BUG
-        bool "BUG() support" if EMBEDDED
+        bool "BUG() support" if EXPERT
         default y
         help
           Disabling this option eliminates support for BUG and WARN, reducing
@@ -884,12 +1003,12 @@ config BUG
 
 config ELF_CORE
         default y
-        bool "Enable ELF core dumps" if EMBEDDED
+        bool "Enable ELF core dumps" if EXPERT
         help
           Enable support for generating core dumps. Disabling saves about 4k.
 
 config PCSPKR_PLATFORM
-        bool "Enable PC-Speaker support" if EMBEDDED
+        bool "Enable PC-Speaker support" if EXPERT
         depends on ALPHA || X86 || MIPS || PPC_PREP || PPC_CHRP || PPC_PSERIES
         default y
         help
@@ -898,14 +1017,14 @@ config PCSPKR_PLATFORM
 
 config BASE_FULL
         default y
-        bool "Enable full-sized data structures for core" if EMBEDDED
+        bool "Enable full-sized data structures for core" if EXPERT
         help
           Disabling this option reduces the size of miscellaneous core
           kernel data structures. This saves memory on small machines,
           but may reduce performance.
 
 config FUTEX
-        bool "Enable futex support" if EMBEDDED
+        bool "Enable futex support" if EXPERT
         default y
         select RT_MUTEXES
         help
@@ -914,7 +1033,7 @@ config FUTEX
           run glibc-based applications correctly.
 
 config EPOLL
-        bool "Enable eventpoll support" if EMBEDDED
+        bool "Enable eventpoll support" if EXPERT
         default y
         select ANON_INODES
         help
@@ -922,7 +1041,7 @@ config EPOLL
           support for epoll family of system calls.
 
 config SIGNALFD
-        bool "Enable signalfd() system call" if EMBEDDED
+        bool "Enable signalfd() system call" if EXPERT
         select ANON_INODES
         default y
         help
@@ -932,7 +1051,7 @@ config SIGNALFD
           If unsure, say Y.
 
 config TIMERFD
-        bool "Enable timerfd() system call" if EMBEDDED
+        bool "Enable timerfd() system call" if EXPERT
         select ANON_INODES
         default y
         help
@@ -942,7 +1061,7 @@ config TIMERFD
           If unsure, say Y.
 
 config EVENTFD
-        bool "Enable eventfd() system call" if EMBEDDED
+        bool "Enable eventfd() system call" if EXPERT
         select ANON_INODES
         default y
         help
@@ -952,7 +1071,7 @@ config EVENTFD
           If unsure, say Y.
 
 config SHMEM
-        bool "Use full shmem filesystem" if EMBEDDED
+        bool "Use full shmem filesystem" if EXPERT
         default y
         depends on MMU
         help
@@ -963,13 +1082,21 @@ config SHMEM
           which may be appropriate on small systems without swap.
 
 config AIO
-        bool "Enable AIO support" if EMBEDDED
+        bool "Enable AIO support" if EXPERT
         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 EMBEDDED
+        bool "Embedded system"
+        select EXPERT
+        help
+          This option should be enabled if compiling the kernel for
+          an embedded system so certain expert options are available
+          for configuration.
+
 config HAVE_PERF_EVENTS
         bool
         help
@@ -987,6 +1114,7 @@ config PERF_EVENTS
         default y if (PROFILING || PERF_COUNTERS)
         depends on HAVE_PERF_EVENTS
         select ANON_INODES
+        select IRQ_WORK
         help
           Enable kernel support for various performance events provided
           by software and hardware.
@@ -1039,16 +1167,16 @@ endmenu
 
 config VM_EVENT_COUNTERS
         default y
-        bool "Enable VM event counters for /proc/vmstat" if EMBEDDED
+        bool "Enable VM event counters for /proc/vmstat" if EXPERT
         help
           VM event counters are needed for event counts to be shown.
           This option allows the disabling of the VM event counters
-          on EMBEDDED systems.  /proc/vmstat will only show page counts
+          on EXPERT 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
+        bool "Enable PCI quirk workarounds" if EXPERT
         depends on PCI
         help
           This enables workarounds for various PCI chipset
@@ -1057,7 +1185,7 @@ config PCI_QUIRKS
 
 config SLUB_DEBUG
         default y
-        bool "Enable SLUB debugging support" if EMBEDDED
+        bool "Enable SLUB debugging support" if EXPERT
         depends on SLUB && SYSFS
         help
           SLUB has extensive debug support features. Disabling these can
@@ -1101,7 +1229,7 @@ config SLUB
            a slab allocator.
 
 config SLOB
-        depends on EMBEDDED
+        depends on EXPERT
         bool "SLOB (Simple Allocator)"
         help
            SLOB replaces the stock allocator with a drastically simpler
@@ -1112,7 +1240,7 @@ endchoice
 
 config MMAP_ALLOW_UNINITIALIZED
         bool "Allow mmapped anonymous memory to be uninitialized"
-        depends on EMBEDDED && !MMU
+        depends on EXPERT && !MMU
         default n
         help
           Normally, and according to the Linux spec, anonymous memory obtained
diff --git a/init/calibrate.c b/init/calibrate.c
index 6eb48e53d61c..aae2f40fea4c 100644
--- a/init/calibrate.c
+++ b/init/calibrate.c
@@ -38,6 +38,9 @@ static unsigned long __cpuinit calibrate_delay_direct(void)
         unsigned long timer_rate_min, timer_rate_max;
         unsigned long good_timer_sum = 0;
         unsigned long good_timer_count = 0;
+        unsigned long measured_times[MAX_DIRECT_CALIBRATION_RETRIES];
+        int max = -1; /* index of measured_times with max/min values or not set */
+        int min = -1;
         int i;
 
         if (read_current_timer(&pre_start) < 0 )
@@ -66,7 +69,7 @@ static unsigned long __cpuinit calibrate_delay_direct(void)
                 pre_start = 0;
                 read_current_timer(&start);
                 start_jiffies = jiffies;
-                while (jiffies <= (start_jiffies + 1)) {
+                while (time_before_eq(jiffies, start_jiffies + 1)) {
                         pre_start = start;
                         read_current_timer(&start);
                 }
@@ -74,8 +77,8 @@ static unsigned long __cpuinit calibrate_delay_direct(void)
 
                 pre_end = 0;
                 end = post_start;
-                while (jiffies <=
-                       (start_jiffies + 1 + DELAY_CALIBRATION_TICKS)) {
+                while (time_before_eq(jiffies, start_jiffies + 1 +
+                                               DELAY_CALIBRATION_TICKS)) {
                         pre_end = end;
                         read_current_timer(&end);
                 }
@@ -90,18 +93,75 @@ static unsigned long __cpuinit calibrate_delay_direct(void)
                  * If the upper limit and lower limit of the timer_rate is
                  * >= 12.5% apart, redo calibration.
                  */
-                if (pre_start != 0 && pre_end != 0 &&
+                if (start >= post_end)
+                        printk(KERN_NOTICE "calibrate_delay_direct() ignoring "
+                                        "timer_rate as we had a TSC wrap around"
+                                        " start=%lu >=post_end=%lu\n",
+                                start, post_end);
+                if (start < post_end && pre_start != 0 && pre_end != 0 &&
                     (timer_rate_max - timer_rate_min) < (timer_rate_max >> 3)) {
                         good_timer_count++;
                         good_timer_sum += timer_rate_max;
-                }
+                        measured_times[i] = timer_rate_max;
+                        if (max < 0 || timer_rate_max > measured_times[max])
+                                max = i;
+                        if (min < 0 || timer_rate_max < measured_times[min])
+                                min = i;
+                } else
+                        measured_times[i] = 0;
+
         }
 
-        if (good_timer_count)
-                return (good_timer_sum/good_timer_count);
+        /*
+         * Find the maximum & minimum - if they differ too much throw out the
+         * one with the largest difference from the mean and try again...
+         */
+        while (good_timer_count > 1) {
+                unsigned long estimate;
+                unsigned long maxdiff;
+
+                /* compute the estimate */
+                estimate = (good_timer_sum/good_timer_count);
+                maxdiff = estimate >> 3;
+
+                /* if range is within 12% let's take it */
+                if ((measured_times[max] - measured_times[min]) < maxdiff)
+                        return estimate;
+
+                /* ok - drop the worse value and try again... */
+                good_timer_sum = 0;
+                good_timer_count = 0;
+                if ((measured_times[max] - estimate) <
+                                (estimate - measured_times[min])) {
+                        printk(KERN_NOTICE "calibrate_delay_direct() dropping "
+                                        "min bogoMips estimate %d = %lu\n",
+                                min, measured_times[min]);
+                        measured_times[min] = 0;
+                        min = max;
+                } else {
+                        printk(KERN_NOTICE "calibrate_delay_direct() dropping "
+                                        "max bogoMips estimate %d = %lu\n",
+                                max, measured_times[max]);
+                        measured_times[max] = 0;
+                        max = min;
+                }
+
+                for (i = 0; i < MAX_DIRECT_CALIBRATION_RETRIES; i++) {
+                        if (measured_times[i] == 0)
+                                continue;
+                        good_timer_count++;
+                        good_timer_sum += measured_times[i];
+                        if (measured_times[i] < measured_times[min])
+                                min = i;
+                        if (measured_times[i] > measured_times[max])
+                                max = i;
+                }
 
-        printk(KERN_WARNING "calibrate_delay_direct() failed to get a good "
-               "estimate for loops_per_jiffy.\nProbably due to long platform interrupts. Consider using \"lpj=\" boot option.\n");
+        }
+
+        printk(KERN_NOTICE "calibrate_delay_direct() failed to get a good "
+               "estimate for loops_per_jiffy.\nProbably due to long platform "
+                "interrupts. Consider using \"lpj=\" boot option.\n");
         return 0;
 }
 #else
@@ -110,8 +170,8 @@ static unsigned long __cpuinit calibrate_delay_direct(void) {return 0;}
 
 /*
  * This is the number of bits of precision for the loops_per_jiffy.  Each
- * bit takes on average 1.5/HZ seconds.  This (like the original) is a little
- * better than 1%
+ * time we refine our estimate after the first takes 1.5/HZ seconds, so try
+ * to start with a good estimate.
  * For the boot cpu we can skip the delay calibration and assign it a value
  * calculated based on the timer frequency.
  * For the rest of the CPUs we cannot assume that the timer frequency is same as
@@ -119,64 +179,98 @@ static unsigned long __cpuinit calibrate_delay_direct(void) {return 0;}
  */
 #define LPS_PREC 8
 
+static unsigned long __cpuinit calibrate_delay_converge(void)
+{
+        /* First stage - slowly accelerate to find initial bounds */
+        unsigned long lpj, lpj_base, ticks, loopadd, loopadd_base, chop_limit;
+        int trials = 0, band = 0, trial_in_band = 0;
+
+        lpj = (1<<12);
+
+        /* wait for "start of" clock tick */
+        ticks = jiffies;
+        while (ticks == jiffies)
+                ; /* nothing */
+        /* Go .. */
+        ticks = jiffies;
+        do {
+                if (++trial_in_band == (1<<band)) {
+                        ++band;
+                        trial_in_band = 0;
+                }
+                __delay(lpj * band);
+                trials += band;
+        } while (ticks == jiffies);
+        /*
+         * We overshot, so retreat to a clear underestimate. Then estimate
+         * the largest likely undershoot. This defines our chop bounds.
+         */
+        trials -= band;
+        loopadd_base = lpj * band;
+        lpj_base = lpj * trials;
+
+recalibrate:
+        lpj = lpj_base;
+        loopadd = loopadd_base;
+
+        /*
+         * Do a binary approximation to get lpj set to
+         * equal one clock (up to LPS_PREC bits)
+         */
+        chop_limit = lpj >> LPS_PREC;
+        while (loopadd > chop_limit) {
+                lpj += loopadd;
+                ticks = jiffies;
+                while (ticks == jiffies)
+                        ; /* nothing */
+                ticks = jiffies;
+                __delay(lpj);
+                if (jiffies != ticks)   /* longer than 1 tick */
+                        lpj -= loopadd;
+                loopadd >>= 1;
+        }
+        /*
+         * If we incremented every single time possible, presume we've
+         * massively underestimated initially, and retry with a higher
+         * start, and larger range. (Only seen on x86_64, due to SMIs)
+         */
+        if (lpj + loopadd * 2 == lpj_base + loopadd_base * 2) {
+                lpj_base = lpj;
+                loopadd_base <<= 2;
+                goto recalibrate;
+        }
+
+        return lpj;
+}
+
 void __cpuinit calibrate_delay(void)
 {
-        unsigned long ticks, loopbit;
-        int lps_precision = LPS_PREC;
+        unsigned long lpj;
         static bool printed;
 
         if (preset_lpj) {
-                loops_per_jiffy = preset_lpj;
+                lpj = preset_lpj;
                 if (!printed)
                         pr_info("Calibrating delay loop (skipped) "
                                 "preset value.. ");
         } else if ((!printed) && lpj_fine) {
-                loops_per_jiffy = lpj_fine;
+                lpj = lpj_fine;
                 pr_info("Calibrating delay loop (skipped), "
                         "value calculated using timer frequency.. ");
-        } else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) {
+        } else if ((lpj = calibrate_delay_direct()) != 0) {
                 if (!printed)
                         pr_info("Calibrating delay using timer "
                                 "specific routine.. ");
         } else {
-                loops_per_jiffy = (1<<12);
-
                 if (!printed)
                         pr_info("Calibrating delay loop... ");
-                while ((loops_per_jiffy <<= 1) != 0) {
-                        /* wait for "start of" clock tick */
-                        ticks = jiffies;
-                        while (ticks == jiffies)
-                                /* nothing */;
-                        /* Go .. */
-                        ticks = jiffies;
-                        __delay(loops_per_jiffy);
-                        ticks = jiffies - ticks;
-                        if (ticks)
-                                break;
-                }
-
-                /*
-                 * Do a binary approximation to get loops_per_jiffy set to
-                 * equal one clock (up to lps_precision bits)
-                 */
-                loops_per_jiffy >>= 1;
-                loopbit = loops_per_jiffy;
-                while (lps_precision-- && (loopbit >>= 1)) {
-                        loops_per_jiffy |= loopbit;
-                        ticks = jiffies;
-                        while (ticks == jiffies)
-                                /* nothing */;
-                        ticks = jiffies;
-                        __delay(loops_per_jiffy);
-                        if (jiffies != ticks)   /* longer than 1 tick */
-                                loops_per_jiffy &= ~loopbit;
-                }
+                lpj = calibrate_delay_converge();
         }
         if (!printed)
                 pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n",
-                        loops_per_jiffy/(500000/HZ),
-                        (loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy);
+                        lpj/(500000/HZ),
+                        (lpj/(5000/HZ)) % 100, lpj);
 
+        loops_per_jiffy = lpj;
         printed = true;
 }
diff --git a/init/do_mounts.c b/init/do_mounts.c
index 02e3ca4fc527..c0851a8e030c 100644
--- a/init/do_mounts.c
+++ b/init/do_mounts.c
@@ -58,6 +58,62 @@ static int __init readwrite(char *str)
 __setup("ro", readonly);
 __setup("rw", readwrite);
 
+#ifdef CONFIG_BLOCK
+/**
+ * match_dev_by_uuid - callback for finding a partition using its uuid
+ * @dev:        device passed in by the caller
+ * @data:       opaque pointer to a 36 byte char array with a UUID
+ *
+ * Returns 1 if the device matches, and 0 otherwise.
+ */
+static int match_dev_by_uuid(struct device *dev, void *data)
+{
+        u8 *uuid = data;
+        struct hd_struct *part = dev_to_part(dev);
+
+        if (!part->info)
+                goto no_match;
+
+        if (memcmp(uuid, part->info->uuid, sizeof(part->info->uuid)))
+                        goto no_match;
+
+        return 1;
+no_match:
+        return 0;
+}
+
+
+/**
+ * devt_from_partuuid - looks up the dev_t of a partition by its UUID
+ * @uuid:       36 byte char array containing a hex ascii UUID
+ *
+ * The function will return the first partition which contains a matching
+ * UUID value in its partition_meta_info struct.  This does not search
+ * by filesystem UUIDs.
+ *
+ * Returns the matching dev_t on success or 0 on failure.
+ */
+static dev_t devt_from_partuuid(char *uuid_str)
+{
+        dev_t res = 0;
+        struct device *dev = NULL;
+        u8 uuid[16];
+
+        /* Pack the requested UUID in the expected format. */
+        part_pack_uuid(uuid_str, uuid);
+
+        dev = class_find_device(&block_class, NULL, uuid, &match_dev_by_uuid);
+        if (!dev)
+                goto done;
+
+        res = dev->devt;
+        put_device(dev);
+
+done:
+        return res;
+}
+#endif
+
 /*
  *      Convert a name into device number.  We accept the following variants:
  *
@@ -68,6 +124,8 @@ __setup("rw", readwrite);
  *         of partition - device number of disk plus the partition number
  *      5) /dev/<disk_name>p<decimal> - same as the above, that form is
  *         used when disk name of partitioned disk ends on a digit.
+ *      6) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
+ *         unique id of a partition if the partition table provides it.
  *
  *      If name doesn't have fall into the categories above, we return (0,0).
  *      block_class is used to check if something is a disk name. If the disk
@@ -82,6 +140,18 @@ dev_t name_to_dev_t(char *name)
         dev_t res = 0;
         int part;
 
+#ifdef CONFIG_BLOCK
+        if (strncmp(name, "PARTUUID=", 9) == 0) {
+                name += 9;
+                if (strlen(name) != 36)
+                        goto fail;
+                res = devt_from_partuuid(name);
+                if (!res)
+                        goto fail;
+                goto done;
+        }
+#endif
+
         if (strncmp(name, "/dev/", 5) != 0) {
                 unsigned maj, min;
 
@@ -116,7 +186,7 @@ dev_t name_to_dev_t(char *name)
                 goto done;
 
         /*
-         * try non-existant, but valid partition, which may only exist
+         * try non-existent, but valid partition, which may only exist
          * after revalidating the disk, like partitioned md devices
          */
         while (p > s && isdigit(p[-1]))
@@ -221,9 +291,10 @@ static int __init do_mount_root(char *name, char *fs, int flags, void *data)
         if (err)
                 return err;
 
-        sys_chdir("/root");
+        sys_chdir((const char __user __force *)"/root");
         ROOT_DEV = current->fs->pwd.mnt->mnt_sb->s_dev;
-        printk("VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
+        printk(KERN_INFO
+               "VFS: Mounted root (%s filesystem)%s on device %u:%u.\n",
                current->fs->pwd.mnt->mnt_sb->s_type->name,
                current->fs->pwd.mnt->mnt_sb->s_flags & MS_RDONLY ?
                " readonly" : "", MAJOR(ROOT_DEV), MINOR(ROOT_DEV));
@@ -291,13 +362,13 @@ out:
 #ifdef CONFIG_ROOT_NFS
 static int __init mount_nfs_root(void)
 {
-        void *data = nfs_root_data();
+        char *root_dev, *root_data;
 
-        create_dev("/dev/root", ROOT_DEV);
-        if (data &&
-            do_mount_root("/dev/root", "nfs", root_mountflags, data) == 0)
-                return 1;
-        return 0;
+        if (nfs_root_data(&root_dev, &root_data) != 0)
+                return 0;
+        if (do_mount_root(root_dev, "nfs", root_mountflags, root_data) != 0)
+                return 0;
+        return 1;
 }
 #endif
 
@@ -418,5 +489,5 @@ void __init prepare_namespace(void)
 out:
         devtmpfs_mount("dev");
         sys_mount(".", "/", NULL, MS_MOVE, NULL);
-        sys_chroot(".");
+        sys_chroot((const char __user __force *)".");
 }
diff --git a/init/do_mounts_md.c b/init/do_mounts_md.c
index 69aebbf8fd2d..32c4799b8c91 100644
--- a/init/do_mounts_md.c
+++ b/init/do_mounts_md.c
@@ -283,7 +283,7 @@ static void __init autodetect_raid(void)
 
         wait_for_device_probe();
 
-        fd = sys_open("/dev/md0", 0, 0);
+        fd = sys_open((const char __user __force *) "/dev/md0", 0, 0);
         if (fd >= 0) {
                 sys_ioctl(fd, RAID_AUTORUN, raid_autopart);
                 sys_close(fd);
diff --git a/init/do_mounts_rd.c b/init/do_mounts_rd.c
index bf3ef667bf36..fe9acb0ae480 100644
--- a/init/do_mounts_rd.c
+++ b/init/do_mounts_rd.c
@@ -64,7 +64,7 @@ identify_ramdisk_image(int fd, int start_block, decompress_fn *decompressor)
 
         buf = kmalloc(size, GFP_KERNEL);
         if (!buf)
-                return -1;
+                return -ENOMEM;
 
         minixsb = (struct minix_super_block *) buf;
         ext2sb = (struct ext2_super_block *) buf;
@@ -168,7 +168,7 @@ int __init rd_load_image(char *from)
         char rotator[4] = { '|' , '/' , '-' , '\\' };
 #endif
 
-        out_fd = sys_open("/dev/ram", O_RDWR, 0);
+        out_fd = sys_open((const char __user __force *) "/dev/ram", O_RDWR, 0);
         if (out_fd < 0)
                 goto out;
 
@@ -267,7 +267,7 @@ noclose_input:
         sys_close(out_fd);
 out:
         kfree(buf);
-        sys_unlink("/dev/ram");
+        sys_unlink((const char __user __force *) "/dev/ram");
         return res;
 }
 
diff --git a/init/initramfs.c b/init/initramfs.c
index 4b9c20205092..2531811d42cb 100644
--- a/init/initramfs.c
+++ b/init/initramfs.c
@@ -483,7 +483,8 @@ static int __init retain_initrd_param(char *str)
 }
 __setup("retain_initrd", retain_initrd_param);
 
-extern char __initramfs_start[], __initramfs_end[];
+extern char __initramfs_start[];
+extern unsigned long __initramfs_size;
 #include <linux/initrd.h>
 #include <linux/kexec.h>
 
@@ -528,7 +529,7 @@ static void __init clean_rootfs(void)
         struct linux_dirent64 *dirp;
         int num;
 
-        fd = sys_open("/", O_RDONLY, 0);
+        fd = sys_open((const char __user __force *) "/", O_RDONLY, 0);
         WARN_ON(fd < 0);
         if (fd < 0)
                 return;
@@ -570,8 +571,7 @@ static void __init clean_rootfs(void)
 
 static int __init populate_rootfs(void)
 {
-        char *err = unpack_to_rootfs(__initramfs_start,
-                         __initramfs_end - __initramfs_start);
+        char *err = unpack_to_rootfs(__initramfs_start, __initramfs_size);
         if (err)
                 panic(err);     /* Failed to decompress INTERNAL initramfs */
         if (initrd_start) {
@@ -585,12 +585,12 @@ static int __init populate_rootfs(void)
                         return 0;
                 } else {
                         clean_rootfs();
-                        unpack_to_rootfs(__initramfs_start,
-                                 __initramfs_end - __initramfs_start);
+                        unpack_to_rootfs(__initramfs_start, __initramfs_size);
                 }
                 printk(KERN_INFO "rootfs image is not initramfs (%s)"
                                 "; looks like an initrd\n", err);
-                fd = sys_open("/initrd.image", O_WRONLY|O_CREAT, 0700);
+                fd = sys_open((const char __user __force *) "/initrd.image",
+                              O_WRONLY|O_CREAT, 0700);
                 if (fd >= 0) {
                         sys_write(fd, (char *)initrd_start,
                                         initrd_end - initrd_start);
diff --git a/init/main.c b/init/main.c
index 94ab488039aa..d7211faed2ad 100644
--- a/init/main.c
+++ b/init/main.c
@@ -20,7 +20,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/initrd.h>
 #include <linux/bootmem.h>
 #include <linux/acpi.h>
@@ -68,6 +67,7 @@
 #include <linux/sfi.h>
 #include <linux/shmem_fs.h>
 #include <linux/slab.h>
+#include <linux/perf_event.h>
 
 #include <asm/io.h>
 #include <asm/bugs.h>
@@ -96,6 +96,15 @@ static inline void mark_rodata_ro(void) { }
 extern void tc_init(void);
 #endif
 
+/*
+ * Debug helper: via this flag we know that we are in 'early bootup code'
+ * where only the boot processor is running with IRQ disabled.  This means
+ * two things - IRQ must not be enabled before the flag is cleared and some
+ * operations which are not allowed with IRQ disabled are allowed while the
+ * flag is set.
+ */
+bool early_boot_irqs_disabled __read_mostly;
+
 enum system_states system_state __read_mostly;
 EXPORT_SYMBOL(system_state);
 
@@ -120,63 +129,6 @@ static char *static_command_line;
 static char *execute_command;
 static char *ramdisk_execute_command;
 
-#ifdef CONFIG_SMP
-/* Setup configured maximum number of CPUs to activate */
-unsigned int setup_max_cpus = NR_CPUS;
-EXPORT_SYMBOL(setup_max_cpus);
-
-
-/*
- * Setup routine for controlling SMP activation
- *
- * Command-line option of "nosmp" or "maxcpus=0" will disable SMP
- * activation entirely (the MPS table probe still happens, though).
- *
- * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer
- * greater than 0, limits the maximum number of CPUs activated in
- * SMP mode to <NUM>.
- */
-
-void __weak arch_disable_smp_support(void) { }
-
-static int __init nosmp(char *str)
-{
-        setup_max_cpus = 0;
-        arch_disable_smp_support();
-
-        return 0;
-}
-
-early_param("nosmp", nosmp);
-
-/* this is hard limit */
-static int __init nrcpus(char *str)
-{
-        int nr_cpus;
-
-        get_option(&str, &nr_cpus);
-        if (nr_cpus > 0 && nr_cpus < nr_cpu_ids)
-                nr_cpu_ids = nr_cpus;
-
-        return 0;
-}
-
-early_param("nr_cpus", nrcpus);
-
-static int __init maxcpus(char *str)
-{
-        get_option(&str, &setup_max_cpus);
-        if (setup_max_cpus == 0)
-                arch_disable_smp_support();
-
-        return 0;
-}
-
-early_param("maxcpus", maxcpus);
-#else
-static const unsigned int setup_max_cpus = NR_CPUS;
-#endif
-
 /*
  * If set, this is an indication to the drivers that reset the underlying
  * device before going ahead with the initialization otherwise driver might
@@ -353,7 +305,7 @@ static int __init rdinit_setup(char *str)
 __setup("rdinit=", rdinit_setup);
 
 #ifndef CONFIG_SMP
-
+static const unsigned int setup_max_cpus = NR_CPUS;
 #ifdef CONFIG_X86_LOCAL_APIC
 static void __init smp_init(void)
 {
@@ -365,37 +317,6 @@ static void __init smp_init(void)
 
 static inline void setup_nr_cpu_ids(void) { }
 static inline void smp_prepare_cpus(unsigned int maxcpus) { }
-
-#else
-
-/* Setup number of possible processor ids */
-int nr_cpu_ids __read_mostly = NR_CPUS;
-EXPORT_SYMBOL(nr_cpu_ids);
-
-/* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */
-static void __init setup_nr_cpu_ids(void)
-{
-        nr_cpu_ids = find_last_bit(cpumask_bits(cpu_possible_mask),NR_CPUS) + 1;
-}
-
-/* Called by boot processor to activate the rest. */
-static void __init smp_init(void)
-{
-        unsigned int cpu;
-
-        /* FIXME: This should be done in userspace --RR */
-        for_each_present_cpu(cpu) {
-                if (num_online_cpus() >= setup_max_cpus)
-                        break;
-                if (!cpu_online(cpu))
-                        cpu_up(cpu);
-        }
-
-        /* Any cleanup work */
-        printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus());
-        smp_cpus_done(setup_max_cpus);
-}
-
 #endif
 
 /*
@@ -424,7 +345,6 @@ static void __init setup_command_line(char *command_line)
 static __initdata DECLARE_COMPLETION(kthreadd_done);
 
 static noinline void __init_refok rest_init(void)
-        __releases(kernel_lock)
 {
         int pid;
 
@@ -555,8 +475,7 @@ asmlinkage void __init start_kernel(void)
         cgroup_init_early();
 
         local_irq_disable();
-        early_boot_irqs_off();
-        early_init_irq_lock_class();
+        early_boot_irqs_disabled = true;
 
 /*
  * Interrupts are still disabled. Do necessary setups, then
@@ -568,6 +487,7 @@ asmlinkage void __init start_kernel(void)
         printk(KERN_NOTICE "%s", linux_banner);
         setup_arch(&command_line);
         mm_init_owner(&init_mm, &init_task);
+        mm_init_cpumask(&init_mm);
         setup_command_line(command_line);
         setup_nr_cpu_ids();
         setup_per_cpu_areas();
@@ -585,11 +505,13 @@ asmlinkage void __init start_kernel(void)
          * These use large bootmem allocations and must precede
          * kmem_cache_init()
          */
+        setup_log_buf(0);
         pidhash_init();
         vfs_caches_init_early();
         sort_main_extable();
         trap_init();
         mm_init();
+
         /*
          * Set up the scheduler prior starting any interrupts (such as the
          * timer interrupt). Full topology setup happens at smp_init()
@@ -606,6 +528,8 @@ asmlinkage void __init start_kernel(void)
                                 "enabled *very* early, fixing it\n");
                 local_irq_disable();
         }
+        idr_init_cache();
+        perf_event_init();
         rcu_init();
         radix_tree_init();
         /* init some links before init_ISA_irqs() */
@@ -618,10 +542,11 @@ asmlinkage void __init start_kernel(void)
         timekeeping_init();
         time_init();
         profile_init();
+        call_function_init();
         if (!irqs_disabled())
                 printk(KERN_CRIT "start_kernel(): bug: interrupts were "
                                  "enabled early\n");
-        early_boot_irqs_on();
+        early_boot_irqs_disabled = false;
         local_irq_enable();
 
         /* Interrupts are enabled now so all GFP allocations are safe. */
@@ -659,9 +584,8 @@ asmlinkage void __init start_kernel(void)
 #endif
         page_cgroup_init();
         enable_debug_pagealloc();
-        kmemleak_init();
         debug_objects_mem_init();
-        idr_init_cache();
+        kmemleak_init();
         setup_per_cpu_pageset();
         numa_policy_init();
         if (late_time_init)
@@ -778,9 +702,6 @@ static void __init do_initcalls(void)
 
         for (fn = __early_initcall_end; fn < __initcall_end; fn++)
                 do_one_initcall(*fn);
-
-        /* Make sure there is no pending stuff from the initcall sequence */
-        flush_scheduled_work();
 }
 
 /*
@@ -819,7 +740,6 @@ static void run_init_process(const char *init_filename)
  * makes it inline to init() and it becomes part of init.text section
  */
 static noinline int init_post(void)
-        __releases(kernel_lock)
 {
         /* need to finish all async __init code before freeing the memory */
         async_synchronize_full();
@@ -871,21 +791,13 @@ static int __init kernel_init(void * unused)
          * init can run on any cpu.
          */
         set_cpus_allowed_ptr(current, cpu_all_mask);
-        /*
-         * Tell the world that we're going to be the grim
-         * reaper of innocent orphaned children.
-         *
-         * We don't want people to have to make incorrect
-         * assumptions about where in the task array this
-         * can be found.
-         */
-        init_pid_ns.child_reaper = current;
 
         cad_pid = task_pid(current);
 
         smp_prepare_cpus(setup_max_cpus);
 
         do_pre_smp_initcalls();
+        lockup_detector_init();
 
         smp_init();
         sched_init_smp();
diff --git a/init/noinitramfs.c b/init/noinitramfs.c
index f4c1a3a1b8c5..267739d85179 100644
--- a/init/noinitramfs.c
+++ b/init/noinitramfs.c
@@ -29,17 +29,17 @@ static int __init default_rootfs(void)
 {
         int err;
 
-        err = sys_mkdir("/dev", 0755);
+        err = sys_mkdir((const char __user __force *) "/dev", 0755);
         if (err < 0)
                 goto out;
 
-        err = sys_mknod((const char __user *) "/dev/console",
+        err = sys_mknod((const char __user __force *) "/dev/console",
                         S_IFCHR | S_IRUSR | S_IWUSR,
                         new_encode_dev(MKDEV(5, 1)));
         if (err < 0)
                 goto out;
 
-        err = sys_mkdir("/root", 0700);
+        err = sys_mkdir((const char __user __force *) "/root", 0700);
         if (err < 0)
                 goto out;
 
diff --git a/init/version.c b/init/version.c
index adff586401a5..86fe0ccb997a 100644
--- a/init/version.c
+++ b/init/version.c
@@ -33,6 +33,7 @@ struct uts_namespace init_uts_ns = {
                 .machine        = UTS_MACHINE,
                 .domainname     = UTS_DOMAINNAME,
         },
+        .user_ns = &init_user_ns,
 };
 EXPORT_SYMBOL_GPL(init_uts_ns);