31 files changed, 974 insertions, 299 deletions

diff --git a/scripts/Makefile.dtbinst b/scripts/Makefile.dtbinst
index 909ed7a2ac61..1c15717e0d56 100644
--- a/scripts/Makefile.dtbinst
+++ b/scripts/Makefile.dtbinst
@@ -18,7 +18,7 @@ export dtbinst-root ?= $(obj)
 
 include include/config/auto.conf
 include scripts/Kbuild.include
-include $(srctree)/$(obj)/Makefile
+include $(src)/Makefile
 
 PHONY += __dtbs_install_prep
 __dtbs_install_prep:
diff --git a/scripts/Makefile.fwinst b/scripts/Makefile.fwinst
index 5b698add4f31..b27290035253 100644
--- a/scripts/Makefile.fwinst
+++ b/scripts/Makefile.fwinst
@@ -13,7 +13,7 @@ src := $(obj)
 -include $(objtree)/.config
 
 include scripts/Kbuild.include
-include $(srctree)/$(obj)/Makefile
+include $(src)/Makefile
 
 include scripts/Makefile.host
 
diff --git a/scripts/Makefile.kasan b/scripts/Makefile.kasan
index 631619b2b118..3f874d24234f 100644
--- a/scripts/Makefile.kasan
+++ b/scripts/Makefile.kasan
@@ -13,12 +13,16 @@ CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \
                 --param asan-instrumentation-with-call-threshold=$(call_threshold))
 
 ifeq ($(call cc-option, $(CFLAGS_KASAN_MINIMAL) -Werror),)
+   ifneq ($(CONFIG_COMPILE_TEST),y)
         $(warning Cannot use CONFIG_KASAN: \
             -fsanitize=kernel-address is not supported by compiler)
+   endif
 else
     ifeq ($(CFLAGS_KASAN),)
-        $(warning CONFIG_KASAN: compiler does not support all options.\
-            Trying minimal configuration)
+        ifneq ($(CONFIG_COMPILE_TEST),y)
+            $(warning CONFIG_KASAN: compiler does not support all options.\
+                Trying minimal configuration)
+        endif
         CFLAGS_KASAN := $(CFLAGS_KASAN_MINIMAL)
     endif
 endif
diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib
index 044eb4f89a91..79e86613712f 100644
--- a/scripts/Makefile.lib
+++ b/scripts/Makefile.lib
@@ -282,7 +282,8 @@ $(obj)/%.dtb.S: $(obj)/%.dtb
         $(call cmd,dt_S_dtb)
 
 quiet_cmd_dtc = DTC     $@
-cmd_dtc = $(CPP) $(dtc_cpp_flags) -x assembler-with-cpp -o $(dtc-tmp) $< ; \
+cmd_dtc = mkdir -p $(dir ${dtc-tmp}) ; \
+        $(CPP) $(dtc_cpp_flags) -x assembler-with-cpp -o $(dtc-tmp) $< ; \
         $(objtree)/scripts/dtc/dtc -O dtb -o $@ -b 0 \
                 -i $(dir $<) $(DTC_FLAGS) \
                 -d $(depfile).dtc.tmp $(dtc-tmp) ; \
diff --git a/scripts/check_extable.sh b/scripts/check_extable.sh
new file mode 100755
index 000000000000..0fb6b1c97c27
--- /dev/null
+++ b/scripts/check_extable.sh
@@ -0,0 +1,146 @@
+#! /bin/bash
+# (c) 2015, Quentin Casasnovas <quentin.casasnovas@oracle.com>
+
+obj=$1
+
+file ${obj} | grep -q ELF || (echo "${obj} is not and ELF file." 1>&2 ; exit 0)
+
+# Bail out early if there isn't an __ex_table section in this object file.
+objdump -hj __ex_table ${obj} 2> /dev/null > /dev/null
+[ $? -ne 0 ] && exit 0
+
+white_list=.text,.fixup
+
+suspicious_relocs=$(objdump -rj __ex_table ${obj}  | tail -n +6 |
+                        grep -v $(eval echo -e{${white_list}}) | awk '{print $3}')
+
+# No suspicious relocs in __ex_table, jobs a good'un
+[ -z "${suspicious_relocs}" ] && exit 0
+
+
+# After this point, something is seriously wrong since we just found out we
+# have some relocations in __ex_table which point to sections which aren't
+# white listed.  If you're adding a new section in the Linux kernel, and
+# you're expecting this section to contain code which can fault (i.e. the
+# __ex_table relocation to your new section is expected), simply add your
+# new section to the white_list variable above.  If not, you're probably
+# doing something wrong and the rest of this code is just trying to print
+# you more information about it.
+
+function find_section_offset_from_symbol()
+{
+    eval $(objdump -t ${obj} | grep ${1} | sed 's/\([0-9a-f]\+\) .\{7\} \([^ \t]\+\).*/section="\2"; section_offset="0x\1" /')
+
+    # addr2line takes addresses in hexadecimal...
+    section_offset=$(printf "0x%016x" $(( ${section_offset} + $2 )) )
+}
+
+function find_symbol_and_offset_from_reloc()
+{
+    # Extract symbol and offset from the objdump output
+    eval $(echo $reloc | sed 's/\([^+]\+\)+\?\(0x[0-9a-f]\+\)\?/symbol="\1"; symbol_offset="\2"/')
+
+    # When the relocation points to the begining of a symbol or section, it
+    # won't print the offset since it is zero.
+    if [ -z "${symbol_offset}" ]; then
+        symbol_offset=0x0
+    fi
+}
+
+function find_alt_replacement_target()
+{
+    # The target of the .altinstr_replacement is the relocation just before
+    # the .altinstr_replacement one.
+    eval $(objdump -rj .altinstructions ${obj} | grep -B1 "${section}+${section_offset}" | head -n1 | awk '{print $3}' |
+           sed 's/\([^+]\+\)+\(0x[0-9a-f]\+\)/alt_target_section="\1"; alt_target_offset="\2"/')
+}
+
+function handle_alt_replacement_reloc()
+{
+    # This will define alt_target_section and alt_target_section_offset
+    find_alt_replacement_target ${section} ${section_offset}
+
+    echo "Error: found a reference to .altinstr_replacement in __ex_table:"
+    addr2line -fip -j ${alt_target_section} -e ${obj} ${alt_target_offset} | awk '{print "\t" $0}'
+
+    error=true
+}
+
+function is_executable_section()
+{
+    objdump -hwj ${section} ${obj} | grep -q CODE
+    return $?
+}
+
+function handle_suspicious_generic_reloc()
+{
+    if is_executable_section ${section}; then
+        # We've got a relocation to a non white listed _executable_
+        # section, print a warning so the developper adds the section to
+        # the white list or fix his code.  We try to pretty-print the file
+        # and line number where that relocation was added.
+        echo "Warning: found a reference to section \"${section}\" in __ex_table:"
+        addr2line -fip -j ${section} -e ${obj} ${section_offset} | awk '{print "\t" $0}'
+    else
+        # Something is definitively wrong here since we've got a relocation
+        # to a non-executable section, there's no way this would ever be
+        # running in the kernel.
+        echo "Error: found a reference to non-executable section \"${section}\" in __ex_table at offset ${section_offset}"
+        error=true
+    fi
+}
+
+function handle_suspicious_reloc()
+{
+    case "${section}" in
+        ".altinstr_replacement")
+            handle_alt_replacement_reloc ${section} ${section_offset}
+            ;;
+        *)
+            handle_suspicious_generic_reloc ${section} ${section_offset}
+            ;;
+    esac
+}
+
+function diagnose()
+{
+
+    for reloc in ${suspicious_relocs}; do
+        # Let's find out where the target of the relocation in __ex_table
+        # is, this will define ${symbol} and ${symbol_offset}
+        find_symbol_and_offset_from_reloc ${reloc}
+
+        # When there's a global symbol at the place of the relocation,
+        # objdump will use it instead of giving us a section+offset, so
+        # let's find out which section is this symbol in and the total
+        # offset withing that section.
+        find_section_offset_from_symbol ${symbol} ${symbol_offset}
+
+        # In this case objdump was presenting us with a reloc to a symbol
+        # rather than a section. Now that we've got the actual section,
+        # we can skip it if it's in the white_list.
+        if [ -z "$( echo $section | grep -v $(eval echo -e{${white_list}}))" ]; then
+            continue;
+        fi
+
+        # Will either print a warning if the relocation happens to be in a
+        # section we do not know but has executable bit set, or error out.
+        handle_suspicious_reloc
+    done
+}
+
+function check_debug_info() {
+    objdump -hj .debug_info ${obj} 2> /dev/null > /dev/null ||
+        echo -e "${obj} does not contain debug information, the addr2line output will be limited.\n" \
+             "Recompile ${obj} with CONFIG_DEBUG_INFO to get a more useful output."
+}
+
+check_debug_info
+
+diagnose
+
+if [ "${error}" ]; then
+    exit 1
+fi
+
+exit 0
diff --git a/scripts/checkkconfigsymbols.py b/scripts/checkkconfigsymbols.py
index e9cc689033fe..74086a583d8d 100644..100755
--- a/scripts/checkkconfigsymbols.py
+++ b/scripts/checkkconfigsymbols.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 
-"""Find Kconfig identifiers that are referenced but not defined."""
+"""Find Kconfig symbols that are referenced but not defined."""
 
-# (c) 2014 Valentin Rothberg <valentinrothberg@gmail.com>
+# (c) 2014-2015 Valentin Rothberg <Valentin.Rothberg@lip6.fr>
 # (c) 2014 Stefan Hengelein <stefan.hengelein@fau.de>
 #
 # Licensed under the terms of the GNU GPL License version 2
@@ -10,7 +10,9 @@
 
 import os
 import re
+import sys
 from subprocess import Popen, PIPE, STDOUT
+from optparse import OptionParser
 
 
 # regex expressions
@@ -32,22 +34,149 @@ REGEX_KCONFIG_HELP = re.compile(r"^\s+(help|---help---)\s*$")
 REGEX_FILTER_FEATURES = re.compile(r"[A-Za-z0-9]$")
 
 
+def parse_options():
+    """The user interface of this module."""
+    usage = "%prog [options]\n\n"                                              \
+            "Run this tool to detect Kconfig symbols that are referenced but " \
+            "not defined in\nKconfig.  The output of this tool has the "       \
+            "format \'Undefined symbol\\tFile list\'\n\n"                      \
+            "If no option is specified, %prog will default to check your\n"    \
+            "current tree.  Please note that specifying commits will "         \
+            "\'git reset --hard\'\nyour current tree!  You may save "          \
+            "uncommitted changes to avoid losing data."
+
+    parser = OptionParser(usage=usage)
+
+    parser.add_option('-c', '--commit', dest='commit', action='store',
+                      default="",
+                      help="Check if the specified commit (hash) introduces "
+                           "undefined Kconfig symbols.")
+
+    parser.add_option('-d', '--diff', dest='diff', action='store',
+                      default="",
+                      help="Diff undefined symbols between two commits.  The "
+                           "input format bases on Git log's "
+                           "\'commmit1..commit2\'.")
+
+    parser.add_option('', '--force', dest='force', action='store_true',
+                      default=False,
+                      help="Reset current Git tree even when it's dirty.")
+
+    (opts, _) = parser.parse_args()
+
+    if opts.commit and opts.diff:
+        sys.exit("Please specify only one option at once.")
+
+    if opts.diff and not re.match(r"^[\w\-\.]+\.\.[\w\-\.]+$", opts.diff):
+        sys.exit("Please specify valid input in the following format: "
+                 "\'commmit1..commit2\'")
+
+    if opts.commit or opts.diff:
+        if not opts.force and tree_is_dirty():
+            sys.exit("The current Git tree is dirty (see 'git status').  "
+                     "Running this script may\ndelete important data since it "
+                     "calls 'git reset --hard' for some performance\nreasons. "
+                     " Please run this script in a clean Git tree or pass "
+                     "'--force' if you\nwant to ignore this warning and "
+                     "continue.")
+
+    return opts
+
+
 def main():
     """Main function of this module."""
+    opts = parse_options()
+
+    if opts.commit or opts.diff:
+        head = get_head()
+
+        # get commit range
+        commit_a = None
+        commit_b = None
+        if opts.commit:
+            commit_a = opts.commit + "~"
+            commit_b = opts.commit
+        elif opts.diff:
+            split = opts.diff.split("..")
+            commit_a = split[0]
+            commit_b = split[1]
+            undefined_a = {}
+            undefined_b = {}
+
+        # get undefined items before the commit
+        execute("git reset --hard %s" % commit_a)
+        undefined_a = check_symbols()
+
+        # get undefined items for the commit
+        execute("git reset --hard %s" % commit_b)
+        undefined_b = check_symbols()
+
+        # report cases that are present for the commit but not before
+        for feature in sorted(undefined_b):
+            # feature has not been undefined before
+            if not feature in undefined_a:
+                files = sorted(undefined_b.get(feature))
+                print "%s\t%s" % (feature, ", ".join(files))
+            # check if there are new files that reference the undefined feature
+            else:
+                files = sorted(undefined_b.get(feature) -
+                               undefined_a.get(feature))
+                if files:
+                    print "%s\t%s" % (feature, ", ".join(files))
+
+        # reset to head
+        execute("git reset --hard %s" % head)
+
+    # default to check the entire tree
+    else:
+        undefined = check_symbols()
+        for feature in sorted(undefined):
+            files = sorted(undefined.get(feature))
+            print "%s\t%s" % (feature, ", ".join(files))
+
+
+def execute(cmd):
+    """Execute %cmd and return stdout.  Exit in case of error."""
+    pop = Popen(cmd, stdout=PIPE, stderr=STDOUT, shell=True)
+    (stdout, _) = pop.communicate()  # wait until finished
+    if pop.returncode != 0:
+        sys.exit(stdout)
+    return stdout
+
+
+def tree_is_dirty():
+    """Return true if the current working tree is dirty (i.e., if any file has
+    been added, deleted, modified, renamed or copied but not committed)."""
+    stdout = execute("git status --porcelain")
+    for line in stdout:
+        if re.findall(r"[URMADC]{1}", line[:2]):
+            return True
+    return False
+
+
+def get_head():
+    """Return commit hash of current HEAD."""
+    stdout = execute("git rev-parse HEAD")
+    return stdout.strip('\n')
+
+
+def check_symbols():
+    """Find undefined Kconfig symbols and return a dict with the symbol as key
+    and a list of referencing files as value."""
     source_files = []
     kconfig_files = []
     defined_features = set()
     referenced_features = dict()  # {feature: [files]}
 
     # use 'git ls-files' to get the worklist
-    pop = Popen("git ls-files", stdout=PIPE, stderr=STDOUT, shell=True)
-    (stdout, _) = pop.communicate()  # wait until finished
+    stdout = execute("git ls-files")
     if len(stdout) > 0 and stdout[-1] == "\n":
         stdout = stdout[:-1]
 
     for gitfile in stdout.rsplit("\n"):
-        if ".git" in gitfile or "ChangeLog" in gitfile or \
-                ".log" in gitfile or os.path.isdir(gitfile):
+        if ".git" in gitfile or "ChangeLog" in gitfile or      \
+                ".log" in gitfile or os.path.isdir(gitfile) or \
+                gitfile.startswith("tools/"):
             continue
         if REGEX_FILE_KCONFIG.match(gitfile):
             kconfig_files.append(gitfile)
@@ -61,7 +190,7 @@ def main():
     for kfile in kconfig_files:
         parse_kconfig_file(kfile, defined_features, referenced_features)
 
-    print "Undefined symbol used\tFile list"
+    undefined = {}  # {feature: [files]}
     for feature in sorted(referenced_features):
         # filter some false positives
         if feature == "FOO" or feature == "BAR" or \
@@ -72,8 +201,8 @@ def main():
                 # avoid false positives for kernel modules
                 if feature[:-len("_MODULE")] in defined_features:
                     continue
-            files = referenced_features.get(feature)
-            print "%s\t%s" % (feature, ", ".join(files))
+            undefined[feature] = referenced_features.get(feature)
+    return undefined
 
 
 def parse_source_file(sfile, referenced_features):
diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index d12435992dea..89b1df4e72ab 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -47,6 +47,8 @@ my $ignore_perl_version = 0;
 my $minimum_perl_version = 5.10.0;
 my $min_conf_desc_length = 4;
 my $spelling_file = "$D/spelling.txt";
+my $codespell = 0;
+my $codespellfile = "/usr/local/share/codespell/dictionary.txt";
 
 sub help {
         my ($exitcode) = @_;
@@ -88,6 +90,9 @@ Options:
                              file.  It's your fault if there's no backup or git
   --ignore-perl-version      override checking of perl version.  expect
                              runtime errors.
+  --codespell                Use the codespell dictionary for spelling/typos
+                             (default:/usr/local/share/codespell/dictionary.txt)
+  --codespellfile            Use this codespell dictionary
   -h, --help, --version      display this help and exit
 
 When FILE is - read standard input.
@@ -146,6 +151,8 @@ GetOptions(
         'ignore-perl-version!' => \$ignore_perl_version,
         'debug=s'       => \%debug,
         'test-only=s'   => \$tst_only,
+        'codespell!'    => \$codespell,
+        'codespellfile=s'       => \$codespellfile,
         'h|help'        => \$help,
         'version'       => \$help
 ) or help(1);
@@ -316,6 +323,7 @@ our $Operators	= qr{
 
 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
 
+our $BasicType;
 our $NonptrType;
 our $NonptrTypeMisordered;
 our $NonptrTypeWithAttr;
@@ -436,6 +444,14 @@ foreach my $entry (@mode_permission_funcs) {
         $mode_perms_search .= $entry->[0];
 }
 
+our $mode_perms_world_writable = qr{
+        S_IWUGO         |
+        S_IWOTH         |
+        S_IRWXUGO       |
+        S_IALLUGO       |
+        0[0-7][0-7][2367]
+}x;
+
 our $allowed_asm_includes = qr{(?x:
         irq|
         memory|
@@ -449,7 +465,6 @@ my $misspellings;
 my %spelling_fix;
 
 if (open(my $spelling, '<', $spelling_file)) {
-        my @spelling_list;
         while (<$spelling>) {
                 my $line = $_;
 
@@ -461,21 +476,50 @@ if (open(my $spelling, '<', $spelling_file)) {
 
                 my ($suspect, $fix) = split(/\|\|/, $line);
 
-                push(@spelling_list, $suspect);
                 $spelling_fix{$suspect} = $fix;
         }
         close($spelling);
-        $misspellings = join("|", @spelling_list);
 } else {
         warn "No typos will be found - file '$spelling_file': $!\n";
 }
 
+if ($codespell) {
+        if (open(my $spelling, '<', $codespellfile)) {
+                while (<$spelling>) {
+                        my $line = $_;
+
+                        $line =~ s/\s*\n?$//g;
+                        $line =~ s/^\s*//g;
+
+                        next if ($line =~ m/^\s*#/);
+                        next if ($line =~ m/^\s*$/);
+                        next if ($line =~ m/, disabled/i);
+
+                        $line =~ s/,.*$//;
+
+                        my ($suspect, $fix) = split(/->/, $line);
+
+                        $spelling_fix{$suspect} = $fix;
+                }
+                close($spelling);
+        } else {
+                warn "No codespell typos will be found - file '$codespellfile': $!\n";
+        }
+}
+
+$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
+
 sub build_types {
         my $mods = "(?x:  \n" . join("|\n  ", @modifierList) . "\n)";
         my $all = "(?x:  \n" . join("|\n  ", @typeList) . "\n)";
         my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
         my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
         $Modifier       = qr{(?:$Attribute|$Sparse|$mods)};
+        $BasicType      = qr{
+                                (?:$typeOtherOSTypedefs\b)|
+                                (?:$typeTypedefs\b)|
+                                (?:${all}\b)
+                }x;
         $NonptrType     = qr{
                         (?:$Modifier\s+|const\s+)*
                         (?:
@@ -1646,7 +1690,7 @@ sub fix_inserted_deleted_lines {
         foreach my $old_line (@{$linesRef}) {
                 my $save_line = 1;
                 my $line = $old_line;   #don't modify the array
-                if ($line =~ /^(?:\+\+\+\|\-\-\-)\s+\S+/) {     #new filename
+                if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {      #new filename
                         $delta_offset = 0;
                 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {    #new hunk
                         $range_last_linenr = $new_linenr;
@@ -1854,6 +1898,7 @@ sub process {
 
         my $in_header_lines = $file ? 0 : 1;
         my $in_commit_log = 0;          #Scanning lines before patch
+        my $commit_log_long_line = 0;
         my $reported_maintainer_file = 0;
         my $non_utf8_charset = 0;
 
@@ -2189,6 +2234,14 @@ sub process {
                               "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
                 }
 
+# Check for line lengths > 75 in commit log, warn once
+                if ($in_commit_log && !$commit_log_long_line &&
+                    length($line) > 75) {
+                        WARN("COMMIT_LOG_LONG_LINE",
+                             "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
+                        $commit_log_long_line = 1;
+                }
+
 # Check for git id commit length and improperly formed commit descriptions
                 if ($in_commit_log && $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i) {
                         my $init_char = $1;
@@ -2303,8 +2356,9 @@ sub process {
                 }
 
 # Check for various typo / spelling mistakes
-                if (defined($misspellings) && ($in_commit_log || $line =~ /^\+/)) {
-                        while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:$|[^a-z@])/gi) {
+                if (defined($misspellings) &&
+                    ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
+                        while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
                                 my $typo = $1;
                                 my $typo_fix = $spelling_fix{lc($typo)};
                                 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
@@ -2459,8 +2513,9 @@ sub process {
 #line length limit
                 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
                     $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
-                    !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
-                    $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
+                    !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?$String\s*(?:|,|\)\s*;)\s*$/ ||
+                      $line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
+                      $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) &&
                     $length > $max_line_length)
                 {
                         WARN("LONG_LINE",
@@ -2552,8 +2607,15 @@ sub process {
                         }
                 }
 
-                if ($line =~ /^\+.*(\w+\s*)?\(\s*$Type\s*\)[ \t]+(?!$Assignment|$Arithmetic|[,;:\?\(\{\}\[\<\>]|&&|\|\||\\$)/ &&
-                    (!defined($1) || $1 !~ /sizeof\s*/)) {
+# check for space after cast like "(int) foo" or "(struct foo) bar"
+# avoid checking a few false positives:
+#   "sizeof(<type>)" or "__alignof__(<type>)"
+#   function pointer declarations like "(*foo)(int) = bar;"
+#   structure definitions like "(struct foo) { 0 };"
+#   multiline macros that define functions
+#   known attributes or the __attribute__ keyword
+                if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
+                    (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
                         if (CHK("SPACING",
                                 "No space is necessary after a cast\n" . $herecurr) &&
                             $fix) {
@@ -3146,6 +3208,18 @@ sub process {
                                 $herecurr);
                }
 
+# check for const <foo> const where <foo> is not a pointer or array type
+                if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
+                        my $found = $1;
+                        if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
+                                WARN("CONST_CONST",
+                                     "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
+                        } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
+                                WARN("CONST_CONST",
+                                     "'const $found const' should probably be 'const $found'\n" . $herecurr);
+                        }
+                }
+
 # check for non-global char *foo[] = {"bar", ...} declarations.
                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
                         WARN("STATIC_CONST_CHAR_ARRAY",
@@ -3153,6 +3227,19 @@ sub process {
                                 $herecurr);
                }
 
+# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
+                if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
+                        my $array = $1;
+                        if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
+                                my $array_div = $1;
+                                if (WARN("ARRAY_SIZE",
+                                         "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
+                                    $fix) {
+                                        $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
+                                }
+                        }
+                }
+
 # check for function declarations without arguments like "int foo()"
                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
                         if (ERROR("FUNCTION_WITHOUT_ARGS",
@@ -3309,6 +3396,14 @@ sub process {
                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
                 }
 
+# ENOSYS means "bad syscall nr" and nothing else.  This will have a small
+# number of false positives, but assembly files are not checked, so at
+# least the arch entry code will not trigger this warning.
+                if ($line =~ /\bENOSYS\b/) {
+                        WARN("ENOSYS",
+                             "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
+                }
+
 # function brace can't be on same line, except for #defines of do while,
 # or if closed on same line
                 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
@@ -3565,7 +3660,7 @@ sub process {
 
                                 # Ignore operators passed as parameters.
                                 if ($op_type ne 'V' &&
-                                    $ca =~ /\s$/ && $cc =~ /^\s*,/) {
+                                    $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
 
 #                               # Ignore comments
 #                               } elsif ($op =~ /^$;+$/) {
@@ -3750,6 +3845,14 @@ sub process {
                                                 $ok = 1;
                                         }
 
+                                        # for asm volatile statements
+                                        # ignore a colon with another
+                                        # colon immediately before or after
+                                        if (($op eq ':') &&
+                                            ($ca =~ /:$/ || $cc =~ /^:/)) {
+                                                $ok = 1;
+                                        }
+
                                         # messages are ERROR, but ?: are CHK
                                         if ($ok == 0) {
                                                 my $msg_type = \&ERROR;
@@ -3963,12 +4066,12 @@ sub process {
                         }
                 }
 
-# Return of what appears to be an errno should normally be -'ve
-                if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
+# Return of what appears to be an errno should normally be negative
+                if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
                         my $name = $1;
                         if ($name ne 'EOF' && $name ne 'ERROR') {
                                 WARN("USE_NEGATIVE_ERRNO",
-                                     "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
+                                     "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
                         }
                 }
 
@@ -4178,7 +4281,8 @@ sub process {
                         }
                 }
 
-#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
+# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
+# itself <asm/foo.h> (uses RAW line)
                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
                         my $file = "$1.h";
                         my $checkfile = "include/linux/$file";
@@ -4186,12 +4290,15 @@ sub process {
                             $realfile ne $checkfile &&
                             $1 !~ /$allowed_asm_includes/)
                         {
-                                if ($realfile =~ m{^arch/}) {
-                                        CHK("ARCH_INCLUDE_LINUX",
-                                            "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
-                                } else {
-                                        WARN("INCLUDE_LINUX",
-                                             "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
+                                my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
+                                if ($asminclude > 0) {
+                                        if ($realfile =~ m{^arch/}) {
+                                                CHK("ARCH_INCLUDE_LINUX",
+                                                    "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
+                                        } else {
+                                                WARN("INCLUDE_LINUX",
+                                                     "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
+                                        }
                                 }
                         }
                 }
@@ -4700,6 +4807,16 @@ sub process {
                         }
                 }
 
+# check for __read_mostly with const non-pointer (should just be const)
+                if ($line =~ /\b__read_mostly\b/ &&
+                    $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
+                        if (ERROR("CONST_READ_MOSTLY",
+                                  "Invalid use of __read_mostly with const type\n" . $herecurr) &&
+                            $fix) {
+                                $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
+                        }
+                }
+
 # don't use __constant_<foo> functions outside of include/uapi/
                 if ($realfile !~ m@^include/uapi/@ &&
                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
@@ -5261,6 +5378,7 @@ sub process {
                                 stacktrace_ops|
                                 sysfs_ops|
                                 tty_operations|
+                                uart_ops|
                                 usb_mon_operations|
                                 wd_ops}x;
                 if ($line !~ /\bconst\b/ &&
@@ -5318,8 +5436,8 @@ sub process {
                         }
                 }
 
-                if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
-                    $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
+                if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
+                    $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
                         WARN("EXPORTED_WORLD_WRITABLE",
                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
                 }
diff --git a/scripts/coccinelle/misc/bugon.cocci b/scripts/coccinelle/misc/bugon.cocci
index 3b7eec24fb5a..27c97f1f2767 100644
--- a/scripts/coccinelle/misc/bugon.cocci
+++ b/scripts/coccinelle/misc/bugon.cocci
@@ -57,6 +57,6 @@ coccilib.org.print_todo(p[0], "WARNING use BUG_ON")
 p << r.p;
 @@
 
-msg="WARNING: Use BUG_ON"
+msg="WARNING: Use BUG_ON instead of if condition followed by BUG.\nPlease make sure the condition has no side effects (see conditional BUG_ON definition in include/asm-generic/bug.h)"
 coccilib.report.print_report(p[0], msg)
 
diff --git a/scripts/coccinelle/misc/irqf_oneshot.cocci b/scripts/coccinelle/misc/irqf_oneshot.cocci
index 6cfde94be0ef..a24a754ae1d7 100644
--- a/scripts/coccinelle/misc/irqf_oneshot.cocci
+++ b/scripts/coccinelle/misc/irqf_oneshot.cocci
@@ -12,11 +12,13 @@ virtual org
 virtual report
 
 @r1@
+expression dev;
 expression irq;
 expression thread_fn;
 expression flags;
 position p;
 @@
+(
 request_threaded_irq@p(irq, NULL, thread_fn,
 (
 flags | IRQF_ONESHOT
@@ -24,13 +26,24 @@ flags | IRQF_ONESHOT
 IRQF_ONESHOT
 )
 , ...)
+|
+devm_request_threaded_irq@p(dev, irq, NULL, thread_fn,
+(
+flags | IRQF_ONESHOT
+|
+IRQF_ONESHOT
+)
+, ...)
+)
 
 @depends on patch@
+expression dev;
 expression irq;
 expression thread_fn;
 expression flags;
 position p != r1.p;
 @@
+(
 request_threaded_irq@p(irq, NULL, thread_fn,
 (
 -0
@@ -40,6 +53,17 @@ request_threaded_irq@p(irq, NULL, thread_fn,
 +flags | IRQF_ONESHOT
 )
 , ...)
+|
+devm_request_threaded_irq@p(dev, irq, NULL, thread_fn,
+(
+-0
++IRQF_ONESHOT
+|
+-flags
++flags | IRQF_ONESHOT
+)
+, ...)
+)
 
 @depends on context@
 position p != r1.p;
diff --git a/scripts/extract-ikconfig b/scripts/extract-ikconfig
index e1862429ccda..3b42f255e2ba 100755
--- a/scripts/extract-ikconfig
+++ b/scripts/extract-ikconfig
@@ -61,6 +61,7 @@ try_decompress '\3757zXZ\000' abcde unxz
 try_decompress 'BZh'          xy    bunzip2
 try_decompress '\135\0\0\0'   xxx   unlzma
 try_decompress '\211\114\132' xy    'lzop -d'
+try_decompress '\002\041\114\030' xyy 'lz4 -d -l'
 
 # Bail out:
 echo "$me: Cannot find kernel config." >&2
diff --git a/scripts/kallsyms.c b/scripts/kallsyms.c
index c6d33bd15b04..8fa81e84e295 100644
--- a/scripts/kallsyms.c
+++ b/scripts/kallsyms.c
@@ -212,15 +212,22 @@ static int symbol_valid(struct sym_entry *s)
                 "_SDA_BASE_",           /* ppc */
                 "_SDA2_BASE_",          /* ppc */
                 NULL };
+
+        static char *special_suffixes[] = {
+                "_veneer",              /* arm */
+                NULL };
+
         int i;
-        int offset = 1;
+        char *sym_name = (char *)s->sym + 1;
+
 
         if (s->addr < kernel_start_addr)
                 return 0;
 
         /* skip prefix char */
-        if (symbol_prefix_char && *(s->sym + 1) == symbol_prefix_char)
-                offset++;
+        if (symbol_prefix_char && *sym_name == symbol_prefix_char)
+                sym_name++;
+
 
         /* if --all-symbols is not specified, then symbols outside the text
          * and inittext sections are discarded */
@@ -235,22 +242,26 @@ static int symbol_valid(struct sym_entry *s)
                  * rules.
                  */
                 if ((s->addr == text_range_text->end &&
-                                strcmp((char *)s->sym + offset,
+                                strcmp(sym_name,
                                        text_range_text->end_sym)) ||
                     (s->addr == text_range_inittext->end &&
-                                strcmp((char *)s->sym + offset,
+                                strcmp(sym_name,
                                        text_range_inittext->end_sym)))
                         return 0;
         }
 
         /* Exclude symbols which vary between passes. */
-        if (strstr((char *)s->sym + offset, "_compiled."))
-                return 0;
-
         for (i = 0; special_symbols[i]; i++)
-                if( strcmp((char *)s->sym + offset, special_symbols[i]) == 0 )
+                if (strcmp(sym_name, special_symbols[i]) == 0)
                         return 0;
 
+        for (i = 0; special_suffixes[i]; i++) {
+                int l = strlen(sym_name) - strlen(special_suffixes[i]);
+
+                if (l >= 0 && strcmp(sym_name + l, special_suffixes[i]) == 0)
+                        return 0;
+        }
+
         return 1;
 }
 
diff --git a/scripts/kconfig/Makefile b/scripts/kconfig/Makefile
index 9645c0739386..d9b1fef0c67e 100644
--- a/scripts/kconfig/Makefile
+++ b/scripts/kconfig/Makefile
@@ -2,7 +2,7 @@
 # Kernel configuration targets
 # These targets are used from top-level makefile
 
-PHONY += oldconfig xconfig gconfig menuconfig config silentoldconfig update-po-config \
+PHONY += xconfig gconfig menuconfig config silentoldconfig update-po-config \
         localmodconfig localyesconfig
 
 ifdef KBUILD_KCONFIG
@@ -11,30 +11,31 @@ else
 Kconfig := Kconfig
 endif
 
+ifeq ($(quiet),silent_)
+silent := -s
+endif
+
 # We need this, in case the user has it in its environment
 unexport CONFIG_
 
 xconfig: $(obj)/qconf
-        $< $(Kconfig)
+        $< $(silent) $(Kconfig)
 
 gconfig: $(obj)/gconf
-        $< $(Kconfig)
+        $< $(silent) $(Kconfig)
 
 menuconfig: $(obj)/mconf
-        $< $(Kconfig)
+        $< $(silent) $(Kconfig)
 
 config: $(obj)/conf
-        $< --oldaskconfig $(Kconfig)
+        $< $(silent) --oldaskconfig $(Kconfig)
 
 nconfig: $(obj)/nconf
-        $< $(Kconfig)
-
-oldconfig: $(obj)/conf
-        $< --$@ $(Kconfig)
+        $< $(silent) $(Kconfig)
 
 silentoldconfig: $(obj)/conf
         $(Q)mkdir -p include/config include/generated
-        $< --$@ $(Kconfig)
+        $< $(silent) --$@ $(Kconfig)
 
 localyesconfig localmodconfig: $(obj)/streamline_config.pl $(obj)/conf
         $(Q)mkdir -p include/config include/generated
@@ -43,18 +44,18 @@ localyesconfig localmodconfig: $(obj)/streamline_config.pl $(obj)/conf
                         cmp -s .tmp.config .config ||                   \
                         (mv -f .config .config.old.1;                   \
                          mv -f .tmp.config .config;                     \
-                         $(obj)/conf --silentoldconfig $(Kconfig);      \
+                         $(obj)/conf $(silent) --silentoldconfig $(Kconfig); \
                          mv -f .config.old.1 .config.old)               \
         else                                                            \
                         mv -f .tmp.config .config;                      \
-                        $(obj)/conf --silentoldconfig $(Kconfig);       \
+                        $(obj)/conf $(silent) --silentoldconfig $(Kconfig); \
         fi
         $(Q)rm -f .tmp.config
 
 # Create new linux.pot file
 # Adjust charset to UTF-8 in .po file to accept UTF-8 in Kconfig files
 update-po-config: $(obj)/kxgettext $(obj)/gconf.glade.h
-        $(Q)echo "  GEN     config.pot"
+        $(Q)$(kecho) "  GEN     config.pot"
         $(Q)xgettext --default-domain=linux                         \
             --add-comments --keyword=_ --keyword=N_                 \
             --from-code=UTF-8                                       \
@@ -65,61 +66,58 @@ update-po-config: $(obj)/kxgettext $(obj)/gconf.glade.h
         $(Q)(for i in `ls $(srctree)/arch/*/Kconfig      \
             $(srctree)/arch/*/um/Kconfig`;               \
             do                                           \
-                echo "  GEN     $$i";                    \
+                $(kecho) "  GEN     $$i";                    \
                 $(obj)/kxgettext $$i                     \
                      >> $(obj)/config.pot;               \
             done )
-        $(Q)echo "  GEN     linux.pot"
+        $(Q)$(kecho) "  GEN     linux.pot"
         $(Q)msguniq --sort-by-file --to-code=UTF-8 $(obj)/config.pot \
             --output $(obj)/linux.pot
         $(Q)rm -f $(obj)/config.pot
 
-PHONY += allnoconfig allyesconfig allmodconfig alldefconfig randconfig
-
-allnoconfig allyesconfig allmodconfig alldefconfig randconfig: $(obj)/conf
-        $< --$@ $(Kconfig)
+# These targets map 1:1 to the commandline options of 'conf'
+simple-targets := oldconfig allnoconfig allyesconfig allmodconfig \
+        alldefconfig randconfig listnewconfig olddefconfig
+PHONY += $(simple-targets)
 
-PHONY += listnewconfig olddefconfig oldnoconfig savedefconfig defconfig
+$(simple-targets): $(obj)/conf
+        $< $(silent) --$@ $(Kconfig)
 
-listnewconfig olddefconfig: $(obj)/conf
-        $< --$@ $(Kconfig)
+PHONY += oldnoconfig savedefconfig defconfig
 
 # oldnoconfig is an alias of olddefconfig, because people already are dependent
 # on its behavior(sets new symbols to their default value but not 'n') with the
 # counter-intuitive name.
-oldnoconfig: $(obj)/conf
-        $< --olddefconfig $(Kconfig)
+oldnoconfig: olddefconfig
 
 savedefconfig: $(obj)/conf
-        $< --$@=defconfig $(Kconfig)
+        $< $(silent) --$@=defconfig $(Kconfig)
 
 defconfig: $(obj)/conf
 ifeq ($(KBUILD_DEFCONFIG),)
-        $< --defconfig $(Kconfig)
+        $< $(silent) --defconfig $(Kconfig)
 else
-        @echo "*** Default configuration is based on '$(KBUILD_DEFCONFIG)'"
-        $(Q)$< --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
+        @$(kecho) "*** Default configuration is based on '$(KBUILD_DEFCONFIG)'"
+        $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
 endif
 
 %_defconfig: $(obj)/conf
-        $(Q)$< --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
+        $(Q)$< $(silent) --defconfig=arch/$(SRCARCH)/configs/$@ $(Kconfig)
 
-configfiles=$(wildcard $(srctree)/kernel/configs/$(1).config $(srctree)/arch/$(SRCARCH)/configs/$(1).config)
+configfiles=$(wildcard $(srctree)/kernel/configs/$@ $(srctree)/arch/$(SRCARCH)/configs/$@)
 
-define mergeconfig
-$(if $(wildcard $(objtree)/.config),, $(error You need an existing .config for this target))
-$(if $(call configfiles,$(1)),, $(error No configuration exists for this target on this architecture))
-$(Q)$(CONFIG_SHELL) $(srctree)/scripts/kconfig/merge_config.sh -m -O $(objtree) $(objtree)/.config $(call configfiles,$(1))
-$(Q)yes "" | $(MAKE) -f $(srctree)/Makefile oldconfig
-endef
+%.config: $(obj)/conf
+        $(if $(call configfiles),, $(error No configuration exists for this target on this architecture))
+        $(Q)$(CONFIG_SHELL) $(srctree)/scripts/kconfig/merge_config.sh -m .config $(configfiles)
+        +$(Q)yes "" | $(MAKE) -f $(srctree)/Makefile oldconfig
 
 PHONY += kvmconfig
-kvmconfig:
-        $(call mergeconfig,kvm_guest)
+kvmconfig: kvm_guest.config
+        @:
 
 PHONY += tinyconfig
-tinyconfig: allnoconfig
-        $(call mergeconfig,tiny)
+tinyconfig:
+        $(Q)$(MAKE) -f $(srctree)/Makefile allnoconfig tiny.config
 
 # Help text used by make help
 help:
@@ -221,7 +219,7 @@ $(obj)/.tmp_qtcheck: $(src)/Makefile
 
 # QT needs some extra effort...
 $(obj)/.tmp_qtcheck:
-        @set -e; echo "  CHECK   qt"; dir=""; pkg=""; \
+        @set -e; $(kecho) "  CHECK   qt"; dir=""; pkg=""; \
         if ! pkg-config --exists QtCore 2> /dev/null; then \
             echo "* Unable to find the QT4 tool qmake. Trying to use QT3"; \
             pkg-config --exists qt 2> /dev/null && pkg=qt; \
diff --git a/scripts/kconfig/conf.c b/scripts/kconfig/conf.c
index fef75fc756f4..6c204318bc94 100644
--- a/scripts/kconfig/conf.c
+++ b/scripts/kconfig/conf.c
@@ -471,7 +471,7 @@ static struct option long_opts[] = {
 static void conf_usage(const char *progname)
 {
 
-        printf("Usage: %s [option] <kconfig-file>\n", progname);
+        printf("Usage: %s [-s] [option] <kconfig-file>\n", progname);
         printf("[option] is _one_ of the following:\n");
         printf("  --listnewconfig         List new options\n");
         printf("  --oldaskconfig          Start a new configuration using a line-oriented program\n");
@@ -501,7 +501,11 @@ int main(int ac, char **av)
 
         tty_stdio = isatty(0) && isatty(1) && isatty(2);
 
-        while ((opt = getopt_long(ac, av, "", long_opts, NULL)) != -1) {
+        while ((opt = getopt_long(ac, av, "s", long_opts, NULL)) != -1) {
+                if (opt == 's') {
+                        conf_set_message_callback(NULL);
+                        continue;
+                }
                 input_mode = (enum input_mode)opt;
                 switch (opt) {
                 case silentoldconfig:
diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c
index 28df18dd1147..c814f57672fc 100644
--- a/scripts/kconfig/confdata.c
+++ b/scripts/kconfig/confdata.c
@@ -16,6 +16,11 @@
 
 #include "lkc.h"
 
+struct conf_printer {
+        void (*print_symbol)(FILE *, struct symbol *, const char *, void *);
+        void (*print_comment)(FILE *, const char *, void *);
+};
+
 static void conf_warning(const char *fmt, ...)
         __attribute__ ((format (printf, 1, 2)));
 
diff --git a/scripts/kconfig/expr.c b/scripts/kconfig/expr.c
index d6626521f9b9..fb0a2a286dca 100644
--- a/scripts/kconfig/expr.c
+++ b/scripts/kconfig/expr.c
@@ -11,6 +11,12 @@
 
 #define DEBUG_EXPR      0
 
+static int expr_eq(struct expr *e1, struct expr *e2);
+static struct expr *expr_eliminate_yn(struct expr *e);
+static struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2);
+static struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2);
+static void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2);
+
 struct expr *expr_alloc_symbol(struct symbol *sym)
 {
         struct expr *e = xcalloc(1, sizeof(*e));
@@ -186,7 +192,7 @@ void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
 #undef e1
 #undef e2
 
-int expr_eq(struct expr *e1, struct expr *e2)
+static int expr_eq(struct expr *e1, struct expr *e2)
 {
         int res, old_count;
 
@@ -228,7 +234,7 @@ int expr_eq(struct expr *e1, struct expr *e2)
         return 0;
 }
 
-struct expr *expr_eliminate_yn(struct expr *e)
+static struct expr *expr_eliminate_yn(struct expr *e)
 {
         struct expr *tmp;
 
@@ -823,7 +829,7 @@ bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
         return false;
 }
 
-struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
+static struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
 {
         struct expr *tmp = NULL;
         expr_extract_eq(E_AND, &tmp, ep1, ep2);
@@ -834,7 +840,7 @@ struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
         return tmp;
 }
 
-struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
+static struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
 {
         struct expr *tmp = NULL;
         expr_extract_eq(E_OR, &tmp, ep1, ep2);
@@ -845,7 +851,7 @@ struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
         return tmp;
 }
 
-void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2)
+static void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2)
 {
 #define e1 (*ep1)
 #define e2 (*ep2)
@@ -976,11 +982,8 @@ tristate expr_calc_value(struct expr *e)
         }
 }
 
-int expr_compare_type(enum expr_type t1, enum expr_type t2)
+static int expr_compare_type(enum expr_type t1, enum expr_type t2)
 {
-#if 0
-        return 1;
-#else
         if (t1 == t2)
                 return 0;
         switch (t1) {
@@ -1005,7 +1008,6 @@ int expr_compare_type(enum expr_type t1, enum expr_type t2)
         }
         printf("[%dgt%d?]", t1, t2);
         return 0;
-#endif
 }
 
 static inline struct expr *
diff --git a/scripts/kconfig/expr.h b/scripts/kconfig/expr.h
index 412ea8a2abb8..a2fc96a2bd2c 100644
--- a/scripts/kconfig/expr.h
+++ b/scripts/kconfig/expr.h
@@ -205,18 +205,13 @@ struct expr *expr_alloc_and(struct expr *e1, struct expr *e2);
 struct expr *expr_alloc_or(struct expr *e1, struct expr *e2);
 struct expr *expr_copy(const struct expr *org);
 void expr_free(struct expr *e);
-int expr_eq(struct expr *e1, struct expr *e2);
 void expr_eliminate_eq(struct expr **ep1, struct expr **ep2);
 tristate expr_calc_value(struct expr *e);
-struct expr *expr_eliminate_yn(struct expr *e);
 struct expr *expr_trans_bool(struct expr *e);
 struct expr *expr_eliminate_dups(struct expr *e);
 struct expr *expr_transform(struct expr *e);
 int expr_contains_symbol(struct expr *dep, struct symbol *sym);
 bool expr_depends_symbol(struct expr *dep, struct symbol *sym);
-struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2);
-struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2);
-void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2);
 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym);
 struct expr *expr_simplify_unmet_dep(struct expr *e1, struct expr *e2);
 
diff --git a/scripts/kconfig/gconf.c b/scripts/kconfig/gconf.c
index d0a35b21f308..26d208b435a0 100644
--- a/scripts/kconfig/gconf.c
+++ b/scripts/kconfig/gconf.c
@@ -169,14 +169,6 @@ void init_main_window(const gchar * glade_file)
         style = gtk_widget_get_style(main_wnd);
         widget = glade_xml_get_widget(xml, "toolbar1");
 
-#if 0   /* Use stock Gtk icons instead */
-        replace_button_icon(xml, main_wnd->window, style,
-                            "button1", (gchar **) xpm_back);
-        replace_button_icon(xml, main_wnd->window, style,
-                            "button2", (gchar **) xpm_load);
-        replace_button_icon(xml, main_wnd->window, style,
-                            "button3", (gchar **) xpm_save);
-#endif
         replace_button_icon(xml, main_wnd->window, style,
                             "button4", (gchar **) xpm_single_view);
         replace_button_icon(xml, main_wnd->window, style,
@@ -184,22 +176,6 @@ void init_main_window(const gchar * glade_file)
         replace_button_icon(xml, main_wnd->window, style,
                             "button6", (gchar **) xpm_tree_view);
 
-#if 0
-        switch (view_mode) {
-        case SINGLE_VIEW:
-                widget = glade_xml_get_widget(xml, "button4");
-                g_signal_emit_by_name(widget, "clicked");
-                break;
-        case SPLIT_VIEW:
-                widget = glade_xml_get_widget(xml, "button5");
-                g_signal_emit_by_name(widget, "clicked");
-                break;
-        case FULL_VIEW:
-                widget = glade_xml_get_widget(xml, "button6");
-                g_signal_emit_by_name(widget, "clicked");
-                break;
-        }
-#endif
         txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
         tag1 = gtk_text_buffer_create_tag(txtbuf, "mytag1",
                                           "foreground", "red",
@@ -1498,9 +1474,12 @@ int main(int ac, char *av[])
                 case 'a':
                         //showAll = 1;
                         break;
+                case 's':
+                        conf_set_message_callback(NULL);
+                        break;
                 case 'h':
                 case '?':
-                        printf("%s <config>\n", av[0]);
+                        printf("%s [-s] <config>\n", av[0]);
                         exit(0);
                 }
                 name = av[2];
diff --git a/scripts/kconfig/lkc.h b/scripts/kconfig/lkc.h
index d5daa7af8b49..91ca126ea080 100644
--- a/scripts/kconfig/lkc.h
+++ b/scripts/kconfig/lkc.h
@@ -21,9 +21,7 @@ static inline char *bind_textdomain_codeset(const char *dn, char *c) { return c;
 extern "C" {
 #endif
 
-#define P(name,type,arg)        extern type name arg
 #include "lkc_proto.h"
-#undef P
 
 #define SRCTREE "srctree"
 
@@ -70,9 +68,6 @@ struct kconf_id {
         enum symbol_type stype;
 };
 
-extern int zconfdebug;
-
-int zconfparse(void);
 void zconfdump(FILE *out);
 void zconf_starthelp(void);
 FILE *zconf_fopen(const char *name);
@@ -90,11 +85,6 @@ void sym_add_change_count(int count);
 bool conf_set_all_new_symbols(enum conf_def_mode mode);
 void set_all_choice_values(struct symbol *csym);
 
-struct conf_printer {
-        void (*print_symbol)(FILE *, struct symbol *, const char *, void *);
-        void (*print_comment)(FILE *, const char *, void *);
-};
-
 /* confdata.c and expr.c */
 static inline void xfwrite(const void *str, size_t len, size_t count, FILE *out)
 {
@@ -113,7 +103,6 @@ void menu_add_entry(struct symbol *sym);
 void menu_end_entry(void);
 void menu_add_dep(struct expr *dep);
 void menu_add_visibility(struct expr *dep);
-struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep);
 struct property *menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep);
 void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep);
 void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep);
@@ -137,7 +126,6 @@ struct gstr {
         int max_width;
 };
 struct gstr str_new(void);
-struct gstr str_assign(const char *s);
 void str_free(struct gstr *gs);
 void str_append(struct gstr *gs, const char *s);
 void str_printf(struct gstr *gs, const char *fmt, ...);
@@ -148,8 +136,6 @@ extern struct expr *sym_env_list;
 
 void sym_init(void);
 void sym_clear_all_valid(void);
-void sym_set_all_changed(void);
-void sym_set_changed(struct symbol *sym);
 struct symbol *sym_choice_default(struct symbol *sym);
 const char *sym_get_string_default(struct symbol *sym);
 struct symbol *sym_check_deps(struct symbol *sym);
diff --git a/scripts/kconfig/lkc_proto.h b/scripts/kconfig/lkc_proto.h
index ecdb9659b67d..d5398718ec2a 100644
--- a/scripts/kconfig/lkc_proto.h
+++ b/scripts/kconfig/lkc_proto.h
@@ -1,57 +1,52 @@
 #include <stdarg.h>
 
 /* confdata.c */
-P(conf_parse,void,(const char *name));
-P(conf_read,int,(const char *name));
-P(conf_read_simple,int,(const char *name, int));
-P(conf_write_defconfig,int,(const char *name));
-P(conf_write,int,(const char *name));
-P(conf_write_autoconf,int,(void));
-P(conf_get_changed,bool,(void));
-P(conf_set_changed_callback, void,(void (*fn)(void)));
-P(conf_set_message_callback, void,(void (*fn)(const char *fmt, va_list ap)));
+void conf_parse(const char *name);
+int conf_read(const char *name);
+int conf_read_simple(const char *name, int);
+int conf_write_defconfig(const char *name);
+int conf_write(const char *name);
+int conf_write_autoconf(void);
+bool conf_get_changed(void);
+void conf_set_changed_callback(void (*fn)(void));
+void conf_set_message_callback(void (*fn)(const char *fmt, va_list ap));
 
 /* menu.c */
-P(rootmenu,struct menu,);
+extern struct menu rootmenu;
 
-P(menu_is_empty, bool, (struct menu *menu));
-P(menu_is_visible, bool, (struct menu *menu));
-P(menu_has_prompt, bool, (struct menu *menu));
-P(menu_get_prompt,const char *,(struct menu *menu));
-P(menu_get_root_menu,struct menu *,(struct menu *menu));
-P(menu_get_parent_menu,struct menu *,(struct menu *menu));
-P(menu_has_help,bool,(struct menu *menu));
-P(menu_get_help,const char *,(struct menu *menu));
-P(get_symbol_str, void, (struct gstr *r, struct symbol *sym, struct list_head
-                         *head));
-P(get_relations_str, struct gstr, (struct symbol **sym_arr, struct list_head
-                                   *head));
-P(menu_get_ext_help,void,(struct menu *menu, struct gstr *help));
+bool menu_is_empty(struct menu *menu);
+bool menu_is_visible(struct menu *menu);
+bool menu_has_prompt(struct menu *menu);
+const char * menu_get_prompt(struct menu *menu);
+struct menu * menu_get_root_menu(struct menu *menu);
+struct menu * menu_get_parent_menu(struct menu *menu);
+bool menu_has_help(struct menu *menu);
+const char * menu_get_help(struct menu *menu);
+struct gstr get_relations_str(struct symbol **sym_arr, struct list_head *head);
+void menu_get_ext_help(struct menu *menu, struct gstr *help);
 
 /* symbol.c */
-P(symbol_hash,struct symbol *,[SYMBOL_HASHSIZE]);
+extern struct symbol * symbol_hash[SYMBOL_HASHSIZE];
 
-P(sym_lookup,struct symbol *,(const char *name, int flags));
-P(sym_find,struct symbol *,(const char *name));
-P(sym_expand_string_value,const char *,(const char *in));
-P(sym_escape_string_value, const char *,(const char *in));
-P(sym_re_search,struct symbol **,(const char *pattern));
-P(sym_type_name,const char *,(enum symbol_type type));
-P(sym_calc_value,void,(struct symbol *sym));
-P(sym_get_type,enum symbol_type,(struct symbol *sym));
-P(sym_tristate_within_range,bool,(struct symbol *sym,tristate tri));
-P(sym_set_tristate_value,bool,(struct symbol *sym,tristate tri));
-P(sym_toggle_tristate_value,tristate,(struct symbol *sym));
-P(sym_string_valid,bool,(struct symbol *sym, const char *newval));
-P(sym_string_within_range,bool,(struct symbol *sym, const char *str));
-P(sym_set_string_value,bool,(struct symbol *sym, const char *newval));
-P(sym_is_changable,bool,(struct symbol *sym));
-P(sym_get_choice_prop,struct property *,(struct symbol *sym));
-P(sym_get_default_prop,struct property *,(struct symbol *sym));
-P(sym_get_string_value,const char *,(struct symbol *sym));
+struct symbol * sym_lookup(const char *name, int flags);
+struct symbol * sym_find(const char *name);
+const char * sym_expand_string_value(const char *in);
+const char * sym_escape_string_value(const char *in);
+struct symbol ** sym_re_search(const char *pattern);
+const char * sym_type_name(enum symbol_type type);
+void sym_calc_value(struct symbol *sym);
+enum symbol_type sym_get_type(struct symbol *sym);
+bool sym_tristate_within_range(struct symbol *sym,tristate tri);
+bool sym_set_tristate_value(struct symbol *sym,tristate tri);
+tristate sym_toggle_tristate_value(struct symbol *sym);
+bool sym_string_valid(struct symbol *sym, const char *newval);
+bool sym_string_within_range(struct symbol *sym, const char *str);
+bool sym_set_string_value(struct symbol *sym, const char *newval);
+bool sym_is_changable(struct symbol *sym);
+struct property * sym_get_choice_prop(struct symbol *sym);
+const char * sym_get_string_value(struct symbol *sym);
 
-P(prop_get_type_name,const char *,(enum prop_type type));
+const char * prop_get_type_name(enum prop_type type);
 
 /* expr.c */
-P(expr_compare_type,int,(enum expr_type t1, enum expr_type t2));
-P(expr_print,void,(struct expr *e, void (*fn)(void *, struct symbol *, const char *), void *data, int prevtoken));
+void expr_print(struct expr *e, void (*fn)(void *, struct symbol *, const char *), void *data, int prevtoken);
diff --git a/scripts/kconfig/mconf.c b/scripts/kconfig/mconf.c
index 4dd37552abc2..315ce2c7cb9d 100644
--- a/scripts/kconfig/mconf.c
+++ b/scripts/kconfig/mconf.c
@@ -279,6 +279,7 @@ static int child_count;
 static int single_menu_mode;
 static int show_all_options;
 static int save_and_exit;
+static int silent;
 
 static void conf(struct menu *menu, struct menu *active_menu);
 static void conf_choice(struct menu *menu);
@@ -777,10 +778,12 @@ static void conf_message_callback(const char *fmt, va_list ap)
         char buf[PATH_MAX+1];
 
         vsnprintf(buf, sizeof(buf), fmt, ap);
-        if (save_and_exit)
-                printf("%s", buf);
-        else
+        if (save_and_exit) {
+                if (!silent)
+                        printf("%s", buf);
+        } else {
                 show_textbox(NULL, buf, 6, 60);
+        }
 }
 
 static void show_help(struct menu *menu)
@@ -977,16 +980,18 @@ static int handle_exit(void)
                 }
                 /* fall through */
         case -1:
-                printf(_("\n\n"
-                         "*** End of the configuration.\n"
-                         "*** Execute 'make' to start the build or try 'make help'."
-                         "\n\n"));
+                if (!silent)
+                        printf(_("\n\n"
+                                 "*** End of the configuration.\n"
+                                 "*** Execute 'make' to start the build or try 'make help'."
+                                 "\n\n"));
                 res = 0;
                 break;
         default:
-                fprintf(stderr, _("\n\n"
-                                  "Your configuration changes were NOT saved."
-                                  "\n\n"));
+                if (!silent)
+                        fprintf(stderr, _("\n\n"
+                                          "Your configuration changes were NOT saved."
+                                          "\n\n"));
                 if (res != KEY_ESC)
                         res = 0;
         }
@@ -1010,6 +1015,12 @@ int main(int ac, char **av)
 
         signal(SIGINT, sig_handler);
 
+        if (ac > 1 && strcmp(av[1], "-s") == 0) {
+                silent = 1;
+                /* Silence conf_read() until the real callback is set up */
+                conf_set_message_callback(NULL);
+                av++;
+        }
         conf_parse(av[1]);
         conf_read(NULL);
 
diff --git a/scripts/kconfig/menu.c b/scripts/kconfig/menu.c
index 72c9dba84c5d..b05cc3d4a9be 100644
--- a/scripts/kconfig/menu.c
+++ b/scripts/kconfig/menu.c
@@ -125,7 +125,7 @@ void menu_set_type(int type)
                 sym_type_name(sym->type), sym_type_name(type));
 }
 
-struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep)
+static struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep)
 {
         struct property *prop = prop_alloc(type, current_entry->sym);
 
@@ -615,7 +615,7 @@ static struct property *get_symbol_prop(struct symbol *sym)
 /*
  * head is optional and may be NULL
  */
-void get_symbol_str(struct gstr *r, struct symbol *sym,
+static void get_symbol_str(struct gstr *r, struct symbol *sym,
                     struct list_head *head)
 {
         bool hit;
diff --git a/scripts/kconfig/merge_config.sh b/scripts/kconfig/merge_config.sh
index 2ab91b9b100d..ec8e20350a64 100755
--- a/scripts/kconfig/merge_config.sh
+++ b/scripts/kconfig/merge_config.sh
@@ -35,7 +35,7 @@ usage() {
         echo "  -O    dir to put generated output files"
 }
 
-MAKE=true
+RUNMAKE=true
 ALLTARGET=alldefconfig
 WARNREDUN=false
 OUTPUT=.
@@ -48,7 +48,7 @@ while true; do
                 continue
                 ;;
         "-m")
-                MAKE=false
+                RUNMAKE=false
                 shift
                 continue
                 ;;
@@ -85,6 +85,11 @@ fi
 INITFILE=$1
 shift;
 
+if [ ! -r "$INITFILE" ]; then
+        echo "The base file '$INITFILE' does not exist.  Exit." >&2
+        exit 1
+fi
+
 MERGE_LIST=$*
 SED_CONFIG_EXP="s/^\(# \)\{0,1\}\(CONFIG_[a-zA-Z0-9_]*\)[= ].*/\2/p"
 TMP_FILE=$(mktemp ./.tmp.config.XXXXXXXXXX)
@@ -92,31 +97,29 @@ TMP_FILE=$(mktemp ./.tmp.config.XXXXXXXXXX)
 echo "Using $INITFILE as base"
 cat $INITFILE > $TMP_FILE
 
-# Merge files, printing warnings on overrided values
+# Merge files, printing warnings on overridden values
 for MERGE_FILE in $MERGE_LIST ; do
         echo "Merging $MERGE_FILE"
         CFG_LIST=$(sed -n "$SED_CONFIG_EXP" $MERGE_FILE)
 
         for CFG in $CFG_LIST ; do
-                grep -q -w $CFG $TMP_FILE
-                if [ $? -eq 0 ] ; then
-                        PREV_VAL=$(grep -w $CFG $TMP_FILE)
-                        NEW_VAL=$(grep -w $CFG $MERGE_FILE)
-                        if [ "x$PREV_VAL" != "x$NEW_VAL" ] ; then
+                grep -q -w $CFG $TMP_FILE || continue
+                PREV_VAL=$(grep -w $CFG $TMP_FILE)
+                NEW_VAL=$(grep -w $CFG $MERGE_FILE)
+                if [ "x$PREV_VAL" != "x$NEW_VAL" ] ; then
                         echo Value of $CFG is redefined by fragment $MERGE_FILE:
                         echo Previous  value: $PREV_VAL
                         echo New value:       $NEW_VAL
                         echo
-                        elif [ "$WARNREDUN" = "true" ]; then
+                elif [ "$WARNREDUN" = "true" ]; then
                         echo Value of $CFG is redundant by fragment $MERGE_FILE:
-                        fi
-                        sed -i "/$CFG[ =]/d" $TMP_FILE
                 fi
+                sed -i "/$CFG[ =]/d" $TMP_FILE
         done
         cat $MERGE_FILE >> $TMP_FILE
 done
 
-if [ "$MAKE" = "false" ]; then
+if [ "$RUNMAKE" = "false" ]; then
         cp $TMP_FILE $OUTPUT/.config
         echo "#"
         echo "# merged configuration written to $OUTPUT/.config (needs make)"
diff --git a/scripts/kconfig/nconf.c b/scripts/kconfig/nconf.c
index 984489ef2b46..d42d534a66cd 100644
--- a/scripts/kconfig/nconf.c
+++ b/scripts/kconfig/nconf.c
@@ -1482,6 +1482,11 @@ int main(int ac, char **av)
         bindtextdomain(PACKAGE, LOCALEDIR);
         textdomain(PACKAGE);
 
+        if (ac > 1 && strcmp(av[1], "-s") == 0) {
+                /* Silence conf_read() until the real callback is set up */
+                conf_set_message_callback(NULL);
+                av++;
+        }
         conf_parse(av[1]);
         conf_read(NULL);
 
diff --git a/scripts/kconfig/qconf.cc b/scripts/kconfig/qconf.cc
index 9d3b04b0769c..c3bb7fe8dfa6 100644
--- a/scripts/kconfig/qconf.cc
+++ b/scripts/kconfig/qconf.cc
@@ -1746,7 +1746,7 @@ static const char *progname;
 
 static void usage(void)
 {
-        printf(_("%s <config>\n"), progname);
+        printf(_("%s [-s] <config>\n"), progname);
         exit(0);
 }
 
@@ -1762,6 +1762,9 @@ int main(int ac, char** av)
         configApp = new QApplication(ac, av);
         if (ac > 1 && av[1][0] == '-') {
                 switch (av[1][1]) {
+                case 's':
+                        conf_set_message_callback(NULL);
+                        break;
                 case 'h':
                 case '?':
                         usage();
diff --git a/scripts/kconfig/symbol.c b/scripts/kconfig/symbol.c
index 7caabdb51c64..6731377f9bb2 100644
--- a/scripts/kconfig/symbol.c
+++ b/scripts/kconfig/symbol.c
@@ -112,7 +112,7 @@ struct property *sym_get_env_prop(struct symbol *sym)
         return NULL;
 }
 
-struct property *sym_get_default_prop(struct symbol *sym)
+static struct property *sym_get_default_prop(struct symbol *sym)
 {
         struct property *prop;
 
@@ -186,6 +186,26 @@ static void sym_validate_range(struct symbol *sym)
         sym->curr.val = strdup(str);
 }
 
+static void sym_set_changed(struct symbol *sym)
+{
+        struct property *prop;
+
+        sym->flags |= SYMBOL_CHANGED;
+        for (prop = sym->prop; prop; prop = prop->next) {
+                if (prop->menu)
+                        prop->menu->flags |= MENU_CHANGED;
+        }
+}
+
+static void sym_set_all_changed(void)
+{
+        struct symbol *sym;
+        int i;
+
+        for_all_symbols(i, sym)
+                sym_set_changed(sym);
+}
+
 static void sym_calc_visibility(struct symbol *sym)
 {
         struct property *prop;
@@ -451,26 +471,6 @@ void sym_clear_all_valid(void)
                 sym_calc_value(modules_sym);
 }
 
-void sym_set_changed(struct symbol *sym)
-{
-        struct property *prop;
-
-        sym->flags |= SYMBOL_CHANGED;
-        for (prop = sym->prop; prop; prop = prop->next) {
-                if (prop->menu)
-                        prop->menu->flags |= MENU_CHANGED;
-        }
-}
-
-void sym_set_all_changed(void)
-{
-        struct symbol *sym;
-        int i;
-
-        for_all_symbols(i, sym)
-                sym_set_changed(sym);
-}
-
 bool sym_tristate_within_range(struct symbol *sym, tristate val)
 {
         int type = sym_get_type(sym);
diff --git a/scripts/kconfig/util.c b/scripts/kconfig/util.c
index 94f9c83e324f..0e76042473cc 100644
--- a/scripts/kconfig/util.c
+++ b/scripts/kconfig/util.c
@@ -88,16 +88,6 @@ struct gstr str_new(void)
         return gs;
 }
 
-/* Allocate and assign growable string */
-struct gstr str_assign(const char *s)
-{
-        struct gstr gs;
-        gs.s = strdup(s);
-        gs.len = strlen(s) + 1;
-        gs.max_width = 0;
-        return gs;
-}
-
 /* Free storage for growable string */
 void str_free(struct gstr *gs)
 {
diff --git a/scripts/mod/devicetable-offsets.c b/scripts/mod/devicetable-offsets.c
index f282516acc7b..fce36d0f6898 100644
--- a/scripts/mod/devicetable-offsets.c
+++ b/scripts/mod/devicetable-offsets.c
@@ -168,6 +168,9 @@ int main(void)
         DEVID_FIELD(amba_id, id);
         DEVID_FIELD(amba_id, mask);
 
+        DEVID(mips_cdmm_device_id);
+        DEVID_FIELD(mips_cdmm_device_id, type);
+
         DEVID(x86_cpu_id);
         DEVID_FIELD(x86_cpu_id, feature);
         DEVID_FIELD(x86_cpu_id, family);
diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
index e614ef689eee..78691d51a479 100644
--- a/scripts/mod/file2alias.c
+++ b/scripts/mod/file2alias.c
@@ -1109,6 +1109,22 @@ static int do_amba_entry(const char *filename,
 }
 ADD_TO_DEVTABLE("amba", amba_id, do_amba_entry);
 
+/*
+ * looks like: "mipscdmm:tN"
+ *
+ * N is exactly 2 digits, where each is an upper-case hex digit, or
+ *      a ? or [] pattern matching exactly one digit.
+ */
+static int do_mips_cdmm_entry(const char *filename,
+                              void *symval, char *alias)
+{
+        DEF_FIELD(symval, mips_cdmm_device_id, type);
+
+        sprintf(alias, "mipscdmm:t%02X*", type);
+        return 1;
+}
+ADD_TO_DEVTABLE("mipscdmm", mips_cdmm_device_id, do_mips_cdmm_entry);
+
 /* LOOKS like cpu:type:x86,venVVVVfamFFFFmodMMMM:feature:*,FEAT,*
  * All fields are numbers. It would be nicer to use strings for vendor
  * and feature, but getting those out of the build system here is too
diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c
index d439856f8176..91ee1b2e0f9a 100644
--- a/scripts/mod/modpost.c
+++ b/scripts/mod/modpost.c
@@ -776,6 +776,7 @@ static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
  * "foo" will match an exact string equal to "foo"
  * "*foo" will match a string that ends with "foo"
  * "foo*" will match a string that begins with "foo"
+ * "*foo*" will match a string that contains "foo"
  */
 static int match(const char *sym, const char * const pat[])
 {
@@ -784,8 +785,17 @@ static int match(const char *sym, const char * const pat[])
                 p = *pat++;
                 const char *endp = p + strlen(p) - 1;
 
+                /* "*foo*" */
+                if (*p == '*' && *endp == '*') {
+                        char *here, *bare = strndup(p + 1, strlen(p) - 2);
+
+                        here = strstr(sym, bare);
+                        free(bare);
+                        if (here != NULL)
+                                return 1;
+                }
                 /* "*foo" */
-                if (*p == '*') {
+                else if (*p == '*') {
                         if (strrcmp(sym, p + 1) == 0)
                                 return 1;
                 }
@@ -873,7 +883,10 @@ static void check_section(const char *modname, struct elf_info *elf,
 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
 
 #define DATA_SECTIONS ".data", ".data.rel"
-#define TEXT_SECTIONS ".text", ".text.unlikely"
+#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
+                ".kprobes.text"
+#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
+                ".fixup", ".entry.text", ".exception.text", ".text.*"
 
 #define INIT_SECTIONS      ".init.*"
 #define MEM_INIT_SECTIONS  ".meminit.*"
@@ -881,6 +894,9 @@ static void check_section(const char *modname, struct elf_info *elf,
 #define EXIT_SECTIONS      ".exit.*"
 #define MEM_EXIT_SECTIONS  ".memexit.*"
 
+#define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
+                TEXT_SECTIONS, OTHER_TEXT_SECTIONS
+
 /* init data sections */
 static const char *const init_data_sections[] =
         { ALL_INIT_DATA_SECTIONS, NULL };
@@ -892,6 +908,9 @@ static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
 static const char *const init_exit_sections[] =
         {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
 
+/* all text sections */
+static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
+
 /* data section */
 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 
@@ -910,6 +929,7 @@ static const char *const data_sections[] = { DATA_SECTIONS, NULL };
 static const char *const head_sections[] = { ".head.text*", NULL };
 static const char *const linker_symbols[] =
         { "__init_begin", "_sinittext", "_einittext", NULL };
+static const char *const optim_symbols[] = { "*.constprop.*", NULL };
 
 enum mismatch {
         TEXT_TO_ANY_INIT,
@@ -921,34 +941,65 @@ enum mismatch {
         ANY_INIT_TO_ANY_EXIT,
         ANY_EXIT_TO_ANY_INIT,
         EXPORT_TO_INIT_EXIT,
+        EXTABLE_TO_NON_TEXT,
 };
 
+/**
+ * Describe how to match sections on different criterias:
+ *
+ * @fromsec: Array of sections to be matched.
+ *
+ * @bad_tosec: Relocations applied to a section in @fromsec to a section in
+ * this array is forbidden (black-list).  Can be empty.
+ *
+ * @good_tosec: Relocations applied to a section in @fromsec must be
+ * targetting sections in this array (white-list).  Can be empty.
+ *
+ * @mismatch: Type of mismatch.
+ *
+ * @symbol_white_list: Do not match a relocation to a symbol in this list
+ * even if it is targetting a section in @bad_to_sec.
+ *
+ * @handler: Specific handler to call when a match is found.  If NULL,
+ * default_mismatch_handler() will be called.
+ *
+ */
 struct sectioncheck {
         const char *fromsec[20];
-        const char *tosec[20];
+        const char *bad_tosec[20];
+        const char *good_tosec[20];
         enum mismatch mismatch;
         const char *symbol_white_list[20];
+        void (*handler)(const char *modname, struct elf_info *elf,
+                        const struct sectioncheck* const mismatch,
+                        Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
+
 };
 
+static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
+                                     const struct sectioncheck* const mismatch,
+                                     Elf_Rela *r, Elf_Sym *sym,
+                                     const char *fromsec);
+
 static const struct sectioncheck sectioncheck[] = {
 /* Do not reference init/exit code/data from
  * normal code and data
  */
 {
         .fromsec = { TEXT_SECTIONS, NULL },
-        .tosec   = { ALL_INIT_SECTIONS, NULL },
+        .bad_tosec = { ALL_INIT_SECTIONS, NULL },
         .mismatch = TEXT_TO_ANY_INIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 {
         .fromsec = { DATA_SECTIONS, NULL },
-        .tosec   = { ALL_XXXINIT_SECTIONS, NULL },
+        .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
         .mismatch = DATA_TO_ANY_INIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 {
         .fromsec = { DATA_SECTIONS, NULL },
-        .tosec   = { INIT_SECTIONS, NULL },
+        .bad_tosec = { INIT_SECTIONS, NULL },
         .mismatch = DATA_TO_ANY_INIT,
         .symbol_white_list = {
                 "*_template", "*_timer", "*_sht", "*_ops",
@@ -957,56 +1008,66 @@ static const struct sectioncheck sectioncheck[] = {
 },
 {
         .fromsec = { TEXT_SECTIONS, NULL },
-        .tosec   = { ALL_EXIT_SECTIONS, NULL },
+        .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
         .mismatch = TEXT_TO_ANY_EXIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 {
         .fromsec = { DATA_SECTIONS, NULL },
-        .tosec   = { ALL_EXIT_SECTIONS, NULL },
+        .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
         .mismatch = DATA_TO_ANY_EXIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 /* Do not reference init code/data from meminit code/data */
 {
         .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
-        .tosec   = { INIT_SECTIONS, NULL },
+        .bad_tosec = { INIT_SECTIONS, NULL },
         .mismatch = XXXINIT_TO_SOME_INIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 /* Do not reference exit code/data from memexit code/data */
 {
         .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
-        .tosec   = { EXIT_SECTIONS, NULL },
+        .bad_tosec = { EXIT_SECTIONS, NULL },
         .mismatch = XXXEXIT_TO_SOME_EXIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 /* Do not use exit code/data from init code */
 {
         .fromsec = { ALL_INIT_SECTIONS, NULL },
-        .tosec   = { ALL_EXIT_SECTIONS, NULL },
+        .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
         .mismatch = ANY_INIT_TO_ANY_EXIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 /* Do not use init code/data from exit code */
 {
         .fromsec = { ALL_EXIT_SECTIONS, NULL },
-        .tosec   = { ALL_INIT_SECTIONS, NULL },
+        .bad_tosec = { ALL_INIT_SECTIONS, NULL },
         .mismatch = ANY_EXIT_TO_ANY_INIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
 },
 {
         .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
-        .tosec   = { INIT_SECTIONS, NULL },
+        .bad_tosec = { INIT_SECTIONS, NULL },
         .mismatch = ANY_INIT_TO_ANY_EXIT,
         .symbol_white_list = { NULL },
 },
 /* Do not export init/exit functions or data */
 {
         .fromsec = { "__ksymtab*", NULL },
-        .tosec   = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
+        .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
         .mismatch = EXPORT_TO_INIT_EXIT,
         .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
+},
+{
+        .fromsec = { "__ex_table", NULL },
+        /* If you're adding any new black-listed sections in here, consider
+         * adding a special 'printer' for them in scripts/check_extable.
+         */
+        .bad_tosec = { ".altinstr_replacement", NULL },
+        .good_tosec = {ALL_TEXT_SECTIONS , NULL},
+        .mismatch = EXTABLE_TO_NON_TEXT,
+        .handler = extable_mismatch_handler,
 }
 };
 
@@ -1017,10 +1078,22 @@ static const struct sectioncheck *section_mismatch(
         int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
         const struct sectioncheck *check = &sectioncheck[0];
 
+        /*
+         * The target section could be the SHT_NUL section when we're
+         * handling relocations to un-resolved symbols, trying to match it
+         * doesn't make much sense and causes build failures on parisc and
+         * mn10300 architectures.
+         */
+        if (*tosec == '\0')
+                return NULL;
+
         for (i = 0; i < elems; i++) {
-                if (match(fromsec, check->fromsec) &&
-                    match(tosec, check->tosec))
-                        return check;
+                if (match(fromsec, check->fromsec)) {
+                        if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
+                                return check;
+                        if (check->good_tosec[0] && !match(tosec, check->good_tosec))
+                                return check;
+                }
                 check++;
         }
         return NULL;
@@ -1067,6 +1140,17 @@ static const struct sectioncheck *section_mismatch(
  *   This pattern is identified by
  *   refsymname = __init_begin, _sinittext, _einittext
  *
+ * Pattern 5:
+ *   GCC may optimize static inlines when fed constant arg(s) resulting
+ *   in functions like cpumask_empty() -- generating an associated symbol
+ *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
+ *   is passed in comes from __init, like say nmi_ipi_mask, we get a
+ *   meaningless section warning.  May need to add isra symbols too...
+ *   This pattern is identified by
+ *   tosec   = init section
+ *   fromsec = text section
+ *   refsymname = *.constprop.*
+ *
  **/
 static int secref_whitelist(const struct sectioncheck *mismatch,
                             const char *fromsec, const char *fromsym,
@@ -1099,6 +1183,12 @@ static int secref_whitelist(const struct sectioncheck *mismatch,
         if (match(tosym, linker_symbols))
                 return 0;
 
+        /* Check for pattern 5 */
+        if (match(fromsec, text_sections) &&
+            match(tosec, init_sections) &&
+            match(fromsym, optim_symbols))
+                return 0;
+
         return 1;
 }
 
@@ -1261,6 +1351,15 @@ static void print_section_list(const char * const list[20])
         fprintf(stderr, "\n");
 }
 
+static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
+{
+        switch (is_func) {
+        case 0: *name = "variable"; *name_p = ""; break;
+        case 1: *name = "function"; *name_p = "()"; break;
+        default: *name = "(unknown reference)"; *name_p = ""; break;
+        }
+}
+
 /*
  * Print a warning about a section mismatch.
  * Try to find symbols near it so user can find it.
@@ -1280,21 +1379,13 @@ static void report_sec_mismatch(const char *modname,
         char *prl_from;
         char *prl_to;
 
-        switch (from_is_func) {
-        case 0: from = "variable"; from_p = "";   break;
-        case 1: from = "function"; from_p = "()"; break;
-        default: from = "(unknown reference)"; from_p = ""; break;
-        }
-        switch (to_is_func) {
-        case 0: to = "variable"; to_p = "";   break;
-        case 1: to = "function"; to_p = "()"; break;
-        default: to = "(unknown reference)"; to_p = ""; break;
-        }
-
         sec_mismatch_count++;
         if (!sec_mismatch_verbose)
                 return;
 
+        get_pretty_name(from_is_func, &from, &from_p);
+        get_pretty_name(to_is_func, &to, &to_p);
+
         warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
              "to the %s %s:%s%s\n",
              modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
@@ -1408,41 +1499,179 @@ static void report_sec_mismatch(const char *modname,
                 tosym, prl_to, prl_to, tosym);
                 free(prl_to);
                 break;
+        case EXTABLE_TO_NON_TEXT:
+                fatal("There's a special handler for this mismatch type, "
+                      "we should never get here.");
+                break;
         }
         fprintf(stderr, "\n");
 }
 
-static void check_section_mismatch(const char *modname, struct elf_info *elf,
-                                   Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
+static void default_mismatch_handler(const char *modname, struct elf_info *elf,
+                                     const struct sectioncheck* const mismatch,
+                                     Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
 {
         const char *tosec;
-        const struct sectioncheck *mismatch;
+        Elf_Sym *to;
+        Elf_Sym *from;
+        const char *tosym;
+        const char *fromsym;
+
+        from = find_elf_symbol2(elf, r->r_offset, fromsec);
+        fromsym = sym_name(elf, from);
+
+        if (!strncmp(fromsym, "reference___initcall",
+                     sizeof("reference___initcall")-1))
+                return;
 
         tosec = sec_name(elf, get_secindex(elf, sym));
-        mismatch = section_mismatch(fromsec, tosec);
+        to = find_elf_symbol(elf, r->r_addend, sym);
+        tosym = sym_name(elf, to);
+
+        /* check whitelist - we may ignore it */
+        if (secref_whitelist(mismatch,
+                             fromsec, fromsym, tosec, tosym)) {
+                report_sec_mismatch(modname, mismatch,
+                                    fromsec, r->r_offset, fromsym,
+                                    is_function(from), tosec, tosym,
+                                    is_function(to));
+        }
+}
+
+static int is_executable_section(struct elf_info* elf, unsigned int section_index)
+{
+        if (section_index > elf->num_sections)
+                fatal("section_index is outside elf->num_sections!\n");
+
+        return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
+}
+
+/*
+ * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
+ * to know the sizeof(struct exception_table_entry) for the target architecture.
+ */
+static unsigned int extable_entry_size = 0;
+static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
+{
+        /*
+         * If we're currently checking the second relocation within __ex_table,
+         * that relocation offset tells us the offsetof(struct
+         * exception_table_entry, fixup) which is equal to sizeof(struct
+         * exception_table_entry) divided by two.  We use that to our advantage
+         * since there's no portable way to get that size as every architecture
+         * seems to go with different sized types.  Not pretty but better than
+         * hard-coding the size for every architecture..
+         */
+        if (!extable_entry_size)
+                extable_entry_size = r->r_offset * 2;
+}
+
+static inline bool is_extable_fault_address(Elf_Rela *r)
+{
+        /*
+         * extable_entry_size is only discovered after we've handled the
+         * _second_ relocation in __ex_table, so only abort when we're not
+         * handling the first reloc and extable_entry_size is zero.
+         */
+        if (r->r_offset && extable_entry_size == 0)
+                fatal("extable_entry size hasn't been discovered!\n");
+
+        return ((r->r_offset == 0) ||
+                (r->r_offset % extable_entry_size == 0));
+}
+
+#define is_second_extable_reloc(Start, Cur, Sec)                        \
+        (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
+
+static void report_extable_warnings(const char* modname, struct elf_info* elf,
+                                    const struct sectioncheck* const mismatch,
+                                    Elf_Rela* r, Elf_Sym* sym,
+                                    const char* fromsec, const char* tosec)
+{
+        Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
+        const char* fromsym_name = sym_name(elf, fromsym);
+        Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
+        const char* tosym_name = sym_name(elf, tosym);
+        const char* from_pretty_name;
+        const char* from_pretty_name_p;
+        const char* to_pretty_name;
+        const char* to_pretty_name_p;
+
+        get_pretty_name(is_function(fromsym),
+                        &from_pretty_name, &from_pretty_name_p);
+        get_pretty_name(is_function(tosym),
+                        &to_pretty_name, &to_pretty_name_p);
+
+        warn("%s(%s+0x%lx): Section mismatch in reference"
+             " from the %s %s%s to the %s %s:%s%s\n",
+             modname, fromsec, (long)r->r_offset, from_pretty_name,
+             fromsym_name, from_pretty_name_p,
+             to_pretty_name, tosec, tosym_name, to_pretty_name_p);
+
+        if (!match(tosec, mismatch->bad_tosec) &&
+            is_executable_section(elf, get_secindex(elf, sym)))
+                fprintf(stderr,
+                        "The relocation at %s+0x%lx references\n"
+                        "section \"%s\" which is not in the list of\n"
+                        "authorized sections.  If you're adding a new section\n"
+                        "and/or if this reference is valid, add \"%s\" to the\n"
+                        "list of authorized sections to jump to on fault.\n"
+                        "This can be achieved by adding \"%s\" to \n"
+                        "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
+                        fromsec, (long)r->r_offset, tosec, tosec, tosec);
+}
+
+static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
+                                     const struct sectioncheck* const mismatch,
+                                     Elf_Rela* r, Elf_Sym* sym,
+                                     const char *fromsec)
+{
+        const char* tosec = sec_name(elf, get_secindex(elf, sym));
+
+        sec_mismatch_count++;
+
+        if (sec_mismatch_verbose)
+                report_extable_warnings(modname, elf, mismatch, r, sym,
+                                        fromsec, tosec);
+
+        if (match(tosec, mismatch->bad_tosec))
+                fatal("The relocation at %s+0x%lx references\n"
+                      "section \"%s\" which is black-listed.\n"
+                      "Something is seriously wrong and should be fixed.\n"
+                      "You might get more information about where this is\n"
+                      "coming from by using scripts/check_extable.sh %s\n",
+                      fromsec, (long)r->r_offset, tosec, modname);
+        else if (!is_executable_section(elf, get_secindex(elf, sym))) {
+                if (is_extable_fault_address(r))
+                        fatal("The relocation at %s+0x%lx references\n"
+                              "section \"%s\" which is not executable, IOW\n"
+                              "it is not possible for the kernel to fault\n"
+                              "at that address.  Something is seriously wrong\n"
+                              "and should be fixed.\n",
+                              fromsec, (long)r->r_offset, tosec);
+                else
+                        fatal("The relocation at %s+0x%lx references\n"
+                              "section \"%s\" which is not executable, IOW\n"
+                              "the kernel will fault if it ever tries to\n"
+                              "jump to it.  Something is seriously wrong\n"
+                              "and should be fixed.\n",
+                              fromsec, (long)r->r_offset, tosec);
+        }
+}
+
+static void check_section_mismatch(const char *modname, struct elf_info *elf,
+                                   Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
+{
+        const char *tosec = sec_name(elf, get_secindex(elf, sym));;
+        const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
+
         if (mismatch) {
-                Elf_Sym *to;
-                Elf_Sym *from;
-                const char *tosym;
-                const char *fromsym;
-
-                from = find_elf_symbol2(elf, r->r_offset, fromsec);
-                fromsym = sym_name(elf, from);
-                to = find_elf_symbol(elf, r->r_addend, sym);
-                tosym = sym_name(elf, to);
-
-                if (!strncmp(fromsym, "reference___initcall",
-                                sizeof("reference___initcall")-1))
-                        return;
-
-                /* check whitelist - we may ignore it */
-                if (secref_whitelist(mismatch,
-                                        fromsec, fromsym, tosec, tosym)) {
-                        report_sec_mismatch(modname, mismatch,
-                           fromsec, r->r_offset, fromsym,
-                           is_function(from), tosec, tosym,
-                           is_function(to));
-                }
+                if (mismatch->handler)
+                        mismatch->handler(modname, elf,  mismatch,
+                                          r, sym, fromsec);
+                else
+                        default_mismatch_handler(modname, elf, mismatch,
+                                                 r, sym, fromsec);
         }
 }
 
@@ -1582,6 +1811,8 @@ static void section_rela(const char *modname, struct elf_info *elf,
                 /* Skip special sections */
                 if (is_shndx_special(sym->st_shndx))
                         continue;
+                if (is_second_extable_reloc(start, rela, fromsec))
+                        find_extable_entry_size(fromsec, &r);
                 check_section_mismatch(modname, elf, &r, sym, fromsec);
         }
 }
@@ -1640,6 +1871,8 @@ static void section_rel(const char *modname, struct elf_info *elf,
                 /* Skip special sections */
                 if (is_shndx_special(sym->st_shndx))
                         continue;
+                if (is_second_extable_reloc(start, rel, fromsec))
+                        find_extable_entry_size(fromsec, &r);
                 check_section_mismatch(modname, elf, &r, sym, fromsec);
         }
 }
diff --git a/scripts/spelling.txt b/scripts/spelling.txt
index fc7fd52b5e03..bb8e4d0a1911 100644
--- a/scripts/spelling.txt
+++ b/scripts/spelling.txt
@@ -825,6 +825,7 @@ retreived||retrieved
 retreive||retrieve
 retrive||retrieve
 retuned||returned
+reudce||reduce
 reuest||request
 reuqest||request
 reutnred||returned
diff --git a/scripts/xen-hypercalls.sh b/scripts/xen-hypercalls.sh
new file mode 100644
index 000000000000..676d9226814f
--- /dev/null
+++ b/scripts/xen-hypercalls.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+out="$1"
+shift
+in="$@"
+
+for i in $in; do
+        eval $CPP $LINUXINCLUDE -dD -imacros "$i" -x c /dev/null
+done | \
+awk '$1 == "#define" && $2 ~ /__HYPERVISOR_[a-z][a-z_0-9]*/ { v[$3] = $2 }
+        END {   print "/* auto-generated by scripts/xen-hypercall.sh */"
+                for (i in v) if (!(v[i] in v))
+                        print "HYPERCALL("substr(v[i], 14)")"}' | sort -u >$out