commit: a481927cb9e7dd1d92cec3fda3662f4b293d4518 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Tue May 24 11:58:27 2016 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Tue May 24 11:58:27 2016 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=a481927c
Linux patch 3.12.60 0000_README | 4 + 1059_linux-3.12.60.patch | 2460 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2464 insertions(+) diff --git a/0000_README b/0000_README index fdbff05..b2378f8 100644 --- a/0000_README +++ b/0000_README @@ -278,6 +278,10 @@ Patch: 1058_linux-3.12.59.patch From: http://www.kernel.org Desc: Linux 3.12.59 +Patch: 1059_linux-3.12.60.patch +From: http://www.kernel.org +Desc: Linux 3.12.60 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1059_linux-3.12.60.patch b/1059_linux-3.12.60.patch new file mode 100644 index 0000000..9d9f893 --- /dev/null +++ b/1059_linux-3.12.60.patch @@ -0,0 +1,2460 @@ +diff --git a/MAINTAINERS b/MAINTAINERS +index 44881abcfb06..b3233331dc0d 100644 +--- a/MAINTAINERS ++++ b/MAINTAINERS +@@ -3165,8 +3165,8 @@ F: Documentation/x86/efi-stub.txt + F: arch/ia64/kernel/efi.c + F: arch/x86/boot/compressed/eboot.[ch] + F: arch/x86/include/asm/efi.h +-F: arch/x86/platform/efi/* +-F: drivers/firmware/efi/* ++F: arch/x86/platform/efi/ ++F: drivers/firmware/efi/ + F: include/linux/efi*.h + + EFI VARIABLE FILESYSTEM +diff --git a/Makefile b/Makefile +index d683fdba9e8a..8dedf316dd48 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 3 + PATCHLEVEL = 12 +-SUBLEVEL = 59 ++SUBLEVEL = 60 + EXTRAVERSION = + NAME = One Giant Leap for Frogkind + +diff --git a/arch/arm/mach-omap2/cpuidle34xx.c b/arch/arm/mach-omap2/cpuidle34xx.c +index e18709d3b95d..38e1bdcaf015 100644 +--- a/arch/arm/mach-omap2/cpuidle34xx.c ++++ b/arch/arm/mach-omap2/cpuidle34xx.c +@@ -34,6 +34,7 @@ + #include "pm.h" + #include "control.h" + #include "common.h" ++#include "soc.h" + + /* Mach specific information to be recorded in the C-state driver_data */ + struct omap3_idle_statedata { +@@ -322,6 +323,69 @@ static struct cpuidle_driver omap3_idle_driver = { + .safe_state_index = 0, + }; + ++/* ++ * Numbers based on measurements made in October 2009 for PM optimized kernel ++ * with CPU freq enabled on device Nokia N900. Assumes OPP2 (main idle OPP, ++ * and worst case latencies). ++ */ ++static struct cpuidle_driver omap3430_idle_driver = { ++ .name = "omap3430_idle", ++ .owner = THIS_MODULE, ++ .states = { ++ { ++ .enter = omap3_enter_idle_bm, ++ .exit_latency = 110 + 162, ++ .target_residency = 5, ++ .name = "C1", ++ .desc = "MPU ON + CORE ON", ++ }, ++ { ++ .enter = omap3_enter_idle_bm, ++ .exit_latency = 106 + 180, ++ .target_residency = 309, ++ .name = "C2", ++ .desc = "MPU ON + CORE ON", ++ }, ++ { ++ .enter = omap3_enter_idle_bm, ++ .exit_latency = 107 + 410, ++ .target_residency = 46057, ++ .name = "C3", ++ .desc = "MPU RET + CORE ON", ++ }, ++ { ++ .enter = omap3_enter_idle_bm, ++ .exit_latency = 121 + 3374, ++ .target_residency = 46057, ++ .name = "C4", ++ .desc = "MPU OFF + CORE ON", ++ }, ++ { ++ .enter = omap3_enter_idle_bm, ++ .exit_latency = 855 + 1146, ++ .target_residency = 46057, ++ .name = "C5", ++ .desc = "MPU RET + CORE RET", ++ }, ++ { ++ .enter = omap3_enter_idle_bm, ++ .exit_latency = 7580 + 4134, ++ .target_residency = 484329, ++ .name = "C6", ++ .desc = "MPU OFF + CORE RET", ++ }, ++ { ++ .enter = omap3_enter_idle_bm, ++ .exit_latency = 7505 + 15274, ++ .target_residency = 484329, ++ .name = "C7", ++ .desc = "MPU OFF + CORE OFF", ++ }, ++ }, ++ .state_count = ARRAY_SIZE(omap3_idle_data), ++ .safe_state_index = 0, ++}; ++ + /* Public functions */ + + /** +@@ -340,5 +404,8 @@ int __init omap3_idle_init(void) + if (!mpu_pd || !core_pd || !per_pd || !cam_pd) + return -ENODEV; + +- return cpuidle_register(&omap3_idle_driver, NULL); ++ if (cpu_is_omap3430()) ++ return cpuidle_register(&omap3430_idle_driver, NULL); ++ else ++ return cpuidle_register(&omap3_idle_driver, NULL); + } +diff --git a/arch/arm/mach-omap2/omap_hwmod.c b/arch/arm/mach-omap2/omap_hwmod.c +index 68a9bec32c9e..407d2e3791c3 100644 +--- a/arch/arm/mach-omap2/omap_hwmod.c ++++ b/arch/arm/mach-omap2/omap_hwmod.c +@@ -1435,9 +1435,7 @@ static void _enable_sysc(struct omap_hwmod *oh) + (sf & SYSC_HAS_CLOCKACTIVITY)) + _set_clockactivity(oh, oh->class->sysc->clockact, &v); + +- /* If the cached value is the same as the new value, skip the write */ +- if (oh->_sysc_cache != v) +- _write_sysconfig(v, oh); ++ _write_sysconfig(v, oh); + + /* + * Set the autoidle bit only after setting the smartidle bit +@@ -1500,7 +1498,9 @@ static void _idle_sysc(struct omap_hwmod *oh) + _set_master_standbymode(oh, idlemode, &v); + } + +- _write_sysconfig(v, oh); ++ /* If the cached value is the same as the new value, skip the write */ ++ if (oh->_sysc_cache != v) ++ _write_sysconfig(v, oh); + } + + /** +diff --git a/arch/arm/mach-omap2/sleep34xx.S b/arch/arm/mach-omap2/sleep34xx.S +index d1dedc8195ed..eafd120b53f1 100644 +--- a/arch/arm/mach-omap2/sleep34xx.S ++++ b/arch/arm/mach-omap2/sleep34xx.S +@@ -203,23 +203,8 @@ save_context_wfi: + */ + ldr r1, kernel_flush + blx r1 +- /* +- * The kernel doesn't interwork: v7_flush_dcache_all in particluar will +- * always return in Thumb state when CONFIG_THUMB2_KERNEL is enabled. +- * This sequence switches back to ARM. Note that .align may insert a +- * nop: bx pc needs to be word-aligned in order to work. +- */ +- THUMB( .thumb ) +- THUMB( .align ) +- THUMB( bx pc ) +- THUMB( nop ) +- .arm +- + b omap3_do_wfi +- +-/* +- * Local variables +- */ ++ENDPROC(omap34xx_cpu_suspend) + omap3_do_wfi_sram_addr: + .word omap3_do_wfi_sram + kernel_flush: +@@ -364,10 +349,7 @@ exit_nonoff_modes: + * =================================== + */ + ldmfd sp!, {r4 - r11, pc} @ restore regs and return +- +-/* +- * Local variables +- */ ++ENDPROC(omap3_do_wfi) + sdrc_power: + .word SDRC_POWER_V + cm_idlest1_core: +diff --git a/arch/arm/mach-socfpga/headsmp.S b/arch/arm/mach-socfpga/headsmp.S +index 95c115d8b5ee..b143f946bb79 100644 +--- a/arch/arm/mach-socfpga/headsmp.S ++++ b/arch/arm/mach-socfpga/headsmp.S +@@ -11,6 +11,7 @@ + #include <linux/init.h> + + .arch armv7-a ++ .arm + + ENTRY(secondary_trampoline) + movw r2, #:lower16:cpu1start_addr +diff --git a/arch/powerpc/include/uapi/asm/cputable.h b/arch/powerpc/include/uapi/asm/cputable.h +index de2c0e4ee1aa..67de80a8e178 100644 +--- a/arch/powerpc/include/uapi/asm/cputable.h ++++ b/arch/powerpc/include/uapi/asm/cputable.h +@@ -31,6 +31,7 @@ + #define PPC_FEATURE_PSERIES_PERFMON_COMPAT \ + 0x00000040 + ++/* Reserved - do not use 0x00000004 */ + #define PPC_FEATURE_TRUE_LE 0x00000002 + #define PPC_FEATURE_PPC_LE 0x00000001 + +diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c +index b7634ce41dbc..70433feb54b8 100644 +--- a/arch/powerpc/kernel/prom.c ++++ b/arch/powerpc/kernel/prom.c +@@ -159,7 +159,7 @@ static struct ibm_pa_feature { + {CPU_FTR_NOEXECUTE, 0, 0, 0, 6, 0}, + {CPU_FTR_NODSISRALIGN, 0, 0, 1, 1, 1}, + {0, MMU_FTR_CI_LARGE_PAGE, 0, 1, 2, 0}, +- {CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0}, ++ {CPU_FTR_REAL_LE, 0, PPC_FEATURE_TRUE_LE, 5, 0, 0}, + }; + + static void __init scan_features(unsigned long node, unsigned char *ftrs, +diff --git a/arch/x86/kernel/sysfb_efi.c b/arch/x86/kernel/sysfb_efi.c +index b285d4e8c68e..5da924bbf0a0 100644 +--- a/arch/x86/kernel/sysfb_efi.c ++++ b/arch/x86/kernel/sysfb_efi.c +@@ -106,14 +106,24 @@ static int __init efifb_set_system(const struct dmi_system_id *id) + continue; + for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) { + resource_size_t start, end; ++ unsigned long flags; ++ ++ flags = pci_resource_flags(dev, i); ++ if (!(flags & IORESOURCE_MEM)) ++ continue; ++ ++ if (flags & IORESOURCE_UNSET) ++ continue; ++ ++ if (pci_resource_len(dev, i) == 0) ++ continue; + + start = pci_resource_start(dev, i); +- if (start == 0) +- break; + end = pci_resource_end(dev, i); + if (screen_info.lfb_base >= start && + screen_info.lfb_base < end) { + found_bar = 1; ++ break; + } + } + } +diff --git a/crypto/ahash.c b/crypto/ahash.c +index b246858ca032..781a8a73a7ff 100644 +--- a/crypto/ahash.c ++++ b/crypto/ahash.c +@@ -64,8 +64,9 @@ static int hash_walk_new_entry(struct crypto_hash_walk *walk) + struct scatterlist *sg; + + sg = walk->sg; +- walk->pg = sg_page(sg); + walk->offset = sg->offset; ++ walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT); ++ walk->offset = offset_in_page(walk->offset); + walk->entrylen = sg->length; + + if (walk->entrylen > walk->total) +diff --git a/crypto/gcm.c b/crypto/gcm.c +index 9cea4d0b6904..f0bd00b15f26 100644 +--- a/crypto/gcm.c ++++ b/crypto/gcm.c +@@ -1173,6 +1173,9 @@ static struct aead_request *crypto_rfc4543_crypt(struct aead_request *req, + aead_request_set_tfm(subreq, ctx->child); + aead_request_set_callback(subreq, req->base.flags, crypto_rfc4543_done, + req); ++ if (!enc) ++ aead_request_set_callback(subreq, req->base.flags, ++ req->base.complete, req->base.data); + aead_request_set_crypt(subreq, cipher, cipher, enc ? 0 : authsize, iv); + aead_request_set_assoc(subreq, assoc, assoclen); + +diff --git a/drivers/acpi/acpica/dsmethod.c b/drivers/acpi/acpica/dsmethod.c +index a9ffd44c18fe..2184259c386b 100644 +--- a/drivers/acpi/acpica/dsmethod.c ++++ b/drivers/acpi/acpica/dsmethod.c +@@ -267,6 +267,9 @@ acpi_ds_begin_method_execution(struct acpi_namespace_node *method_node, + obj_desc->method.mutex->mutex. + original_sync_level = + obj_desc->method.mutex->mutex.sync_level; ++ ++ obj_desc->method.mutex->mutex.thread_id = ++ acpi_os_get_thread_id(); + } + } + +diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c +index b71f4397bcfb..708b40cecfcf 100644 +--- a/drivers/block/nbd.c ++++ b/drivers/block/nbd.c +@@ -581,8 +581,8 @@ static void do_nbd_request(struct request_queue *q) + BUG_ON(nbd->magic != NBD_MAGIC); + + if (unlikely(!nbd->sock)) { +- dev_err(disk_to_dev(nbd->disk), +- "Attempted send on closed socket\n"); ++ dev_err_ratelimited(disk_to_dev(nbd->disk), ++ "Attempted send on closed socket\n"); + req->errors++; + nbd_end_request(req); + spin_lock_irq(q->queue_lock); +diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c +index 19ad8f0c83ef..897b6b9e53b1 100644 +--- a/drivers/block/paride/pd.c ++++ b/drivers/block/paride/pd.c +@@ -126,7 +126,7 @@ + */ + #include <linux/types.h> + +-static bool verbose = 0; ++static int verbose = 0; + static int major = PD_MAJOR; + static char *name = PD_NAME; + static int cluster = 64; +@@ -161,7 +161,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV}; + static DEFINE_MUTEX(pd_mutex); + static DEFINE_SPINLOCK(pd_lock); + +-module_param(verbose, bool, 0); ++module_param(verbose, int, 0); + module_param(major, int, 0); + module_param(name, charp, 0); + module_param(cluster, int, 0); +diff --git a/drivers/block/paride/pt.c b/drivers/block/paride/pt.c +index 2596042eb987..ada45058e04d 100644 +--- a/drivers/block/paride/pt.c ++++ b/drivers/block/paride/pt.c +@@ -117,7 +117,7 @@ + + */ + +-static bool verbose = 0; ++static int verbose = 0; + static int major = PT_MAJOR; + static char *name = PT_NAME; + static int disable = 0; +@@ -152,7 +152,7 @@ static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3}; + + #include <asm/uaccess.h> + +-module_param(verbose, bool, 0); ++module_param(verbose, int, 0); + module_param(major, int, 0); + module_param(name, charp, 0); + module_param_array(drive0, int, NULL, 0); +diff --git a/drivers/bus/imx-weim.c b/drivers/bus/imx-weim.c +index 3ef58c8dbf11..78737f4fd894 100644 +--- a/drivers/bus/imx-weim.c ++++ b/drivers/bus/imx-weim.c +@@ -92,7 +92,7 @@ static int __init weim_parse_dt(struct platform_device *pdev, + struct device_node *child; + int ret; + +- for_each_child_of_node(pdev->dev.of_node, child) { ++ for_each_available_child_of_node(pdev->dev.of_node, child) { + if (!child->name) + continue; + +diff --git a/drivers/clk/versatile/clk-sp810.c b/drivers/clk/versatile/clk-sp810.c +index b9e05bde0c06..a21e2fa66a2a 100644 +--- a/drivers/clk/versatile/clk-sp810.c ++++ b/drivers/clk/versatile/clk-sp810.c +@@ -141,6 +141,7 @@ void __init clk_sp810_of_setup(struct device_node *node) + const char *parent_names[2]; + char name[12]; + struct clk_init_data init; ++ static int instance; + int i; + + if (!sp810) { +@@ -172,7 +173,7 @@ void __init clk_sp810_of_setup(struct device_node *node) + init.num_parents = ARRAY_SIZE(parent_names); + + for (i = 0; i < ARRAY_SIZE(sp810->timerclken); i++) { +- snprintf(name, ARRAY_SIZE(name), "timerclken%d", i); ++ snprintf(name, sizeof(name), "sp810_%d_%d", instance, i); + + sp810->timerclken[i].sp810 = sp810; + sp810->timerclken[i].channel = i; +@@ -184,5 +185,6 @@ void __init clk_sp810_of_setup(struct device_node *node) + } + + of_clk_add_provider(node, clk_sp810_timerclken_of_get, sp810); ++ instance++; + } + CLK_OF_DECLARE(sp810, "arm,sp810", clk_sp810_of_setup); +diff --git a/drivers/edac/i7core_edac.c b/drivers/edac/i7core_edac.c +index c67fb4d707d3..69c9c4ecaaa9 100644 +--- a/drivers/edac/i7core_edac.c ++++ b/drivers/edac/i7core_edac.c +@@ -1878,7 +1878,7 @@ static int i7core_mce_check_error(struct notifier_block *nb, unsigned long val, + + i7_dev = get_i7core_dev(mce->socketid); + if (!i7_dev) +- return NOTIFY_BAD; ++ return NOTIFY_DONE; + + mci = i7_dev->mci; + pvt = mci->pvt_info; +diff --git a/drivers/edac/sb_edac.c b/drivers/edac/sb_edac.c +index 3bdefbfb4377..0d40f7f0c379 100644 +--- a/drivers/edac/sb_edac.c ++++ b/drivers/edac/sb_edac.c +@@ -1538,7 +1538,7 @@ static int sbridge_mce_check_error(struct notifier_block *nb, unsigned long val, + + mci = get_mci_for_node_id(mce->socketid); + if (!mci) +- return NOTIFY_BAD; ++ return NOTIFY_DONE; + pvt = mci->pvt_info; + + /* +diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c +index 4e2f46938bf0..e7566d4931c6 100644 +--- a/drivers/firmware/efi/vars.c ++++ b/drivers/firmware/efi/vars.c +@@ -202,29 +202,44 @@ static const struct variable_validate variable_validate[] = { + { NULL_GUID, "", NULL }, + }; + ++/* ++ * Check if @var_name matches the pattern given in @match_name. ++ * ++ * @var_name: an array of @len non-NUL characters. ++ * @match_name: a NUL-terminated pattern string, optionally ending in "*". A ++ * final "*" character matches any trailing characters @var_name, ++ * including the case when there are none left in @var_name. ++ * @match: on output, the number of non-wildcard characters in @match_name ++ * that @var_name matches, regardless of the return value. ++ * @return: whether @var_name fully matches @match_name. ++ */ + static bool + variable_matches(const char *var_name, size_t len, const char *match_name, + int *match) + { + for (*match = 0; ; (*match)++) { + char c = match_name[*match]; +- char u = var_name[*match]; + +- /* Wildcard in the matching name means we've matched */ +- if (c == '*') ++ switch (c) { ++ case '*': ++ /* Wildcard in @match_name means we've matched. */ + return true; + +- /* Case sensitive match */ +- if (!c && *match == len) +- return true; ++ case '\0': ++ /* @match_name has ended. Has @var_name too? */ ++ return (*match == len); + +- if (c != u) ++ default: ++ /* ++ * We've reached a non-wildcard char in @match_name. ++ * Continue only if there's an identical character in ++ * @var_name. ++ */ ++ if (*match < len && c == var_name[*match]) ++ continue; + return false; +- +- if (!c) +- return true; ++ } + } +- return true; + } + + bool +diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c +index 3c25af46ba07..74ef54a4645f 100644 +--- a/drivers/gpu/drm/i915/intel_crt.c ++++ b/drivers/gpu/drm/i915/intel_crt.c +@@ -248,8 +248,14 @@ static bool intel_crt_compute_config(struct intel_encoder *encoder, + pipe_config->has_pch_encoder = true; + + /* LPT FDI RX only supports 8bpc. */ +- if (HAS_PCH_LPT(dev)) ++ if (HAS_PCH_LPT(dev)) { ++ if (pipe_config->bw_constrained && pipe_config->pipe_bpp < 24) { ++ DRM_DEBUG_KMS("LPT only supports 24bpp\n"); ++ return false; ++ } ++ + pipe_config->pipe_bpp = 24; ++ } + + return true; + } +diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c +index 98976f054597..dc59c2d33fbe 100644 +--- a/drivers/gpu/drm/qxl/qxl_display.c ++++ b/drivers/gpu/drm/qxl/qxl_display.c +@@ -287,10 +287,15 @@ static int qxl_crtc_cursor_set2(struct drm_crtc *crtc, + + qxl_bo_kunmap(user_bo); + ++ qcrtc->cur_x += qcrtc->hot_spot_x - hot_x; ++ qcrtc->cur_y += qcrtc->hot_spot_y - hot_y; ++ qcrtc->hot_spot_x = hot_x; ++ qcrtc->hot_spot_y = hot_y; ++ + cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release); + cmd->type = QXL_CURSOR_SET; +- cmd->u.set.position.x = qcrtc->cur_x; +- cmd->u.set.position.y = qcrtc->cur_y; ++ cmd->u.set.position.x = qcrtc->cur_x + qcrtc->hot_spot_x; ++ cmd->u.set.position.y = qcrtc->cur_y + qcrtc->hot_spot_y; + + cmd->u.set.shape = qxl_bo_physical_address(qdev, cursor_bo, 0); + +@@ -353,8 +358,8 @@ static int qxl_crtc_cursor_move(struct drm_crtc *crtc, + + cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release); + cmd->type = QXL_CURSOR_MOVE; +- cmd->u.position.x = qcrtc->cur_x; +- cmd->u.position.y = qcrtc->cur_y; ++ cmd->u.position.x = qcrtc->cur_x + qcrtc->hot_spot_x; ++ cmd->u.position.y = qcrtc->cur_y + qcrtc->hot_spot_y; + qxl_release_unmap(qdev, release, &cmd->release_info); + + qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false); +diff --git a/drivers/gpu/drm/qxl/qxl_drv.h b/drivers/gpu/drm/qxl/qxl_drv.h +index 9cfafd7a1af6..0bc4991e3002 100644 +--- a/drivers/gpu/drm/qxl/qxl_drv.h ++++ b/drivers/gpu/drm/qxl/qxl_drv.h +@@ -139,6 +139,8 @@ struct qxl_crtc { + int index; + int cur_x; + int cur_y; ++ int hot_spot_x; ++ int hot_spot_y; + }; + + struct qxl_output { +diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c +index ecd4a3dd51bb..d988fff65ee5 100644 +--- a/drivers/gpu/drm/radeon/atombios_crtc.c ++++ b/drivers/gpu/drm/radeon/atombios_crtc.c +@@ -1572,6 +1572,7 @@ static u32 radeon_get_pll_use_mask(struct drm_crtc *crtc) + static int radeon_get_shared_dp_ppll(struct drm_crtc *crtc) + { + struct drm_device *dev = crtc->dev; ++ struct radeon_device *rdev = dev->dev_private; + struct drm_crtc *test_crtc; + struct radeon_crtc *test_radeon_crtc; + +@@ -1581,6 +1582,10 @@ static int radeon_get_shared_dp_ppll(struct drm_crtc *crtc) + test_radeon_crtc = to_radeon_crtc(test_crtc); + if (test_radeon_crtc->encoder && + ENCODER_MODE_IS_DP(atombios_get_encoder_mode(test_radeon_crtc->encoder))) { ++ /* PPLL2 is exclusive to UNIPHYA on DCE61 */ ++ if (ASIC_IS_DCE61(rdev) && !ASIC_IS_DCE8(rdev) && ++ test_radeon_crtc->pll_id == ATOM_PPLL2) ++ continue; + /* for DP use the same PLL for all */ + if (test_radeon_crtc->pll_id != ATOM_PPLL_INVALID) + return test_radeon_crtc->pll_id; +@@ -1602,6 +1607,7 @@ static int radeon_get_shared_nondp_ppll(struct drm_crtc *crtc) + { + struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc); + struct drm_device *dev = crtc->dev; ++ struct radeon_device *rdev = dev->dev_private; + struct drm_crtc *test_crtc; + struct radeon_crtc *test_radeon_crtc; + u32 adjusted_clock, test_adjusted_clock; +@@ -1617,6 +1623,10 @@ static int radeon_get_shared_nondp_ppll(struct drm_crtc *crtc) + test_radeon_crtc = to_radeon_crtc(test_crtc); + if (test_radeon_crtc->encoder && + !ENCODER_MODE_IS_DP(atombios_get_encoder_mode(test_radeon_crtc->encoder))) { ++ /* PPLL2 is exclusive to UNIPHYA on DCE61 */ ++ if (ASIC_IS_DCE61(rdev) && !ASIC_IS_DCE8(rdev) && ++ test_radeon_crtc->pll_id == ATOM_PPLL2) ++ continue; + /* check if we are already driving this connector with another crtc */ + if (test_radeon_crtc->connector == radeon_crtc->connector) { + /* if we are, return that pll */ +diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c +index f9fe46f52cfa..d13f3dda6769 100644 +--- a/drivers/hv/vmbus_drv.c ++++ b/drivers/hv/vmbus_drv.c +@@ -32,6 +32,7 @@ + #include <linux/acpi.h> + #include <acpi/acpi_bus.h> + #include <linux/completion.h> ++#include <linux/cpu.h> + #include <linux/hyperv.h> + #include <linux/kernel_stat.h> + #include <asm/hyperv.h> +@@ -517,6 +518,39 @@ static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc) + desc->action->handler(irq, desc->action->dev_id); + } + ++#ifdef CONFIG_HOTPLUG_CPU ++static int hyperv_cpu_disable(void) ++{ ++ return -ENOSYS; ++} ++ ++static void hv_cpu_hotplug_quirk(bool vmbus_loaded) ++{ ++ static void *previous_cpu_disable; ++ ++ /* ++ * Offlining a CPU when running on newer hypervisors (WS2012R2, Win8, ++ * ...) is not supported at this moment as channel interrupts are ++ * distributed across all of them. ++ */ ++ ++ if ((vmbus_proto_version == VERSION_WS2008) || ++ (vmbus_proto_version == VERSION_WIN7)) ++ return; ++ ++ if (vmbus_loaded) { ++ previous_cpu_disable = smp_ops.cpu_disable; ++ smp_ops.cpu_disable = hyperv_cpu_disable; ++ pr_notice("CPU offlining is not supported by hypervisor\n"); ++ } else if (previous_cpu_disable) ++ smp_ops.cpu_disable = previous_cpu_disable; ++} ++#else ++static void hv_cpu_hotplug_quirk(bool vmbus_loaded) ++{ ++} ++#endif ++ + /* + * vmbus_bus_init -Main vmbus driver initialization routine. + * +@@ -575,6 +609,7 @@ static int vmbus_bus_init(int irq) + if (ret) + goto err_alloc; + ++ hv_cpu_hotplug_quirk(true); + vmbus_request_offers(); + + return 0; +@@ -812,6 +847,7 @@ static void __exit vmbus_exit(void) + bus_unregister(&hv_bus); + hv_cleanup(); + acpi_bus_unregister_driver(&vmbus_acpi_driver); ++ hv_cpu_hotplug_quirk(false); + } + + +diff --git a/drivers/iio/magnetometer/ak8975.c b/drivers/iio/magnetometer/ak8975.c +index aeba3bbdadb0..3a26a1171e3b 100644 +--- a/drivers/iio/magnetometer/ak8975.c ++++ b/drivers/iio/magnetometer/ak8975.c +@@ -151,6 +151,8 @@ static int ak8975_setup_irq(struct ak8975_data *data) + int rc; + int irq; + ++ init_waitqueue_head(&data->data_ready_queue); ++ clear_bit(0, &data->flags); + if (client->irq) + irq = client->irq; + else +@@ -166,8 +168,6 @@ static int ak8975_setup_irq(struct ak8975_data *data) + return rc; + } + +- init_waitqueue_head(&data->data_ready_queue); +- clear_bit(0, &data->flags); + data->eoc_irq = irq; + + return rc; +diff --git a/drivers/input/misc/max8997_haptic.c b/drivers/input/misc/max8997_haptic.c +index e973133212a5..a8c91226cd22 100644 +--- a/drivers/input/misc/max8997_haptic.c ++++ b/drivers/input/misc/max8997_haptic.c +@@ -246,12 +246,14 @@ static int max8997_haptic_probe(struct platform_device *pdev) + struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent); + const struct max8997_platform_data *pdata = + dev_get_platdata(iodev->dev); +- const struct max8997_haptic_platform_data *haptic_pdata = +- pdata->haptic_pdata; ++ const struct max8997_haptic_platform_data *haptic_pdata = NULL; + struct max8997_haptic *chip; + struct input_dev *input_dev; + int error; + ++ if (pdata) ++ haptic_pdata = pdata->haptic_pdata; ++ + if (!haptic_pdata) { + dev_err(&pdev->dev, "no haptic platform data\n"); + return -EINVAL; +diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c +index e38024cf0227..42825216e83d 100644 +--- a/drivers/input/serio/i8042.c ++++ b/drivers/input/serio/i8042.c +@@ -871,7 +871,7 @@ static int __init i8042_check_aux(void) + static int i8042_controller_check(void) + { + if (i8042_flush()) { +- pr_err("No controller found\n"); ++ pr_info("No controller found\n"); + return -ENODEV; + } + +diff --git a/drivers/input/tablet/gtco.c b/drivers/input/tablet/gtco.c +index 29e01ab6859f..a9f8f925ba2b 100644 +--- a/drivers/input/tablet/gtco.c ++++ b/drivers/input/tablet/gtco.c +@@ -869,6 +869,14 @@ static int gtco_probe(struct usb_interface *usbinterface, + goto err_free_buf; + } + ++ /* Sanity check that a device has an endpoint */ ++ if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) { ++ dev_err(&usbinterface->dev, ++ "Invalid number of endpoints\n"); ++ error = -EINVAL; ++ goto err_free_urb; ++ } ++ + /* + * The endpoint is always altsetting 0, we know this since we know + * this device only has one interrupt endpoint +@@ -890,7 +898,7 @@ static int gtco_probe(struct usb_interface *usbinterface, + * HID report descriptor + */ + if (usb_get_extra_descriptor(usbinterface->cur_altsetting, +- HID_DEVICE_TYPE, &hid_desc) != 0){ ++ HID_DEVICE_TYPE, &hid_desc) != 0) { + dev_err(&usbinterface->dev, + "Can't retrieve exta USB descriptor to get hid report descriptor length\n"); + error = -EIO; +diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c +index ea195360747e..6ad648151a89 100644 +--- a/drivers/input/touchscreen/ads7846.c ++++ b/drivers/input/touchscreen/ads7846.c +@@ -700,18 +700,22 @@ static int ads7846_no_filter(void *ads, int data_idx, int *val) + + static int ads7846_get_value(struct ads7846 *ts, struct spi_message *m) + { ++ int value; + struct spi_transfer *t = + list_entry(m->transfers.prev, struct spi_transfer, transfer_list); + + if (ts->model == 7845) { +- return be16_to_cpup((__be16 *)&(((char*)t->rx_buf)[1])) >> 3; ++ value = be16_to_cpup((__be16 *)&(((char *)t->rx_buf)[1])); + } else { + /* + * adjust: on-wire is a must-ignore bit, a BE12 value, then + * padding; built from two 8 bit values written msb-first. + */ +- return be16_to_cpup((__be16 *)t->rx_buf) >> 3; ++ value = be16_to_cpup((__be16 *)t->rx_buf); + } ++ ++ /* enforce ADC output is 12 bits width */ ++ return (value >> 3) & 0xfff; + } + + static void ads7846_update_value(struct spi_message *m, int val) +diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig +index 8dacd4c9ee87..3eaafbc66974 100644 +--- a/drivers/misc/Kconfig ++++ b/drivers/misc/Kconfig +@@ -451,7 +451,7 @@ config ARM_CHARLCD + still useful. + + config BMP085 +- bool ++ tristate + depends on SYSFS + + config BMP085_I2C +diff --git a/drivers/misc/ad525x_dpot.c b/drivers/misc/ad525x_dpot.c +index 0daadcf1ed7a..65fb74402c37 100644 +--- a/drivers/misc/ad525x_dpot.c ++++ b/drivers/misc/ad525x_dpot.c +@@ -216,7 +216,7 @@ static s32 dpot_read_i2c(struct dpot_data *dpot, u8 reg) + */ + value = swab16(value); + +- if (dpot->uid == DPOT_UID(AD5271_ID)) ++ if (dpot->uid == DPOT_UID(AD5274_ID)) + value = value >> 2; + return value; + default: +diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c +index 4aa4d2d18933..4e697ea67ae2 100644 +--- a/drivers/mmc/host/sdhci.c ++++ b/drivers/mmc/host/sdhci.c +@@ -2417,9 +2417,7 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id) + + if (host->runtime_suspended) { + spin_unlock(&host->lock); +- pr_warning("%s: got irq while runtime suspended\n", +- mmc_hostname(host->mmc)); +- return IRQ_HANDLED; ++ return IRQ_NONE; + } + + intmask = sdhci_readl(host, SDHCI_INT_STATUS); +diff --git a/drivers/net/ethernet/atheros/atlx/atl2.c b/drivers/net/ethernet/atheros/atlx/atl2.c +index 265ce1b752ed..96fe542b4acb 100644 +--- a/drivers/net/ethernet/atheros/atlx/atl2.c ++++ b/drivers/net/ethernet/atheros/atlx/atl2.c +@@ -1413,7 +1413,7 @@ static int atl2_probe(struct pci_dev *pdev, const struct pci_device_id *ent) + + err = -EIO; + +- netdev->hw_features = NETIF_F_SG | NETIF_F_HW_VLAN_CTAG_RX; ++ netdev->hw_features = NETIF_F_HW_VLAN_CTAG_RX; + netdev->features |= (NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX); + + /* Init PHY as early as possible due to power saving issue */ +diff --git a/drivers/net/ethernet/mellanox/mlx4/en_tx.c b/drivers/net/ethernet/mellanox/mlx4/en_tx.c +index 0698c82d6ff1..3d3cd0f1adf8 100644 +--- a/drivers/net/ethernet/mellanox/mlx4/en_tx.c ++++ b/drivers/net/ethernet/mellanox/mlx4/en_tx.c +@@ -343,7 +343,6 @@ static void mlx4_en_process_tx_cq(struct net_device *dev, struct mlx4_en_cq *cq) + u32 packets = 0; + u32 bytes = 0; + int factor = priv->cqe_factor; +- u64 timestamp = 0; + + if (!priv->port_up) + return; +@@ -375,9 +374,12 @@ static void mlx4_en_process_tx_cq(struct net_device *dev, struct mlx4_en_cq *cq) + new_index = be16_to_cpu(cqe->wqe_index) & size_mask; + + do { ++ u64 timestamp = 0; ++ + txbbs_skipped += ring->last_nr_txbb; + ring_index = (ring_index + ring->last_nr_txbb) & size_mask; +- if (ring->tx_info[ring_index].ts_requested) ++ ++ if (unlikely(ring->tx_info[ring_index].ts_requested)) + timestamp = mlx4_en_get_cqe_ts(cqe); + + /* free next descriptor */ +diff --git a/drivers/pinctrl/pinctrl-single.c b/drivers/pinctrl/pinctrl-single.c +index a82ace4d9a20..44cbed9540dd 100644 +--- a/drivers/pinctrl/pinctrl-single.c ++++ b/drivers/pinctrl/pinctrl-single.c +@@ -1263,9 +1263,9 @@ static int pcs_parse_bits_in_pinctrl_entry(struct pcs_device *pcs, + + /* Parse pins in each row from LSB */ + while (mask) { +- bit_pos = ffs(mask); ++ bit_pos = __ffs(mask); + pin_num_from_lsb = bit_pos / pcs->bits_per_pin; +- mask_pos = ((pcs->fmask) << (bit_pos - 1)); ++ mask_pos = ((pcs->fmask) << bit_pos); + val_pos = val & mask_pos; + submask = mask & mask_pos; + mask &= ~mask_pos; +@@ -1549,7 +1549,7 @@ static int pcs_probe(struct platform_device *pdev) + ret = of_property_read_u32(np, "pinctrl-single,function-mask", + &pcs->fmask); + if (!ret) { +- pcs->fshift = ffs(pcs->fmask) - 1; ++ pcs->fshift = __ffs(pcs->fmask); + pcs->fmax = pcs->fmask >> pcs->fshift; + } else { + /* If mask property doesn't exist, function mux is invalid. */ +diff --git a/drivers/pnp/pnpbios/bioscalls.c b/drivers/pnp/pnpbios/bioscalls.c +index 769d265b221b..deb7f4bcdb7b 100644 +--- a/drivers/pnp/pnpbios/bioscalls.c ++++ b/drivers/pnp/pnpbios/bioscalls.c +@@ -21,7 +21,7 @@ + + #include "pnpbios.h" + +-static struct { ++__visible struct { + u16 offset; + u16 segment; + } pnp_bios_callpoint; +@@ -41,6 +41,7 @@ asmlinkage void pnp_bios_callfunc(void); + + __asm__(".text \n" + __ALIGN_STR "\n" ++ ".globl pnp_bios_callfunc\n" + "pnp_bios_callfunc:\n" + " pushl %edx \n" + " pushl %ecx \n" +@@ -66,9 +67,9 @@ static struct desc_struct bad_bios_desc = GDT_ENTRY_INIT(0x4092, + * after PnP BIOS oopses. + */ + +-u32 pnp_bios_fault_esp; +-u32 pnp_bios_fault_eip; +-u32 pnp_bios_is_utter_crap = 0; ++__visible u32 pnp_bios_fault_esp; ++__visible u32 pnp_bios_fault_eip; ++__visible u32 pnp_bios_is_utter_crap = 0; + + static spinlock_t pnp_bios_lock; + +diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c +index 54e104e197e3..1018a1d6c548 100644 +--- a/drivers/rtc/rtc-vr41xx.c ++++ b/drivers/rtc/rtc-vr41xx.c +@@ -272,12 +272,13 @@ static irqreturn_t rtclong1_interrupt(int irq, void *dev_id) + } + + static const struct rtc_class_ops vr41xx_rtc_ops = { +- .release = vr41xx_rtc_release, +- .ioctl = vr41xx_rtc_ioctl, +- .read_time = vr41xx_rtc_read_time, +- .set_time = vr41xx_rtc_set_time, +- .read_alarm = vr41xx_rtc_read_alarm, +- .set_alarm = vr41xx_rtc_set_alarm, ++ .release = vr41xx_rtc_release, ++ .ioctl = vr41xx_rtc_ioctl, ++ .read_time = vr41xx_rtc_read_time, ++ .set_time = vr41xx_rtc_set_time, ++ .read_alarm = vr41xx_rtc_read_alarm, ++ .set_alarm = vr41xx_rtc_set_alarm, ++ .alarm_irq_enable = vr41xx_rtc_alarm_irq_enable, + }; + + static int rtc_probe(struct platform_device *pdev) +diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c +index 153de0cbfbc3..3b73eea72946 100644 +--- a/drivers/scsi/lpfc/lpfc_init.c ++++ b/drivers/scsi/lpfc/lpfc_init.c +@@ -2697,7 +2697,7 @@ lpfc_online(struct lpfc_hba *phba) + } + + vports = lpfc_create_vport_work_array(phba); +- if (vports != NULL) ++ if (vports != NULL) { + for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { + struct Scsi_Host *shost; + shost = lpfc_shost_from_vport(vports[i]); +@@ -2714,7 +2714,8 @@ lpfc_online(struct lpfc_hba *phba) + } + spin_unlock_irq(shost->host_lock); + } +- lpfc_destroy_vport_work_array(phba, vports); ++ } ++ lpfc_destroy_vport_work_array(phba, vports); + + lpfc_unblock_mgmt_io(phba); + return 0; +diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c +index 0c6a2660d1d5..2b01c88ad416 100644 +--- a/drivers/scsi/scsi_lib.c ++++ b/drivers/scsi/scsi_lib.c +@@ -1096,7 +1096,17 @@ int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask) + struct scsi_data_buffer *prot_sdb = cmd->prot_sdb; + int ivecs, count; + +- BUG_ON(prot_sdb == NULL); ++ if (prot_sdb == NULL) { ++ /* ++ * This can happen if someone (e.g. multipath) ++ * queues a command to a device on an adapter ++ * that does not support DIX. ++ */ ++ WARN_ON_ONCE(1); ++ error = BLKPREP_KILL; ++ goto err_exit; ++ } ++ + ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio); + + if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) { +diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c +index 537750261aaa..53c24978353c 100644 +--- a/drivers/tty/serial/sh-sci.c ++++ b/drivers/tty/serial/sh-sci.c +@@ -41,7 +41,6 @@ + #include <linux/console.h> + #include <linux/platform_device.h> + #include <linux/serial_sci.h> +-#include <linux/notifier.h> + #include <linux/pm_runtime.h> + #include <linux/cpufreq.h> + #include <linux/clk.h> +@@ -97,8 +96,6 @@ struct sci_port { + struct timer_list rx_timer; + unsigned int rx_timeout; + #endif +- +- struct notifier_block freq_transition; + }; + + /* Function prototypes */ +@@ -1008,30 +1005,6 @@ static irqreturn_t sci_mpxed_interrupt(int irq, void *ptr) + return ret; + } + +-/* +- * Here we define a transition notifier so that we can update all of our +- * ports' baud rate when the peripheral clock changes. +- */ +-static int sci_notifier(struct notifier_block *self, +- unsigned long phase, void *p) +-{ +- struct sci_port *sci_port; +- unsigned long flags; +- +- sci_port = container_of(self, struct sci_port, freq_transition); +- +- if ((phase == CPUFREQ_POSTCHANGE) || +- (phase == CPUFREQ_RESUMECHANGE)) { +- struct uart_port *port = &sci_port->port; +- +- spin_lock_irqsave(&port->lock, flags); +- port->uartclk = clk_get_rate(sci_port->iclk); +- spin_unlock_irqrestore(&port->lock, flags); +- } +- +- return NOTIFY_OK; +-} +- + static struct sci_irq_desc { + const char *desc; + irq_handler_t handler; +@@ -2427,9 +2400,6 @@ static int sci_remove(struct platform_device *dev) + { + struct sci_port *port = platform_get_drvdata(dev); + +- cpufreq_unregister_notifier(&port->freq_transition, +- CPUFREQ_TRANSITION_NOTIFIER); +- + uart_remove_one_port(&sci_uart_driver, &port->port); + + sci_cleanup_single(port); +@@ -2487,15 +2457,6 @@ static int sci_probe(struct platform_device *dev) + if (ret) + return ret; + +- sp->freq_transition.notifier_call = sci_notifier; +- +- ret = cpufreq_register_notifier(&sp->freq_transition, +- CPUFREQ_TRANSITION_NOTIFIER); +- if (unlikely(ret < 0)) { +- sci_cleanup_single(sp); +- return ret; +- } +- + #ifdef CONFIG_SH_STANDARD_BIOS + sh_bios_gdb_detach(); + #endif +diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c +index 04b21577e8ed..1778aeeb9e5c 100644 +--- a/drivers/usb/core/hcd-pci.c ++++ b/drivers/usb/core/hcd-pci.c +@@ -74,6 +74,15 @@ static void for_each_companion(struct pci_dev *pdev, struct usb_hcd *hcd, + if (companion->bus != pdev->bus || + PCI_SLOT(companion->devfn) != slot) + continue; ++ ++ /* ++ * Companion device should be either UHCI,OHCI or EHCI host ++ * controller, otherwise skip. ++ */ ++ if (companion->class != CL_UHCI && companion->class != CL_OHCI && ++ companion->class != CL_EHCI) ++ continue; ++ + companion_hcd = pci_get_drvdata(companion); + if (!companion_hcd || !companion_hcd->self.root_hub) + continue; +diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c +index 9552d2080d12..bd889c621ba2 100644 +--- a/drivers/usb/host/xhci-mem.c ++++ b/drivers/usb/host/xhci-mem.c +@@ -1785,6 +1785,12 @@ no_bw: + kfree(xhci->rh_bw); + kfree(xhci->ext_caps); + ++ xhci->usb2_ports = NULL; ++ xhci->usb3_ports = NULL; ++ xhci->port_array = NULL; ++ xhci->rh_bw = NULL; ++ xhci->ext_caps = NULL; ++ + xhci->page_size = 0; + xhci->page_shift = 0; + xhci->bus_state[0].bus_suspended = 0; +diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c +index bab76bc1e525..4063099f429a 100644 +--- a/drivers/usb/serial/cp210x.c ++++ b/drivers/usb/serial/cp210x.c +@@ -108,6 +108,7 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */ + { USB_DEVICE(0x10C4, 0x8281) }, /* Nanotec Plug & Drive */ + { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */ ++ { USB_DEVICE(0x10C4, 0x82F4) }, /* Starizona MicroTouch */ + { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */ + { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */ + { USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */ +@@ -117,6 +118,7 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */ + { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */ + { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */ ++ { USB_DEVICE(0x10C4, 0x84B6) }, /* Starizona Hyperion */ + { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */ + { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */ + { USB_DEVICE(0x10C4, 0x85F8) }, /* Virtenio Preon32 */ +@@ -140,6 +142,8 @@ static const struct usb_device_id id_table[] = { + { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */ + { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */ + { USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */ ++ { USB_DEVICE(0x12B8, 0xEC60) }, /* Link G4 ECU */ ++ { USB_DEVICE(0x12B8, 0xEC62) }, /* Link G4+ ECU */ + { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */ + { USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */ + { USB_DEVICE(0x166A, 0x0201) }, /* Clipsal 5500PACA C-Bus Pascal Automation Controller */ +diff --git a/drivers/video/da8xx-fb.c b/drivers/video/da8xx-fb.c +index e030e17a83f2..e68b5b229952 100644 +--- a/drivers/video/da8xx-fb.c ++++ b/drivers/video/da8xx-fb.c +@@ -210,8 +210,7 @@ static struct fb_videomode known_lcd_panels[] = { + .lower_margin = 2, + .hsync_len = 0, + .vsync_len = 0, +- .sync = FB_SYNC_CLK_INVERT | +- FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, ++ .sync = FB_SYNC_CLK_INVERT, + }, + /* Sharp LK043T1DG01 */ + [1] = { +@@ -225,7 +224,7 @@ static struct fb_videomode known_lcd_panels[] = { + .lower_margin = 2, + .hsync_len = 41, + .vsync_len = 10, +- .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, ++ .sync = 0, + .flag = 0, + }, + [2] = { +@@ -240,7 +239,7 @@ static struct fb_videomode known_lcd_panels[] = { + .lower_margin = 10, + .hsync_len = 10, + .vsync_len = 10, +- .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, ++ .sync = 0, + .flag = 0, + }, + }; +diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c +index cfda0a6c07a7..55e284935f10 100644 +--- a/drivers/virtio/virtio_balloon.c ++++ b/drivers/virtio/virtio_balloon.c +@@ -164,8 +164,8 @@ static void release_pages_by_pfn(const u32 pfns[], unsigned int num) + /* Find pfns pointing at start of each page, get pages and free them. */ + for (i = 0; i < num; i += VIRTIO_BALLOON_PAGES_PER_PAGE) { + struct page *page = balloon_pfn_to_page(pfns[i]); +- balloon_page_free(page); + adjust_managed_page_count(page, 1); ++ put_page(page); /* balloon reference */ + } + } + +@@ -399,6 +399,8 @@ int virtballoon_migratepage(struct address_space *mapping, + if (!mutex_trylock(&vb->balloon_lock)) + return -EAGAIN; + ++ get_page(newpage); /* balloon reference */ ++ + /* balloon's page migration 1st step -- inflate "newpage" */ + spin_lock_irqsave(&vb_dev_info->pages_lock, flags); + balloon_page_insert(newpage, mapping, &vb_dev_info->pages); +@@ -408,12 +410,7 @@ int virtballoon_migratepage(struct address_space *mapping, + set_page_pfns(vb->pfns, newpage); + tell_host(vb, vb->inflate_vq); + +- /* +- * balloon's page migration 2nd step -- deflate "page" +- * +- * It's safe to delete page->lru here because this page is at +- * an isolated migration list, and this step is expected to happen here +- */ ++ /* balloon's page migration 2nd step -- deflate "page" */ + balloon_page_delete(page); + vb->num_pfns = VIRTIO_BALLOON_PAGES_PER_PAGE; + set_page_pfns(vb->pfns, page); +@@ -421,7 +418,9 @@ int virtballoon_migratepage(struct address_space *mapping, + + mutex_unlock(&vb->balloon_lock); + +- return MIGRATEPAGE_BALLOON_SUCCESS; ++ put_page(page); /* balloon reference */ ++ ++ return MIGRATEPAGE_SUCCESS; + } + + /* define the balloon_mapping->a_ops callback to allow balloon page migration */ +diff --git a/fs/isofs/rock.c b/fs/isofs/rock.c +index 735d7522a3a9..204659a5f6db 100644 +--- a/fs/isofs/rock.c ++++ b/fs/isofs/rock.c +@@ -203,6 +203,8 @@ int get_rock_ridge_filename(struct iso_directory_record *de, + int retnamlen = 0; + int truncate = 0; + int ret = 0; ++ char *p; ++ int len; + + if (!ISOFS_SB(inode->i_sb)->s_rock) + return 0; +@@ -267,12 +269,17 @@ repeat: + rr->u.NM.flags); + break; + } +- if ((strlen(retname) + rr->len - 5) >= 254) { ++ len = rr->len - 5; ++ if (retnamlen + len >= 254) { + truncate = 1; + break; + } +- strncat(retname, rr->u.NM.name, rr->len - 5); +- retnamlen += rr->len - 5; ++ p = memchr(rr->u.NM.name, '\0', len); ++ if (unlikely(p)) ++ len = p - rr->u.NM.name; ++ memcpy(retname + retnamlen, rr->u.NM.name, len); ++ retnamlen += len; ++ retname[retnamlen] = '\0'; + break; + case SIG('R', 'E'): + kfree(rs.buffer); +diff --git a/fs/proc/base.c b/fs/proc/base.c +index 293c987a5dab..582d34aaa56e 100644 +--- a/fs/proc/base.c ++++ b/fs/proc/base.c +@@ -844,7 +844,8 @@ static ssize_t environ_read(struct file *file, char __user *buf, + int ret = 0; + struct mm_struct *mm = file->private_data; + +- if (!mm) ++ /* Ensure the process spawned far enough to have an environment. */ ++ if (!mm || !mm->env_end) + return 0; + + page = (char *)__get_free_page(GFP_TEMPORARY); +diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c +index 52b5375faedc..93a5e91796e9 100644 +--- a/fs/xfs/xfs_ioctl.c ++++ b/fs/xfs/xfs_ioctl.c +@@ -1718,12 +1718,6 @@ xfs_file_ioctl( + if (mp->m_flags & XFS_MOUNT_RDONLY) + return -XFS_ERROR(EROFS); + +- if (!capable(CAP_SYS_ADMIN)) +- return -EPERM; +- +- if (mp->m_flags & XFS_MOUNT_RDONLY) +- return -XFS_ERROR(EROFS); +- + if (copy_from_user(&eofb, arg, sizeof(eofb))) + return -XFS_ERROR(EFAULT); + +diff --git a/include/linux/balloon_compaction.h b/include/linux/balloon_compaction.h +index 089743ade734..38aa07d5b81c 100644 +--- a/include/linux/balloon_compaction.h ++++ b/include/linux/balloon_compaction.h +@@ -27,10 +27,13 @@ + * counter raised only while it is under our special handling; + * + * iii. after the lockless scan step have selected a potential balloon page for +- * isolation, re-test the page->mapping flags and the page ref counter ++ * isolation, re-test the PageBalloon mark and the PagePrivate flag + * under the proper page lock, to ensure isolating a valid balloon page + * (not yet isolated, nor under release procedure) + * ++ * iv. isolation or dequeueing procedure must clear PagePrivate flag under ++ * page lock together with removing page from balloon device page list. ++ * + * The functions provided by this interface are placed to help on coping with + * the aforementioned balloon page corner case, as well as to ensure the simple + * set of exposed rules are satisfied while we are dealing with balloon pages +@@ -71,28 +74,6 @@ static inline void balloon_devinfo_free(struct balloon_dev_info *b_dev_info) + kfree(b_dev_info); + } + +-/* +- * balloon_page_free - release a balloon page back to the page free lists +- * @page: ballooned page to be set free +- * +- * This function must be used to properly set free an isolated/dequeued balloon +- * page at the end of a sucessful page migration, or at the balloon driver's +- * page release procedure. +- */ +-static inline void balloon_page_free(struct page *page) +-{ +- /* +- * Balloon pages always get an extra refcount before being isolated +- * and before being dequeued to help on sorting out fortuite colisions +- * between a thread attempting to isolate and another thread attempting +- * to release the very same balloon page. +- * +- * Before we handle the page back to Buddy, lets drop its extra refcnt. +- */ +- put_page(page); +- __free_page(page); +-} +- + #ifdef CONFIG_BALLOON_COMPACTION + extern bool balloon_page_isolate(struct page *page); + extern void balloon_page_putback(struct page *page); +@@ -108,74 +89,33 @@ static inline void balloon_mapping_free(struct address_space *balloon_mapping) + } + + /* +- * page_flags_cleared - helper to perform balloon @page ->flags tests. +- * +- * As balloon pages are obtained from buddy and we do not play with page->flags +- * at driver level (exception made when we get the page lock for compaction), +- * we can safely identify a ballooned page by checking if the +- * PAGE_FLAGS_CHECK_AT_PREP page->flags are all cleared. This approach also +- * helps us skip ballooned pages that are locked for compaction or release, thus +- * mitigating their racy check at balloon_page_movable() +- */ +-static inline bool page_flags_cleared(struct page *page) +-{ +- return !(page->flags & PAGE_FLAGS_CHECK_AT_PREP); +-} +- +-/* +- * __is_movable_balloon_page - helper to perform @page mapping->flags tests ++ * __is_movable_balloon_page - helper to perform @page PageBalloon tests + */ + static inline bool __is_movable_balloon_page(struct page *page) + { +- struct address_space *mapping = page->mapping; +- return mapping_balloon(mapping); ++ return PageBalloon(page); + } + + /* +- * balloon_page_movable - test page->mapping->flags to identify balloon pages +- * that can be moved by compaction/migration. +- * +- * This function is used at core compaction's page isolation scheme, therefore +- * most pages exposed to it are not enlisted as balloon pages and so, to avoid +- * undesired side effects like racing against __free_pages(), we cannot afford +- * holding the page locked while testing page->mapping->flags here. ++ * balloon_page_movable - test PageBalloon to identify balloon pages ++ * and PagePrivate to check that the page is not ++ * isolated and can be moved by compaction/migration. + * + * As we might return false positives in the case of a balloon page being just +- * released under us, the page->mapping->flags need to be re-tested later, +- * under the proper page lock, at the functions that will be coping with the +- * balloon page case. ++ * released under us, this need to be re-tested later, under the page lock. + */ + static inline bool balloon_page_movable(struct page *page) + { +- /* +- * Before dereferencing and testing mapping->flags, let's make sure +- * this is not a page that uses ->mapping in a different way +- */ +- if (page_flags_cleared(page) && !page_mapped(page) && +- page_count(page) == 1) +- return __is_movable_balloon_page(page); +- +- return false; ++ return PageBalloon(page) && PagePrivate(page); + } + + /* + * isolated_balloon_page - identify an isolated balloon page on private + * compaction/migration page lists. +- * +- * After a compaction thread isolates a balloon page for migration, it raises +- * the page refcount to prevent concurrent compaction threads from re-isolating +- * the same page. For that reason putback_movable_pages(), or other routines +- * that need to identify isolated balloon pages on private pagelists, cannot +- * rely on balloon_page_movable() to accomplish the task. + */ + static inline bool isolated_balloon_page(struct page *page) + { +- /* Already isolated balloon pages, by default, have a raised refcount */ +- if (page_flags_cleared(page) && !page_mapped(page) && +- page_count(page) >= 2) +- return __is_movable_balloon_page(page); +- +- return false; ++ return PageBalloon(page); + } + + /* +@@ -192,6 +132,8 @@ static inline void balloon_page_insert(struct page *page, + struct address_space *mapping, + struct list_head *head) + { ++ __SetPageBalloon(page); ++ SetPagePrivate(page); + page->mapping = mapping; + list_add(&page->lru, head); + } +@@ -206,8 +148,12 @@ static inline void balloon_page_insert(struct page *page, + */ + static inline void balloon_page_delete(struct page *page) + { ++ __ClearPageBalloon(page); + page->mapping = NULL; +- list_del(&page->lru); ++ if (PagePrivate(page)) { ++ ClearPagePrivate(page); ++ list_del(&page->lru); ++ } + } + + /* +@@ -258,6 +204,11 @@ static inline void balloon_page_delete(struct page *page) + list_del(&page->lru); + } + ++static inline bool __is_movable_balloon_page(struct page *page) ++{ ++ return false; ++} ++ + static inline bool balloon_page_movable(struct page *page) + { + return false; +diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h +index 65856c3599b4..953cd12175c4 100644 +--- a/include/linux/compiler-gcc.h ++++ b/include/linux/compiler-gcc.h +@@ -177,7 +177,7 @@ + #define unreachable() __builtin_unreachable() + + /* Mark a function definition as prohibited from being cloned. */ +-#define __noclone __attribute__((__noclone__)) ++#define __noclone __attribute__((__noclone__, __optimize__("no-tracer"))) + + #endif /* GCC_VERSION >= 40500 */ + +diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h +index a7ebb89ae9fb..ade2390ffe92 100644 +--- a/include/linux/cpuset.h ++++ b/include/linux/cpuset.h +@@ -132,10 +132,14 @@ static inline bool read_mems_allowed_retry(unsigned int seq) + + static inline void set_mems_allowed(nodemask_t nodemask) + { ++ unsigned long flags; ++ + task_lock(current); ++ local_irq_save(flags); + write_seqcount_begin(¤t->mems_allowed_seq); + current->mems_allowed = nodemask; + write_seqcount_end(¤t->mems_allowed_seq); ++ local_irq_restore(flags); + task_unlock(current); + } + +diff --git a/include/linux/migrate.h b/include/linux/migrate.h +index 449905ebcab3..ebee4fe4c948 100644 +--- a/include/linux/migrate.h ++++ b/include/linux/migrate.h +@@ -13,18 +13,9 @@ typedef void free_page_t(struct page *page, unsigned long private); + * Return values from addresss_space_operations.migratepage(): + * - negative errno on page migration failure; + * - zero on page migration success; +- * +- * The balloon page migration introduces this special case where a 'distinct' +- * return code is used to flag a successful page migration to unmap_and_move(). +- * This approach is necessary because page migration can race against balloon +- * deflation procedure, and for such case we could introduce a nasty page leak +- * if a successfully migrated balloon page gets released concurrently with +- * migration's unmap_and_move() wrap-up steps. + */ + #define MIGRATEPAGE_SUCCESS 0 +-#define MIGRATEPAGE_BALLOON_SUCCESS 1 /* special ret code for balloon page +- * sucessful migration case. +- */ ++ + enum migrate_reason { + MR_COMPACTION, + MR_MEMORY_FAILURE, +diff --git a/include/linux/mm.h b/include/linux/mm.h +index 3f4bb8eb12a4..79aa518c16a3 100644 +--- a/include/linux/mm.h ++++ b/include/linux/mm.h +@@ -477,6 +477,25 @@ static inline void __ClearPageBuddy(struct page *page) + atomic_set(&page->_mapcount, -1); + } + ++#define PAGE_BALLOON_MAPCOUNT_VALUE (-256) ++ ++static inline int PageBalloon(struct page *page) ++{ ++ return atomic_read(&page->_mapcount) == PAGE_BALLOON_MAPCOUNT_VALUE; ++} ++ ++static inline void __SetPageBalloon(struct page *page) ++{ ++ VM_BUG_ON(atomic_read(&page->_mapcount) != -1); ++ atomic_set(&page->_mapcount, PAGE_BALLOON_MAPCOUNT_VALUE); ++} ++ ++static inline void __ClearPageBalloon(struct page *page) ++{ ++ VM_BUG_ON(!PageBalloon(page)); ++ atomic_set(&page->_mapcount, -1); ++} ++ + void put_page(struct page *page); + void put_pages_list(struct list_head *pages); + +diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h +index 45e921401b06..740c6df3b3a7 100644 +--- a/include/linux/mod_devicetable.h ++++ b/include/linux/mod_devicetable.h +@@ -398,6 +398,7 @@ struct virtio_device_id { + /* + * For Hyper-V devices we use the device guid as the id. + */ ++#define vmbus_device_id hv_vmbus_device_id + struct hv_vmbus_device_id { + __u8 guid[16]; + kernel_ulong_t driver_data; /* Data private to the driver */ +@@ -548,6 +549,11 @@ struct amba_id { + * See documentation of "x86_match_cpu" for details. + */ + ++/* ++ * MODULE_DEVICE_TABLE expects this struct to be called x86cpu_device_id. ++ * Although gcc seems to ignore this error, clang fails without this define. ++ */ ++#define x86cpu_device_id x86_cpu_id + struct x86_cpu_id { + __u16 vendor; + __u16 family; +@@ -575,6 +581,7 @@ struct ipack_device_id { + #define MEI_CL_MODULE_PREFIX "mei:" + #define MEI_CL_NAME_SIZE 32 + ++#define mei_device_id mei_cl_device_id + struct mei_cl_device_id { + char name[MEI_CL_NAME_SIZE]; + kernel_ulong_t driver_info; +@@ -594,6 +601,7 @@ struct mei_cl_device_id { + * Identifies a RapidIO device based on both the device/vendor IDs and + * the assembly device/vendor IDs. + */ ++#define rapidio_device_id rio_device_id + struct rio_device_id { + __u16 did, vid; + __u16 asm_did, asm_vid; +diff --git a/include/linux/poison.h b/include/linux/poison.h +index 2110a81c5e2a..253c9b4198ef 100644 +--- a/include/linux/poison.h ++++ b/include/linux/poison.h +@@ -19,8 +19,8 @@ + * under normal circumstances, used to verify that nobody uses + * non-initialized list entries. + */ +-#define LIST_POISON1 ((void *) 0x00100100 + POISON_POINTER_DELTA) +-#define LIST_POISON2 ((void *) 0x00200200 + POISON_POINTER_DELTA) ++#define LIST_POISON1 ((void *) 0x100 + POISON_POINTER_DELTA) ++#define LIST_POISON2 ((void *) 0x200 + POISON_POINTER_DELTA) + + /********** include/linux/timer.h **********/ + /* +diff --git a/kernel/sched/core.c b/kernel/sched/core.c +index dd794a9b6850..e382c14652d0 100644 +--- a/kernel/sched/core.c ++++ b/kernel/sched/core.c +@@ -6865,8 +6865,12 @@ void sched_move_task(struct task_struct *tsk) + if (unlikely(running)) + tsk->sched_class->put_prev_task(rq, tsk); + +- tg = container_of(task_css_check(tsk, cpu_cgroup_subsys_id, +- lockdep_is_held(&tsk->sighand->siglock)), ++ /* ++ * All callers are synchronized by task_rq_lock(); we do not use RCU ++ * which is pointless here. Thus, we pass "true" to task_css_check() ++ * to prevent lockdep warnings. ++ */ ++ tg = container_of(task_css_check(tsk, cpu_cgroup_subsys_id, true), + struct task_group, css); + tg = autogroup_task_group(tsk, tg); + tsk->sched_task_group = tg; +diff --git a/kernel/workqueue.c b/kernel/workqueue.c +index bb5f920268d7..2bc1257e420f 100644 +--- a/kernel/workqueue.c ++++ b/kernel/workqueue.c +@@ -622,6 +622,35 @@ static void set_work_pool_and_clear_pending(struct work_struct *work, + */ + smp_wmb(); + set_work_data(work, (unsigned long)pool_id << WORK_OFFQ_POOL_SHIFT, 0); ++ /* ++ * The following mb guarantees that previous clear of a PENDING bit ++ * will not be reordered with any speculative LOADS or STORES from ++ * work->current_func, which is executed afterwards. This possible ++ * reordering can lead to a missed execution on attempt to qeueue ++ * the same @work. E.g. consider this case: ++ * ++ * CPU#0 CPU#1 ++ * ---------------------------- -------------------------------- ++ * ++ * 1 STORE event_indicated ++ * 2 queue_work_on() { ++ * 3 test_and_set_bit(PENDING) ++ * 4 } set_..._and_clear_pending() { ++ * 5 set_work_data() # clear bit ++ * 6 smp_mb() ++ * 7 work->current_func() { ++ * 8 LOAD event_indicated ++ * } ++ * ++ * Without an explicit full barrier speculative LOAD on line 8 can ++ * be executed before CPU#0 does STORE on line 1. If that happens, ++ * CPU#0 observes the PENDING bit is still set and new execution of ++ * a @work is not queued in a hope, that CPU#1 will eventually ++ * finish the queued @work. Meanwhile CPU#1 does not see ++ * event_indicated is set, because speculative LOAD was executed ++ * before actual STORE. ++ */ ++ smp_mb(); + } + + static void clear_work_data(struct work_struct *work) +diff --git a/lib/asn1_decoder.c b/lib/asn1_decoder.c +index 11b9b01fda6b..b1c885297113 100644 +--- a/lib/asn1_decoder.c ++++ b/lib/asn1_decoder.c +@@ -69,7 +69,7 @@ next_tag: + + /* Extract a tag from the data */ + tag = data[dp++]; +- if (tag == 0) { ++ if (tag == ASN1_EOC) { + /* It appears to be an EOC. */ + if (data[dp++] != 0) + goto invalid_eoc; +@@ -91,10 +91,8 @@ next_tag: + + /* Extract the length */ + len = data[dp++]; +- if (len <= 0x7f) { +- dp += len; +- goto next_tag; +- } ++ if (len <= 0x7f) ++ goto check_length; + + if (unlikely(len == ASN1_INDEFINITE_LENGTH)) { + /* Indefinite length */ +@@ -105,14 +103,18 @@ next_tag: + } + + n = len - 0x80; +- if (unlikely(n > sizeof(size_t) - 1)) ++ if (unlikely(n > sizeof(len) - 1)) + goto length_too_long; + if (unlikely(n > datalen - dp)) + goto data_overrun_error; +- for (len = 0; n > 0; n--) { ++ len = 0; ++ for (; n > 0; n--) { + len <<= 8; + len |= data[dp++]; + } ++check_length: ++ if (len > datalen - dp) ++ goto data_overrun_error; + dp += len; + goto next_tag; + +@@ -208,9 +210,8 @@ next_op: + unsigned char tmp; + + /* Skip conditional matches if possible */ +- if ((op & ASN1_OP_MATCH__COND && +- flags & FLAG_MATCHED) || +- dp == datalen) { ++ if ((op & ASN1_OP_MATCH__COND && flags & FLAG_MATCHED) || ++ (op & ASN1_OP_MATCH__SKIP && dp == datalen)) { + pc += asn1_op_lengths[op]; + goto next_op; + } +diff --git a/lib/lz4/lz4defs.h b/lib/lz4/lz4defs.h +index abcecdc2d0f2..0710a62ad2f6 100644 +--- a/lib/lz4/lz4defs.h ++++ b/lib/lz4/lz4defs.h +@@ -11,8 +11,7 @@ + /* + * Detects 64 bits mode + */ +-#if (defined(__x86_64__) || defined(__x86_64) || defined(__amd64__) \ +- || defined(__ppc64__) || defined(__LP64__)) ++#if defined(CONFIG_64BIT) + #define LZ4_ARCH64 1 + #else + #define LZ4_ARCH64 0 +@@ -35,6 +34,10 @@ typedef struct _U64_S { u64 v; } U64_S; + + #define PUT4(s, d) (A32(d) = A32(s)) + #define PUT8(s, d) (A64(d) = A64(s)) ++ ++#define LZ4_READ_LITTLEENDIAN_16(d, s, p) \ ++ (d = s - A16(p)) ++ + #define LZ4_WRITE_LITTLEENDIAN_16(p, v) \ + do { \ + A16(p) = v; \ +@@ -51,10 +54,13 @@ typedef struct _U64_S { u64 v; } U64_S; + #define PUT8(s, d) \ + put_unaligned(get_unaligned((const u64 *) s), (u64 *) d) + +-#define LZ4_WRITE_LITTLEENDIAN_16(p, v) \ +- do { \ +- put_unaligned(v, (u16 *)(p)); \ +- p += 2; \ ++#define LZ4_READ_LITTLEENDIAN_16(d, s, p) \ ++ (d = s - get_unaligned_le16(p)) ++ ++#define LZ4_WRITE_LITTLEENDIAN_16(p, v) \ ++ do { \ ++ put_unaligned_le16(v, (u16 *)(p)); \ ++ p += 2; \ + } while (0) + #endif + +@@ -140,9 +146,6 @@ typedef struct _U64_S { u64 v; } U64_S; + + #endif + +-#define LZ4_READ_LITTLEENDIAN_16(d, s, p) \ +- (d = s - get_unaligned_le16(p)) +- + #define LZ4_WILDCOPY(s, d, e) \ + do { \ + LZ4_COPYPACKET(s, d); \ +diff --git a/mm/balloon_compaction.c b/mm/balloon_compaction.c +index 07dbc8ec46cf..2ad56effb962 100644 +--- a/mm/balloon_compaction.c ++++ b/mm/balloon_compaction.c +@@ -93,17 +93,14 @@ struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info) + * to be released by the balloon driver. + */ + if (trylock_page(page)) { ++#ifdef CONFIG_BALLOON_COMPACTION ++ if (!PagePrivate(page)) { ++ /* raced with isolation */ ++ unlock_page(page); ++ continue; ++ } ++#endif + spin_lock_irqsave(&b_dev_info->pages_lock, flags); +- /* +- * Raise the page refcount here to prevent any wrong +- * attempt to isolate this page, in case of coliding +- * with balloon_page_isolate() just after we release +- * the page lock. +- * +- * balloon_page_free() will take care of dropping +- * this extra refcount later. +- */ +- get_page(page); + balloon_page_delete(page); + spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); + unlock_page(page); +@@ -187,7 +184,9 @@ static inline void __isolate_balloon_page(struct page *page) + { + struct balloon_dev_info *b_dev_info = page->mapping->private_data; + unsigned long flags; ++ + spin_lock_irqsave(&b_dev_info->pages_lock, flags); ++ ClearPagePrivate(page); + list_del(&page->lru); + b_dev_info->isolated_pages++; + spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); +@@ -197,7 +196,9 @@ static inline void __putback_balloon_page(struct page *page) + { + struct balloon_dev_info *b_dev_info = page->mapping->private_data; + unsigned long flags; ++ + spin_lock_irqsave(&b_dev_info->pages_lock, flags); ++ SetPagePrivate(page); + list_add(&page->lru, &b_dev_info->pages); + b_dev_info->isolated_pages--; + spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); +@@ -235,12 +236,11 @@ bool balloon_page_isolate(struct page *page) + */ + if (likely(trylock_page(page))) { + /* +- * A ballooned page, by default, has just one refcount. ++ * A ballooned page, by default, has PagePrivate set. + * Prevent concurrent compaction threads from isolating +- * an already isolated balloon page by refcount check. ++ * an already isolated balloon page by clearing it. + */ +- if (__is_movable_balloon_page(page) && +- page_count(page) == 2) { ++ if (balloon_page_movable(page)) { + __isolate_balloon_page(page); + unlock_page(page); + return true; +diff --git a/mm/compaction.c b/mm/compaction.c +index ddcdbe0e42d9..6590b57db751 100644 +--- a/mm/compaction.c ++++ b/mm/compaction.c +@@ -595,7 +595,7 @@ isolate_migratepages_range(struct zone *zone, struct compact_control *cc, + */ + if (!PageLRU(page)) { + if (unlikely(balloon_page_movable(page))) { +- if (locked && balloon_page_isolate(page)) { ++ if (balloon_page_isolate(page)) { + /* Successfully isolated */ + goto isolate_success; + } +diff --git a/mm/migrate.c b/mm/migrate.c +index 05502f10c842..0c14c0e1bdd6 100644 +--- a/mm/migrate.c ++++ b/mm/migrate.c +@@ -856,7 +856,7 @@ static int __unmap_and_move(struct page *page, struct page *newpage, + } + } + +- if (unlikely(balloon_page_movable(page))) { ++ if (unlikely(isolated_balloon_page(page))) { + /* + * A ballooned page does not need any special attention from + * physical to virtual reverse mapping procedures. +@@ -904,9 +904,7 @@ skip_unmap: + put_anon_vma(anon_vma); + + uncharge: +- mem_cgroup_end_migration(mem, page, newpage, +- (rc == MIGRATEPAGE_SUCCESS || +- rc == MIGRATEPAGE_BALLOON_SUCCESS)); ++ mem_cgroup_end_migration(mem, page, newpage, rc == MIGRATEPAGE_SUCCESS); + unlock_page(page); + out: + return rc; +@@ -938,17 +936,6 @@ static int unmap_and_move(new_page_t get_new_page, free_page_t put_new_page, + + rc = __unmap_and_move(page, newpage, force, mode); + +- if (unlikely(rc == MIGRATEPAGE_BALLOON_SUCCESS)) { +- /* +- * A ballooned page has been migrated already. +- * Now, it's the time to wrap-up counters, +- * handle the page back to Buddy and return. +- */ +- dec_zone_page_state(page, NR_ISOLATED_ANON + +- page_is_file_cache(page)); +- balloon_page_free(page); +- return MIGRATEPAGE_SUCCESS; +- } + out: + if (rc != -EAGAIN) { + /* +@@ -971,6 +958,9 @@ out: + if (rc != MIGRATEPAGE_SUCCESS && put_new_page) { + ClearPageSwapBacked(newpage); + put_new_page(newpage, private); ++ } else if (unlikely(__is_movable_balloon_page(newpage))) { ++ /* drop our reference, page already in the balloon */ ++ put_page(newpage); + } else + putback_lru_page(newpage); + +diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c +index 0439395d7ba5..cf91099c4eca 100644 +--- a/net/batman-adv/routing.c ++++ b/net/batman-adv/routing.c +@@ -70,6 +70,15 @@ static void _batadv_update_route(struct batadv_priv *bat_priv, + neigh_node = NULL; + + spin_lock_bh(&orig_node->neigh_list_lock); ++ /* curr_router used earlier may not be the current orig_node->router ++ * anymore because it was dereferenced outside of the neigh_list_lock ++ * protected region. After the new best neighbor has replace the current ++ * best neighbor the reference counter needs to decrease. Consequently, ++ * the code needs to ensure the curr_router variable contains a pointer ++ * to the replaced best neighbor. ++ */ ++ curr_router = rcu_dereference_protected(orig_node->router, true); ++ + rcu_assign_pointer(orig_node->router, neigh_node); + spin_unlock_bh(&orig_node->neigh_list_lock); + +diff --git a/net/batman-adv/send.c b/net/batman-adv/send.c +index 0266edd0fa7f..3e002d3d8765 100644 +--- a/net/batman-adv/send.c ++++ b/net/batman-adv/send.c +@@ -364,6 +364,9 @@ batadv_purge_outstanding_packets(struct batadv_priv *bat_priv, + + if (pending) { + hlist_del(&forw_packet->list); ++ if (!forw_packet->own) ++ atomic_inc(&bat_priv->batman_queue_left); ++ + batadv_forw_packet_free(forw_packet); + } + } +@@ -390,6 +393,9 @@ batadv_purge_outstanding_packets(struct batadv_priv *bat_priv, + + if (pending) { + hlist_del(&forw_packet->list); ++ if (!forw_packet->own) ++ atomic_inc(&bat_priv->bcast_queue_left); ++ + batadv_forw_packet_free(forw_packet); + } + } +diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c +index 813db4e64602..40ac803135c6 100644 +--- a/net/batman-adv/soft-interface.c ++++ b/net/batman-adv/soft-interface.c +@@ -326,10 +326,16 @@ void batadv_interface_rx(struct net_device *soft_iface, + skb_pull_rcsum(skb, hdr_size); + skb_reset_mac_header(skb); + ++ if (unlikely(!pskb_may_pull(skb, ETH_HLEN))) ++ goto dropped; ++ + ethhdr = eth_hdr(skb); + + switch (ntohs(ethhdr->h_proto)) { + case ETH_P_8021Q: ++ if (!pskb_may_pull(skb, VLAN_ETH_HLEN)) ++ goto dropped; ++ + vhdr = (struct vlan_ethhdr *)skb->data; + vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK; + vid |= BATADV_VLAN_HAS_TAG; +@@ -343,8 +349,6 @@ void batadv_interface_rx(struct net_device *soft_iface, + } + + /* skb->dev & skb->pkt_type are set here */ +- if (unlikely(!pskb_may_pull(skb, ETH_HLEN))) +- goto dropped; + skb->protocol = eth_type_trans(skb, soft_iface); + + /* should not be necessary anymore as we use skb_pull_rcsum() +diff --git a/net/bridge/br_ioctl.c b/net/bridge/br_ioctl.c +index b73eaba85667..a882db499d33 100644 +--- a/net/bridge/br_ioctl.c ++++ b/net/bridge/br_ioctl.c +@@ -21,18 +21,19 @@ + #include <asm/uaccess.h> + #include "br_private.h" + +-/* called with RTNL */ + static int get_bridge_ifindices(struct net *net, int *indices, int num) + { + struct net_device *dev; + int i = 0; + +- for_each_netdev(net, dev) { ++ rcu_read_lock(); ++ for_each_netdev_rcu(net, dev) { + if (i >= num) + break; + if (dev->priv_flags & IFF_EBRIDGE) + indices[i++] = dev->ifindex; + } ++ rcu_read_unlock(); + + return i; + } +diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c +index fd3a16e45dd9..5093f42d7afc 100644 +--- a/net/core/rtnetlink.c ++++ b/net/core/rtnetlink.c +@@ -950,14 +950,16 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, + goto nla_put_failure; + + if (1) { +- struct rtnl_link_ifmap map = { +- .mem_start = dev->mem_start, +- .mem_end = dev->mem_end, +- .base_addr = dev->base_addr, +- .irq = dev->irq, +- .dma = dev->dma, +- .port = dev->if_port, +- }; ++ struct rtnl_link_ifmap map; ++ ++ memset(&map, 0, sizeof(map)); ++ map.mem_start = dev->mem_start; ++ map.mem_end = dev->mem_end; ++ map.base_addr = dev->base_addr; ++ map.irq = dev->irq; ++ map.dma = dev->dma; ++ map.port = dev->if_port; ++ + if (nla_put(skb, IFLA_MAP, sizeof(map), &map)) + goto nla_put_failure; + } +diff --git a/net/decnet/dn_route.c b/net/decnet/dn_route.c +index fe32388ea24f..b9610051f3b2 100644 +--- a/net/decnet/dn_route.c ++++ b/net/decnet/dn_route.c +@@ -1030,10 +1030,13 @@ source_ok: + if (!fld.daddr) { + fld.daddr = fld.saddr; + +- err = -EADDRNOTAVAIL; + if (dev_out) + dev_put(dev_out); ++ err = -EINVAL; + dev_out = init_net.loopback_dev; ++ if (!dev_out->dn_ptr) ++ goto out; ++ err = -EADDRNOTAVAIL; + dev_hold(dev_out); + if (!fld.daddr) { + fld.daddr = +@@ -1106,6 +1109,8 @@ source_ok: + if (dev_out == NULL) + goto out; + dn_db = rcu_dereference_raw(dev_out->dn_ptr); ++ if (!dn_db) ++ goto e_inval; + /* Possible improvement - check all devices for local addr */ + if (dn_dev_islocal(dev_out, fld.daddr)) { + dev_put(dev_out); +@@ -1147,6 +1152,8 @@ select_source: + dev_put(dev_out); + dev_out = init_net.loopback_dev; + dev_hold(dev_out); ++ if (!dev_out->dn_ptr) ++ goto e_inval; + fld.flowidn_oif = dev_out->ifindex; + if (res.fi) + dn_fib_info_put(res.fi); +diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c +index 25a0946f7074..3d3966bf3df6 100644 +--- a/net/ipv4/fib_frontend.c ++++ b/net/ipv4/fib_frontend.c +@@ -797,7 +797,11 @@ void fib_del_ifaddr(struct in_ifaddr *ifa, struct in_ifaddr *iprim) + if (ifa->ifa_flags & IFA_F_SECONDARY) { + prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask); + if (prim == NULL) { +- pr_warn("%s: bug: prim == NULL\n", __func__); ++ /* if the device has been deleted, we don't perform ++ * address promotion ++ */ ++ if (!in_dev->dead) ++ pr_warn("%s: bug: prim == NULL\n", __func__); + return; + } + if (iprim && iprim != prim) { +diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c +index ec12b169931b..82c28244ad96 100644 +--- a/net/ipv4/fib_semantics.c ++++ b/net/ipv4/fib_semantics.c +@@ -860,6 +860,8 @@ struct fib_info *fib_create_info(struct fib_config *cfg) + val = 65535 - 40; + if (type == RTAX_MTU && val > 65535 - 15) + val = 65535 - 15; ++ if (type == RTAX_HOPLIMIT && val > 255) ++ val = 255; + fi->fib_metrics[type - 1] = val; + } + } +diff --git a/net/ipv4/route.c b/net/ipv4/route.c +index ae001e8e81b9..1454176792b3 100644 +--- a/net/ipv4/route.c ++++ b/net/ipv4/route.c +@@ -1968,6 +1968,18 @@ static struct rtable *__mkroute_output(const struct fib_result *res, + */ + if (fi && res->prefixlen < 4) + fi = NULL; ++ } else if ((type == RTN_LOCAL) && (orig_oif != 0) && ++ (orig_oif != dev_out->ifindex)) { ++ /* For local routes that require a particular output interface ++ * we do not want to cache the result. Caching the result ++ * causes incorrect behaviour when there are multiple source ++ * addresses on the interface, the end result being that if the ++ * intended recipient is waiting on that interface for the ++ * packet he won't receive it because it will be delivered on ++ * the loopback interface and the IP_PKTINFO ipi_ifindex will ++ * be set to the loopback interface as well. ++ */ ++ fi = NULL; + } + + fnhe = NULL; +diff --git a/net/ipv6/route.c b/net/ipv6/route.c +index 0464f9a9d2dc..f862c7688c99 100644 +--- a/net/ipv6/route.c ++++ b/net/ipv6/route.c +@@ -1670,7 +1670,11 @@ install_route: + goto out; + } + +- dst_metric_set(&rt->dst, type, nla_get_u32(nla)); ++ if (type == RTAX_HOPLIMIT && nla_get_u32(nla) > 255) ++ dst_metric_set(&rt->dst, type, 255); ++ else ++ dst_metric_set(&rt->dst, type, ++ nla_get_u32(nla)); + } + } + } +diff --git a/net/llc/af_llc.c b/net/llc/af_llc.c +index c71b699eb555..a6c281ddd8b4 100644 +--- a/net/llc/af_llc.c ++++ b/net/llc/af_llc.c +@@ -626,6 +626,7 @@ static void llc_cmsg_rcv(struct msghdr *msg, struct sk_buff *skb) + if (llc->cmsg_flags & LLC_CMSG_PKTINFO) { + struct llc_pktinfo info; + ++ memset(&info, 0, sizeof(info)); + info.lpi_ifindex = llc_sk(skb->sk)->dev->ifindex; + llc_pdu_decode_dsap(skb, &info.lpi_sap); + llc_pdu_decode_da(skb, info.lpi_mac); +diff --git a/net/netfilter/ipvs/ip_vs_pe_sip.c b/net/netfilter/ipvs/ip_vs_pe_sip.c +index bed5f7042529..bb318e4623a3 100644 +--- a/net/netfilter/ipvs/ip_vs_pe_sip.c ++++ b/net/netfilter/ipvs/ip_vs_pe_sip.c +@@ -88,7 +88,7 @@ ip_vs_sip_fill_param(struct ip_vs_conn_param *p, struct sk_buff *skb) + dptr = skb->data + dataoff; + datalen = skb->len - dataoff; + +- if (get_callid(dptr, dataoff, datalen, &matchoff, &matchlen)) ++ if (get_callid(dptr, 0, datalen, &matchoff, &matchlen)) + return -EINVAL; + + /* N.B: pe_data is only set on success, +diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c +index 370ee2b9713d..63d0f92f45d0 100644 +--- a/net/packet/af_packet.c ++++ b/net/packet/af_packet.c +@@ -2977,6 +2977,7 @@ static int packet_mc_add(struct sock *sk, struct packet_mreq_max *mreq) + i->ifindex = mreq->mr_ifindex; + i->alen = mreq->mr_alen; + memcpy(i->addr, mreq->mr_address, i->alen); ++ memset(i->addr + i->alen, 0, sizeof(i->addr) - i->alen); + i->count = 1; + i->next = po->mclist; + po->mclist = i; +diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c +index b87e83d07478..14ac1a1e1bbf 100644 +--- a/net/sched/sch_netem.c ++++ b/net/sched/sch_netem.c +@@ -394,6 +394,25 @@ static void tfifo_enqueue(struct sk_buff *nskb, struct Qdisc *sch) + sch->q.qlen++; + } + ++/* netem can't properly corrupt a megapacket (like we get from GSO), so instead ++ * when we statistically choose to corrupt one, we instead segment it, returning ++ * the first packet to be corrupted, and re-enqueue the remaining frames ++ */ ++static struct sk_buff *netem_segment(struct sk_buff *skb, struct Qdisc *sch) ++{ ++ struct sk_buff *segs; ++ netdev_features_t features = netif_skb_features(skb); ++ ++ segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK); ++ ++ if (IS_ERR_OR_NULL(segs)) { ++ qdisc_reshape_fail(skb, sch); ++ return NULL; ++ } ++ consume_skb(skb); ++ return segs; ++} ++ + /* + * Insert one skb into qdisc. + * Note: parent depends on return value to account for queue length. +@@ -406,7 +425,11 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch) + /* We don't fill cb now as skb_unshare() may invalidate it */ + struct netem_skb_cb *cb; + struct sk_buff *skb2; ++ struct sk_buff *segs = NULL; ++ unsigned int len = 0, last_len; ++ int nb = 0; + int count = 1; ++ int rc = NET_XMIT_SUCCESS; + + /* Random duplication */ + if (q->duplicate && q->duplicate >= get_crandom(&q->dup_cor)) +@@ -452,10 +475,23 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch) + * do it now in software before we mangle it. + */ + if (q->corrupt && q->corrupt >= get_crandom(&q->corrupt_cor)) { ++ if (skb_is_gso(skb)) { ++ segs = netem_segment(skb, sch); ++ if (!segs) ++ return NET_XMIT_DROP; ++ } else { ++ segs = skb; ++ } ++ ++ skb = segs; ++ segs = segs->next; ++ + if (!(skb = skb_unshare(skb, GFP_ATOMIC)) || + (skb->ip_summed == CHECKSUM_PARTIAL && +- skb_checksum_help(skb))) +- return qdisc_drop(skb, sch); ++ skb_checksum_help(skb))) { ++ rc = qdisc_drop(skb, sch); ++ goto finish_segs; ++ } + + skb->data[net_random() % skb_headlen(skb)] ^= 1<<(net_random() % 8); + } +@@ -514,6 +550,27 @@ static int netem_enqueue(struct sk_buff *skb, struct Qdisc *sch) + sch->qstats.requeues++; + } + ++finish_segs: ++ if (segs) { ++ while (segs) { ++ skb2 = segs->next; ++ segs->next = NULL; ++ qdisc_skb_cb(segs)->pkt_len = segs->len; ++ last_len = segs->len; ++ rc = qdisc_enqueue(segs, sch); ++ if (rc != NET_XMIT_SUCCESS) { ++ if (net_xmit_drop_count(rc)) ++ sch->qstats.drops++; ++ } else { ++ nb++; ++ len += last_len; ++ } ++ segs = skb2; ++ } ++ sch->q.qlen += nb; ++ if (nb > 1) ++ qdisc_tree_decrease_qlen(sch, 1 - nb); ++ } + return NET_XMIT_SUCCESS; + } + +diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c +index f3e2b7d8f325..b81e0a33a8be 100644 +--- a/net/sunrpc/cache.c ++++ b/net/sunrpc/cache.c +@@ -1189,14 +1189,14 @@ int sunrpc_cache_pipe_upcall(struct cache_detail *detail, struct cache_head *h) + } + + crq->q.reader = 0; +- crq->item = cache_get(h); + crq->buf = buf; + crq->len = 0; + crq->readers = 0; + spin_lock(&queue_lock); +- if (test_bit(CACHE_PENDING, &h->flags)) ++ if (test_bit(CACHE_PENDING, &h->flags)) { ++ crq->item = cache_get(h); + list_add_tail(&crq->q.list, &detail->queue); +- else ++ } else + /* Lost a race, no longer PENDING, so don't enqueue */ + ret = -EAGAIN; + spin_unlock(&queue_lock); +diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c +index 85d232bed87d..e8d3313ea2c9 100644 +--- a/net/vmw_vsock/af_vsock.c ++++ b/net/vmw_vsock/af_vsock.c +@@ -1796,27 +1796,8 @@ vsock_stream_recvmsg(struct kiocb *kiocb, + else if (sk->sk_shutdown & RCV_SHUTDOWN) + err = 0; + +- if (copied > 0) { +- /* We only do these additional bookkeeping/notification steps +- * if we actually copied something out of the queue pair +- * instead of just peeking ahead. +- */ +- +- if (!(flags & MSG_PEEK)) { +- /* If the other side has shutdown for sending and there +- * is nothing more to read, then modify the socket +- * state. +- */ +- if (vsk->peer_shutdown & SEND_SHUTDOWN) { +- if (vsock_stream_has_data(vsk) <= 0) { +- sk->sk_state = SS_UNCONNECTED; +- sock_set_flag(sk, SOCK_DONE); +- sk->sk_state_change(sk); +- } +- } +- } ++ if (copied > 0) + err = copied; +- } + + out_wait: + finish_wait(sk_sleep(sk), &wait); +diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c +index 79c3e641581d..cda142009426 100644 +--- a/net/wireless/nl80211.c ++++ b/net/wireless/nl80211.c +@@ -11156,7 +11156,7 @@ static int nl80211_netlink_notify(struct notifier_block * nb, + struct wireless_dev *wdev; + struct cfg80211_beacon_registration *reg, *tmp; + +- if (state != NETLINK_URELEASE) ++ if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC) + return NOTIFY_DONE; + + rcu_read_lock(); +diff --git a/net/x25/x25_facilities.c b/net/x25/x25_facilities.c +index b8253250d723..c42bf2b8ec4f 100644 +--- a/net/x25/x25_facilities.c ++++ b/net/x25/x25_facilities.c +@@ -275,6 +275,7 @@ int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk, + + memset(&theirs, 0, sizeof(theirs)); + memcpy(new, ours, sizeof(*new)); ++ memset(dte, 0, sizeof(*dte)); + + len = x25_parse_facilities(skb, &theirs, dte, &x25->vc_facil_mask); + if (len < 0) +diff --git a/scripts/asn1_compiler.c b/scripts/asn1_compiler.c +index db0e5cd34c70..91c4117637ae 100644 +--- a/scripts/asn1_compiler.c ++++ b/scripts/asn1_compiler.c +@@ -1353,6 +1353,8 @@ static void render_out_of_line_list(FILE *out) + render_opcode(out, "ASN1_OP_END_SET_OF%s,\n", act); + render_opcode(out, "_jump_target(%u),\n", entry); + break; ++ default: ++ break; + } + if (e->action) + render_opcode(out, "_action(ACT_%s),\n", +diff --git a/sound/soc/codecs/rt5640.c b/sound/soc/codecs/rt5640.c +index aa5253a3548e..5929116fd886 100644 +--- a/sound/soc/codecs/rt5640.c ++++ b/sound/soc/codecs/rt5640.c +@@ -358,7 +358,7 @@ static unsigned int bst_tlv[] = { + + /* Interface data select */ + static const char * const rt5640_data_select[] = { +- "Normal", "left copy to right", "right copy to left", "Swap"}; ++ "Normal", "Swap", "left copy to right", "right copy to left"}; + + static const SOC_ENUM_SINGLE_DECL(rt5640_if1_dac_enum, RT5640_DIG_INF_DATA, + RT5640_IF1_DAC_SEL_SFT, rt5640_data_select); +diff --git a/sound/soc/codecs/rt5640.h b/sound/soc/codecs/rt5640.h +index 5e8df25a13f3..02e3fe767df6 100644 +--- a/sound/soc/codecs/rt5640.h ++++ b/sound/soc/codecs/rt5640.h +@@ -435,39 +435,39 @@ + #define RT5640_IF1_DAC_SEL_MASK (0x3 << 14) + #define RT5640_IF1_DAC_SEL_SFT 14 + #define RT5640_IF1_DAC_SEL_NOR (0x0 << 14) +-#define RT5640_IF1_DAC_SEL_L2R (0x1 << 14) +-#define RT5640_IF1_DAC_SEL_R2L (0x2 << 14) +-#define RT5640_IF1_DAC_SEL_SWAP (0x3 << 14) ++#define RT5640_IF1_DAC_SEL_SWAP (0x1 << 14) ++#define RT5640_IF1_DAC_SEL_L2R (0x2 << 14) ++#define RT5640_IF1_DAC_SEL_R2L (0x3 << 14) + #define RT5640_IF1_ADC_SEL_MASK (0x3 << 12) + #define RT5640_IF1_ADC_SEL_SFT 12 + #define RT5640_IF1_ADC_SEL_NOR (0x0 << 12) +-#define RT5640_IF1_ADC_SEL_L2R (0x1 << 12) +-#define RT5640_IF1_ADC_SEL_R2L (0x2 << 12) +-#define RT5640_IF1_ADC_SEL_SWAP (0x3 << 12) ++#define RT5640_IF1_ADC_SEL_SWAP (0x1 << 12) ++#define RT5640_IF1_ADC_SEL_L2R (0x2 << 12) ++#define RT5640_IF1_ADC_SEL_R2L (0x3 << 12) + #define RT5640_IF2_DAC_SEL_MASK (0x3 << 10) + #define RT5640_IF2_DAC_SEL_SFT 10 + #define RT5640_IF2_DAC_SEL_NOR (0x0 << 10) +-#define RT5640_IF2_DAC_SEL_L2R (0x1 << 10) +-#define RT5640_IF2_DAC_SEL_R2L (0x2 << 10) +-#define RT5640_IF2_DAC_SEL_SWAP (0x3 << 10) ++#define RT5640_IF2_DAC_SEL_SWAP (0x1 << 10) ++#define RT5640_IF2_DAC_SEL_L2R (0x2 << 10) ++#define RT5640_IF2_DAC_SEL_R2L (0x3 << 10) + #define RT5640_IF2_ADC_SEL_MASK (0x3 << 8) + #define RT5640_IF2_ADC_SEL_SFT 8 + #define RT5640_IF2_ADC_SEL_NOR (0x0 << 8) +-#define RT5640_IF2_ADC_SEL_L2R (0x1 << 8) +-#define RT5640_IF2_ADC_SEL_R2L (0x2 << 8) +-#define RT5640_IF2_ADC_SEL_SWAP (0x3 << 8) ++#define RT5640_IF2_ADC_SEL_SWAP (0x1 << 8) ++#define RT5640_IF2_ADC_SEL_L2R (0x2 << 8) ++#define RT5640_IF2_ADC_SEL_R2L (0x3 << 8) + #define RT5640_IF3_DAC_SEL_MASK (0x3 << 6) + #define RT5640_IF3_DAC_SEL_SFT 6 + #define RT5640_IF3_DAC_SEL_NOR (0x0 << 6) +-#define RT5640_IF3_DAC_SEL_L2R (0x1 << 6) +-#define RT5640_IF3_DAC_SEL_R2L (0x2 << 6) +-#define RT5640_IF3_DAC_SEL_SWAP (0x3 << 6) ++#define RT5640_IF3_DAC_SEL_SWAP (0x1 << 6) ++#define RT5640_IF3_DAC_SEL_L2R (0x2 << 6) ++#define RT5640_IF3_DAC_SEL_R2L (0x3 << 6) + #define RT5640_IF3_ADC_SEL_MASK (0x3 << 4) + #define RT5640_IF3_ADC_SEL_SFT 4 + #define RT5640_IF3_ADC_SEL_NOR (0x0 << 4) +-#define RT5640_IF3_ADC_SEL_L2R (0x1 << 4) +-#define RT5640_IF3_ADC_SEL_R2L (0x2 << 4) +-#define RT5640_IF3_ADC_SEL_SWAP (0x3 << 4) ++#define RT5640_IF3_ADC_SEL_SWAP (0x1 << 4) ++#define RT5640_IF3_ADC_SEL_L2R (0x2 << 4) ++#define RT5640_IF3_ADC_SEL_R2L (0x3 << 4) + + /* REC Left Mixer Control 1 (0x3b) */ + #define RT5640_G_HP_L_RM_L_MASK (0x7 << 13) +diff --git a/sound/soc/samsung/s3c-i2s-v2.c b/sound/soc/samsung/s3c-i2s-v2.c +index e5e81b111001..a2edb3c904a3 100644 +--- a/sound/soc/samsung/s3c-i2s-v2.c ++++ b/sound/soc/samsung/s3c-i2s-v2.c +@@ -730,7 +730,7 @@ static int s3c2412_i2s_resume(struct snd_soc_dai *dai) + #endif + + int s3c_i2sv2_register_component(struct device *dev, int id, +- struct snd_soc_component_driver *cmp_drv, ++ const struct snd_soc_component_driver *cmp_drv, + struct snd_soc_dai_driver *dai_drv) + { + struct snd_soc_dai_ops *ops = drv->ops; +diff --git a/sound/soc/samsung/s3c-i2s-v2.h b/sound/soc/samsung/s3c-i2s-v2.h +index 90abab364b49..d0684145ed1f 100644 +--- a/sound/soc/samsung/s3c-i2s-v2.h ++++ b/sound/soc/samsung/s3c-i2s-v2.h +@@ -101,7 +101,7 @@ extern int s3c_i2sv2_probe(struct snd_soc_dai *dai, + * soc core. + */ + extern int s3c_i2sv2_register_component(struct device *dev, int id, +- struct snd_soc_component_driver *cmp_drv, ++ const struct snd_soc_component_driver *cmp_drv, + struct snd_soc_dai_driver *dai_drv); + + #endif /* __SND_SOC_S3C24XX_S3C_I2SV2_I2S_H */ +diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt +index 73c9759005a3..0f5e3d75f623 100644 +--- a/tools/perf/Documentation/perf-stat.txt ++++ b/tools/perf/Documentation/perf-stat.txt +@@ -50,6 +50,14 @@ OPTIONS + --scale:: + scale/normalize counter values + ++-d:: ++--detailed:: ++ print more detailed statistics, can be specified up to 3 times ++ ++ -d: detailed events, L1 and LLC data cache ++ -d -d: more detailed events, dTLB and iTLB events ++ -d -d -d: very detailed events, adding prefetch events ++ + -r:: + --repeat=<n>:: + repeat command and print average + stddev (max: 100). 0 means forever.
