From a73da5a99a13b34e18f98c1ad0c327fdad000257 Mon Sep 17 00:00:00 2001 From: Waldemar Brodkorb Date: Tue, 26 Sep 2017 04:38:48 +0200 Subject: sample for SUN JavaStation --- target/linux/patches/2.6.32.70/new-gcc.patch | 186 +++++++++++++++++++++ .../linux/patches/2.6.32.70/no-extern-inline.patch | 30 ++++ target/linux/patches/2.6.32.70/perl-fix.patch | 12 ++ 3 files changed, 228 insertions(+) create mode 100644 target/linux/patches/2.6.32.70/new-gcc.patch create mode 100644 target/linux/patches/2.6.32.70/no-extern-inline.patch create mode 100644 target/linux/patches/2.6.32.70/perl-fix.patch (limited to 'target/linux/patches/2.6.32.70') diff --git a/target/linux/patches/2.6.32.70/new-gcc.patch b/target/linux/patches/2.6.32.70/new-gcc.patch new file mode 100644 index 000000000..3272a2fb3 --- /dev/null +++ b/target/linux/patches/2.6.32.70/new-gcc.patch @@ -0,0 +1,186 @@ +diff -Nur linux-2.6.32.70.orig/include/linux/compiler-gcc.h linux-2.6.32.70/include/linux/compiler-gcc.h +--- linux-2.6.32.70.orig/include/linux/compiler-gcc.h 2016-01-29 22:13:00.000000000 +0100 ++++ linux-2.6.32.70/include/linux/compiler-gcc.h 2017-09-26 03:48:39.644239377 +0200 +@@ -6,6 +6,10 @@ + * Common definitions for all gcc versions go here. + */ + ++#define GCC_VERSION (__GNUC__ * 10000 \ ++ + __GNUC_MINOR__ * 100 \ ++ + __GNUC_PATCHLEVEL__) ++ + + /* Optimization barrier */ + /* The "volatile" is due to gcc bugs */ +@@ -79,8 +83,167 @@ + #define noinline __attribute__((noinline)) + #define __attribute_const__ __attribute__((__const__)) + #define __maybe_unused __attribute__((unused)) ++#define __always_unused __attribute__((unused)) ++ ++/* gcc version specific checks */ ++ ++#if GCC_VERSION < 30200 ++# error Sorry, your compiler is too old - please upgrade it. ++#endif ++ ++#if GCC_VERSION < 30300 ++# define __used __attribute__((__unused__)) ++#else ++# define __used __attribute__((__used__)) ++#endif ++ ++#ifdef CONFIG_GCOV_KERNEL ++# if GCC_VERSION < 30400 ++# error "GCOV profiling support for gcc versions below 3.4 not included" ++# endif /* __GNUC_MINOR__ */ ++#endif /* CONFIG_GCOV_KERNEL */ ++ ++#if GCC_VERSION >= 30400 ++#define __must_check __attribute__((warn_unused_result)) ++#endif ++ ++#if GCC_VERSION >= 40000 ++ ++/* GCC 4.1.[01] miscompiles __weak */ ++#ifdef __KERNEL__ ++# if GCC_VERSION >= 40100 && GCC_VERSION <= 40101 ++# error Your version of gcc miscompiles the __weak directive ++# endif ++#endif ++ ++#define __used __attribute__((__used__)) ++#define __compiler_offsetof(a, b) \ ++ __builtin_offsetof(a, b) ++ ++#if GCC_VERSION >= 40100 && GCC_VERSION < 40600 ++# define __compiletime_object_size(obj) __builtin_object_size(obj, 0) ++#endif ++ ++#if GCC_VERSION >= 40300 ++/* Mark functions as cold. gcc will assume any path leading to a call ++ * to them will be unlikely. This means a lot of manual unlikely()s ++ * are unnecessary now for any paths leading to the usual suspects ++ * like BUG(), printk(), panic() etc. [but let's keep them for now for ++ * older compilers] ++ * ++ * Early snapshots of gcc 4.3 don't support this and we can't detect this ++ * in the preprocessor, but we can live with this because they're unreleased. ++ * Maketime probing would be overkill here. ++ * ++ * gcc also has a __attribute__((__hot__)) to move hot functions into ++ * a special section, but I don't see any sense in this right now in ++ * the kernel context ++ */ ++#define __cold __attribute__((__cold__)) ++ ++#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__) ++ ++#ifndef __CHECKER__ ++# define __compiletime_warning(message) __attribute__((warning(message))) ++# define __compiletime_error(message) __attribute__((error(message))) ++#endif /* __CHECKER__ */ ++#endif /* GCC_VERSION >= 40300 */ ++ ++#if GCC_VERSION >= 40500 ++/* ++ * Mark a position in code as unreachable. This can be used to ++ * suppress control flow warnings after asm blocks that transfer ++ * control elsewhere. ++ * ++ * Early snapshots of gcc 4.5 don't support this and we can't detect ++ * this in the preprocessor, but we can live with this because they're ++ * unreleased. Really, we need to have autoconf for the kernel. ++ */ ++#define unreachable() __builtin_unreachable() ++ ++/* Mark a function definition as prohibited from being cloned. */ ++#define __noclone __attribute__((__noclone__, __optimize__("no-tracer"))) ++ ++#endif /* GCC_VERSION >= 40500 */ ++ ++#if GCC_VERSION >= 40600 ++/* ++ * When used with Link Time Optimization, gcc can optimize away C functions or ++ * variables which are referenced only from assembly code. __visible tells the ++ * optimizer that something else uses this function or variable, thus preventing ++ * this. ++ */ ++#define __visible __attribute__((externally_visible)) ++#endif ++ ++ ++#if GCC_VERSION >= 40900 && !defined(__CHECKER__) ++/* ++ * __assume_aligned(n, k): Tell the optimizer that the returned ++ * pointer can be assumed to be k modulo n. The second argument is ++ * optional (default 0), so we use a variadic macro to make the ++ * shorthand. ++ * ++ * Beware: Do not apply this to functions which may return ++ * ERR_PTRs. Also, it is probably unwise to apply it to functions ++ * returning extra information in the low bits (but in that case the ++ * compiler should see some alignment anyway, when the return value is ++ * massaged by 'flags = ptr & 3; ptr &= ~3;'). ++ */ ++#define __assume_aligned(a, ...) __attribute__((__assume_aligned__(a, ## __VA_ARGS__))) ++#endif ++ ++/* ++ * GCC 'asm goto' miscompiles certain code sequences: ++ * ++ * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670 ++ * ++ * Work it around via a compiler barrier quirk suggested by Jakub Jelinek. ++ * ++ * (asm goto is automatically volatile - the naming reflects this.) ++ */ ++#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0) ++ ++#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP ++#if GCC_VERSION >= 40400 ++#define __HAVE_BUILTIN_BSWAP32__ ++#define __HAVE_BUILTIN_BSWAP64__ ++#endif ++#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600) ++#define __HAVE_BUILTIN_BSWAP16__ ++#endif ++#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */ ++ ++#if GCC_VERSION >= 70000 ++#define KASAN_ABI_VERSION 5 ++#elif GCC_VERSION >= 50000 ++#define KASAN_ABI_VERSION 4 ++#elif GCC_VERSION >= 40902 ++#define KASAN_ABI_VERSION 3 ++#endif ++ ++#if GCC_VERSION >= 40902 ++/* ++ * Tell the compiler that address safety instrumentation (KASAN) ++ * should not be applied to that function. ++ * Conflicts with inlining: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368 ++ */ ++#define __no_sanitize_address __attribute__((no_sanitize_address)) ++#endif ++ ++#endif /* gcc version >= 40000 specific checks */ ++ ++#if !defined(__noclone) ++#define __noclone /* not needed */ ++#endif ++ ++#if !defined(__no_sanitize_address) ++#define __no_sanitize_address ++#endif ++ ++/* ++ * A trick to suppress uninitialized variable warning without generating any ++ * code ++ */ ++#define uninitialized_var(x) x = x + +-#define __gcc_header(x) #x +-#define _gcc_header(x) __gcc_header(linux/compiler-gcc##x.h) +-#define gcc_header(x) _gcc_header(x) +-#include gcc_header(__GNUC__) diff --git a/target/linux/patches/2.6.32.70/no-extern-inline.patch b/target/linux/patches/2.6.32.70/no-extern-inline.patch new file mode 100644 index 000000000..092a6b1d7 --- /dev/null +++ b/target/linux/patches/2.6.32.70/no-extern-inline.patch @@ -0,0 +1,30 @@ +diff -Nur linux-2.6.32.70.orig/include/linux/inotify.h linux-2.6.32.70/include/linux/inotify.h +--- linux-2.6.32.70.orig/include/linux/inotify.h 2016-01-29 22:13:00.000000000 +0100 ++++ linux-2.6.32.70/include/linux/inotify.h 2017-09-26 04:19:21.883681676 +0200 +@@ -230,12 +230,12 @@ + { + } + +-extern inline int pin_inotify_watch(struct inotify_watch *watch) ++static inline int pin_inotify_watch(struct inotify_watch *watch) + { + return 0; + } + +-extern inline void unpin_inotify_watch(struct inotify_watch *watch) ++static inline void unpin_inotify_watch(struct inotify_watch *watch) + { + } + +diff -Nur linux-2.6.32.70.orig/include/linux/tty.h linux-2.6.32.70/include/linux/tty.h +--- linux-2.6.32.70.orig/include/linux/tty.h 2016-01-29 22:13:00.000000000 +0100 ++++ linux-2.6.32.70/include/linux/tty.h 2017-09-26 04:06:38.856051772 +0200 +@@ -478,7 +478,7 @@ + extern void tty_port_close_end(struct tty_port *port, struct tty_struct *tty); + extern void tty_port_close(struct tty_port *port, + struct tty_struct *tty, struct file *filp); +-extern inline int tty_port_users(struct tty_port *port) ++static inline int tty_port_users(struct tty_port *port) + { + return port->count + port->blocked_open; + } diff --git a/target/linux/patches/2.6.32.70/perl-fix.patch b/target/linux/patches/2.6.32.70/perl-fix.patch new file mode 100644 index 000000000..2de40e0e3 --- /dev/null +++ b/target/linux/patches/2.6.32.70/perl-fix.patch @@ -0,0 +1,12 @@ +diff -Nur linux-1d008423ab5fd12459f53342e4d17585ec63cfe4.orig/kernel/timeconst.pl linux-1d008423ab5fd12459f53342e4d17585ec63cfe4/kernel/timeconst.pl +--- linux-1d008423ab5fd12459f53342e4d17585ec63cfe4.orig/kernel/timeconst.pl 2016-12-22 18:05:10.000000000 +0100 ++++ linux-1d008423ab5fd12459f53342e4d17585ec63cfe4/kernel/timeconst.pl 2016-12-22 18:42:55.573173008 +0100 +@@ -370,7 +370,7 @@ + } + + @val = @{$canned_values{$hz}}; +- if (!defined(@val)) { ++ if (!@val) { + @val = compute_values($hz); + } + output($hz, @val); -- cgit v1.2.3