25 files changed, 1002 insertions, 63 deletions
diff --git a/scripts/Kbuild.include b/scripts/Kbuild.include
index edd2794569db..d3437b82ac25 100644
--- a/scripts/Kbuild.include
+++ b/scripts/Kbuild.include
@@ -129,17 +129,15 @@ cc-disable-warning = $(call try-run,\
        $(CC) $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) -W$(strip $(1)) -c -x c /dev/null -o "$$TMP",-Wno-$(strip $(1)))
 # cc-version
-# Usage gcc-ver := $(call cc-version)
 cc-version = $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-version.sh $(CC))
 # cc-fullversion
-# Usage gcc-ver := $(call cc-fullversion)
 cc-fullversion = $(shell $(CONFIG_SHELL) \
        $(srctree)/scripts/gcc-version.sh -p $(CC))
 # cc-ifversion
 # Usage:  EXTRA_CFLAGS += $(call cc-ifversion, -lt, 0402, -O1)
-cc-ifversion = $(shell [ $(call cc-version, $(CC)) $(1) $(2) ] && echo $(3))
+cc-ifversion = $(shell [ $(cc-version) $(1) $(2) ] && echo $(3) || echo $(4))
 # cc-ldoption
 # Usage: ldflags += $(call cc-ldoption, -Wl$(comma)--hash-style=both)
@@ -157,13 +155,12 @@ ld-option = $(call try-run,\
 ar-option = $(call try-run, $(AR) rc$(1) "$$TMP",$(1),$(2))
 # ld-version
-# Usage: $(call ld-version)
 # Note this is mainly for HJ Lu's 3 number binutil versions
 ld-version = $(shell $(LD) --version | $(srctree)/scripts/ld-version.sh)
 # ld-ifversion
 # Usage:  $(call ld-ifversion, -ge, 22252, y)
-ld-ifversion = $(shell [ $(call ld-version) $(1) $(2) ] && echo $(3))
+ld-ifversion = $(shell [ $(ld-version) $(1) $(2) ] && echo $(3) || echo $(4))
 ######
diff --git a/scripts/Makefile b/scripts/Makefile
index 72902b5f2721..2016a64497ab 100644
--- a/scripts/Makefile
+++ b/scripts/Makefile
@@ -36,6 +36,7 @@ subdir-$(CONFIG_MODVERSIONS) += genksyms
 subdir-y                     += mod
 subdir-$(CONFIG_SECURITY_SELINUX) += selinux
 subdir-$(CONFIG_DTC)         += dtc
+subdir-$(CONFIG_GDB_SCRIPTS) += gdb
 # Let clean descend into subdirs
 subdir- += basic kconfig package
diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index 649ce6844033..01df30af4d4a 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -234,8 +234,9 @@ sub_cmd_record_mcount = set -e ; perl $(srctree)/scripts/recordmcount.pl "$(ARCH
        "$(if $(part-of-module),1,0)" "$(@)";
 recordmcount_source := $(srctree)/scripts/recordmcount.pl
 endif
-cmd_record_mcount =                                             \
+cmd_record_mcount =                                             \
-        if [ "$(findstring -pg,$(_c_flags))" = "-pg" ]; then    \
+        if [ "$(findstring $(CC_FLAGS_FTRACE),$(_c_flags))" =   \
+             "$(CC_FLAGS_FTRACE)" ]; then                       \
                $(sub_cmd_record_mcount)                        \
        fi;
 endif
diff --git a/scripts/Makefile.clean b/scripts/Makefile.clean
index 627f8cbbedb8..55c96cb8070f 100644
--- a/scripts/Makefile.clean
+++ b/scripts/Makefile.clean
@@ -71,9 +71,6 @@ endif
 ifneq ($(strip $(__clean-dirs)),)
        +$(call cmd,cleandir)
 endif
-ifneq ($(strip $(clean-rule)),)
-        +$(clean-rule)
-endif
        @:
diff --git a/scripts/Makefile.kasan b/scripts/Makefile.kasan
new file mode 100644
index 000000000000..631619b2b118
--- /dev/null
+++ b/scripts/Makefile.kasan
@@ -0,0 +1,25 @@
+ifdef CONFIG_KASAN
+ifdef CONFIG_KASAN_INLINE
+        call_threshold := 10000
+else
+        call_threshold := 0
+endif
+CFLAGS_KASAN_MINIMAL := -fsanitize=kernel-address
+CFLAGS_KASAN := $(call cc-option, -fsanitize=kernel-address \
+                -fasan-shadow-offset=$(CONFIG_KASAN_SHADOW_OFFSET) \
+                --param asan-stack=1 --param asan-globals=1 \
+                --param asan-instrumentation-with-call-threshold=$(call_threshold))
+ifeq ($(call cc-option, $(CFLAGS_KASAN_MINIMAL) -Werror),)
+        $(warning Cannot use CONFIG_KASAN: \
+            -fsanitize=kernel-address is not supported by compiler)
+else
+    ifeq ($(CFLAGS_KASAN),)
+        $(warning CONFIG_KASAN: compiler does not support all options.\
+            Trying minimal configuration)
+        CFLAGS_KASAN := $(CFLAGS_KASAN_MINIMAL)
+    endif
+endif
+endif
diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib
index 511755200634..044eb4f89a91 100644
--- a/scripts/Makefile.lib
+++ b/scripts/Makefile.lib
@@ -119,6 +119,16 @@ _c_flags += $(if $(patsubst n%,, \
                $(CFLAGS_GCOV))
 endif
+#
+# Enable address sanitizer flags for kernel except some files or directories
+# we don't want to check (depends on variables KASAN_SANITIZE_obj.o, KASAN_SANITIZE)
+#
+ifeq ($(CONFIG_KASAN),y)
+_c_flags += $(if $(patsubst n%,, \
+                $(KASAN_SANITIZE_$(basetarget).o)$(KASAN_SANITIZE)y), \
+                $(CFLAGS_KASAN))
+endif
 # If building the kernel in a separate objtree expand all occurrences
 # of -Idir to -I$(srctree)/dir except for absolute paths (starting with '/').
diff --git a/scripts/asn1_compiler.c b/scripts/asn1_compiler.c
index 91c4117637ae..7750e9c31483 100644
--- a/scripts/asn1_compiler.c
+++ b/scripts/asn1_compiler.c
@@ -311,6 +311,9 @@ struct token {
 static struct token *token_list;
 static unsigned nr_tokens;
+static _Bool verbose;
+#define debug(fmt, ...) do { if (verbose) printf(fmt, ## __VA_ARGS__); } while (0)
 static int directive_compare(const void *_key, const void *_pdir)
 {
@@ -322,21 +325,21 @@ static int directive_compare(const void *_key, const void *_pdir)
        dlen = strlen(dir);
        clen = (dlen < token->size) ? dlen : token->size;
-        //printf("cmp(%*.*s,%s) = ",
+        //debug("cmp(%*.*s,%s) = ",
        //       (int)token->size, (int)token->size, token->value,
        //       dir);
        val = memcmp(token->value, dir, clen);
        if (val != 0) {
-                //printf("%d [cmp]\n", val);
+                //debug("%d [cmp]\n", val);
                return val;
        }
        if (dlen == token->size) {
-                //printf("0\n");
+                //debug("0\n");
                return 0;
        }
-        //printf("%d\n", (int)dlen - (int)token->size);
+        //debug("%d\n", (int)dlen - (int)token->size);
        return dlen - token->size; /* shorter -> negative */
 }
@@ -515,13 +518,13 @@ static void tokenise(char *buffer, char *end)
        }
        nr_tokens = tix;
-        printf("Extracted %u tokens\n", nr_tokens);
+        debug("Extracted %u tokens\n", nr_tokens);
 #if 0
        {
                int n;
                for (n = 0; n < nr_tokens; n++)
-                        printf("Token %3u: '%*.*s'\n",
+                        debug("Token %3u: '%*.*s'\n",
                               n,
                               (int)token_list[n].size, (int)token_list[n].size,
                               token_list[n].value);
@@ -542,6 +545,7 @@ int main(int argc, char **argv)
        ssize_t readlen;
        FILE *out, *hdr;
        char *buffer, *p;
+        char *kbuild_verbose;
        int fd;
        if (argc != 4) {
@@ -550,6 +554,10 @@ int main(int argc, char **argv)
                exit(2);
        }
+        kbuild_verbose = getenv("KBUILD_VERBOSE");
+        if (kbuild_verbose)
+                verbose = atoi(kbuild_verbose);
        filename = argv[1];
        outputname = argv[2];
        headername = argv[3];
@@ -748,11 +756,11 @@ static void build_type_list(void)
        qsort(type_index, nr, sizeof(type_index[0]), type_index_compare);
-        printf("Extracted %u types\n", nr_types);
+        debug("Extracted %u types\n", nr_types);
 #if 0
        for (n = 0; n < nr_types; n++) {
                struct type *type = type_index[n];
-                printf("- %*.*s\n",
+                debug("- %*.*s\n",
                       (int)type->name->size,
                       (int)type->name->size,
                       type->name->value);
@@ -793,7 +801,7 @@ static void parse(void)
        } while (type++, !(type->flags & TYPE_STOP_MARKER));
-        printf("Extracted %u actions\n", nr_actions);
+        debug("Extracted %u actions\n", nr_actions);
 }
 static struct element *element_list;
@@ -1284,7 +1292,7 @@ static void render(FILE *out, FILE *hdr)
        }
        /* We do two passes - the first one calculates all the offsets */
-        printf("Pass 1\n");
+        debug("Pass 1\n");
        nr_entries = 0;
        root = &type_list[0];
        render_element(NULL, root->element, NULL);
@@ -1295,7 +1303,7 @@ static void render(FILE *out, FILE *hdr)
                e->flags &= ~ELEMENT_RENDERED;
        /* And then we actually render */
-        printf("Pass 2\n");
+        debug("Pass 2\n");
        fprintf(out, "\n");
        fprintf(out, "static const unsigned char %s_machine[] = {\n",
                grammar_name);
diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index f0bb6d60c07b..d12435992dea 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -278,6 +278,7 @@ our $Attribute	= qr{
                        __noreturn|
                        __used|
                        __cold|
+                        __pure|
                        __noclone|
                        __deprecated|
                        __read_mostly|
@@ -298,6 +299,7 @@ our $Binary	= qr{(?i)0b[01]+$Int_type?};
 our $Hex        = qr{(?i)0x[0-9a-f]+$Int_type?};
 our $Int        = qr{[0-9]+$Int_type?};
 our $Octal      = qr{0[0-7]+$Int_type?};
+our $String     = qr{"[X\t]*"};
 our $Float_hex  = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
 our $Float_dec  = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
 our $Float_int  = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
@@ -337,6 +339,11 @@ our $UTF8	= qr{
        | $NON_ASCII_UTF8
 }x;
+our $typeOtherOSTypedefs = qr{(?x:
+        u_(?:char|short|int|long) |          # bsd
+        u(?:nchar|short|int|long)            # sysv
+)};
 our $typeTypedefs = qr{(?x:
        (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
        atomic_t
@@ -473,6 +480,7 @@ sub build_types {
                        (?:$Modifier\s+|const\s+)*
                        (?:
                                (?:typeof|__typeof__)\s*\([^\)]*\)|
+                                (?:$typeOtherOSTypedefs\b)|
                                (?:$typeTypedefs\b)|
                                (?:${all}\b)
                        )
@@ -490,6 +498,7 @@ sub build_types {
                        (?:
                                (?:typeof|__typeof__)\s*\([^\)]*\)|
                                (?:$typeTypedefs\b)|
+                                (?:$typeOtherOSTypedefs\b)|
                                (?:${allWithAttr}\b)
                        )
                        (?:\s+$Modifier|\s+const)*
@@ -517,7 +526,7 @@ our $Typecast	= qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
-our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
+our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
 our $declaration_macros = qr{(?x:
        (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,2}\s*\(|
@@ -632,6 +641,8 @@ sub git_commit_info {
        $output =~ s/^\s*//gm;
        my @lines = split("\n", $output);
+        return ($id, $desc) if ($#lines < 0);
        if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
 # Maybe one day convert this block of bash into something that returns
 # all matching commit ids, but it's very slow...
@@ -2159,6 +2170,13 @@ sub process {
                        }
                }
+# Check email subject for common tools that don't need to be mentioned
+                if ($in_header_lines &&
+                    $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
+                        WARN("EMAIL_SUBJECT",
+                             "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
+                }
 # Check for old stable address
                if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
                        ERROR("STABLE_ADDRESS",
@@ -2171,21 +2189,49 @@ sub process {
                              "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
                }
-# Check for improperly formed commit descriptions
+# Check for git id commit length and improperly formed commit descriptions
-                if ($in_commit_log &&
+                if ($in_commit_log && $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i) {
-                    $line =~ /\bcommit\s+[0-9a-f]{5,}/i &&
-                    !($line =~ /\b[Cc]ommit [0-9a-f]{12,40} \("/ ||
-                      ($line =~ /\b[Cc]ommit [0-9a-f]{12,40}\s*$/ &&
-                       defined $rawlines[$linenr] &&
-                       $rawlines[$linenr] =~ /^\s*\("/))) {
-                        $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i;
                        my $init_char = $1;
                        my $orig_commit = lc($2);
-                        my $id = '01234567890ab';
+                        my $short = 1;
-                        my $desc = 'commit description';
+                        my $long = 0;
-                        ($id, $desc) = git_commit_info($orig_commit, $id, $desc);
+                        my $case = 1;
-                        ERROR("GIT_COMMIT_ID",
+                        my $space = 1;
-                              "Please use 12 or more chars for the git commit ID like: '${init_char}ommit $id (\"$desc\")'\n" . $herecurr);
+                        my $hasdesc = 0;
+                        my $hasparens = 0;
+                        my $id = '0123456789ab';
+                        my $orig_desc = "commit description";
+                        my $description = "";
+                        $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
+                        $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
+                        $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
+                        $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
+                        if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
+                                $orig_desc = $1;
+                                $hasparens = 1;
+                        } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
+                                 defined $rawlines[$linenr] &&
+                                 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
+                                $orig_desc = $1;
+                                $hasparens = 1;
+                        } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
+                                 defined $rawlines[$linenr] &&
+                                 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
+                                $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
+                                $orig_desc = $1;
+                                $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
+                                $orig_desc .= " " . $1;
+                                $hasparens = 1;
+                        }
+                        ($id, $description) = git_commit_info($orig_commit,
+                                                              $id, $orig_desc);
+                        if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
+                                ERROR("GIT_COMMIT_ID",
+                                      "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
+                        }
                }
 # Check for added, moved or deleted files
@@ -2355,6 +2401,13 @@ sub process {
                             "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
                }
+# discourage the use of boolean for type definition attributes of Kconfig options
+                if ($realfile =~ /Kconfig/ &&
+                    $line =~ /^\+\s*\bboolean\b/) {
+                        WARN("CONFIG_TYPE_BOOLEAN",
+                             "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
+                }
                if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
                    ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
                        my $flag = $1;
@@ -2499,7 +2552,7 @@ sub process {
                        }
                }
-                if ($line =~ /^\+.*(\w+\s*)?\(\s*$Type\s*\)[ \t]+(?!$Assignment|$Arithmetic|[,;\({\[\<\>])/ &&
+                if ($line =~ /^\+.*(\w+\s*)?\(\s*$Type\s*\)[ \t]+(?!$Assignment|$Arithmetic|[,;:\?\(\{\}\[\<\>]|&&|\|\||\\$)/ &&
                    (!defined($1) || $1 !~ /sizeof\s*/)) {
                        if (CHK("SPACING",
                                "No space is necessary after a cast\n" . $herecurr) &&
@@ -3124,6 +3177,7 @@ sub process {
                    $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
                    $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
                    $line !~ /\b$typeTypedefs\b/ &&
+                    $line !~ /\b$typeOtherOSTypedefs\b/ &&
                    $line !~ /\b__bitwise(?:__|)\b/) {
                        WARN("NEW_TYPEDEFS",
                             "do not add new typedefs\n" . $herecurr);
@@ -3200,7 +3254,7 @@ sub process {
 # check for uses of printk_ratelimit
                if ($line =~ /\bprintk_ratelimit\s*\(/) {
                        WARN("PRINTK_RATELIMITED",
-"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
+                             "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
                }
 # printk should use KERN_* levels.  Note that follow on printk's on the
@@ -3646,7 +3700,22 @@ sub process {
                                         $op eq '*' or $op eq '/' or
                                         $op eq '%')
                                {
-                                        if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
+                                        if ($check) {
+                                                if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
+                                                        if (CHK("SPACING",
+                                                                "spaces preferred around that '$op' $at\n" . $hereptr)) {
+                                                                $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
+                                                                $fix_elements[$n + 2] =~ s/^\s+//;
+                                                                $line_fixed = 1;
+                                                        }
+                                                } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
+                                                        if (CHK("SPACING",
+                                                                "space preferred before that '$op' $at\n" . $hereptr)) {
+                                                                $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
+                                                                $line_fixed = 1;
+                                                        }
+                                                }
+                                        } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
                                                if (ERROR("SPACING",
                                                          "need consistent spacing around '$op' $at\n" . $hereptr)) {
                                                        $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
@@ -4251,6 +4320,7 @@ sub process {
                        $ctx = $dstat;
                        $dstat =~ s/\\\n.//g;
+                        $dstat =~ s/$;/ /g;
                        if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
                                my $stmts = $2;
@@ -4417,12 +4487,18 @@ sub process {
 # check for unnecessary blank lines around braces
                if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
-                        CHK("BRACES",
+                        if (CHK("BRACES",
-                            "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
+                                "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
+                            $fix && $prevrawline =~ /^\+/) {
+                                fix_delete_line($fixlinenr - 1, $prevrawline);
+                        }
                }
                if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
-                        CHK("BRACES",
+                        if (CHK("BRACES",
-                            "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
+                                "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
+                            $fix) {
+                                fix_delete_line($fixlinenr, $rawline);
+                        }
                }
 # no volatiles please
@@ -4545,7 +4621,7 @@ sub process {
                }
 # check for logging functions with KERN_<LEVEL>
-                if ($line !~ /printk\s*\(/ &&
+                if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
                    $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
                        my $level = $1;
                        if (WARN("UNNECESSARY_KERN_LEVEL",
@@ -4804,7 +4880,8 @@ sub process {
 # check for seq_printf uses that could be seq_puts
                if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
                        my $fmt = get_quoted_string($line, $rawline);
-                        if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
+                        $fmt =~ s/%%//g;
+                        if ($fmt !~ /%/) {
                                if (WARN("PREFER_SEQ_PUTS",
                                         "Prefer seq_puts to seq_printf\n" . $herecurr) &&
                                    $fix) {
@@ -5089,6 +5166,12 @@ sub process {
                        }
                }
+# check for uses of __DATE__, __TIME__, __TIMESTAMP__
+                while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
+                        ERROR("DATE_TIME",
+                              "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
+                }
 # check for use of yield()
                if ($line =~ /\byield\s*\(\s*\)/) {
                        WARN("YIELD",
@@ -5140,8 +5223,9 @@ sub process {
                             "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
                }
-# check for various ops structs, ensure they are const.
+# check for various structs that are normally const (ops, kgdb, device_tree)
-                my $struct_ops = qr{acpi_dock_ops|
+                my $const_structs = qr{
+                                acpi_dock_ops|
                                address_space_operations|
                                backlight_ops|
                                block_device_operations|
@@ -5164,6 +5248,7 @@ sub process {
                                mtrr_ops|
                                neigh_ops|
                                nlmsvc_binding|
+                                of_device_id|
                                pci_raw_ops|
                                pipe_buf_operations|
                                platform_hibernation_ops|
@@ -5179,7 +5264,7 @@ sub process {
                                usb_mon_operations|
                                wd_ops}x;
                if ($line !~ /\bconst\b/ &&
-                    $line =~ /\bstruct\s+($struct_ops)\b/) {
+                    $line =~ /\bstruct\s+($const_structs)\b/) {
                        WARN("CONST_STRUCT",
                             "struct $1 should normally be const\n" .
                                $herecurr);
@@ -5204,6 +5289,13 @@ sub process {
                              "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
                }
+# likely/unlikely comparisons similar to "(likely(foo) > 0)"
+                if ($^V && $^V ge 5.10.0 &&
+                    $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
+                        WARN("LIKELY_MISUSE",
+                             "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
+                }
 # whine mightly about in_atomic
                if ($line =~ /\bin_atomic\s*\(/) {
                        if ($realfile =~ m@^drivers/@) {
@@ -5255,6 +5347,9 @@ sub process {
                                             length($val) ne 4)) {
                                                ERROR("NON_OCTAL_PERMISSIONS",
                                                      "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
+                                        } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
+                                                ERROR("EXPORTED_WORLD_WRITABLE",
+                                                      "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
                                        }
                                }
                        }
diff --git a/scripts/diffconfig b/scripts/diffconfig
index 6d672836e187..0db267d0adc9 100755
--- a/scripts/diffconfig
+++ b/scripts/diffconfig
@@ -28,7 +28,6 @@ If no config files are specified, .config and .config.old are used.
 Example usage:
 $ diffconfig .config config-with-some-changes
 -EXT2_FS_XATTR  n
-EXT2_FS_XIP  n
 CRAMFS  n -> y
 EXT2_FS  y -> n
 LOG_BUF_SHIFT  14 -> 16
diff --git a/scripts/gdb/Makefile b/scripts/gdb/Makefile
new file mode 100644
index 000000000000..62f5f65becfd
--- /dev/null
+++ b/scripts/gdb/Makefile
@@ -0,0 +1 @@
+subdir-y := linux
diff --git a/scripts/gdb/linux/.gitignore b/scripts/gdb/linux/.gitignore
new file mode 100644
index 000000000000..52e4e61140d1
--- /dev/null
+++ b/scripts/gdb/linux/.gitignore
@@ -0,0 +1,2 @@
+*.pyc
+*.pyo
diff --git a/scripts/gdb/linux/Makefile b/scripts/gdb/linux/Makefile
new file mode 100644
index 000000000000..6cf1ecf61057
--- /dev/null
+++ b/scripts/gdb/linux/Makefile
@@ -0,0 +1,11 @@
+always := gdb-scripts
+SRCTREE := $(shell cd $(srctree) && /bin/pwd)
+$(obj)/gdb-scripts:
+ifneq ($(KBUILD_SRC),)
+        $(Q)ln -fsn $(SRCTREE)/$(obj)/*.py $(objtree)/$(obj)
+endif
+        @:
+clean-files := *.pyc *.pyo $(if $(KBUILD_SRC),*.py)
diff --git a/scripts/gdb/linux/__init__.py b/scripts/gdb/linux/__init__.py
new file mode 100644
index 000000000000..4680fb176337
--- /dev/null
+++ b/scripts/gdb/linux/__init__.py
@@ -0,0 +1 @@
+# nothing to do for the initialization of this package
diff --git a/scripts/gdb/linux/cpus.py b/scripts/gdb/linux/cpus.py
new file mode 100644
index 000000000000..4297b83fedef
--- /dev/null
+++ b/scripts/gdb/linux/cpus.py
@@ -0,0 +1,135 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  per-cpu tools
+#
+# Copyright (c) Siemens AG, 2011-2013
+#
+# Authors:
+#  Jan Kiszka <jan.kiszka@siemens.com>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+import gdb
+from linux import tasks, utils
+MAX_CPUS = 4096
+def get_current_cpu():
+    if utils.get_gdbserver_type() == utils.GDBSERVER_QEMU:
+        return gdb.selected_thread().num - 1
+    elif utils.get_gdbserver_type() == utils.GDBSERVER_KGDB:
+        tid = gdb.selected_thread().ptid[2]
+        if tid > (0x100000000 - MAX_CPUS - 2):
+            return 0x100000000 - tid - 2
+        else:
+            return tasks.get_thread_info(tasks.get_task_by_pid(tid))['cpu']
+    else:
+        raise gdb.GdbError("Sorry, obtaining the current CPU is not yet "
+                           "supported with this gdb server.")
+def per_cpu(var_ptr, cpu):
+    if cpu == -1:
+        cpu = get_current_cpu()
+    if utils.is_target_arch("sparc:v9"):
+        offset = gdb.parse_and_eval(
+            "trap_block[{0}].__per_cpu_base".format(str(cpu)))
+    else:
+        try:
+            offset = gdb.parse_and_eval(
+                "__per_cpu_offset[{0}]".format(str(cpu)))
+        except gdb.error:
+            # !CONFIG_SMP case
+            offset = 0
+    pointer = var_ptr.cast(utils.get_long_type()) + offset
+    return pointer.cast(var_ptr.type).dereference()
+cpu_mask = {}
+def cpu_mask_invalidate(event):
+    global cpu_mask
+    cpu_mask = {}
+    gdb.events.stop.disconnect(cpu_mask_invalidate)
+    if hasattr(gdb.events, 'new_objfile'):
+        gdb.events.new_objfile.disconnect(cpu_mask_invalidate)
+def cpu_list(mask_name):
+    global cpu_mask
+    mask = None
+    if mask_name in cpu_mask:
+        mask = cpu_mask[mask_name]
+    if mask is None:
+        mask = gdb.parse_and_eval(mask_name + ".bits")
+        if hasattr(gdb, 'events'):
+            cpu_mask[mask_name] = mask
+            gdb.events.stop.connect(cpu_mask_invalidate)
+            if hasattr(gdb.events, 'new_objfile'):
+                gdb.events.new_objfile.connect(cpu_mask_invalidate)
+    bits_per_entry = mask[0].type.sizeof * 8
+    num_entries = mask.type.sizeof * 8 / bits_per_entry
+    entry = -1
+    bits = 0
+    while True:
+        while bits == 0:
+            entry += 1
+            if entry == num_entries:
+                return
+            bits = mask[entry]
+            if bits != 0:
+                bit = 0
+                break
+        while bits & 1 == 0:
+            bits >>= 1
+            bit += 1
+        cpu = entry * bits_per_entry + bit
+        bits >>= 1
+        bit += 1
+        yield cpu
+class PerCpu(gdb.Function):
+    """Return per-cpu variable.
+$lx_per_cpu("VAR"[, CPU]): Return the per-cpu variable called VAR for the
+given CPU number. If CPU is omitted, the CPU of the current context is used.
+Note that VAR has to be quoted as string."""
+    def __init__(self):
+        super(PerCpu, self).__init__("lx_per_cpu")
+    def invoke(self, var_name, cpu=-1):
+        var_ptr = gdb.parse_and_eval("&" + var_name.string())
+        return per_cpu(var_ptr, cpu)
+PerCpu()
+class LxCurrentFunc(gdb.Function):
+    """Return current task.
+$lx_current([CPU]): Return the per-cpu task variable for the given CPU
+number. If CPU is omitted, the CPU of the current context is used."""
+    def __init__(self):
+        super(LxCurrentFunc, self).__init__("lx_current")
+    def invoke(self, cpu=-1):
+        var_ptr = gdb.parse_and_eval("&current_task")
+        return per_cpu(var_ptr, cpu).dereference()
+LxCurrentFunc()
diff --git a/scripts/gdb/linux/dmesg.py b/scripts/gdb/linux/dmesg.py
new file mode 100644
index 000000000000..3c947f0c5dad
--- /dev/null
+++ b/scripts/gdb/linux/dmesg.py
@@ -0,0 +1,65 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  kernel log buffer dump
+#
+# Copyright (c) Siemens AG, 2011, 2012
+#
+# Authors:
+#  Jan Kiszka <jan.kiszka@siemens.com>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+import gdb
+import string
+from linux import utils
+class LxDmesg(gdb.Command):
+    """Print Linux kernel log buffer."""
+    def __init__(self):
+        super(LxDmesg, self).__init__("lx-dmesg", gdb.COMMAND_DATA)
+    def invoke(self, arg, from_tty):
+        log_buf_addr = int(str(gdb.parse_and_eval("log_buf")).split()[0], 16)
+        log_first_idx = int(gdb.parse_and_eval("log_first_idx"))
+        log_next_idx = int(gdb.parse_and_eval("log_next_idx"))
+        log_buf_len = int(gdb.parse_and_eval("log_buf_len"))
+        inf = gdb.inferiors()[0]
+        start = log_buf_addr + log_first_idx
+        if log_first_idx < log_next_idx:
+            log_buf_2nd_half = -1
+            length = log_next_idx - log_first_idx
+            log_buf = inf.read_memory(start, length)
+        else:
+            log_buf_2nd_half = log_buf_len - log_first_idx
+            log_buf = inf.read_memory(start, log_buf_2nd_half) + \
+                inf.read_memory(log_buf_addr, log_next_idx)
+        pos = 0
+        while pos < log_buf.__len__():
+            length = utils.read_u16(log_buf[pos + 8:pos + 10])
+            if length == 0:
+                if log_buf_2nd_half == -1:
+                    gdb.write("Corrupted log buffer!\n")
+                    break
+                pos = log_buf_2nd_half
+                continue
+            text_len = utils.read_u16(log_buf[pos + 10:pos + 12])
+            text = log_buf[pos + 16:pos + 16 + text_len]
+            time_stamp = utils.read_u64(log_buf[pos:pos + 8])
+            for line in memoryview(text).tobytes().splitlines():
+                gdb.write("[{time:12.6f}] {line}\n".format(
+                    time=time_stamp / 1000000000.0,
+                    line=line))
+            pos += length
+LxDmesg()
diff --git a/scripts/gdb/linux/modules.py b/scripts/gdb/linux/modules.py
new file mode 100644
index 000000000000..a1504c4f1900
--- /dev/null
+++ b/scripts/gdb/linux/modules.py
@@ -0,0 +1,103 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  module tools
+#
+# Copyright (c) Siemens AG, 2013
+#
+# Authors:
+#  Jan Kiszka <jan.kiszka@siemens.com>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+import gdb
+from linux import cpus, utils
+module_type = utils.CachedType("struct module")
+def module_list():
+    global module_type
+    module_ptr_type = module_type.get_type().pointer()
+    modules = gdb.parse_and_eval("modules")
+    entry = modules['next']
+    end_of_list = modules.address
+    while entry != end_of_list:
+        yield utils.container_of(entry, module_ptr_type, "list")
+        entry = entry['next']
+def find_module_by_name(name):
+    for module in module_list():
+        if module['name'].string() == name:
+            return module
+    return None
+class LxModule(gdb.Function):
+    """Find module by name and return the module variable.
+$lx_module("MODULE"): Given the name MODULE, iterate over all loaded modules
+of the target and return that module variable which MODULE matches."""
+    def __init__(self):
+        super(LxModule, self).__init__("lx_module")
+    def invoke(self, mod_name):
+        mod_name = mod_name.string()
+        module = find_module_by_name(mod_name)
+        if module:
+            return module.dereference()
+        else:
+            raise gdb.GdbError("Unable to find MODULE " + mod_name)
+LxModule()
+class LxLsmod(gdb.Command):
+    """List currently loaded modules."""
+    _module_use_type = utils.CachedType("struct module_use")
+    def __init__(self):
+        super(LxLsmod, self).__init__("lx-lsmod", gdb.COMMAND_DATA)
+    def invoke(self, arg, from_tty):
+        gdb.write(
+            "Address{0}    Module                  Size  Used by\n".format(
+                "        " if utils.get_long_type().sizeof == 8 else ""))
+        for module in module_list():
+            ref = 0
+            module_refptr = module['refptr']
+            for cpu in cpus.cpu_list("cpu_possible_mask"):
+                refptr = cpus.per_cpu(module_refptr, cpu)
+                ref += refptr['incs']
+                ref -= refptr['decs']
+            gdb.write("{address} {name:<19} {size:>8}  {ref}".format(
+                address=str(module['module_core']).split()[0],
+                name=module['name'].string(),
+                size=str(module['core_size']),
+                ref=str(ref)))
+            source_list = module['source_list']
+            t = self._module_use_type.get_type().pointer()
+            entry = source_list['next']
+            first = True
+            while entry != source_list.address:
+                use = utils.container_of(entry, t, "source_list")
+                gdb.write("{separator}{name}".format(
+                    separator=" " if first else ",",
+                    name=use['source']['name'].string()))
+                first = False
+                entry = entry['next']
+            gdb.write("\n")
+LxLsmod()
diff --git a/scripts/gdb/linux/symbols.py b/scripts/gdb/linux/symbols.py
new file mode 100644
index 000000000000..cd5bea965d4e
--- /dev/null
+++ b/scripts/gdb/linux/symbols.py
@@ -0,0 +1,177 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  load kernel and module symbols
+#
+# Copyright (c) Siemens AG, 2011-2013
+#
+# Authors:
+#  Jan Kiszka <jan.kiszka@siemens.com>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+import gdb
+import os
+import re
+import string
+from linux import modules, utils
+if hasattr(gdb, 'Breakpoint'):
+    class LoadModuleBreakpoint(gdb.Breakpoint):
+        def __init__(self, spec, gdb_command):
+            super(LoadModuleBreakpoint, self).__init__(spec, internal=True)
+            self.silent = True
+            self.gdb_command = gdb_command
+        def stop(self):
+            module = gdb.parse_and_eval("mod")
+            module_name = module['name'].string()
+            cmd = self.gdb_command
+            # enforce update if object file is not found
+            cmd.module_files_updated = False
+            # Disable pagination while reporting symbol (re-)loading.
+            # The console input is blocked in this context so that we would
+            # get stuck waiting for the user to acknowledge paged output.
+            show_pagination = gdb.execute("show pagination", to_string=True)
+            pagination = show_pagination.endswith("on.\n")
+            gdb.execute("set pagination off")
+            if module_name in cmd.loaded_modules:
+                gdb.write("refreshing all symbols to reload module "
+                          "'{0}'\n".format(module_name))
+                cmd.load_all_symbols()
+            else:
+                cmd.load_module_symbols(module)
+            # restore pagination state
+            gdb.execute("set pagination %s" % ("on" if pagination else "off"))
+            return False
+class LxSymbols(gdb.Command):
+    """(Re-)load symbols of Linux kernel and currently loaded modules.
+The kernel (vmlinux) is taken from the current working directly. Modules (.ko)
+are scanned recursively, starting in the same directory. Optionally, the module
+search path can be extended by a space separated list of paths passed to the
+lx-symbols command."""
+    module_paths = []
+    module_files = []
+    module_files_updated = False
+    loaded_modules = []
+    breakpoint = None
+    def __init__(self):
+        super(LxSymbols, self).__init__("lx-symbols", gdb.COMMAND_FILES,
+                                        gdb.COMPLETE_FILENAME)
+    def _update_module_files(self):
+        self.module_files = []
+        for path in self.module_paths:
+            gdb.write("scanning for modules in {0}\n".format(path))
+            for root, dirs, files in os.walk(path):
+                for name in files:
+                    if name.endswith(".ko"):
+                        self.module_files.append(root + "/" + name)
+        self.module_files_updated = True
+    def _get_module_file(self, module_name):
+        module_pattern = ".*/{0}\.ko$".format(
+            module_name.replace("_", r"[_\-]"))
+        for name in self.module_files:
+            if re.match(module_pattern, name) and os.path.exists(name):
+                return name
+        return None
+    def _section_arguments(self, module):
+        try:
+            sect_attrs = module['sect_attrs'].dereference()
+        except gdb.error:
+            return ""
+        attrs = sect_attrs['attrs']
+        section_name_to_address = {
+            attrs[n]['name'].string() : attrs[n]['address']
+            for n in range(int(sect_attrs['nsections']))}
+        args = []
+        for section_name in [".data", ".data..read_mostly", ".rodata", ".bss"]:
+            address = section_name_to_address.get(section_name)
+            if address:
+                args.append(" -s {name} {addr}".format(
+                    name=section_name, addr=str(address)))
+        return "".join(args)
+    def load_module_symbols(self, module):
+        module_name = module['name'].string()
+        module_addr = str(module['module_core']).split()[0]
+        module_file = self._get_module_file(module_name)
+        if not module_file and not self.module_files_updated:
+            self._update_module_files()
+            module_file = self._get_module_file(module_name)
+        if module_file:
+            gdb.write("loading @{addr}: {filename}\n".format(
+                addr=module_addr, filename=module_file))
+            cmdline = "add-symbol-file {filename} {addr}{sections}".format(
+                filename=module_file,
+                addr=module_addr,
+                sections=self._section_arguments(module))
+            gdb.execute(cmdline, to_string=True)
+            if not module_name in self.loaded_modules:
+                self.loaded_modules.append(module_name)
+        else:
+            gdb.write("no module object found for '{0}'\n".format(module_name))
+    def load_all_symbols(self):
+        gdb.write("loading vmlinux\n")
+        # Dropping symbols will disable all breakpoints. So save their states
+        # and restore them afterward.
+        saved_states = []
+        if hasattr(gdb, 'breakpoints') and not gdb.breakpoints() is None:
+            for bp in gdb.breakpoints():
+                saved_states.append({'breakpoint': bp, 'enabled': bp.enabled})
+        # drop all current symbols and reload vmlinux
+        gdb.execute("symbol-file", to_string=True)
+        gdb.execute("symbol-file vmlinux")
+        self.loaded_modules = []
+        module_list = modules.module_list()
+        if not module_list:
+            gdb.write("no modules found\n")
+        else:
+            [self.load_module_symbols(module) for module in module_list]
+        for saved_state in saved_states:
+            saved_state['breakpoint'].enabled = saved_state['enabled']
+    def invoke(self, arg, from_tty):
+        self.module_paths = arg.split()
+        self.module_paths.append(os.getcwd())
+        # enforce update
+        self.module_files = []
+        self.module_files_updated = False
+        self.load_all_symbols()
+        if hasattr(gdb, 'Breakpoint'):
+            if not self.breakpoint is None:
+                self.breakpoint.delete()
+                self.breakpoint = None
+            self.breakpoint = LoadModuleBreakpoint(
+                "kernel/module.c:do_init_module", self)
+        else:
+            gdb.write("Note: symbol update on module loading not supported "
+                      "with this gdb version\n")
+LxSymbols()
diff --git a/scripts/gdb/linux/tasks.py b/scripts/gdb/linux/tasks.py
new file mode 100644
index 000000000000..e2037d9bb7eb
--- /dev/null
+++ b/scripts/gdb/linux/tasks.py
@@ -0,0 +1,100 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  task & thread tools
+#
+# Copyright (c) Siemens AG, 2011-2013
+#
+# Authors:
+#  Jan Kiszka <jan.kiszka@siemens.com>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+import gdb
+from linux import utils
+task_type = utils.CachedType("struct task_struct")
+def task_lists():
+    global task_type
+    task_ptr_type = task_type.get_type().pointer()
+    init_task = gdb.parse_and_eval("init_task").address
+    t = g = init_task
+    while True:
+        while True:
+            yield t
+            t = utils.container_of(t['thread_group']['next'],
+                                   task_ptr_type, "thread_group")
+            if t == g:
+                break
+        t = g = utils.container_of(g['tasks']['next'],
+                                   task_ptr_type, "tasks")
+        if t == init_task:
+            return
+def get_task_by_pid(pid):
+    for task in task_lists():
+        if int(task['pid']) == pid:
+            return task
+    return None
+class LxTaskByPidFunc(gdb.Function):
+    """Find Linux task by PID and return the task_struct variable.
+$lx_task_by_pid(PID): Given PID, iterate over all tasks of the target and
+return that task_struct variable which PID matches."""
+    def __init__(self):
+        super(LxTaskByPidFunc, self).__init__("lx_task_by_pid")
+    def invoke(self, pid):
+        task = get_task_by_pid(pid)
+        if task:
+            return task.dereference()
+        else:
+            raise gdb.GdbError("No task of PID " + str(pid))
+LxTaskByPidFunc()
+thread_info_type = utils.CachedType("struct thread_info")
+ia64_task_size = None
+def get_thread_info(task):
+    global thread_info_type
+    thread_info_ptr_type = thread_info_type.get_type().pointer()
+    if utils.is_target_arch("ia64"):
+        global ia64_task_size
+        if ia64_task_size is None:
+            ia64_task_size = gdb.parse_and_eval("sizeof(struct task_struct)")
+        thread_info_addr = task.address + ia64_task_size
+        thread_info = thread_info_addr.cast(thread_info_ptr_type)
+    else:
+        thread_info = task['stack'].cast(thread_info_ptr_type)
+    return thread_info.dereference()
+class LxThreadInfoFunc (gdb.Function):
+    """Calculate Linux thread_info from task variable.
+$lx_thread_info(TASK): Given TASK, return the corresponding thread_info
+variable."""
+    def __init__(self):
+        super(LxThreadInfoFunc, self).__init__("lx_thread_info")
+    def invoke(self, task):
+        return get_thread_info(task)
+LxThreadInfoFunc()
diff --git a/scripts/gdb/linux/utils.py b/scripts/gdb/linux/utils.py
new file mode 100644
index 000000000000..128c306db3ee
--- /dev/null
+++ b/scripts/gdb/linux/utils.py
@@ -0,0 +1,156 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  common utilities
+#
+# Copyright (c) Siemens AG, 2011-2013
+#
+# Authors:
+#  Jan Kiszka <jan.kiszka@siemens.com>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+import gdb
+class CachedType:
+    def __init__(self, name):
+        self._type = None
+        self._name = name
+    def _new_objfile_handler(self, event):
+        self._type = None
+        gdb.events.new_objfile.disconnect(self._new_objfile_handler)
+    def get_type(self):
+        if self._type is None:
+            self._type = gdb.lookup_type(self._name)
+            if self._type is None:
+                raise gdb.GdbError(
+                    "cannot resolve type '{0}'".format(self._name))
+            if hasattr(gdb, 'events') and hasattr(gdb.events, 'new_objfile'):
+                gdb.events.new_objfile.connect(self._new_objfile_handler)
+        return self._type
+long_type = CachedType("long")
+def get_long_type():
+    global long_type
+    return long_type.get_type()
+def offset_of(typeobj, field):
+    element = gdb.Value(0).cast(typeobj)
+    return int(str(element[field].address).split()[0], 16)
+def container_of(ptr, typeobj, member):
+    return (ptr.cast(get_long_type()) -
+            offset_of(typeobj, member)).cast(typeobj)
+class ContainerOf(gdb.Function):
+    """Return pointer to containing data structure.
+$container_of(PTR, "TYPE", "ELEMENT"): Given PTR, return a pointer to the
+data structure of the type TYPE in which PTR is the address of ELEMENT.
+Note that TYPE and ELEMENT have to be quoted as strings."""
+    def __init__(self):
+        super(ContainerOf, self).__init__("container_of")
+    def invoke(self, ptr, typename, elementname):
+        return container_of(ptr, gdb.lookup_type(typename.string()).pointer(),
+                            elementname.string())
+ContainerOf()
+BIG_ENDIAN = 0
+LITTLE_ENDIAN = 1
+target_endianness = None
+def get_target_endianness():
+    global target_endianness
+    if target_endianness is None:
+        endian = gdb.execute("show endian", to_string=True)
+        if "little endian" in endian:
+            target_endianness = LITTLE_ENDIAN
+        elif "big endian" in endian:
+            target_endianness = BIG_ENDIAN
+        else:
+            raise gdb.GdgError("unknown endianness '{0}'".format(str(endian)))
+    return target_endianness
+def read_u16(buffer):
+    if get_target_endianness() == LITTLE_ENDIAN:
+        return ord(buffer[0]) + (ord(buffer[1]) << 8)
+    else:
+        return ord(buffer[1]) + (ord(buffer[0]) << 8)
+def read_u32(buffer):
+    if get_target_endianness() == LITTLE_ENDIAN:
+        return read_u16(buffer[0:2]) + (read_u16(buffer[2:4]) << 16)
+    else:
+        return read_u16(buffer[2:4]) + (read_u16(buffer[0:2]) << 16)
+def read_u64(buffer):
+    if get_target_endianness() == LITTLE_ENDIAN:
+        return read_u32(buffer[0:4]) + (read_u32(buffer[4:8]) << 32)
+    else:
+        return read_u32(buffer[4:8]) + (read_u32(buffer[0:4]) << 32)
+target_arch = None
+def is_target_arch(arch):
+    if hasattr(gdb.Frame, 'architecture'):
+        return arch in gdb.newest_frame().architecture().name()
+    else:
+        global target_arch
+        if target_arch is None:
+            target_arch = gdb.execute("show architecture", to_string=True)
+        return arch in target_arch
+GDBSERVER_QEMU = 0
+GDBSERVER_KGDB = 1
+gdbserver_type = None
+def get_gdbserver_type():
+    def exit_handler(event):
+        global gdbserver_type
+        gdbserver_type = None
+        gdb.events.exited.disconnect(exit_handler)
+    def probe_qemu():
+        try:
+            return gdb.execute("monitor info version", to_string=True) != ""
+        except:
+            return False
+    def probe_kgdb():
+        try:
+            thread_info = gdb.execute("info thread 2", to_string=True)
+            return "shadowCPU0" in thread_info
+        except:
+            return False
+    global gdbserver_type
+    if gdbserver_type is None:
+        if probe_qemu():
+            gdbserver_type = GDBSERVER_QEMU
+        elif probe_kgdb():
+            gdbserver_type = GDBSERVER_KGDB
+        if not gdbserver_type is None and hasattr(gdb, 'events'):
+            gdb.events.exited.connect(exit_handler)
+    return gdbserver_type
diff --git a/scripts/gdb/vmlinux-gdb.py b/scripts/gdb/vmlinux-gdb.py
new file mode 100644
index 000000000000..48489285f119
--- /dev/null
+++ b/scripts/gdb/vmlinux-gdb.py
@@ -0,0 +1,30 @@
+#
+# gdb helper commands and functions for Linux kernel debugging
+#
+#  loader module
+#
+# Copyright (c) Siemens AG, 2012, 2013
+#
+# Authors:
+#  Jan Kiszka <jan.kiszka@siemens.com>
+#
+# This work is licensed under the terms of the GNU GPL version 2.
+#
+import os
+sys.path.insert(0, os.path.dirname(__file__) + "/scripts/gdb")
+try:
+    gdb.parse_and_eval("0")
+    gdb.execute("", to_string=True)
+except:
+    gdb.write("NOTE: gdb 7.2 or later required for Linux helper scripts to "
+              "work.\n")
+else:
+    import linux.utils
+    import linux.symbols
+    import linux.modules
+    import linux.dmesg
+    import linux.tasks
+    import linux.cpus
diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c
index f88d90f20228..28df18dd1147 100644
--- a/scripts/kconfig/confdata.c
+++ b/scripts/kconfig/confdata.c
@@ -59,6 +59,7 @@ static void conf_message(const char *fmt, ...)
        va_start(ap, fmt);
        if (conf_message_callback)
                conf_message_callback(fmt, ap);
+        va_end(ap);
 }
 const char *conf_get_configname(void)
diff --git a/scripts/kconfig/merge_config.sh b/scripts/kconfig/merge_config.sh
index 81b0c61bb9e2..2ab91b9b100d 100755
--- a/scripts/kconfig/merge_config.sh
+++ b/scripts/kconfig/merge_config.sh
@@ -77,6 +77,11 @@ while true; do
        esac
 done
+if [ "$#" -lt 2 ] ; then
+        usage
+        exit
+fi
 INITFILE=$1
 shift;
diff --git a/scripts/module-common.lds b/scripts/module-common.lds
index 0865b3e752be..73a2c7da0e55 100644
--- a/scripts/module-common.lds
+++ b/scripts/module-common.lds
@@ -6,14 +6,17 @@
 SECTIONS {
        /DISCARD/ : { *(.discard) }
-        __ksymtab               : { *(SORT(___ksymtab+*)) }
+        __ksymtab               0 : { *(SORT(___ksymtab+*)) }
-        __ksymtab_gpl           : { *(SORT(___ksymtab_gpl+*)) }
+        __ksymtab_gpl           0 : { *(SORT(___ksymtab_gpl+*)) }
-        __ksymtab_unused        : { *(SORT(___ksymtab_unused+*)) }
+        __ksymtab_unused        0 : { *(SORT(___ksymtab_unused+*)) }
-        __ksymtab_unused_gpl    : { *(SORT(___ksymtab_unused_gpl+*)) }
+        __ksymtab_unused_gpl    0 : { *(SORT(___ksymtab_unused_gpl+*)) }
-        __ksymtab_gpl_future    : { *(SORT(___ksymtab_gpl_future+*)) }
+        __ksymtab_gpl_future    0 : { *(SORT(___ksymtab_gpl_future+*)) }
-        __kcrctab               : { *(SORT(___kcrctab+*)) }
+        __kcrctab               0 : { *(SORT(___kcrctab+*)) }
-        __kcrctab_gpl           : { *(SORT(___kcrctab_gpl+*)) }
+        __kcrctab_gpl           0 : { *(SORT(___kcrctab_gpl+*)) }
-        __kcrctab_unused        : { *(SORT(___kcrctab_unused+*)) }
+        __kcrctab_unused        0 : { *(SORT(___kcrctab_unused+*)) }
-        __kcrctab_unused_gpl    : { *(SORT(___kcrctab_unused_gpl+*)) }
+        __kcrctab_unused_gpl    0 : { *(SORT(___kcrctab_unused_gpl+*)) }
-        __kcrctab_gpl_future    : { *(SORT(___kcrctab_gpl_future+*)) }
+        __kcrctab_gpl_future    0 : { *(SORT(___kcrctab_gpl_future+*)) }
+        . = ALIGN(8);
+        .init_array             0 : { *(SORT(.init_array.*)) *(.init_array) }
 }
diff --git a/scripts/package/builddeb b/scripts/package/builddeb
index 59726243c2eb..88dbf23b6970 100755
--- a/scripts/package/builddeb
+++ b/scripts/package/builddeb
@@ -217,9 +217,20 @@ else
 fi
 maintainer="$name <$email>"
+# Try to determine distribution
+if [ -n "$KDEB_CHANGELOG_DIST" ]; then
+        distribution=$KDEB_CHANGELOG_DIST
+elif distribution=$(lsb_release -cs 2>/dev/null) && [ -n "$distribution" ]; then
+        : # nothing to do in this case
+else
+        distribution="unstable"
+        echo >&2 "Using default distribution of 'unstable' in the changelog"
+        echo >&2 "Install lsb-release or set \$KDEB_CHANGELOG_DIST explicitly"
+fi
 # Generate a simple changelog template
 cat <<EOF > debian/changelog
-linux-upstream ($packageversion) unstable; urgency=low
+linux-upstream ($packageversion) $distribution; urgency=low
  * Custom built Linux kernel.
@@ -233,10 +244,10 @@ This is a packacked upstream version of the Linux kernel.
 The sources may be found at most Linux ftp sites, including:
 ftp://ftp.kernel.org/pub/linux/kernel
-Copyright: 1991 - 2009 Linus Torvalds and others.
+Copyright: 1991 - 2015 Linus Torvalds and others.
 The git repository for mainline kernel development is at:
-git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
+git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/scripts/recordmcount.pl b/scripts/recordmcount.pl
index 537c38ca2e1c..826470d7f000 100755
--- a/scripts/recordmcount.pl
+++ b/scripts/recordmcount.pl
@@ -242,8 +242,13 @@ if ($arch eq "x86_64") {
    $cc .= " -m32";
 } elsif ($arch eq "s390" && $bits == 64) {
-    $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_390_(PC|PLT)32DBL\\s+_mcount\\+0x2\$";
+    if ($cc =~ /-DCC_USING_HOTPATCH/) {
-    $mcount_adjust = -14;
+        $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*c0 04 00 00 00 00\\s*brcl\\s*0,[0-9a-f]+ <([^\+]*)>\$";
+        $mcount_adjust = 0;
+    } else {
+        $mcount_regex = "^\\s*([0-9a-fA-F]+):\\s*R_390_(PC|PLT)32DBL\\s+_mcount\\+0x2\$";
+        $mcount_adjust = -14;
+    }
    $alignment = 8;
    $type = ".quad";
    $ld .= " -m elf64_s390";