Merge Linus' tree to be be to apply submitted patches to newer code than

current trivial.git base

5 files changed, 221 insertions, 67 deletions

diff --git a/init/Kconfig b/init/Kconfig
index 6069b210d83a..2081a4d3d917 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -507,6 +507,16 @@ config PREEMPT_RCU
           This option enables preemptible-RCU code that is common between
           TREE_PREEMPT_RCU and, in the old days, TINY_PREEMPT_RCU.
 
+config TASKS_RCU
+        bool "Task_based RCU implementation using voluntary context switch"
+        default n
+        help
+          This option enables a task-based RCU implementation that uses
+          only voluntary context switch (not preemption!), idle, and
+          user-mode execution as quiescent states.
+
+          If unsure, say N.
+
 config RCU_STALL_COMMON
         def_bool ( TREE_RCU || TREE_PREEMPT_RCU || RCU_TRACE )
         help
@@ -737,7 +747,7 @@ choice
 
 config RCU_NOCB_CPU_NONE
         bool "No build_forced no-CBs CPUs"
-        depends on RCU_NOCB_CPU && !NO_HZ_FULL_ALL
+        depends on RCU_NOCB_CPU
         help
           This option does not force any of the CPUs to be no-CBs CPUs.
           Only CPUs designated by the rcu_nocbs= boot parameter will be
@@ -751,7 +761,7 @@ config RCU_NOCB_CPU_NONE
 
 config RCU_NOCB_CPU_ZERO
         bool "CPU 0 is a build_forced no-CBs CPU"
-        depends on RCU_NOCB_CPU && !NO_HZ_FULL_ALL
+        depends on RCU_NOCB_CPU
         help
           This option forces CPU 0 to be a no-CBs CPU, so that its RCU
           callbacks are invoked by a per-CPU kthread whose name begins
@@ -783,8 +793,13 @@ endchoice
 
 endmenu # "RCU Subsystem"
 
+config BUILD_BIN2C
+        bool
+        default n
+
 config IKCONFIG
         tristate "Kernel .config support"
+        select BUILD_BIN2C
         ---help---
           This option enables the complete Linux kernel ".config" file
           contents to be saved in the kernel. It provides documentation
@@ -806,16 +821,57 @@ config LOG_BUF_SHIFT
         int "Kernel log buffer size (16 => 64KB, 17 => 128KB)"
         range 12 21
         default 17
+        depends on PRINTK
         help
-          Select kernel log buffer size as a power of 2.
+          Select the minimal kernel log buffer size as a power of 2.
+          The final size is affected by LOG_CPU_MAX_BUF_SHIFT config
+          parameter, see below. Any higher size also might be forced
+          by "log_buf_len" boot parameter.
+
           Examples:
-                     17 => 128 KB
+                     17 => 128 KB
                      16 => 64 KB
-                     15 => 32 KB
-                     14 => 16 KB
+                     15 => 32 KB
+                     14 => 16 KB
                      13 =>  8 KB
                      12 =>  4 KB
 
+config LOG_CPU_MAX_BUF_SHIFT
+        int "CPU kernel log buffer size contribution (13 => 8 KB, 17 => 128KB)"
+        depends on SMP
+        range 0 21
+        default 12 if !BASE_SMALL
+        default 0 if BASE_SMALL
+        depends on PRINTK
+        help
+          This option allows to increase the default ring buffer size
+          according to the number of CPUs. The value defines the contribution
+          of each CPU as a power of 2. The used space is typically only few
+          lines however it might be much more when problems are reported,
+          e.g. backtraces.
+
+          The increased size means that a new buffer has to be allocated and
+          the original static one is unused. It makes sense only on systems
+          with more CPUs. Therefore this value is used only when the sum of
+          contributions is greater than the half of the default kernel ring
+          buffer as defined by LOG_BUF_SHIFT. The default values are set
+          so that more than 64 CPUs are needed to trigger the allocation.
+
+          Also this option is ignored when "log_buf_len" kernel parameter is
+          used as it forces an exact (power of two) size of the ring buffer.
+
+          The number of possible CPUs is used for this computation ignoring
+          hotplugging making the compuation optimal for the the worst case
+          scenerio while allowing a simple algorithm to be used from bootup.
+
+          Examples shift values and their meaning:
+                     17 => 128 KB for each CPU
+                     16 =>  64 KB for each CPU
+                     15 =>  32 KB for each CPU
+                     14 =>  16 KB for each CPU
+                     13 =>   8 KB for each CPU
+                     12 =>   4 KB for each CPU
+
 #
 # Architectures with an unreliable sched_clock() should select this:
 #
@@ -844,17 +900,6 @@ config ARCH_SUPPORTS_INT128
 config ARCH_WANT_NUMA_VARIABLE_LOCALITY
         bool
 
-#
-# For architectures that are willing to define _PAGE_NUMA as _PAGE_PROTNONE
-config ARCH_WANTS_PROT_NUMA_PROT_NONE
-        bool
-
-config ARCH_USES_NUMA_PROT_NONE
-        bool
-        default y
-        depends on ARCH_WANTS_PROT_NUMA_PROT_NONE
-        depends on NUMA_BALANCING
-
 config NUMA_BALANCING_DEFAULT_ENABLED
         bool "Automatically enable NUMA aware memory/task placement"
         default y
@@ -1296,6 +1341,10 @@ config SYSCTL_ARCH_UNALIGN_ALLOW
 config HAVE_PCSPKR_PLATFORM
         bool
 
+# interpreter that classic socket filters depend on
+config BPF
+        bool
+
 menuconfig EXPERT
         bool "Configure standard kernel features (expert users)"
         # Unhide debug options, to make the on-by-default options visible
@@ -1432,6 +1481,7 @@ config FUTEX
 
 config HAVE_FUTEX_CMPXCHG
         bool
+        depends on FUTEX
         help
           Architectures should select this if futex_atomic_cmpxchg_inatomic()
           is implemented and always working. This removes a couple of runtime
@@ -1475,6 +1525,16 @@ config EVENTFD
 
           If unsure, say Y.
 
+# syscall, maps, verifier
+config BPF_SYSCALL
+        bool "Enable bpf() system call" if EXPERT
+        select ANON_INODES
+        select BPF
+        default n
+        help
+          Enable the bpf() system call that allows to manipulate eBPF
+          programs and maps via file descriptors.
+
 config SHMEM
         bool "Use full shmem filesystem" if EXPERT
         default y
@@ -1494,6 +1554,16 @@ config AIO
           by some high performance threaded applications. Disabling
           this option saves about 7k.
 
+config ADVISE_SYSCALLS
+        bool "Enable madvise/fadvise syscalls" if EXPERT
+        default y
+        help
+          This option enables the madvise and fadvise syscalls, used by
+          applications to advise the kernel about their future memory or file
+          usage, improving performance. If building an embedded system where no
+          applications use these syscalls, you can disable this option to save
+          space.
+
 config PCI_QUIRKS
         default y
         bool "Enable PCI quirk workarounds" if EXPERT
@@ -1863,6 +1933,49 @@ config MODULE_SIG_HASH
         default "sha384" if MODULE_SIG_SHA384
         default "sha512" if MODULE_SIG_SHA512
 
+config MODULE_COMPRESS
+        bool "Compress modules on installation"
+        depends on MODULES
+        help
+          This option compresses the kernel modules when 'make
+          modules_install' is run.
+
+          The modules will be compressed either using gzip or xz depend on the
+          choice made in "Compression algorithm".
+
+          module-init-tools has support for gzip format while kmod handle gzip
+          and xz compressed modules.
+
+          When a kernel module is installed from outside of the main kernel
+          source and uses the Kbuild system for installing modules then that
+          kernel module will also be compressed when it is installed.
+
+          This option provides little benefit when the modules are to be used inside
+          an initrd or initramfs, it generally is more efficient to compress the whole
+          initrd or initramfs instead.
+
+          This is fully compatible with signed modules while the signed module is
+          compressed. module-init-tools or kmod handles decompression and provide to
+          other layer the uncompressed but signed payload.
+
+choice
+        prompt "Compression algorithm"
+        depends on MODULE_COMPRESS
+        default MODULE_COMPRESS_GZIP
+        help
+          This determines which sort of compression will be used during
+          'make modules_install'.
+
+          GZIP (default) and XZ are supported.
+
+config MODULE_COMPRESS_GZIP
+        bool "GZIP"
+
+config MODULE_COMPRESS_XZ
+        bool "XZ"
+
+endchoice
+
 endif # MODULES
 
 config INIT_ALL_POSSIBLE
diff --git a/init/calibrate.c b/init/calibrate.c
index 520702db9acc..ce635dccf3d9 100644
--- a/init/calibrate.c
+++ b/init/calibrate.c
@@ -262,6 +262,15 @@ unsigned long __attribute__((weak)) calibrate_delay_is_known(void)
         return 0;
 }
 
+/*
+ * Indicate the cpu delay calibration is done. This can be used by
+ * architectures to stop accepting delay timer registrations after this point.
+ */
+
+void __attribute__((weak)) calibration_delay_done(void)
+{
+}
+
 void calibrate_delay(void)
 {
         unsigned long lpj;
@@ -301,4 +310,6 @@ void calibrate_delay(void)
 
         loops_per_jiffy = lpj;
         printed = true;
+
+        calibration_delay_done();
 }
diff --git a/init/do_mounts_rd.c b/init/do_mounts_rd.c
index a8227022e3a0..e5d059e8aa11 100644
--- a/init/do_mounts_rd.c
+++ b/init/do_mounts_rd.c
@@ -311,9 +311,9 @@ static int exit_code;
 static int decompress_error;
 static int crd_infd, crd_outfd;
 
-static int __init compr_fill(void *buf, unsigned int len)
+static long __init compr_fill(void *buf, unsigned long len)
 {
-        int r = sys_read(crd_infd, buf, len);
+        long r = sys_read(crd_infd, buf, len);
         if (r < 0)
                 printk(KERN_ERR "RAMDISK: error while reading compressed data");
         else if (r == 0)
@@ -321,13 +321,13 @@ static int __init compr_fill(void *buf, unsigned int len)
         return r;
 }
 
-static int __init compr_flush(void *window, unsigned int outcnt)
+static long __init compr_flush(void *window, unsigned long outcnt)
 {
-        int written = sys_write(crd_outfd, window, outcnt);
+        long written = sys_write(crd_outfd, window, outcnt);
         if (written != outcnt) {
                 if (decompress_error == 0)
                         printk(KERN_ERR
-                               "RAMDISK: incomplete write (%d != %d)\n",
+                               "RAMDISK: incomplete write (%ld != %ld)\n",
                                written, outcnt);
                 decompress_error = 1;
                 return -1;
diff --git a/init/initramfs.c b/init/initramfs.c
index a8497fab1c3d..ad1bd7787bbb 100644
--- a/init/initramfs.c
+++ b/init/initramfs.c
@@ -19,6 +19,29 @@
 #include <linux/syscalls.h>
 #include <linux/utime.h>
 
+static ssize_t __init xwrite(int fd, const char *p, size_t count)
+{
+        ssize_t out = 0;
+
+        /* sys_write only can write MAX_RW_COUNT aka 2G-4K bytes at most */
+        while (count) {
+                ssize_t rv = sys_write(fd, p, count);
+
+                if (rv < 0) {
+                        if (rv == -EINTR || rv == -EAGAIN)
+                                continue;
+                        return out ? out : rv;
+                } else if (rv == 0)
+                        break;
+
+                p += rv;
+                out += rv;
+                count -= rv;
+        }
+
+        return out;
+}
+
 static __initdata char *message;
 static void __init error(char *x)
 {
@@ -174,24 +197,24 @@ static __initdata enum state {
 } state, next_state;
 
 static __initdata char *victim;
-static __initdata unsigned count;
+static unsigned long byte_count __initdata;
 static __initdata loff_t this_header, next_header;
 
 static inline void __init eat(unsigned n)
 {
         victim += n;
         this_header += n;
-        count -= n;
+        byte_count -= n;
 }
 
 static __initdata char *vcollected;
 static __initdata char *collected;
-static __initdata int remains;
+static long remains __initdata;
 static __initdata char *collect;
 
 static void __init read_into(char *buf, unsigned size, enum state next)
 {
-        if (count >= size) {
+        if (byte_count >= size) {
                 collected = victim;
                 eat(size);
                 state = next;
@@ -213,9 +236,9 @@ static int __init do_start(void)
 
 static int __init do_collect(void)
 {
-        unsigned n = remains;
-        if (count < n)
-                n = count;
+        unsigned long n = remains;
+        if (byte_count < n)
+                n = byte_count;
         memcpy(collect, victim, n);
         eat(n);
         collect += n;
@@ -257,8 +280,8 @@ static int __init do_header(void)
 
 static int __init do_skip(void)
 {
-        if (this_header + count < next_header) {
-                eat(count);
+        if (this_header + byte_count < next_header) {
+                eat(byte_count);
                 return 1;
         } else {
                 eat(next_header - this_header);
@@ -269,9 +292,9 @@ static int __init do_skip(void)
 
 static int __init do_reset(void)
 {
-        while(count && *victim == '\0')
+        while (byte_count && *victim == '\0')
                 eat(1);
-        if (count && (this_header & 3))
+        if (byte_count && (this_header & 3))
                 error("broken padding");
         return 1;
 }
@@ -286,11 +309,11 @@ static int __init maybe_link(void)
         return 0;
 }
 
-static void __init clean_path(char *path, umode_t mode)
+static void __init clean_path(char *path, umode_t fmode)
 {
         struct stat st;
 
-        if (!sys_newlstat(path, &st) && (st.st_mode^mode) & S_IFMT) {
+        if (!sys_newlstat(path, &st) && (st.st_mode ^ fmode) & S_IFMT) {
                 if (S_ISDIR(st.st_mode))
                         sys_rmdir(path);
                 else
@@ -345,8 +368,9 @@ static int __init do_name(void)
 
 static int __init do_copy(void)
 {
-        if (count >= body_len) {
-                sys_write(wfd, victim, body_len);
+        if (byte_count >= body_len) {
+                if (xwrite(wfd, victim, body_len) != body_len)
+                        error("write error");
                 sys_close(wfd);
                 do_utime(vcollected, mtime);
                 kfree(vcollected);
@@ -354,9 +378,10 @@ static int __init do_copy(void)
                 state = SkipIt;
                 return 0;
         } else {
-                sys_write(wfd, victim, count);
-                body_len -= count;
-                eat(count);
+                if (xwrite(wfd, victim, byte_count) != byte_count)
+                        error("write error");
+                body_len -= byte_count;
+                eat(byte_count);
                 return 1;
         }
 }
@@ -384,21 +409,21 @@ static __initdata int (*actions[])(void) = {
         [Reset]         = do_reset,
 };
 
-static int __init write_buffer(char *buf, unsigned len)
+static long __init write_buffer(char *buf, unsigned long len)
 {
-        count = len;
+        byte_count = len;
         victim = buf;
 
         while (!actions[state]())
                 ;
-        return len - count;
+        return len - byte_count;
 }
 
-static int __init flush_buffer(void *bufv, unsigned len)
+static long __init flush_buffer(void *bufv, unsigned long len)
 {
         char *buf = (char *) bufv;
-        int written;
-        int origLen = len;
+        long written;
+        long origLen = len;
         if (message)
                 return -1;
         while ((written = write_buffer(buf, len)) < len && !message) {
@@ -417,13 +442,13 @@ static int __init flush_buffer(void *bufv, unsigned len)
         return origLen;
 }
 
-static unsigned my_inptr;   /* index of next byte to be processed in inbuf */
+static unsigned long my_inptr; /* index of next byte to be processed in inbuf */
 
 #include <linux/decompress/generic.h>
 
-static char * __init unpack_to_rootfs(char *buf, unsigned len)
+static char * __init unpack_to_rootfs(char *buf, unsigned long len)
 {
-        int written, res;
+        long written;
         decompress_fn decompress;
         const char *compress_name;
         static __initdata char msg_buf[64];
@@ -457,7 +482,7 @@ static char * __init unpack_to_rootfs(char *buf, unsigned len)
                 decompress = decompress_method(buf, len, &compress_name);
                 pr_debug("Detected %s compressed data\n", compress_name);
                 if (decompress) {
-                        res = decompress(buf, len, NULL, flush_buffer, NULL,
+                        int res = decompress(buf, len, NULL, flush_buffer, NULL,
                                    &my_inptr, error);
                         if (res)
                                 error("decompressor failed");
@@ -603,8 +628,13 @@ static int __init populate_rootfs(void)
                 fd = sys_open("/initrd.image",
                               O_WRONLY|O_CREAT, 0700);
                 if (fd >= 0) {
-                        sys_write(fd, (char *)initrd_start,
-                                        initrd_end - initrd_start);
+                        ssize_t written = xwrite(fd, (char *)initrd_start,
+                                                initrd_end - initrd_start);
+
+                        if (written != initrd_end - initrd_start)
+                                pr_err("/initrd.image: incomplete write (%zd != %ld)\n",
+                                       written, initrd_end - initrd_start);
+
                         sys_close(fd);
                         free_initrd();
                 }
diff --git a/init/main.c b/init/main.c
index e8ae1fef0908..321d0ceb26d3 100644
--- a/init/main.c
+++ b/init/main.c
@@ -6,7 +6,7 @@
  *  GK 2/5/95  -  Changed to support mounting root fs via NFS
  *  Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96
  *  Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96
- *  Simplified starting of init:  Michael A. Griffith <grif@acm.org> 
+ *  Simplified starting of init:  Michael A. Griffith <grif@acm.org>
  */
 
 #define DEBUG           /* Enable initcall_debug */
@@ -136,7 +136,7 @@ static char *ramdisk_execute_command;
  * Used to generate warnings if static_key manipulation functions are used
  * before jump_label_init is called.
  */
-bool static_key_initialized __read_mostly = false;
+bool static_key_initialized __read_mostly;
 EXPORT_SYMBOL_GPL(static_key_initialized);
 
 /*
@@ -159,8 +159,8 @@ static int __init set_reset_devices(char *str)
 
 __setup("reset_devices", set_reset_devices);
 
-static const char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
-const char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
+static const char *argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
+const char *envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
 static const char *panic_later, *panic_param;
 
 extern const struct obs_kernel_param __setup_start[], __setup_end[];
@@ -199,7 +199,6 @@ static int __init obsolete_checksetup(char *line)
  * still work even if initially too large, it will just take slightly longer
  */
 unsigned long loops_per_jiffy = (1<<12);
-
 EXPORT_SYMBOL(loops_per_jiffy);
 
 static int __init debug_kernel(char *str)
@@ -376,8 +375,8 @@ static void __init setup_command_line(char *command_line)
         initcall_command_line =
                 memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
         static_command_line = memblock_virt_alloc(strlen(command_line) + 1, 0);
-        strcpy (saved_command_line, boot_command_line);
-        strcpy (static_command_line, command_line);
+        strcpy(saved_command_line, boot_command_line);
+        strcpy(static_command_line, command_line);
 }
 
 /*
@@ -445,8 +444,8 @@ void __init parse_early_options(char *cmdline)
 /* Arch code calls this early on, or if not, just before other parsing. */
 void __init parse_early_param(void)
 {
-        static __initdata int done = 0;
-        static __initdata char tmp_cmdline[COMMAND_LINE_SIZE];
+        static int done __initdata;
+        static char tmp_cmdline[COMMAND_LINE_SIZE] __initdata;
 
         if (done)
                 return;
@@ -500,14 +499,15 @@ static void __init mm_init(void)
 
 asmlinkage __visible void __init start_kernel(void)
 {
-        char * command_line, *after_dashes;
-        extern const struct kernel_param __start___param[], __stop___param[];
+        char *command_line;
+        char *after_dashes;
 
         /*
          * Need to run as early as possible, to initialize the
          * lockdep hash:
          */
         lockdep_init();
+        set_task_stack_end_magic(&init_task);
         smp_setup_processor_id();
         debug_objects_early_init();
 
@@ -544,7 +544,7 @@ asmlinkage __visible void __init start_kernel(void)
                                   static_command_line, __start___param,
                                   __stop___param - __start___param,
                                   -1, -1, &unknown_bootoption);
-        if (after_dashes)
+        if (!IS_ERR_OR_NULL(after_dashes))
                 parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
                            set_init_arg);
 
@@ -572,17 +572,18 @@ asmlinkage __visible void __init start_kernel(void)
          * fragile until we cpu_idle() for the first time.
          */
         preempt_disable();
-        if (WARN(!irqs_disabled(), "Interrupts were enabled *very* early, fixing it\n"))
+        if (WARN(!irqs_disabled(),
+                 "Interrupts were enabled *very* early, fixing it\n"))
                 local_irq_disable();
         idr_init_cache();
         rcu_init();
-        tick_nohz_init();
         context_tracking_init();
         radix_tree_init();
         /* init some links before init_ISA_irqs() */
         early_irq_init();
         init_IRQ();
         tick_init();
+        rcu_init_nohz();
         init_timers();
         hrtimers_init();
         softirq_init();
@@ -842,7 +843,6 @@ static char *initcall_level_names[] __initdata = {
 
 static void __init do_initcall_level(int level)
 {
-        extern const struct kernel_param __start___param[], __stop___param[];
         initcall_t *fn;
 
         strcpy(initcall_command_line, saved_command_line);