From: Sasha Levin Date: Fri, 23 Nov 2018 20:02:10 +0000 (-0500) Subject: patches for 4.14 X-Git-Tag: v3.18.127~24 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=24f45af0ae2b67cbcce537f0bc5c52058c629104;p=thirdparty%2Fkernel%2Fstable-queue.git patches for 4.14 Signed-off-by: Sasha Levin --- diff --git a/queue-4.14/acpi-watchdog-prefer-itco_wdt-always-when-wdat-table.patch b/queue-4.14/acpi-watchdog-prefer-itco_wdt-always-when-wdat-table.patch new file mode 100644 index 00000000000..7c8d51237de --- /dev/null +++ b/queue-4.14/acpi-watchdog-prefer-itco_wdt-always-when-wdat-table.patch @@ -0,0 +1,130 @@ +From 463f0a0cc20184b89c892e465d47b85d44aa35f0 Mon Sep 17 00:00:00 2001 +From: Mika Westerberg +Date: Tue, 22 May 2018 14:16:50 +0300 +Subject: ACPI / watchdog: Prefer iTCO_wdt always when WDAT table uses RTC SRAM + +[ Upstream commit 5a802a7a285c8877ca872e44eeb0f06afcb5212f ] + +After we added quirk for Lenovo Z50-70 it turns out there are at least +two more systems where WDAT table includes instructions accessing RTC +SRAM. Instead of quirking each system separately, look for such +instructions in the table and automatically prefer iTCO_wdt if found. + +Link: https://bugzilla.kernel.org/show_bug.cgi?id=199033 +Reported-by: Arnold Guy +Reported-by: Alois Nespor +Reported-by: Yury Pakin +Reported-by: Ihor Chyhin +Signed-off-by: Mika Westerberg +Acked-by: Guenter Roeck +Signed-off-by: Rafael J. Wysocki +Signed-off-by: Sasha Levin +--- + drivers/acpi/acpi_watchdog.c | 72 ++++++++++++++++++++++-------------- + 1 file changed, 45 insertions(+), 27 deletions(-) + +diff --git a/drivers/acpi/acpi_watchdog.c b/drivers/acpi/acpi_watchdog.c +index 4bde16fb97d8..95600309ce42 100644 +--- a/drivers/acpi/acpi_watchdog.c ++++ b/drivers/acpi/acpi_watchdog.c +@@ -12,35 +12,51 @@ + #define pr_fmt(fmt) "ACPI: watchdog: " fmt + + #include +-#include + #include + #include + + #include "internal.h" + +-static const struct dmi_system_id acpi_watchdog_skip[] = { +- { +- /* +- * On Lenovo Z50-70 there are two issues with the WDAT +- * table. First some of the instructions use RTC SRAM +- * to store persistent information. This does not work well +- * with Linux RTC driver. Second, more important thing is +- * that the instructions do not actually reset the system. +- * +- * On this particular system iTCO_wdt seems to work just +- * fine so we prefer that over WDAT for now. +- * +- * See also https://bugzilla.kernel.org/show_bug.cgi?id=199033. +- */ +- .ident = "Lenovo Z50-70", +- .matches = { +- DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), +- DMI_MATCH(DMI_PRODUCT_NAME, "20354"), +- DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Z50-70"), +- }, +- }, +- {} +-}; ++#ifdef CONFIG_RTC_MC146818_LIB ++#include ++ ++/* ++ * There are several systems where the WDAT table is accessing RTC SRAM to ++ * store persistent information. This does not work well with the Linux RTC ++ * driver so on those systems we skip WDAT driver and prefer iTCO_wdt ++ * instead. ++ * ++ * See also https://bugzilla.kernel.org/show_bug.cgi?id=199033. ++ */ ++static bool acpi_watchdog_uses_rtc(const struct acpi_table_wdat *wdat) ++{ ++ const struct acpi_wdat_entry *entries; ++ int i; ++ ++ entries = (struct acpi_wdat_entry *)(wdat + 1); ++ for (i = 0; i < wdat->entries; i++) { ++ const struct acpi_generic_address *gas; ++ ++ gas = &entries[i].register_region; ++ if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { ++ switch (gas->address) { ++ case RTC_PORT(0): ++ case RTC_PORT(1): ++ case RTC_PORT(2): ++ case RTC_PORT(3): ++ return true; ++ } ++ } ++ } ++ ++ return false; ++} ++#else ++static bool acpi_watchdog_uses_rtc(const struct acpi_table_wdat *wdat) ++{ ++ return false; ++} ++#endif + + static const struct acpi_table_wdat *acpi_watchdog_get_wdat(void) + { +@@ -50,9 +66,6 @@ static const struct acpi_table_wdat *acpi_watchdog_get_wdat(void) + if (acpi_disabled) + return NULL; + +- if (dmi_check_system(acpi_watchdog_skip)) +- return NULL; +- + status = acpi_get_table(ACPI_SIG_WDAT, 0, + (struct acpi_table_header **)&wdat); + if (ACPI_FAILURE(status)) { +@@ -60,6 +73,11 @@ static const struct acpi_table_wdat *acpi_watchdog_get_wdat(void) + return NULL; + } + ++ if (acpi_watchdog_uses_rtc(wdat)) { ++ pr_info("Skipping WDAT on this system because it uses RTC SRAM\n"); ++ return NULL; ++ } ++ + return wdat; + } + +-- +2.17.1 + diff --git a/queue-4.14/perf-machine-add-machine__is-to-identify-machine-arc.patch b/queue-4.14/perf-machine-add-machine__is-to-identify-machine-arc.patch new file mode 100644 index 00000000000..8b6f5af99bc --- /dev/null +++ b/queue-4.14/perf-machine-add-machine__is-to-identify-machine-arc.patch @@ -0,0 +1,115 @@ +From 1a51164f8834eb16ffe50583ed6740954cbbbc2f Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Wed, 21 Nov 2018 15:52:43 +0200 +Subject: perf machine: Add machine__is() to identify machine arch + +commit dbbd34a666ee117d0e39e71a47f38f02c4a5c698 upstream. + +Add a function to identify the machine architecture. + +Signed-off-by: Adrian Hunter +Tested-by: Jiri Olsa +Cc: Alexander Shishkin +Cc: Andi Kleen +Cc: Andy Lutomirski +Cc: Dave Hansen +Cc: H. Peter Anvin +Cc: Joerg Roedel +Cc: Peter Zijlstra +Cc: Thomas Gleixner +Cc: x86@kernel.org +Link: http://lkml.kernel.org/r/1526548928-20790-6-git-send-email-adrian.hunter@intel.com +Signed-off-by: Arnaldo Carvalho de Melo +Signed-off-by: Sasha Levin +--- + tools/perf/util/env.c | 19 +++++++++++++++++++ + tools/perf/util/env.h | 3 +++ + tools/perf/util/machine.c | 9 +++++++++ + tools/perf/util/machine.h | 2 ++ + 4 files changed, 33 insertions(+) + +diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c +index 6276b340f893..49f58921a968 100644 +--- a/tools/perf/util/env.c ++++ b/tools/perf/util/env.c +@@ -3,6 +3,7 @@ + #include "env.h" + #include "util.h" + #include ++#include + + struct perf_env perf_env; + +@@ -87,6 +88,24 @@ int perf_env__read_cpu_topology_map(struct perf_env *env) + return 0; + } + ++static int perf_env__read_arch(struct perf_env *env) ++{ ++ struct utsname uts; ++ ++ if (env->arch) ++ return 0; ++ ++ if (!uname(&uts)) ++ env->arch = strdup(uts.machine); ++ ++ return env->arch ? 0 : -ENOMEM; ++} ++ ++const char *perf_env__raw_arch(struct perf_env *env) ++{ ++ return env && !perf_env__read_arch(env) ? env->arch : "unknown"; ++} ++ + void cpu_cache_level__free(struct cpu_cache_level *cache) + { + free(cache->type); +diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h +index 1eb35b190b34..bd3869913907 100644 +--- a/tools/perf/util/env.h ++++ b/tools/perf/util/env.h +@@ -65,4 +65,7 @@ int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[]); + int perf_env__read_cpu_topology_map(struct perf_env *env); + + void cpu_cache_level__free(struct cpu_cache_level *cache); ++ ++const char *perf_env__raw_arch(struct perf_env *env); ++ + #endif /* __PERF_ENV_H */ +diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c +index bd5d5b5e2218..2af879693fbe 100644 +--- a/tools/perf/util/machine.c ++++ b/tools/perf/util/machine.c +@@ -2238,6 +2238,15 @@ int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid, + return 0; + } + ++/* ++ * Compares the raw arch string. N.B. see instead perf_env__arch() if a ++ * normalized arch is needed. ++ */ ++bool machine__is(struct machine *machine, const char *arch) ++{ ++ return machine && !strcmp(perf_env__raw_arch(machine->env), arch); ++} ++ + int machine__get_kernel_start(struct machine *machine) + { + struct map *map = machine__kernel_map(machine); +diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h +index d551aa80a59b..fbc5133fb27c 100644 +--- a/tools/perf/util/machine.h ++++ b/tools/perf/util/machine.h +@@ -169,6 +169,8 @@ static inline bool machine__is_host(struct machine *machine) + return machine ? machine->pid == HOST_KERNEL_ID : false; + } + ++bool machine__is(struct machine *machine, const char *arch); ++ + struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid); + struct thread *machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid); + +-- +2.17.1 + diff --git a/queue-4.14/perf-machine-add-nr_cpus_avail.patch b/queue-4.14/perf-machine-add-nr_cpus_avail.patch new file mode 100644 index 00000000000..09579760bf2 --- /dev/null +++ b/queue-4.14/perf-machine-add-nr_cpus_avail.patch @@ -0,0 +1,101 @@ +From 49e900c28d3f9e5a62cf3102968af29cf8f805ca Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Wed, 21 Nov 2018 15:52:45 +0200 +Subject: perf machine: Add nr_cpus_avail() + +commit 9cecca325ea879c84fcd31a5e609a514c1a1dbd1 upstream. + +Add a function to return the number of the machine's available CPUs. + +Signed-off-by: Adrian Hunter +Cc: Alexander Shishkin +Cc: Andi Kleen +Cc: Andy Lutomirski +Cc: Dave Hansen +Cc: H. Peter Anvin +Cc: Jiri Olsa +Cc: Joerg Roedel +Cc: Peter Zijlstra +Cc: Thomas Gleixner +Cc: x86@kernel.org +Link: http://lkml.kernel.org/r/1526986485-6562-5-git-send-email-adrian.hunter@intel.com +Signed-off-by: Arnaldo Carvalho de Melo +Signed-off-by: Sasha Levin +--- + tools/perf/util/env.c | 13 +++++++++++++ + tools/perf/util/env.h | 1 + + tools/perf/util/machine.c | 5 +++++ + tools/perf/util/machine.h | 1 + + 4 files changed, 20 insertions(+) + +diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c +index 49f58921a968..b492cb974aa0 100644 +--- a/tools/perf/util/env.c ++++ b/tools/perf/util/env.c +@@ -101,11 +101,24 @@ static int perf_env__read_arch(struct perf_env *env) + return env->arch ? 0 : -ENOMEM; + } + ++static int perf_env__read_nr_cpus_avail(struct perf_env *env) ++{ ++ if (env->nr_cpus_avail == 0) ++ env->nr_cpus_avail = cpu__max_present_cpu(); ++ ++ return env->nr_cpus_avail ? 0 : -ENOENT; ++} ++ + const char *perf_env__raw_arch(struct perf_env *env) + { + return env && !perf_env__read_arch(env) ? env->arch : "unknown"; + } + ++int perf_env__nr_cpus_avail(struct perf_env *env) ++{ ++ return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0; ++} ++ + void cpu_cache_level__free(struct cpu_cache_level *cache) + { + free(cache->type); +diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h +index bd3869913907..9aace8452751 100644 +--- a/tools/perf/util/env.h ++++ b/tools/perf/util/env.h +@@ -67,5 +67,6 @@ int perf_env__read_cpu_topology_map(struct perf_env *env); + void cpu_cache_level__free(struct cpu_cache_level *cache); + + const char *perf_env__raw_arch(struct perf_env *env); ++int perf_env__nr_cpus_avail(struct perf_env *env); + + #endif /* __PERF_ENV_H */ +diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c +index af18c3d55642..78aa1c5f19ca 100644 +--- a/tools/perf/util/machine.c ++++ b/tools/perf/util/machine.c +@@ -2247,6 +2247,11 @@ bool machine__is(struct machine *machine, const char *arch) + return machine && !strcmp(perf_env__raw_arch(machine->env), arch); + } + ++int machine__nr_cpus_avail(struct machine *machine) ++{ ++ return machine ? perf_env__nr_cpus_avail(machine->env) : 0; ++} ++ + int machine__get_kernel_start(struct machine *machine) + { + struct map *map = machine__kernel_map(machine); +diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h +index fbc5133fb27c..245743d9ce63 100644 +--- a/tools/perf/util/machine.h ++++ b/tools/perf/util/machine.h +@@ -170,6 +170,7 @@ static inline bool machine__is_host(struct machine *machine) + } + + bool machine__is(struct machine *machine, const char *arch); ++int machine__nr_cpus_avail(struct machine *machine); + + struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid); + struct thread *machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid); +-- +2.17.1 + diff --git a/queue-4.14/perf-machine-workaround-missing-maps-for-x86-pti-ent.patch b/queue-4.14/perf-machine-workaround-missing-maps-for-x86-pti-ent.patch new file mode 100644 index 00000000000..65fc5bf1d64 --- /dev/null +++ b/queue-4.14/perf-machine-workaround-missing-maps-for-x86-pti-ent.patch @@ -0,0 +1,191 @@ +From 98b4c8d3e0302ccaa377c1e589a55ac7206e59bd Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Wed, 21 Nov 2018 15:52:46 +0200 +Subject: perf machine: Workaround missing maps for x86 PTI entry trampolines + +commit 4d99e4136580d178e3523281a820be17bf814bf8 upstream. + +On x86_64 the PTI entry trampolines are not in the kernel map created by +perf tools. That results in the addresses having no symbols and prevents +annotation. It also causes Intel PT to have decoding errors at the +trampoline addresses. + +Workaround that by creating maps for the trampolines. + +At present the kernel does not export information revealing where the +trampolines are. Until that happens, the addresses are hardcoded. + +Signed-off-by: Adrian Hunter +Cc: Alexander Shishkin +Cc: Andi Kleen +Cc: Andy Lutomirski +Cc: Dave Hansen +Cc: H. Peter Anvin +Cc: Jiri Olsa +Cc: Joerg Roedel +Cc: Peter Zijlstra +Cc: Thomas Gleixner +Cc: x86@kernel.org +Link: http://lkml.kernel.org/r/1526986485-6562-6-git-send-email-adrian.hunter@intel.com +Signed-off-by: Arnaldo Carvalho de Melo +Signed-off-by: Sasha Levin +--- + tools/perf/util/machine.c | 96 +++++++++++++++++++++++++++++++++++++++ + tools/perf/util/machine.h | 3 ++ + tools/perf/util/symbol.c | 12 +++-- + 3 files changed, 106 insertions(+), 5 deletions(-) + +diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c +index 78aa1c5f19ca..968fd0454e6b 100644 +--- a/tools/perf/util/machine.c ++++ b/tools/perf/util/machine.c +@@ -818,6 +818,102 @@ static int machine__get_running_kernel_start(struct machine *machine, + return 0; + } + ++/* Kernel-space maps for symbols that are outside the main kernel map and module maps */ ++struct extra_kernel_map { ++ u64 start; ++ u64 end; ++ u64 pgoff; ++}; ++ ++static int machine__create_extra_kernel_map(struct machine *machine, ++ struct dso *kernel, ++ struct extra_kernel_map *xm) ++{ ++ struct kmap *kmap; ++ struct map *map; ++ ++ map = map__new2(xm->start, kernel, MAP__FUNCTION); ++ if (!map) ++ return -1; ++ ++ map->end = xm->end; ++ map->pgoff = xm->pgoff; ++ ++ kmap = map__kmap(map); ++ ++ kmap->kmaps = &machine->kmaps; ++ ++ map_groups__insert(&machine->kmaps, map); ++ ++ pr_debug2("Added extra kernel map %" PRIx64 "-%" PRIx64 "\n", ++ map->start, map->end); ++ ++ map__put(map); ++ ++ return 0; ++} ++ ++static u64 find_entry_trampoline(struct dso *dso) ++{ ++ /* Duplicates are removed so lookup all aliases */ ++ const char *syms[] = { ++ "_entry_trampoline", ++ "__entry_trampoline_start", ++ "entry_SYSCALL_64_trampoline", ++ }; ++ struct symbol *sym = dso__first_symbol(dso, MAP__FUNCTION); ++ unsigned int i; ++ ++ for (; sym; sym = dso__next_symbol(sym)) { ++ if (sym->binding != STB_GLOBAL) ++ continue; ++ for (i = 0; i < ARRAY_SIZE(syms); i++) { ++ if (!strcmp(sym->name, syms[i])) ++ return sym->start; ++ } ++ } ++ ++ return 0; ++} ++ ++/* ++ * These values can be used for kernels that do not have symbols for the entry ++ * trampolines in kallsyms. ++ */ ++#define X86_64_CPU_ENTRY_AREA_PER_CPU 0xfffffe0000000000ULL ++#define X86_64_CPU_ENTRY_AREA_SIZE 0x2c000 ++#define X86_64_ENTRY_TRAMPOLINE 0x6000 ++ ++/* Map x86_64 PTI entry trampolines */ ++int machine__map_x86_64_entry_trampolines(struct machine *machine, ++ struct dso *kernel) ++{ ++ u64 pgoff = find_entry_trampoline(kernel); ++ int nr_cpus_avail, cpu; ++ ++ if (!pgoff) ++ return 0; ++ ++ nr_cpus_avail = machine__nr_cpus_avail(machine); ++ ++ /* Add a 1 page map for each CPU's entry trampoline */ ++ for (cpu = 0; cpu < nr_cpus_avail; cpu++) { ++ u64 va = X86_64_CPU_ENTRY_AREA_PER_CPU + ++ cpu * X86_64_CPU_ENTRY_AREA_SIZE + ++ X86_64_ENTRY_TRAMPOLINE; ++ struct extra_kernel_map xm = { ++ .start = va, ++ .end = va + page_size, ++ .pgoff = pgoff, ++ }; ++ ++ if (machine__create_extra_kernel_map(machine, kernel, &xm) < 0) ++ return -1; ++ } ++ ++ return 0; ++} ++ + int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel) + { + int type; +diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h +index 245743d9ce63..13041b036a5b 100644 +--- a/tools/perf/util/machine.h ++++ b/tools/perf/util/machine.h +@@ -266,4 +266,7 @@ int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid, + */ + char *machine__resolve_kernel_addr(void *vmachine, unsigned long long *addrp, char **modp); + ++int machine__map_x86_64_entry_trampolines(struct machine *machine, ++ struct dso *kernel); ++ + #endif /* __PERF_MACHINE_H */ +diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c +index ec40e47aa198..3936f69f385c 100644 +--- a/tools/perf/util/symbol.c ++++ b/tools/perf/util/symbol.c +@@ -1513,20 +1513,22 @@ int dso__load(struct dso *dso, struct map *map) + goto out; + } + ++ if (map->groups && map->groups->machine) ++ machine = map->groups->machine; ++ else ++ machine = NULL; ++ + if (dso->kernel) { + if (dso->kernel == DSO_TYPE_KERNEL) + ret = dso__load_kernel_sym(dso, map); + else if (dso->kernel == DSO_TYPE_GUEST_KERNEL) + ret = dso__load_guest_kernel_sym(dso, map); + ++ if (machine__is(machine, "x86_64")) ++ machine__map_x86_64_entry_trampolines(machine, dso); + goto out; + } + +- if (map->groups && map->groups->machine) +- machine = map->groups->machine; +- else +- machine = NULL; +- + dso->adjust_symbols = 0; + + if (perfmap) { +-- +2.17.1 + diff --git a/queue-4.14/perf-test-code-reading-fix-perf_env-setup-for-pti-en.patch b/queue-4.14/perf-test-code-reading-fix-perf_env-setup-for-pti-en.patch new file mode 100644 index 00000000000..3941003456f --- /dev/null +++ b/queue-4.14/perf-test-code-reading-fix-perf_env-setup-for-pti-en.patch @@ -0,0 +1,38 @@ +From c9ee2c9bcbbdfc9aa1cff87d6a7c0121ba6f08e9 Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Wed, 21 Nov 2018 15:52:47 +0200 +Subject: perf test code-reading: Fix perf_env setup for PTI entry trampolines + +commit f6c66d73bb8192d357bb5fb8cd5826920f811d8c upstream. + +The "Object code reading" test will not create maps for the PTI entry +trampolines unless the machine environment exists to show that the arch is +x86_64. + +Signed-off-by: Adrian Hunter +Reported-by: Arnaldo Carvalho de Melo +Tested-by: Arnaldo Carvalho de Melo +Cc: Jiri Olsa +Link: http://lkml.kernel.org/r/1528183800-21577-1-git-send-email-adrian.hunter@intel.com +[ split from a larger patch ] +Signed-off-by: Arnaldo Carvalho de Melo +Signed-off-by: Sasha Levin +--- + tools/perf/tests/code-reading.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/tools/perf/tests/code-reading.c b/tools/perf/tests/code-reading.c +index fcc8984bc329..acad8ba06d77 100644 +--- a/tools/perf/tests/code-reading.c ++++ b/tools/perf/tests/code-reading.c +@@ -527,6 +527,7 @@ static int do_test_code_reading(bool try_kcore) + pid = getpid(); + + machine = machine__new_host(); ++ machine->env = &perf_env; + + ret = machine__create_kernel_maps(machine); + if (ret < 0) { +-- +2.17.1 + diff --git a/queue-4.14/perf-tools-fix-kernel_start-for-pti-on-x86.patch b/queue-4.14/perf-tools-fix-kernel_start-for-pti-on-x86.patch new file mode 100644 index 00000000000..c526cc05977 --- /dev/null +++ b/queue-4.14/perf-tools-fix-kernel_start-for-pti-on-x86.patch @@ -0,0 +1,49 @@ +From 5bf8be6aeee9116915703769070dd4325fff5a4e Mon Sep 17 00:00:00 2001 +From: Adrian Hunter +Date: Wed, 21 Nov 2018 15:52:44 +0200 +Subject: perf tools: Fix kernel_start for PTI on x86 + +commit 19422a9f2a3be7f3a046285ffae4cbb571aa853a upstream. + +On x86_64, PTI entry trampolines are less than the start of kernel text, +but still above 2^63. So leave kernel_start = 1ULL << 63 for x86_64. + +Signed-off-by: Adrian Hunter +Tested-by: Jiri Olsa +Cc: Alexander Shishkin +Cc: Andi Kleen +Cc: Andy Lutomirski +Cc: Dave Hansen +Cc: H. Peter Anvin +Cc: Joerg Roedel +Cc: Peter Zijlstra +Cc: Thomas Gleixner +Cc: x86@kernel.org +Link: http://lkml.kernel.org/r/1526548928-20790-7-git-send-email-adrian.hunter@intel.com +Signed-off-by: Arnaldo Carvalho de Melo +Signed-off-by: Sasha Levin +--- + tools/perf/util/machine.c | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c +index 2af879693fbe..af18c3d55642 100644 +--- a/tools/perf/util/machine.c ++++ b/tools/perf/util/machine.c +@@ -2263,7 +2263,12 @@ int machine__get_kernel_start(struct machine *machine) + machine->kernel_start = 1ULL << 63; + if (map) { + err = map__load(map); +- if (!err) ++ /* ++ * On x86_64, PTI entry trampolines are less than the ++ * start of kernel text, but still above 2^63. So leave ++ * kernel_start = 1ULL << 63 for x86_64. ++ */ ++ if (!err && !machine__is(machine, "x86_64")) + machine->kernel_start = map->start; + } + return err; +-- +2.17.1 + diff --git a/queue-4.14/series b/queue-4.14/series index 37ca6650353..1ec9a78d007 100644 --- a/queue-4.14/series +++ b/queue-4.14/series @@ -37,3 +37,11 @@ qed-fix-memory-entry-leak-in-qed_init_sp_request.patch qed-fix-blocking-unlimited-spq-entries-leak.patch qed-fix-potential-memory-corruption.patch net-stmmac-fix-rx-packet-size-8191.patch +zram-close-udev-startup-race-condition-as-default-gr.patch +sunrpc-drop-pointless-static-qualifier-in-xdr_get_ne.patch +acpi-watchdog-prefer-itco_wdt-always-when-wdat-table.patch +perf-machine-add-machine__is-to-identify-machine-arc.patch +perf-tools-fix-kernel_start-for-pti-on-x86.patch +perf-machine-add-nr_cpus_avail.patch +perf-machine-workaround-missing-maps-for-x86-pti-ent.patch +perf-test-code-reading-fix-perf_env-setup-for-pti-en.patch diff --git a/queue-4.14/sunrpc-drop-pointless-static-qualifier-in-xdr_get_ne.patch b/queue-4.14/sunrpc-drop-pointless-static-qualifier-in-xdr_get_ne.patch new file mode 100644 index 00000000000..d70eaafaf01 --- /dev/null +++ b/queue-4.14/sunrpc-drop-pointless-static-qualifier-in-xdr_get_ne.patch @@ -0,0 +1,35 @@ +From b210beece7840fc9a7b37e18671029c4c4541d7f Mon Sep 17 00:00:00 2001 +From: YueHaibing +Date: Thu, 8 Nov 2018 02:04:57 +0000 +Subject: SUNRPC: drop pointless static qualifier in + xdr_get_next_encode_buffer() + +[ Upstream commit 025911a5f4e36955498ed50806ad1b02f0f76288 ] + +There is no need to have the '__be32 *p' variable static since new value +always be assigned before use it. + +Signed-off-by: YueHaibing +Cc: stable@vger.kernel.org +Signed-off-by: J. Bruce Fields +Signed-off-by: Sasha Levin +--- + net/sunrpc/xdr.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c +index 13695ba8fc54..4f382805eb9c 100644 +--- a/net/sunrpc/xdr.c ++++ b/net/sunrpc/xdr.c +@@ -512,7 +512,7 @@ EXPORT_SYMBOL_GPL(xdr_commit_encode); + static __be32 *xdr_get_next_encode_buffer(struct xdr_stream *xdr, + size_t nbytes) + { +- static __be32 *p; ++ __be32 *p; + int space_left; + int frag1bytes, frag2bytes; + +-- +2.17.1 + diff --git a/queue-4.14/zram-close-udev-startup-race-condition-as-default-gr.patch b/queue-4.14/zram-close-udev-startup-race-condition-as-default-gr.patch new file mode 100644 index 00000000000..0a478950764 --- /dev/null +++ b/queue-4.14/zram-close-udev-startup-race-condition-as-default-gr.patch @@ -0,0 +1,95 @@ +From ef4887ce993c8008deb82d2cbfa950720046239a Mon Sep 17 00:00:00 2001 +From: Minchan Kim +Date: Fri, 23 Nov 2018 15:25:50 +0900 +Subject: zram: close udev startup race condition as default groups + +commit fef912bf860e upstream. +commit 98af4d4df889 upstream. + +I got a report from Howard Chen that he saw zram and sysfs race(ie, +zram block device file is created but sysfs for it isn't yet) +when he tried to create new zram devices via hotadd knob. + +v4.20 kernel fixes it by [1, 2] but it's too large size to merge +into -stable so this patch fixes the problem by registering defualt +group by Greg KH's approach[3]. + +This patch should be applied to every stable tree [3.16+] currently +existing from kernel.org because the problem was introduced at 2.6.37 +by [4]. + +[1] fef912bf860e, block: genhd: add 'groups' argument to device_add_disk +[2] 98af4d4df889, zram: register default groups with device_add_disk() +[3] http://kroah.com/log/blog/2013/06/26/how-to-create-a-sysfs-file-correctly/ +[4] 33863c21e69e9, Staging: zram: Replace ioctls with sysfs interface + +Cc: Sergey Senozhatsky +Cc: Hannes Reinecke +Tested-by: Howard Chen +Signed-off-by: Minchan Kim +Signed-off-by: Sasha Levin +--- + drivers/block/zram/zram_drv.c | 26 ++++++-------------------- + 1 file changed, 6 insertions(+), 20 deletions(-) + +diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c +index 1e2648e4c286..27b202c64c84 100644 +--- a/drivers/block/zram/zram_drv.c ++++ b/drivers/block/zram/zram_drv.c +@@ -1491,6 +1491,11 @@ static const struct attribute_group zram_disk_attr_group = { + .attrs = zram_disk_attrs, + }; + ++static const struct attribute_group *zram_disk_attr_groups[] = { ++ &zram_disk_attr_group, ++ NULL, ++}; ++ + /* + * Allocate and initialize new zram device. the function returns + * '>= 0' device_id upon success, and negative value otherwise. +@@ -1568,23 +1573,14 @@ static int zram_add(void) + if (ZRAM_LOGICAL_BLOCK_SIZE == PAGE_SIZE) + blk_queue_max_write_zeroes_sectors(zram->disk->queue, UINT_MAX); + ++ disk_to_dev(zram->disk)->groups = zram_disk_attr_groups; + add_disk(zram->disk); + +- ret = sysfs_create_group(&disk_to_dev(zram->disk)->kobj, +- &zram_disk_attr_group); +- if (ret < 0) { +- pr_err("Error creating sysfs group for device %d\n", +- device_id); +- goto out_free_disk; +- } + strlcpy(zram->compressor, default_compressor, sizeof(zram->compressor)); + + pr_info("Added device: %s\n", zram->disk->disk_name); + return device_id; + +-out_free_disk: +- del_gendisk(zram->disk); +- put_disk(zram->disk); + out_free_queue: + blk_cleanup_queue(queue); + out_free_idr: +@@ -1612,16 +1608,6 @@ static int zram_remove(struct zram *zram) + zram->claim = true; + mutex_unlock(&bdev->bd_mutex); + +- /* +- * Remove sysfs first, so no one will perform a disksize +- * store while we destroy the devices. This also helps during +- * hot_remove -- zram_reset_device() is the last holder of +- * ->init_lock, no later/concurrent disksize_store() or any +- * other sysfs handlers are possible. +- */ +- sysfs_remove_group(&disk_to_dev(zram->disk)->kobj, +- &zram_disk_attr_group); +- + /* Make sure all the pending I/O are finished */ + fsync_bdev(bdev); + zram_reset_device(zram); +-- +2.17.1 +