Merge branch 'akpm' (patches from Andrew)

Merge first patch-bomb from Andrew Morton:

 - some misc things

 - ofs2 updates

 - about half of MM

 - checkpatch updates

 - autofs4 update

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (120 commits)
  autofs4: fix string.h include in auto_dev-ioctl.h
  autofs4: use pr_xxx() macros directly for logging
  autofs4: change log print macros to not insert newline
  autofs4: make autofs log prints consistent
  autofs4: fix some white space errors
  autofs4: fix invalid ioctl return in autofs4_root_ioctl_unlocked()
  autofs4: fix coding style line length in autofs4_wait()
  autofs4: fix coding style problem in autofs4_get_set_timeout()
  autofs4: coding style fixes
  autofs: show pipe inode in mount options
  kallsyms: add support for relative offsets in kallsyms address table
  kallsyms: don't overload absolute symbol type for percpu symbols
  x86: kallsyms: disable absolute percpu symbols on !SMP
  checkpatch: fix another left brace warning
  checkpatch: improve UNSPECIFIED_INT test for bare signed/unsigned uses
  checkpatch: warn on bare unsigned or signed declarations without int
  checkpatch: exclude asm volatile from complex macro check
  mm: memcontrol: drop unnecessary lru locking from mem_cgroup_migrate()
  mm: migrate: consolidate mem_cgroup_migrate() calls
  mm/compaction: speed up pageblock_pfn_to_page() when zone is contiguous
  ...

4 files changed, 116 insertions, 14 deletions

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 874132b26d23..d574d13ba963 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -3240,6 +3240,30 @@ sub process {
 #ignore lines not being added
                 next if ($line =~ /^[^\+]/);
 
+# check for declarations of signed or unsigned without int
+                while ($line =~ m{($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
+                        my $type = $1;
+                        my $var = $2;
+                        $var = "" if (!defined $var);
+                        if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
+                                my $sign = $1;
+                                my $pointer = $2;
+
+                                $pointer = "" if (!defined $pointer);
+
+                                if (WARN("UNSPECIFIED_INT",
+                                         "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
+                                    $fix) {
+                                        my $decl = trim($sign) . " int ";
+                                        my $comp_pointer = $pointer;
+                                        $comp_pointer =~ s/\s//g;
+                                        $decl .= $comp_pointer;
+                                        $decl = rtrim($decl) if ($var eq "");
+                                        $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
+                                }
+                        }
+                }
+
 # TEST: allow direct testing of the type matcher.
                 if ($dbg_type) {
                         if ($line =~ /^.\s*$Declare\s*$/) {
@@ -4109,7 +4133,7 @@ sub process {
 ##              }
 
 #need space before brace following if, while, etc
-                if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\){/) ||
+                if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
                     $line =~ /do\{/) {
                         if (ERROR("SPACING",
                                   "space required before the open brace '{'\n" . $herecurr) &&
@@ -4561,6 +4585,9 @@ sub process {
                         {
                         }
 
+                        # Make asm volatile uses seem like a generic function
+                        $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
+
                         my $exceptions = qr{
                                 $Declare|
                                 module_param_named|
diff --git a/scripts/kallsyms.c b/scripts/kallsyms.c
index 8fa81e84e295..638b143ee60f 100644
--- a/scripts/kallsyms.c
+++ b/scripts/kallsyms.c
@@ -22,6 +22,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
+#include <limits.h>
 
 #ifndef ARRAY_SIZE
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
@@ -34,6 +35,7 @@ struct sym_entry {
         unsigned int len;
         unsigned int start_pos;
         unsigned char *sym;
+        unsigned int percpu_absolute;
 };
 
 struct addr_range {
@@ -42,6 +44,7 @@ struct addr_range {
 };
 
 static unsigned long long _text;
+static unsigned long long relative_base;
 static struct addr_range text_ranges[] = {
         { "_stext",     "_etext"     },
         { "_sinittext", "_einittext" },
@@ -61,6 +64,7 @@ static int all_symbols = 0;
 static int absolute_percpu = 0;
 static char symbol_prefix_char = '\0';
 static unsigned long long kernel_start_addr = 0;
+static int base_relative = 0;
 
 int token_profit[0x10000];
 
@@ -74,7 +78,7 @@ static void usage(void)
         fprintf(stderr, "Usage: kallsyms [--all-symbols] "
                         "[--symbol-prefix=<prefix char>] "
                         "[--page-offset=<CONFIG_PAGE_OFFSET>] "
-                        "< in.map > out.S\n");
+                        "[--base-relative] < in.map > out.S\n");
         exit(1);
 }
 
@@ -171,6 +175,8 @@ static int read_symbol(FILE *in, struct sym_entry *s)
         strcpy((char *)s->sym + 1, str);
         s->sym[0] = stype;
 
+        s->percpu_absolute = 0;
+
         /* Record if we've found __per_cpu_start/end. */
         check_symbol_range(sym, s->addr, &percpu_range, 1);
 
@@ -202,6 +208,8 @@ static int symbol_valid(struct sym_entry *s)
          */
         static char *special_symbols[] = {
                 "kallsyms_addresses",
+                "kallsyms_offsets",
+                "kallsyms_relative_base",
                 "kallsyms_num_syms",
                 "kallsyms_names",
                 "kallsyms_markers",
@@ -325,7 +333,7 @@ static int expand_symbol(unsigned char *data, int len, char *result)
 
 static int symbol_absolute(struct sym_entry *s)
 {
-        return toupper(s->sym[0]) == 'A';
+        return s->percpu_absolute;
 }
 
 static void write_src(void)
@@ -346,16 +354,48 @@ static void write_src(void)
 
         printf("\t.section .rodata, \"a\"\n");
 
-        /* Provide proper symbols relocatability by their '_text'
-         * relativeness.  The symbol names cannot be used to construct
-         * normal symbol references as the list of symbols contains
-         * symbols that are declared static and are private to their
-         * .o files.  This prevents .tmp_kallsyms.o or any other
-         * object from referencing them.
+        /* Provide proper symbols relocatability by their relativeness
+         * to a fixed anchor point in the runtime image, either '_text'
+         * for absolute address tables, in which case the linker will
+         * emit the final addresses at build time. Otherwise, use the
+         * offset relative to the lowest value encountered of all relative
+         * symbols, and emit non-relocatable fixed offsets that will be fixed
+         * up at runtime.
+         *
+         * The symbol names cannot be used to construct normal symbol
+         * references as the list of symbols contains symbols that are
+         * declared static and are private to their .o files.  This prevents
+         * .tmp_kallsyms.o or any other object from referencing them.
          */
-        output_label("kallsyms_addresses");
+        if (!base_relative)
+                output_label("kallsyms_addresses");
+        else
+                output_label("kallsyms_offsets");
+
         for (i = 0; i < table_cnt; i++) {
-                if (!symbol_absolute(&table[i])) {
+                if (base_relative) {
+                        long long offset;
+                        int overflow;
+
+                        if (!absolute_percpu) {
+                                offset = table[i].addr - relative_base;
+                                overflow = (offset < 0 || offset > UINT_MAX);
+                        } else if (symbol_absolute(&table[i])) {
+                                offset = table[i].addr;
+                                overflow = (offset < 0 || offset > INT_MAX);
+                        } else {
+                                offset = relative_base - table[i].addr - 1;
+                                overflow = (offset < INT_MIN || offset >= 0);
+                        }
+                        if (overflow) {
+                                fprintf(stderr, "kallsyms failure: "
+                                        "%s symbol value %#llx out of range in relative mode\n",
+                                        symbol_absolute(&table[i]) ? "absolute" : "relative",
+                                        table[i].addr);
+                                exit(EXIT_FAILURE);
+                        }
+                        printf("\t.long\t%#x\n", (int)offset);
+                } else if (!symbol_absolute(&table[i])) {
                         if (_text <= table[i].addr)
                                 printf("\tPTR\t_text + %#llx\n",
                                         table[i].addr - _text);
@@ -368,6 +408,12 @@ static void write_src(void)
         }
         printf("\n");
 
+        if (base_relative) {
+                output_label("kallsyms_relative_base");
+                printf("\tPTR\t_text - %#llx\n", _text - relative_base);
+                printf("\n");
+        }
+
         output_label("kallsyms_num_syms");
         printf("\tPTR\t%d\n", table_cnt);
         printf("\n");
@@ -681,8 +727,27 @@ static void make_percpus_absolute(void)
         unsigned int i;
 
         for (i = 0; i < table_cnt; i++)
-                if (symbol_in_range(&table[i], &percpu_range, 1))
+                if (symbol_in_range(&table[i], &percpu_range, 1)) {
+                        /*
+                         * Keep the 'A' override for percpu symbols to
+                         * ensure consistent behavior compared to older
+                         * versions of this tool.
+                         */
                         table[i].sym[0] = 'A';
+                        table[i].percpu_absolute = 1;
+                }
+}
+
+/* find the minimum non-absolute symbol address */
+static void record_relative_base(void)
+{
+        unsigned int i;
+
+        relative_base = -1ULL;
+        for (i = 0; i < table_cnt; i++)
+                if (!symbol_absolute(&table[i]) &&
+                    table[i].addr < relative_base)
+                        relative_base = table[i].addr;
 }
 
 int main(int argc, char **argv)
@@ -703,7 +768,9 @@ int main(int argc, char **argv)
                         } else if (strncmp(argv[i], "--page-offset=", 14) == 0) {
                                 const char *p = &argv[i][14];
                                 kernel_start_addr = strtoull(p, NULL, 16);
-                        } else
+                        } else if (strcmp(argv[i], "--base-relative") == 0)
+                                base_relative = 1;
+                        else
                                 usage();
                 }
         } else if (argc != 1)
@@ -712,6 +779,8 @@ int main(int argc, char **argv)
         read_map(stdin);
         if (absolute_percpu)
                 make_percpus_absolute();
+        if (base_relative)
+                record_relative_base();
         sort_symbols();
         optimize_token_table();
         write_src();
diff --git a/scripts/link-vmlinux.sh b/scripts/link-vmlinux.sh
index ba6c34ea5429..453ede9d2f3d 100755
--- a/scripts/link-vmlinux.sh
+++ b/scripts/link-vmlinux.sh
@@ -86,10 +86,14 @@ kallsyms()
                 kallsymopt="${kallsymopt} --page-offset=$CONFIG_PAGE_OFFSET"
         fi
 
-        if [ -n "${CONFIG_X86_64}" ]; then
+        if [ -n "${CONFIG_KALLSYMS_ABSOLUTE_PERCPU}" ]; then
                 kallsymopt="${kallsymopt} --absolute-percpu"
         fi
 
+        if [ -n "${CONFIG_KALLSYMS_BASE_RELATIVE}" ]; then
+                kallsymopt="${kallsymopt} --base-relative"
+        fi
+
         local aflags="${KBUILD_AFLAGS} ${KBUILD_AFLAGS_KERNEL}               \
                       ${NOSTDINC_FLAGS} ${LINUXINCLUDE} ${KBUILD_CPPFLAGS}"
 
diff --git a/scripts/namespace.pl b/scripts/namespace.pl
index a71be6b7cdec..9f3c9d47a4a5 100755
--- a/scripts/namespace.pl
+++ b/scripts/namespace.pl
@@ -117,6 +117,8 @@ my %nameexception = (
     'kallsyms_names'    => 1,
     'kallsyms_num_syms' => 1,
     'kallsyms_addresses'=> 1,
+    'kallsyms_offsets'  => 1,
+    'kallsyms_relative_base'=> 1,
     '__this_module'     => 1,
     '_etext'            => 1,
     '_edata'            => 1,