commit: 0747b60014a664daa66d43acaf0c11716f2cb94a Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Nov 8 13:50:47 2017 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Nov 8 13:50:47 2017 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=0747b600
Linux patch 4.4.97 0000_README | 4 + 1096_linux-4.4.97.patch | 1557 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1561 insertions(+) diff --git a/0000_README b/0000_README index 5d56409..cc06fad 100644 --- a/0000_README +++ b/0000_README @@ -427,6 +427,10 @@ Patch: 1095_linux-4.4.96.patch From: http://www.kernel.org Desc: Linux 4.4.96 +Patch: 1096_linux-4.4.97.patch +From: http://www.kernel.org +Desc: Linux 4.4.97 + 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/1096_linux-4.4.97.patch b/1096_linux-4.4.97.patch new file mode 100644 index 0000000..f757746 --- /dev/null +++ b/1096_linux-4.4.97.patch @@ -0,0 +1,1557 @@ +diff --git a/Makefile b/Makefile +index 12dfe1dcbaca..fb1a40d64ba8 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 4 +-SUBLEVEL = 96 ++SUBLEVEL = 97 + EXTRAVERSION = + NAME = Blurry Fish Butt + +diff --git a/arch/arm/boot/dts/armada-375.dtsi b/arch/arm/boot/dts/armada-375.dtsi +index cc952cf8ec30..024f1b75b0a3 100644 +--- a/arch/arm/boot/dts/armada-375.dtsi ++++ b/arch/arm/boot/dts/armada-375.dtsi +@@ -176,9 +176,9 @@ + reg = <0x8000 0x1000>; + cache-unified; + cache-level = <2>; +- arm,double-linefill-incr = <1>; ++ arm,double-linefill-incr = <0>; + arm,double-linefill-wrap = <0>; +- arm,double-linefill = <1>; ++ arm,double-linefill = <0>; + prefetch-data = <1>; + }; + +diff --git a/arch/arm/boot/dts/armada-38x.dtsi b/arch/arm/boot/dts/armada-38x.dtsi +index e8b7f6726772..bf20918f1fad 100644 +--- a/arch/arm/boot/dts/armada-38x.dtsi ++++ b/arch/arm/boot/dts/armada-38x.dtsi +@@ -143,9 +143,9 @@ + reg = <0x8000 0x1000>; + cache-unified; + cache-level = <2>; +- arm,double-linefill-incr = <1>; ++ arm,double-linefill-incr = <0>; + arm,double-linefill-wrap = <0>; +- arm,double-linefill = <1>; ++ arm,double-linefill = <0>; + prefetch-data = <1>; + }; + +diff --git a/arch/arm/boot/dts/armada-39x.dtsi b/arch/arm/boot/dts/armada-39x.dtsi +index dc6efd386dbc..e67f1fd7a4d1 100644 +--- a/arch/arm/boot/dts/armada-39x.dtsi ++++ b/arch/arm/boot/dts/armada-39x.dtsi +@@ -104,9 +104,9 @@ + reg = <0x8000 0x1000>; + cache-unified; + cache-level = <2>; +- arm,double-linefill-incr = <1>; ++ arm,double-linefill-incr = <0>; + arm,double-linefill-wrap = <0>; +- arm,double-linefill = <1>; ++ arm,double-linefill = <0>; + prefetch-data = <1>; + }; + +diff --git a/arch/arm/include/asm/Kbuild b/arch/arm/include/asm/Kbuild +index bd425302c97a..628a38a11a70 100644 +--- a/arch/arm/include/asm/Kbuild ++++ b/arch/arm/include/asm/Kbuild +@@ -36,4 +36,3 @@ generic-y += termbits.h + generic-y += termios.h + generic-y += timex.h + generic-y += trace_clock.h +-generic-y += unaligned.h +diff --git a/arch/arm/include/asm/unaligned.h b/arch/arm/include/asm/unaligned.h +new file mode 100644 +index 000000000000..ab905ffcf193 +--- /dev/null ++++ b/arch/arm/include/asm/unaligned.h +@@ -0,0 +1,27 @@ ++#ifndef __ASM_ARM_UNALIGNED_H ++#define __ASM_ARM_UNALIGNED_H ++ ++/* ++ * We generally want to set CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS on ARMv6+, ++ * but we don't want to use linux/unaligned/access_ok.h since that can lead ++ * to traps on unaligned stm/ldm or strd/ldrd. ++ */ ++#include <asm/byteorder.h> ++ ++#if defined(__LITTLE_ENDIAN) ++# include <linux/unaligned/le_struct.h> ++# include <linux/unaligned/be_byteshift.h> ++# include <linux/unaligned/generic.h> ++# define get_unaligned __get_unaligned_le ++# define put_unaligned __put_unaligned_le ++#elif defined(__BIG_ENDIAN) ++# include <linux/unaligned/be_struct.h> ++# include <linux/unaligned/le_byteshift.h> ++# include <linux/unaligned/generic.h> ++# define get_unaligned __get_unaligned_be ++# define put_unaligned __put_unaligned_be ++#else ++# error need to define endianess ++#endif ++ ++#endif /* __ASM_ARM_UNALIGNED_H */ +diff --git a/arch/arm/mach-pxa/balloon3.c b/arch/arm/mach-pxa/balloon3.c +index a727282bfa99..761d7d64d643 100644 +--- a/arch/arm/mach-pxa/balloon3.c ++++ b/arch/arm/mach-pxa/balloon3.c +@@ -17,6 +17,7 @@ + #include <linux/init.h> + #include <linux/platform_device.h> + #include <linux/interrupt.h> ++#include <linux/leds.h> + #include <linux/sched.h> + #include <linux/bitops.h> + #include <linux/fb.h> +diff --git a/arch/arm/mach-pxa/colibri-pxa270-income.c b/arch/arm/mach-pxa/colibri-pxa270-income.c +index db20d25daaab..1b92a4112bd1 100644 +--- a/arch/arm/mach-pxa/colibri-pxa270-income.c ++++ b/arch/arm/mach-pxa/colibri-pxa270-income.c +@@ -17,6 +17,7 @@ + #include <linux/gpio.h> + #include <linux/init.h> + #include <linux/interrupt.h> ++#include <linux/leds.h> + #include <linux/ioport.h> + #include <linux/kernel.h> + #include <linux/platform_device.h> +diff --git a/arch/arm/mach-pxa/corgi.c b/arch/arm/mach-pxa/corgi.c +index 89f790dda93e..d1f12909f740 100644 +--- a/arch/arm/mach-pxa/corgi.c ++++ b/arch/arm/mach-pxa/corgi.c +@@ -18,6 +18,7 @@ + #include <linux/major.h> + #include <linux/fs.h> + #include <linux/interrupt.h> ++#include <linux/leds.h> + #include <linux/mmc/host.h> + #include <linux/mtd/physmap.h> + #include <linux/pm.h> +diff --git a/arch/arm/mach-pxa/trizeps4.c b/arch/arm/mach-pxa/trizeps4.c +index 066e3a250ee0..5e50c53f1f4b 100644 +--- a/arch/arm/mach-pxa/trizeps4.c ++++ b/arch/arm/mach-pxa/trizeps4.c +@@ -16,6 +16,7 @@ + #include <linux/kernel.h> + #include <linux/platform_device.h> + #include <linux/interrupt.h> ++#include <linux/leds.h> + #include <linux/export.h> + #include <linux/sched.h> + #include <linux/bitops.h> +diff --git a/arch/arm/mach-pxa/vpac270.c b/arch/arm/mach-pxa/vpac270.c +index 54122a983ae3..2cce92924068 100644 +--- a/arch/arm/mach-pxa/vpac270.c ++++ b/arch/arm/mach-pxa/vpac270.c +@@ -15,6 +15,7 @@ + #include <linux/irq.h> + #include <linux/gpio_keys.h> + #include <linux/input.h> ++#include <linux/leds.h> + #include <linux/gpio.h> + #include <linux/usb/gpio_vbus.h> + #include <linux/mtd/mtd.h> +diff --git a/arch/arm/mach-pxa/zeus.c b/arch/arm/mach-pxa/zeus.c +index 30e62a3f0701..d757cfb5f8a6 100644 +--- a/arch/arm/mach-pxa/zeus.c ++++ b/arch/arm/mach-pxa/zeus.c +@@ -13,6 +13,7 @@ + + #include <linux/cpufreq.h> + #include <linux/interrupt.h> ++#include <linux/leds.h> + #include <linux/irq.h> + #include <linux/pm.h> + #include <linux/gpio.h> +diff --git a/arch/arm/mach-pxa/zylonite.c b/arch/arm/mach-pxa/zylonite.c +index e20359a7433c..d7f0a7d87ef2 100644 +--- a/arch/arm/mach-pxa/zylonite.c ++++ b/arch/arm/mach-pxa/zylonite.c +@@ -16,6 +16,7 @@ + #include <linux/module.h> + #include <linux/kernel.h> + #include <linux/interrupt.h> ++#include <linux/leds.h> + #include <linux/init.h> + #include <linux/platform_device.h> + #include <linux/gpio.h> +diff --git a/arch/arm64/kernel/traps.c b/arch/arm64/kernel/traps.c +index ca7f0ac5f708..210826d5bba5 100644 +--- a/arch/arm64/kernel/traps.c ++++ b/arch/arm64/kernel/traps.c +@@ -129,7 +129,7 @@ static void dump_instr(const char *lvl, struct pt_regs *regs) + for (i = -4; i < 1; i++) { + unsigned int val, bad; + +- bad = __get_user(val, &((u32 *)addr)[i]); ++ bad = get_user(val, &((u32 *)addr)[i]); + + if (!bad) + p += sprintf(p, i == 0 ? "(%08x) " : "%08x ", val); +diff --git a/drivers/base/power/wakeirq.c b/drivers/base/power/wakeirq.c +index 404d94c6c8bc..feba1b211898 100644 +--- a/drivers/base/power/wakeirq.c ++++ b/drivers/base/power/wakeirq.c +@@ -141,6 +141,13 @@ static irqreturn_t handle_threaded_wake_irq(int irq, void *_wirq) + struct wake_irq *wirq = _wirq; + int res; + ++ /* Maybe abort suspend? */ ++ if (irqd_is_wakeup_set(irq_get_irq_data(irq))) { ++ pm_wakeup_event(wirq->dev, 0); ++ ++ return IRQ_HANDLED; ++ } ++ + /* We don't want RPM_ASYNC or RPM_NOWAIT here */ + res = pm_runtime_resume(wirq->dev); + if (res < 0) +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c +index bb0da76051a1..e5da6f19b9b8 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c +@@ -284,6 +284,10 @@ static void amdgpu_vce_idle_work_handler(struct work_struct *work) + amdgpu_dpm_enable_vce(adev, false); + } else { + amdgpu_asic_set_vce_clocks(adev, 0, 0); ++ amdgpu_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_VCE, ++ AMD_PG_STATE_GATE); ++ amdgpu_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_VCE, ++ AMD_CG_STATE_GATE); + } + } else { + schedule_delayed_work(&adev->vce.idle_work, +@@ -315,6 +319,11 @@ static void amdgpu_vce_note_usage(struct amdgpu_device *adev) + amdgpu_dpm_enable_vce(adev, true); + } else { + amdgpu_asic_set_vce_clocks(adev, 53300, 40000); ++ amdgpu_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_VCE, ++ AMD_CG_STATE_UNGATE); ++ amdgpu_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_VCE, ++ AMD_PG_STATE_UNGATE); ++ + } + } + } +diff --git a/drivers/gpu/drm/msm/msm_gem_submit.c b/drivers/gpu/drm/msm/msm_gem_submit.c +index fed44d4e5b72..f4eaccb191d4 100644 +--- a/drivers/gpu/drm/msm/msm_gem_submit.c ++++ b/drivers/gpu/drm/msm/msm_gem_submit.c +@@ -34,10 +34,13 @@ static inline void __user *to_user_ptr(u64 address) + } + + static struct msm_gem_submit *submit_create(struct drm_device *dev, +- struct msm_gpu *gpu, int nr) ++ struct msm_gpu *gpu, uint32_t nr) + { + struct msm_gem_submit *submit; +- int sz = sizeof(*submit) + (nr * sizeof(submit->bos[0])); ++ uint64_t sz = sizeof(*submit) + ((u64)nr * sizeof(submit->bos[0])); ++ ++ if (sz > SIZE_MAX) ++ return NULL; + + submit = kmalloc(sz, GFP_TEMPORARY | __GFP_NOWARN | __GFP_NORETRY); + if (submit) { +diff --git a/drivers/i2c/busses/i2c-riic.c b/drivers/i2c/busses/i2c-riic.c +index d7e3af671543..d8803c3bbfdc 100644 +--- a/drivers/i2c/busses/i2c-riic.c ++++ b/drivers/i2c/busses/i2c-riic.c +@@ -80,6 +80,7 @@ + #define ICIER_TEIE 0x40 + #define ICIER_RIE 0x20 + #define ICIER_NAKIE 0x10 ++#define ICIER_SPIE 0x08 + + #define ICSR2_NACKF 0x10 + +@@ -216,11 +217,10 @@ static irqreturn_t riic_tend_isr(int irq, void *data) + return IRQ_NONE; + } + +- if (riic->is_last || riic->err) ++ if (riic->is_last || riic->err) { ++ riic_clear_set_bit(riic, 0, ICIER_SPIE, RIIC_ICIER); + writeb(ICCR2_SP, riic->base + RIIC_ICCR2); +- +- writeb(0, riic->base + RIIC_ICIER); +- complete(&riic->msg_done); ++ } + + return IRQ_HANDLED; + } +@@ -240,13 +240,13 @@ static irqreturn_t riic_rdrf_isr(int irq, void *data) + + if (riic->bytes_left == 1) { + /* STOP must come before we set ACKBT! */ +- if (riic->is_last) ++ if (riic->is_last) { ++ riic_clear_set_bit(riic, 0, ICIER_SPIE, RIIC_ICIER); + writeb(ICCR2_SP, riic->base + RIIC_ICCR2); ++ } + + riic_clear_set_bit(riic, 0, ICMR3_ACKBT, RIIC_ICMR3); + +- writeb(0, riic->base + RIIC_ICIER); +- complete(&riic->msg_done); + } else { + riic_clear_set_bit(riic, ICMR3_ACKBT, 0, RIIC_ICMR3); + } +@@ -259,6 +259,21 @@ static irqreturn_t riic_rdrf_isr(int irq, void *data) + return IRQ_HANDLED; + } + ++static irqreturn_t riic_stop_isr(int irq, void *data) ++{ ++ struct riic_dev *riic = data; ++ ++ /* read back registers to confirm writes have fully propagated */ ++ writeb(0, riic->base + RIIC_ICSR2); ++ readb(riic->base + RIIC_ICSR2); ++ writeb(0, riic->base + RIIC_ICIER); ++ readb(riic->base + RIIC_ICIER); ++ ++ complete(&riic->msg_done); ++ ++ return IRQ_HANDLED; ++} ++ + static u32 riic_func(struct i2c_adapter *adap) + { + return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; +@@ -326,6 +341,7 @@ static struct riic_irq_desc riic_irqs[] = { + { .res_num = 0, .isr = riic_tend_isr, .name = "riic-tend" }, + { .res_num = 1, .isr = riic_rdrf_isr, .name = "riic-rdrf" }, + { .res_num = 2, .isr = riic_tdre_isr, .name = "riic-tdre" }, ++ { .res_num = 3, .isr = riic_stop_isr, .name = "riic-stop" }, + { .res_num = 5, .isr = riic_tend_isr, .name = "riic-nack" }, + }; + +diff --git a/drivers/media/pci/bt8xx/dvb-bt8xx.c b/drivers/media/pci/bt8xx/dvb-bt8xx.c +index d407244fd1bc..bd0f5b195188 100644 +--- a/drivers/media/pci/bt8xx/dvb-bt8xx.c ++++ b/drivers/media/pci/bt8xx/dvb-bt8xx.c +@@ -680,6 +680,7 @@ static void frontend_init(struct dvb_bt8xx_card *card, u32 type) + /* DST is not a frontend, attaching the ASIC */ + if (dvb_attach(dst_attach, state, &card->dvb_adapter) == NULL) { + pr_err("%s: Could not find a Twinhan DST\n", __func__); ++ kfree(state); + break; + } + /* Attach other DST peripherals if any */ +diff --git a/drivers/media/platform/exynos4-is/fimc-is.c b/drivers/media/platform/exynos4-is/fimc-is.c +index 49658ca39e51..a851f20dca23 100644 +--- a/drivers/media/platform/exynos4-is/fimc-is.c ++++ b/drivers/media/platform/exynos4-is/fimc-is.c +@@ -815,12 +815,13 @@ static int fimc_is_probe(struct platform_device *pdev) + is->irq = irq_of_parse_and_map(dev->of_node, 0); + if (!is->irq) { + dev_err(dev, "no irq found\n"); +- return -EINVAL; ++ ret = -EINVAL; ++ goto err_iounmap; + } + + ret = fimc_is_get_clocks(is); + if (ret < 0) +- return ret; ++ goto err_iounmap; + + platform_set_drvdata(pdev, is); + +@@ -880,6 +881,8 @@ err_irq: + free_irq(is->irq, is); + err_clk: + fimc_is_put_clocks(is); ++err_iounmap: ++ iounmap(is->pmu_regs); + return ret; + } + +@@ -935,6 +938,7 @@ static int fimc_is_remove(struct platform_device *pdev) + fimc_is_unregister_subdevs(is); + vb2_dma_contig_cleanup_ctx(is->alloc_ctx); + fimc_is_put_clocks(is); ++ iounmap(is->pmu_regs); + fimc_is_debugfs_remove(is); + release_firmware(is->fw.f_w); + fimc_is_free_cpu_memory(is); +diff --git a/drivers/media/usb/cx231xx/cx231xx-core.c b/drivers/media/usb/cx231xx/cx231xx-core.c +index 19b0293312a0..07670117f922 100644 +--- a/drivers/media/usb/cx231xx/cx231xx-core.c ++++ b/drivers/media/usb/cx231xx/cx231xx-core.c +@@ -356,7 +356,12 @@ int cx231xx_send_vendor_cmd(struct cx231xx *dev, + */ + if ((ven_req->wLength > 4) && ((ven_req->bRequest == 0x4) || + (ven_req->bRequest == 0x5) || +- (ven_req->bRequest == 0x6))) { ++ (ven_req->bRequest == 0x6) || ++ ++ /* Internal Master 3 Bus can send ++ * and receive only 4 bytes per time ++ */ ++ (ven_req->bRequest == 0x2))) { + unsend_size = 0; + pdata = ven_req->pBuff; + +diff --git a/drivers/mfd/ab8500-sysctrl.c b/drivers/mfd/ab8500-sysctrl.c +index 0d1825696153..405ce78c1ef4 100644 +--- a/drivers/mfd/ab8500-sysctrl.c ++++ b/drivers/mfd/ab8500-sysctrl.c +@@ -99,7 +99,7 @@ int ab8500_sysctrl_read(u16 reg, u8 *value) + u8 bank; + + if (sysctrl_dev == NULL) +- return -EINVAL; ++ return -EPROBE_DEFER; + + bank = (reg >> 8); + if (!valid_bank(bank)) +@@ -115,11 +115,13 @@ int ab8500_sysctrl_write(u16 reg, u8 mask, u8 value) + u8 bank; + + if (sysctrl_dev == NULL) +- return -EINVAL; ++ return -EPROBE_DEFER; + + bank = (reg >> 8); +- if (!valid_bank(bank)) ++ if (!valid_bank(bank)) { ++ pr_err("invalid bank\n"); + return -EINVAL; ++ } + + return abx500_mask_and_set_register_interruptible(sysctrl_dev, bank, + (u8)(reg & 0xFF), mask, value); +@@ -180,9 +182,15 @@ static int ab8500_sysctrl_remove(struct platform_device *pdev) + return 0; + } + ++static const struct of_device_id ab8500_sysctrl_match[] = { ++ { .compatible = "stericsson,ab8500-sysctrl", }, ++ {} ++}; ++ + static struct platform_driver ab8500_sysctrl_driver = { + .driver = { + .name = "ab8500-sysctrl", ++ .of_match_table = ab8500_sysctrl_match, + }, + .probe = ab8500_sysctrl_probe, + .remove = ab8500_sysctrl_remove, +diff --git a/drivers/mfd/axp20x.c b/drivers/mfd/axp20x.c +index 9842199e2e6c..89a2dd4d212a 100644 +--- a/drivers/mfd/axp20x.c ++++ b/drivers/mfd/axp20x.c +@@ -164,14 +164,14 @@ static struct resource axp22x_pek_resources[] = { + static struct resource axp288_power_button_resources[] = { + { + .name = "PEK_DBR", +- .start = AXP288_IRQ_POKN, +- .end = AXP288_IRQ_POKN, ++ .start = AXP288_IRQ_POKP, ++ .end = AXP288_IRQ_POKP, + .flags = IORESOURCE_IRQ, + }, + { + .name = "PEK_DBF", +- .start = AXP288_IRQ_POKP, +- .end = AXP288_IRQ_POKP, ++ .start = AXP288_IRQ_POKN, ++ .end = AXP288_IRQ_POKN, + .flags = IORESOURCE_IRQ, + }, + }; +diff --git a/drivers/misc/mei/client.c b/drivers/misc/mei/client.c +index 2ff39fbc70d1..df268365e04e 100644 +--- a/drivers/misc/mei/client.c ++++ b/drivers/misc/mei/client.c +@@ -1300,6 +1300,9 @@ int mei_cl_notify_request(struct mei_cl *cl, struct file *file, u8 request) + return -EOPNOTSUPP; + } + ++ if (!mei_cl_is_connected(cl)) ++ return -ENODEV; ++ + rets = pm_runtime_get(dev->dev); + if (rets < 0 && rets != -EINPROGRESS) { + pm_runtime_put_noidle(dev->dev); +diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c +index 6291d5042ef2..6fed41bd016a 100644 +--- a/drivers/mmc/host/s3cmci.c ++++ b/drivers/mmc/host/s3cmci.c +@@ -21,6 +21,7 @@ + #include <linux/debugfs.h> + #include <linux/seq_file.h> + #include <linux/gpio.h> ++#include <linux/interrupt.h> + #include <linux/irq.h> + #include <linux/io.h> + +diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c +index 9f713b832ba3..5c768c4627d3 100644 +--- a/drivers/platform/x86/intel_mid_thermal.c ++++ b/drivers/platform/x86/intel_mid_thermal.c +@@ -550,6 +550,7 @@ static const struct platform_device_id therm_id_table[] = { + { "msic_thermal", 1 }, + { } + }; ++MODULE_DEVICE_TABLE(platform, therm_id_table); + + static struct platform_driver mid_thermal_driver = { + .driver = { +diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c +index 84c13dffa3a8..e7a6f1222642 100644 +--- a/drivers/s390/block/dasd.c ++++ b/drivers/s390/block/dasd.c +@@ -1635,8 +1635,11 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm, + /* check for for attention message */ + if (scsw_dstat(&irb->scsw) & DEV_STAT_ATTENTION) { + device = dasd_device_from_cdev_locked(cdev); +- device->discipline->check_attention(device, irb->esw.esw1.lpum); +- dasd_put_device(device); ++ if (!IS_ERR(device)) { ++ device->discipline->check_attention(device, ++ irb->esw.esw1.lpum); ++ dasd_put_device(device); ++ } + } + + if (!cqr) +diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c +index e4c243748a97..de33801ca31e 100644 +--- a/drivers/scsi/aacraid/aachba.c ++++ b/drivers/scsi/aacraid/aachba.c +@@ -2977,16 +2977,11 @@ static void aac_srb_callback(void *context, struct fib * fibptr) + return; + + BUG_ON(fibptr == NULL); +- dev = fibptr->dev; +- +- scsi_dma_unmap(scsicmd); + +- /* expose physical device if expose_physicald flag is on */ +- if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01) +- && expose_physicals > 0) +- aac_expose_phy_device(scsicmd); ++ dev = fibptr->dev; + + srbreply = (struct aac_srb_reply *) fib_data(fibptr); ++ + scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ + + if (fibptr->flags & FIB_CONTEXT_FLAG_FASTRESP) { +@@ -2999,158 +2994,176 @@ static void aac_srb_callback(void *context, struct fib * fibptr) + */ + scsi_set_resid(scsicmd, scsi_bufflen(scsicmd) + - le32_to_cpu(srbreply->data_xfer_length)); +- /* +- * First check the fib status +- */ ++ } + +- if (le32_to_cpu(srbreply->status) != ST_OK) { +- int len; + +- printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status)); +- len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), +- SCSI_SENSE_BUFFERSIZE); +- scsicmd->result = DID_ERROR << 16 +- | COMMAND_COMPLETE << 8 +- | SAM_STAT_CHECK_CONDITION; +- memcpy(scsicmd->sense_buffer, +- srbreply->sense_data, len); +- } ++ scsi_dma_unmap(scsicmd); + +- /* +- * Next check the srb status +- */ +- switch ((le32_to_cpu(srbreply->srb_status))&0x3f) { +- case SRB_STATUS_ERROR_RECOVERY: +- case SRB_STATUS_PENDING: +- case SRB_STATUS_SUCCESS: +- scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; +- break; +- case SRB_STATUS_DATA_OVERRUN: +- switch (scsicmd->cmnd[0]) { +- case READ_6: +- case WRITE_6: +- case READ_10: +- case WRITE_10: +- case READ_12: +- case WRITE_12: +- case READ_16: +- case WRITE_16: +- if (le32_to_cpu(srbreply->data_xfer_length) +- < scsicmd->underflow) +- printk(KERN_WARNING"aacraid: SCSI CMD underflow\n"); +- else +- printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n"); +- scsicmd->result = DID_ERROR << 16 +- | COMMAND_COMPLETE << 8; +- break; +- case INQUIRY: { +- scsicmd->result = DID_OK << 16 +- | COMMAND_COMPLETE << 8; +- break; +- } +- default: +- scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; +- break; +- } +- break; +- case SRB_STATUS_ABORTED: +- scsicmd->result = DID_ABORT << 16 | ABORT << 8; +- break; +- case SRB_STATUS_ABORT_FAILED: +- /* +- * Not sure about this one - but assuming the +- * hba was trying to abort for some reason +- */ +- scsicmd->result = DID_ERROR << 16 | ABORT << 8; +- break; +- case SRB_STATUS_PARITY_ERROR: +- scsicmd->result = DID_PARITY << 16 +- | MSG_PARITY_ERROR << 8; +- break; +- case SRB_STATUS_NO_DEVICE: +- case SRB_STATUS_INVALID_PATH_ID: +- case SRB_STATUS_INVALID_TARGET_ID: +- case SRB_STATUS_INVALID_LUN: +- case SRB_STATUS_SELECTION_TIMEOUT: +- scsicmd->result = DID_NO_CONNECT << 16 +- | COMMAND_COMPLETE << 8; +- break; ++ /* expose physical device if expose_physicald flag is on */ ++ if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01) ++ && expose_physicals > 0) ++ aac_expose_phy_device(scsicmd); + +- case SRB_STATUS_COMMAND_TIMEOUT: +- case SRB_STATUS_TIMEOUT: +- scsicmd->result = DID_TIME_OUT << 16 +- | COMMAND_COMPLETE << 8; +- break; ++ /* ++ * First check the fib status ++ */ + +- case SRB_STATUS_BUSY: +- scsicmd->result = DID_BUS_BUSY << 16 +- | COMMAND_COMPLETE << 8; +- break; ++ if (le32_to_cpu(srbreply->status) != ST_OK) { ++ int len; + +- case SRB_STATUS_BUS_RESET: +- scsicmd->result = DID_RESET << 16 +- | COMMAND_COMPLETE << 8; +- break; ++ pr_warn("aac_srb_callback: srb failed, status = %d\n", ++ le32_to_cpu(srbreply->status)); ++ len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), ++ SCSI_SENSE_BUFFERSIZE); ++ scsicmd->result = DID_ERROR << 16 ++ | COMMAND_COMPLETE << 8 ++ | SAM_STAT_CHECK_CONDITION; ++ memcpy(scsicmd->sense_buffer, ++ srbreply->sense_data, len); ++ } + +- case SRB_STATUS_MESSAGE_REJECTED: ++ /* ++ * Next check the srb status ++ */ ++ switch ((le32_to_cpu(srbreply->srb_status))&0x3f) { ++ case SRB_STATUS_ERROR_RECOVERY: ++ case SRB_STATUS_PENDING: ++ case SRB_STATUS_SUCCESS: ++ scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; ++ break; ++ case SRB_STATUS_DATA_OVERRUN: ++ switch (scsicmd->cmnd[0]) { ++ case READ_6: ++ case WRITE_6: ++ case READ_10: ++ case WRITE_10: ++ case READ_12: ++ case WRITE_12: ++ case READ_16: ++ case WRITE_16: ++ if (le32_to_cpu(srbreply->data_xfer_length) ++ < scsicmd->underflow) ++ pr_warn("aacraid: SCSI CMD underflow\n"); ++ else ++ pr_warn("aacraid: SCSI CMD Data Overrun\n"); + scsicmd->result = DID_ERROR << 16 +- | MESSAGE_REJECT << 8; ++ | COMMAND_COMPLETE << 8; ++ break; ++ case INQUIRY: ++ scsicmd->result = DID_OK << 16 ++ | COMMAND_COMPLETE << 8; + break; +- case SRB_STATUS_REQUEST_FLUSHED: +- case SRB_STATUS_ERROR: +- case SRB_STATUS_INVALID_REQUEST: +- case SRB_STATUS_REQUEST_SENSE_FAILED: +- case SRB_STATUS_NO_HBA: +- case SRB_STATUS_UNEXPECTED_BUS_FREE: +- case SRB_STATUS_PHASE_SEQUENCE_FAILURE: +- case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: +- case SRB_STATUS_DELAYED_RETRY: +- case SRB_STATUS_BAD_FUNCTION: +- case SRB_STATUS_NOT_STARTED: +- case SRB_STATUS_NOT_IN_USE: +- case SRB_STATUS_FORCE_ABORT: +- case SRB_STATUS_DOMAIN_VALIDATION_FAIL: + default: ++ scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; ++ break; ++ } ++ break; ++ case SRB_STATUS_ABORTED: ++ scsicmd->result = DID_ABORT << 16 | ABORT << 8; ++ break; ++ case SRB_STATUS_ABORT_FAILED: ++ /* ++ * Not sure about this one - but assuming the ++ * hba was trying to abort for some reason ++ */ ++ scsicmd->result = DID_ERROR << 16 | ABORT << 8; ++ break; ++ case SRB_STATUS_PARITY_ERROR: ++ scsicmd->result = DID_PARITY << 16 ++ | MSG_PARITY_ERROR << 8; ++ break; ++ case SRB_STATUS_NO_DEVICE: ++ case SRB_STATUS_INVALID_PATH_ID: ++ case SRB_STATUS_INVALID_TARGET_ID: ++ case SRB_STATUS_INVALID_LUN: ++ case SRB_STATUS_SELECTION_TIMEOUT: ++ scsicmd->result = DID_NO_CONNECT << 16 ++ | COMMAND_COMPLETE << 8; ++ break; ++ ++ case SRB_STATUS_COMMAND_TIMEOUT: ++ case SRB_STATUS_TIMEOUT: ++ scsicmd->result = DID_TIME_OUT << 16 ++ | COMMAND_COMPLETE << 8; ++ break; ++ ++ case SRB_STATUS_BUSY: ++ scsicmd->result = DID_BUS_BUSY << 16 ++ | COMMAND_COMPLETE << 8; ++ break; ++ ++ case SRB_STATUS_BUS_RESET: ++ scsicmd->result = DID_RESET << 16 ++ | COMMAND_COMPLETE << 8; ++ break; ++ ++ case SRB_STATUS_MESSAGE_REJECTED: ++ scsicmd->result = DID_ERROR << 16 ++ | MESSAGE_REJECT << 8; ++ break; ++ case SRB_STATUS_REQUEST_FLUSHED: ++ case SRB_STATUS_ERROR: ++ case SRB_STATUS_INVALID_REQUEST: ++ case SRB_STATUS_REQUEST_SENSE_FAILED: ++ case SRB_STATUS_NO_HBA: ++ case SRB_STATUS_UNEXPECTED_BUS_FREE: ++ case SRB_STATUS_PHASE_SEQUENCE_FAILURE: ++ case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: ++ case SRB_STATUS_DELAYED_RETRY: ++ case SRB_STATUS_BAD_FUNCTION: ++ case SRB_STATUS_NOT_STARTED: ++ case SRB_STATUS_NOT_IN_USE: ++ case SRB_STATUS_FORCE_ABORT: ++ case SRB_STATUS_DOMAIN_VALIDATION_FAIL: ++ default: + #ifdef AAC_DETAILED_STATUS_INFO +- printk(KERN_INFO "aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n", +- le32_to_cpu(srbreply->srb_status) & 0x3F, +- aac_get_status_string( +- le32_to_cpu(srbreply->srb_status) & 0x3F), +- scsicmd->cmnd[0], +- le32_to_cpu(srbreply->scsi_status)); ++ pr_info("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x -scsi status 0x%x\n", ++ le32_to_cpu(srbreply->srb_status) & 0x3F, ++ aac_get_status_string( ++ le32_to_cpu(srbreply->srb_status) & 0x3F), ++ scsicmd->cmnd[0], ++ le32_to_cpu(srbreply->scsi_status)); + #endif +- if ((scsicmd->cmnd[0] == ATA_12) +- || (scsicmd->cmnd[0] == ATA_16)) { +- if (scsicmd->cmnd[2] & (0x01 << 5)) { +- scsicmd->result = DID_OK << 16 +- | COMMAND_COMPLETE << 8; +- break; +- } else { +- scsicmd->result = DID_ERROR << 16 +- | COMMAND_COMPLETE << 8; +- break; +- } ++ /* ++ * When the CC bit is SET by the host in ATA pass thru CDB, ++ * driver is supposed to return DID_OK ++ * ++ * When the CC bit is RESET by the host, driver should ++ * return DID_ERROR ++ */ ++ if ((scsicmd->cmnd[0] == ATA_12) ++ || (scsicmd->cmnd[0] == ATA_16)) { ++ ++ if (scsicmd->cmnd[2] & (0x01 << 5)) { ++ scsicmd->result = DID_OK << 16 ++ | COMMAND_COMPLETE << 8; ++ break; + } else { + scsicmd->result = DID_ERROR << 16 + | COMMAND_COMPLETE << 8; +- break; ++ break; + } ++ } else { ++ scsicmd->result = DID_ERROR << 16 ++ | COMMAND_COMPLETE << 8; ++ break; + } +- if (le32_to_cpu(srbreply->scsi_status) +- == SAM_STAT_CHECK_CONDITION) { +- int len; ++ } ++ if (le32_to_cpu(srbreply->scsi_status) ++ == SAM_STAT_CHECK_CONDITION) { ++ int len; + +- scsicmd->result |= SAM_STAT_CHECK_CONDITION; +- len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), +- SCSI_SENSE_BUFFERSIZE); ++ scsicmd->result |= SAM_STAT_CHECK_CONDITION; ++ len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), ++ SCSI_SENSE_BUFFERSIZE); + #ifdef AAC_DETAILED_STATUS_INFO +- printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", +- le32_to_cpu(srbreply->status), len); ++ pr_warn("aac_srb_callback: check condition, status = %d len=%d\n", ++ le32_to_cpu(srbreply->status), len); + #endif +- memcpy(scsicmd->sense_buffer, +- srbreply->sense_data, len); +- } ++ memcpy(scsicmd->sense_buffer, ++ srbreply->sense_data, len); + } ++ + /* + * OR in the scsi status (already shifted up a bit) + */ +diff --git a/drivers/staging/lustre/lustre/include/lustre/lustre_user.h b/drivers/staging/lustre/lustre/include/lustre/lustre_user.h +index 80f8ec529424..8ed4558238fc 100644 +--- a/drivers/staging/lustre/lustre/include/lustre/lustre_user.h ++++ b/drivers/staging/lustre/lustre/include/lustre/lustre_user.h +@@ -1063,23 +1063,21 @@ struct hsm_action_item { + * \retval buffer + */ + static inline char *hai_dump_data_field(struct hsm_action_item *hai, +- char *buffer, int len) ++ char *buffer, size_t len) + { +- int i, sz, data_len; ++ int i, data_len; + char *ptr; + + ptr = buffer; +- sz = len; + data_len = hai->hai_len - sizeof(*hai); +- for (i = 0 ; (i < data_len) && (sz > 0) ; i++) { +- int cnt; +- +- cnt = snprintf(ptr, sz, "%.2X", +- (unsigned char)hai->hai_data[i]); +- ptr += cnt; +- sz -= cnt; ++ for (i = 0; (i < data_len) && (len > 2); i++) { ++ snprintf(ptr, 3, "%02X", (unsigned char)hai->hai_data[i]); ++ ptr += 2; ++ len -= 2; + } ++ + *ptr = '\0'; ++ + return buffer; + } + +diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c +index 7f8c70056ffd..040553d6e316 100644 +--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c ++++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lock.c +@@ -550,6 +550,13 @@ struct ldlm_lock *__ldlm_handle2lock(const struct lustre_handle *handle, + if (lock == NULL) + return NULL; + ++ if (lock->l_export && lock->l_export->exp_failed) { ++ CDEBUG(D_INFO, "lock export failed: lock %p, exp %p\n", ++ lock, lock->l_export); ++ LDLM_LOCK_PUT(lock); ++ return NULL; ++ } ++ + /* It's unlikely but possible that someone marked the lock as + * destroyed after we did handle2object on it */ + if (flags == 0 && ((lock->l_flags & LDLM_FL_DESTROYED) == 0)) { +diff --git a/drivers/staging/lustre/lustre/llite/rw26.c b/drivers/staging/lustre/lustre/llite/rw26.c +index 3da4c01e2159..adeefb31cbad 100644 +--- a/drivers/staging/lustre/lustre/llite/rw26.c ++++ b/drivers/staging/lustre/lustre/llite/rw26.c +@@ -376,6 +376,10 @@ static ssize_t ll_direct_IO_26(struct kiocb *iocb, struct iov_iter *iter, + if (!lli->lli_has_smd) + return -EBADF; + ++ /* Check EOF by ourselves */ ++ if (iov_iter_rw(iter) == READ && file_offset >= i_size_read(inode)) ++ return 0; ++ + /* FIXME: io smaller than PAGE_SIZE is broken on ia64 ??? */ + if ((file_offset & ~CFS_PAGE_MASK) || (count & ~CFS_PAGE_MASK)) + return -EINVAL; +diff --git a/drivers/staging/lustre/lustre/ptlrpc/service.c b/drivers/staging/lustre/lustre/ptlrpc/service.c +index f45898f17793..6d3c25ccb297 100644 +--- a/drivers/staging/lustre/lustre/ptlrpc/service.c ++++ b/drivers/staging/lustre/lustre/ptlrpc/service.c +@@ -1240,20 +1240,15 @@ static int ptlrpc_server_hpreq_init(struct ptlrpc_service_part *svcpt, + * it may hit swab race at LU-1044. */ + if (req->rq_ops->hpreq_check) { + rc = req->rq_ops->hpreq_check(req); +- /** +- * XXX: Out of all current +- * ptlrpc_hpreq_ops::hpreq_check(), only +- * ldlm_cancel_hpreq_check() can return an error code; +- * other functions assert in similar places, which seems +- * odd. What also does not seem right is that handlers +- * for those RPCs do not assert on the same checks, but +- * rather handle the error cases. e.g. see +- * ost_rw_hpreq_check(), and ost_brw_read(), +- * ost_brw_write(). ++ if (rc == -ESTALE) { ++ req->rq_status = rc; ++ ptlrpc_error(req); ++ } ++ /** can only return error, ++ * 0 for normal request, ++ * or 1 for high priority request + */ +- if (rc < 0) +- return rc; +- LASSERT(rc == 0 || rc == 1); ++ LASSERT(rc <= 1); + } + + spin_lock_bh(&req->rq_export->exp_rpc_lock); +diff --git a/drivers/staging/rtl8712/ieee80211.h b/drivers/staging/rtl8712/ieee80211.h +index d374824c4f33..7b16c05b5e8b 100644 +--- a/drivers/staging/rtl8712/ieee80211.h ++++ b/drivers/staging/rtl8712/ieee80211.h +@@ -143,52 +143,52 @@ struct ieee_ibss_seq { + }; + + struct ieee80211_hdr { +- u16 frame_ctl; +- u16 duration_id; ++ __le16 frame_ctl; ++ __le16 duration_id; + u8 addr1[ETH_ALEN]; + u8 addr2[ETH_ALEN]; + u8 addr3[ETH_ALEN]; +- u16 seq_ctl; ++ __le16 seq_ctl; + u8 addr4[ETH_ALEN]; +-} __packed; ++} __packed __aligned(2); + + struct ieee80211_hdr_3addr { +- u16 frame_ctl; +- u16 duration_id; ++ __le16 frame_ctl; ++ __le16 duration_id; + u8 addr1[ETH_ALEN]; + u8 addr2[ETH_ALEN]; + u8 addr3[ETH_ALEN]; +- u16 seq_ctl; +-} __packed; ++ __le16 seq_ctl; ++} __packed __aligned(2); + + + struct ieee80211_hdr_qos { +- u16 frame_ctl; +- u16 duration_id; ++ __le16 frame_ctl; ++ __le16 duration_id; + u8 addr1[ETH_ALEN]; + u8 addr2[ETH_ALEN]; + u8 addr3[ETH_ALEN]; +- u16 seq_ctl; ++ __le16 seq_ctl; + u8 addr4[ETH_ALEN]; +- u16 qc; +-} __packed; ++ __le16 qc; ++} __packed __aligned(2); + + struct ieee80211_hdr_3addr_qos { +- u16 frame_ctl; +- u16 duration_id; ++ __le16 frame_ctl; ++ __le16 duration_id; + u8 addr1[ETH_ALEN]; + u8 addr2[ETH_ALEN]; + u8 addr3[ETH_ALEN]; +- u16 seq_ctl; +- u16 qc; ++ __le16 seq_ctl; ++ __le16 qc; + } __packed; + + struct eapol { + u8 snap[6]; +- u16 ethertype; ++ __be16 ethertype; + u8 version; + u8 type; +- u16 length; ++ __le16 length; + } __packed; + + +@@ -528,13 +528,13 @@ struct ieee80211_security { + */ + + struct ieee80211_header_data { +- u16 frame_ctl; +- u16 duration_id; ++ __le16 frame_ctl; ++ __le16 duration_id; + u8 addr1[6]; + u8 addr2[6]; + u8 addr3[6]; +- u16 seq_ctrl; +-}; ++ __le16 seq_ctrl; ++} __packed __aligned(2); + + #define BEACON_PROBE_SSID_ID_POSITION 12 + +@@ -566,18 +566,18 @@ struct ieee80211_info_element { + /* + * These are the data types that can make up management packets + * +- u16 auth_algorithm; +- u16 auth_sequence; +- u16 beacon_interval; +- u16 capability; ++ __le16 auth_algorithm; ++ __le16 auth_sequence; ++ __le16 beacon_interval; ++ __le16 capability; + u8 current_ap[ETH_ALEN]; +- u16 listen_interval; ++ __le16 listen_interval; + struct { + u16 association_id:14, reserved:2; + } __packed; +- u32 time_stamp[2]; +- u16 reason; +- u16 status; ++ __le32 time_stamp[2]; ++ __le16 reason; ++ __le16 status; + */ + + #define IEEE80211_DEFAULT_TX_ESSID "Penguin" +@@ -585,16 +585,16 @@ struct ieee80211_info_element { + + struct ieee80211_authentication { + struct ieee80211_header_data header; +- u16 algorithm; +- u16 transaction; +- u16 status; ++ __le16 algorithm; ++ __le16 transaction; ++ __le16 status; + } __packed; + + struct ieee80211_probe_response { + struct ieee80211_header_data header; +- u32 time_stamp[2]; +- u16 beacon_interval; +- u16 capability; ++ __le32 time_stamp[2]; ++ __le16 beacon_interval; ++ __le16 capability; + struct ieee80211_info_element info_element; + } __packed; + +@@ -604,16 +604,16 @@ struct ieee80211_probe_request { + + struct ieee80211_assoc_request_frame { + struct ieee80211_hdr_3addr header; +- u16 capability; +- u16 listen_interval; ++ __le16 capability; ++ __le16 listen_interval; + struct ieee80211_info_element_hdr info_element; + } __packed; + + struct ieee80211_assoc_response_frame { + struct ieee80211_hdr_3addr header; +- u16 capability; +- u16 status; +- u16 aid; ++ __le16 capability; ++ __le16 status; ++ __le16 aid; + } __packed; + + struct ieee80211_txb { +diff --git a/drivers/staging/rtl8712/rtl871x_xmit.c b/drivers/staging/rtl8712/rtl871x_xmit.c +index 68d65d230fe3..d3ad89c7b8af 100644 +--- a/drivers/staging/rtl8712/rtl871x_xmit.c ++++ b/drivers/staging/rtl8712/rtl871x_xmit.c +@@ -339,7 +339,8 @@ sint r8712_update_attrib(struct _adapter *padapter, _pkt *pkt, + /* if in MP_STATE, update pkt_attrib from mp_txcmd, and overwrite + * some settings above.*/ + if (check_fwstate(pmlmepriv, WIFI_MP_STATE)) +- pattrib->priority = (txdesc.txdw1 >> QSEL_SHT) & 0x1f; ++ pattrib->priority = ++ (le32_to_cpu(txdesc.txdw1) >> QSEL_SHT) & 0x1f; + return _SUCCESS; + } + +@@ -479,7 +480,7 @@ static sint make_wlanhdr(struct _adapter *padapter, u8 *hdr, + struct ieee80211_hdr *pwlanhdr = (struct ieee80211_hdr *)hdr; + struct mlme_priv *pmlmepriv = &padapter->mlmepriv; + struct qos_priv *pqospriv = &pmlmepriv->qospriv; +- u16 *fctrl = &pwlanhdr->frame_ctl; ++ __le16 *fctrl = &pwlanhdr->frame_ctl; + + memset(hdr, 0, WLANHDR_OFFSET); + SetFrameSubType(fctrl, pattrib->subtype); +@@ -568,7 +569,7 @@ static sint r8712_put_snap(u8 *data, u16 h_proto) + snap->oui[0] = oui[0]; + snap->oui[1] = oui[1]; + snap->oui[2] = oui[2]; +- *(u16 *)(data + SNAP_SIZE) = htons(h_proto); ++ *(__be16 *)(data + SNAP_SIZE) = htons(h_proto); + return SNAP_SIZE + sizeof(u16); + } + +diff --git a/drivers/xen/manage.c b/drivers/xen/manage.c +index e12bd3635f83..2dd285827169 100644 +--- a/drivers/xen/manage.c ++++ b/drivers/xen/manage.c +@@ -275,8 +275,16 @@ static void sysrq_handler(struct xenbus_watch *watch, const char **vec, + err = xenbus_transaction_start(&xbt); + if (err) + return; +- if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) { +- pr_err("Unable to read sysrq code in control/sysrq\n"); ++ err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key); ++ if (err < 0) { ++ /* ++ * The Xenstore watch fires directly after registering it and ++ * after a suspend/resume cycle. So ENOENT is no error but ++ * might happen in those cases. ++ */ ++ if (err != -ENOENT) ++ pr_err("Error %d reading sysrq code in control/sysrq\n", ++ err); + xenbus_transaction_end(xbt, 1); + return; + } +diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c +index 297e05c9e2b0..49a0d6b027c1 100644 +--- a/fs/cifs/dir.c ++++ b/fs/cifs/dir.c +@@ -193,7 +193,8 @@ check_name(struct dentry *direntry, struct cifs_tcon *tcon) + struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); + int i; + +- if (unlikely(direntry->d_name.len > ++ if (unlikely(tcon->fsAttrInfo.MaxPathNameComponentLength && ++ direntry->d_name.len > + le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength))) + return -ENAMETOOLONG; + +@@ -509,7 +510,7 @@ cifs_atomic_open(struct inode *inode, struct dentry *direntry, + + rc = check_name(direntry, tcon); + if (rc) +- goto out_free_xid; ++ goto out; + + server = tcon->ses->server; + +diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c +index 84cd77663e1f..1ba82dc5afa3 100644 +--- a/fs/ext4/mballoc.c ++++ b/fs/ext4/mballoc.c +@@ -2136,8 +2136,10 @@ ext4_mb_regular_allocator(struct ext4_allocation_context *ac) + * We search using buddy data only if the order of the request + * is greater than equal to the sbi_s_mb_order2_reqs + * You can tune it via /sys/fs/ext4/<partition>/mb_order2_req ++ * We also support searching for power-of-two requests only for ++ * requests upto maximum buddy size we have constructed. + */ +- if (i >= sbi->s_mb_order2_reqs) { ++ if (i >= sbi->s_mb_order2_reqs && i <= sb->s_blocksize_bits + 2) { + /* + * This should tell if fe_len is exactly power of 2 + */ +@@ -2207,7 +2209,7 @@ repeat: + } + + ac->ac_groups_scanned++; +- if (cr == 0 && ac->ac_2order < sb->s_blocksize_bits+2) ++ if (cr == 0) + ext4_mb_simple_scan_group(ac, &e4b); + else if (cr == 1 && sbi->s_stripe && + !(ac->ac_g_ex.fe_len % sbi->s_stripe)) +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 32941cd6d34b..8bdb0cc2722f 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -2499,9 +2499,9 @@ static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi) + + if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group) + ret = sbi->s_stripe; +- else if (stripe_width <= sbi->s_blocks_per_group) ++ else if (stripe_width && stripe_width <= sbi->s_blocks_per_group) + ret = stripe_width; +- else if (stride <= sbi->s_blocks_per_group) ++ else if (stride && stride <= sbi->s_blocks_per_group) + ret = stride; + else + ret = 0; +diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c +index 86181d6526dc..93e6f029a322 100644 +--- a/fs/ocfs2/alloc.c ++++ b/fs/ocfs2/alloc.c +@@ -7270,13 +7270,24 @@ out: + + static int ocfs2_trim_extent(struct super_block *sb, + struct ocfs2_group_desc *gd, +- u32 start, u32 count) ++ u64 group, u32 start, u32 count) + { + u64 discard, bcount; ++ struct ocfs2_super *osb = OCFS2_SB(sb); + + bcount = ocfs2_clusters_to_blocks(sb, count); +- discard = le64_to_cpu(gd->bg_blkno) + +- ocfs2_clusters_to_blocks(sb, start); ++ discard = ocfs2_clusters_to_blocks(sb, start); ++ ++ /* ++ * For the first cluster group, the gd->bg_blkno is not at the start ++ * of the group, but at an offset from the start. If we add it while ++ * calculating discard for first group, we will wrongly start fstrim a ++ * few blocks after the desried start block and the range can cross ++ * over into the next cluster group. So, add it only if this is not ++ * the first cluster group. ++ */ ++ if (group != osb->first_cluster_group_blkno) ++ discard += le64_to_cpu(gd->bg_blkno); + + trace_ocfs2_trim_extent(sb, (unsigned long long)discard, bcount); + +@@ -7284,7 +7295,7 @@ static int ocfs2_trim_extent(struct super_block *sb, + } + + static int ocfs2_trim_group(struct super_block *sb, +- struct ocfs2_group_desc *gd, ++ struct ocfs2_group_desc *gd, u64 group, + u32 start, u32 max, u32 minbits) + { + int ret = 0, count = 0, next; +@@ -7303,7 +7314,7 @@ static int ocfs2_trim_group(struct super_block *sb, + next = ocfs2_find_next_bit(bitmap, max, start); + + if ((next - start) >= minbits) { +- ret = ocfs2_trim_extent(sb, gd, ++ ret = ocfs2_trim_extent(sb, gd, group, + start, next - start); + if (ret < 0) { + mlog_errno(ret); +@@ -7401,7 +7412,8 @@ int ocfs2_trim_fs(struct super_block *sb, struct fstrim_range *range) + } + + gd = (struct ocfs2_group_desc *)gd_bh->b_data; +- cnt = ocfs2_trim_group(sb, gd, first_bit, last_bit, minlen); ++ cnt = ocfs2_trim_group(sb, gd, group, ++ first_bit, last_bit, minlen); + brelse(gd_bh); + gd_bh = NULL; + if (cnt < 0) { +diff --git a/lib/asn1_decoder.c b/lib/asn1_decoder.c +index 554522934c44..faa2a3f017f8 100644 +--- a/lib/asn1_decoder.c ++++ b/lib/asn1_decoder.c +@@ -283,6 +283,9 @@ next_op: + if (unlikely(len > datalen - dp)) + goto data_overrun_error; + } ++ } else { ++ if (unlikely(len > datalen - dp)) ++ goto data_overrun_error; + } + + if (flags & FLAG_CONS) { +diff --git a/samples/trace_events/trace-events-sample.c b/samples/trace_events/trace-events-sample.c +index 880a7d1d27d2..4ccff66523c9 100644 +--- a/samples/trace_events/trace-events-sample.c ++++ b/samples/trace_events/trace-events-sample.c +@@ -78,28 +78,36 @@ static int simple_thread_fn(void *arg) + } + + static DEFINE_MUTEX(thread_mutex); ++static int simple_thread_cnt; + + void foo_bar_reg(void) + { ++ mutex_lock(&thread_mutex); ++ if (simple_thread_cnt++) ++ goto out; ++ + pr_info("Starting thread for foo_bar_fn\n"); + /* + * We shouldn't be able to start a trace when the module is + * unloading (there's other locks to prevent that). But + * for consistency sake, we still take the thread_mutex. + */ +- mutex_lock(&thread_mutex); + simple_tsk_fn = kthread_run(simple_thread_fn, NULL, "event-sample-fn"); ++ out: + mutex_unlock(&thread_mutex); + } + + void foo_bar_unreg(void) + { +- pr_info("Killing thread for foo_bar_fn\n"); +- /* protect against module unloading */ + mutex_lock(&thread_mutex); ++ if (--simple_thread_cnt) ++ goto out; ++ ++ pr_info("Killing thread for foo_bar_fn\n"); + if (simple_tsk_fn) + kthread_stop(simple_tsk_fn); + simple_tsk_fn = NULL; ++ out: + mutex_unlock(&thread_mutex); + } + +diff --git a/security/keys/keyring.c b/security/keys/keyring.c +index ef828238cdc0..d5264f950ce1 100644 +--- a/security/keys/keyring.c ++++ b/security/keys/keyring.c +@@ -452,34 +452,33 @@ static long keyring_read(const struct key *keyring, + char __user *buffer, size_t buflen) + { + struct keyring_read_iterator_context ctx; +- unsigned long nr_keys; +- int ret; ++ long ret; + + kenter("{%d},,%zu", key_serial(keyring), buflen); + + if (buflen & (sizeof(key_serial_t) - 1)) + return -EINVAL; + +- nr_keys = keyring->keys.nr_leaves_on_tree; +- if (nr_keys == 0) +- return 0; +- +- /* Calculate how much data we could return */ +- if (!buffer || !buflen) +- return nr_keys * sizeof(key_serial_t); +- +- /* Copy the IDs of the subscribed keys into the buffer */ +- ctx.buffer = (key_serial_t __user *)buffer; +- ctx.buflen = buflen; +- ctx.count = 0; +- ret = assoc_array_iterate(&keyring->keys, keyring_read_iterator, &ctx); +- if (ret < 0) { +- kleave(" = %d [iterate]", ret); +- return ret; ++ /* Copy as many key IDs as fit into the buffer */ ++ if (buffer && buflen) { ++ ctx.buffer = (key_serial_t __user *)buffer; ++ ctx.buflen = buflen; ++ ctx.count = 0; ++ ret = assoc_array_iterate(&keyring->keys, ++ keyring_read_iterator, &ctx); ++ if (ret < 0) { ++ kleave(" = %ld [iterate]", ret); ++ return ret; ++ } + } + +- kleave(" = %zu [ok]", ctx.count); +- return ctx.count; ++ /* Return the size of the buffer needed */ ++ ret = keyring->keys.nr_leaves_on_tree * sizeof(key_serial_t); ++ if (ret <= buflen) ++ kleave("= %ld [ok]", ret); ++ else ++ kleave("= %ld [buffer too small]", ret); ++ return ret; + } + + /* +diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c +index e847b9923c19..b36de76f24e2 100644 +--- a/sound/core/seq/seq_clientmgr.c ++++ b/sound/core/seq/seq_clientmgr.c +@@ -676,7 +676,7 @@ static int deliver_to_subscribers(struct snd_seq_client *client, + if (atomic) + read_lock(&grp->list_lock); + else +- down_read(&grp->list_mutex); ++ down_read_nested(&grp->list_mutex, hop); + list_for_each_entry(subs, &grp->list_head, src_list) { + /* both ports ready? */ + if (atomic_read(&subs->ref_count) != 2) +diff --git a/sound/core/timer_compat.c b/sound/core/timer_compat.c +index 2e908225d754..0b4b028e8e98 100644 +--- a/sound/core/timer_compat.c ++++ b/sound/core/timer_compat.c +@@ -106,7 +106,8 @@ enum { + #endif /* CONFIG_X86_X32 */ + }; + +-static long snd_timer_user_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg) ++static long __snd_timer_user_ioctl_compat(struct file *file, unsigned int cmd, ++ unsigned long arg) + { + void __user *argp = compat_ptr(arg); + +@@ -127,7 +128,7 @@ static long snd_timer_user_ioctl_compat(struct file *file, unsigned int cmd, uns + case SNDRV_TIMER_IOCTL_PAUSE: + case SNDRV_TIMER_IOCTL_PAUSE_OLD: + case SNDRV_TIMER_IOCTL_NEXT_DEVICE: +- return snd_timer_user_ioctl(file, cmd, (unsigned long)argp); ++ return __snd_timer_user_ioctl(file, cmd, (unsigned long)argp); + case SNDRV_TIMER_IOCTL_INFO32: + return snd_timer_user_info_compat(file, argp); + case SNDRV_TIMER_IOCTL_STATUS32: +@@ -139,3 +140,15 @@ static long snd_timer_user_ioctl_compat(struct file *file, unsigned int cmd, uns + } + return -ENOIOCTLCMD; + } ++ ++static long snd_timer_user_ioctl_compat(struct file *file, unsigned int cmd, ++ unsigned long arg) ++{ ++ struct snd_timer_user *tu = file->private_data; ++ long ret; ++ ++ mutex_lock(&tu->ioctl_lock); ++ ret = __snd_timer_user_ioctl_compat(file, cmd, arg); ++ mutex_unlock(&tu->ioctl_lock); ++ return ret; ++} +diff --git a/sound/soc/codecs/adau17x1.c b/sound/soc/codecs/adau17x1.c +index fcf05b254ecd..0b9e13eb0a0a 100644 +--- a/sound/soc/codecs/adau17x1.c ++++ b/sound/soc/codecs/adau17x1.c +@@ -89,6 +89,27 @@ static int adau17x1_pll_event(struct snd_soc_dapm_widget *w, + return 0; + } + ++static int adau17x1_adc_fixup(struct snd_soc_dapm_widget *w, ++ struct snd_kcontrol *kcontrol, int event) ++{ ++ struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); ++ struct adau *adau = snd_soc_codec_get_drvdata(codec); ++ ++ /* ++ * If we are capturing, toggle the ADOSR bit in Converter Control 0 to ++ * avoid losing SNR (workaround from ADI). This must be done after ++ * the ADC(s) have been enabled. According to the data sheet, it is ++ * normally illegal to set this bit when the sampling rate is 96 kHz, ++ * but according to ADI it is acceptable for this workaround. ++ */ ++ regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0, ++ ADAU17X1_CONVERTER0_ADOSR, ADAU17X1_CONVERTER0_ADOSR); ++ regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0, ++ ADAU17X1_CONVERTER0_ADOSR, 0); ++ ++ return 0; ++} ++ + static const char * const adau17x1_mono_stereo_text[] = { + "Stereo", + "Mono Left Channel (L+R)", +@@ -120,7 +141,8 @@ static const struct snd_soc_dapm_widget adau17x1_dapm_widgets[] = { + SND_SOC_DAPM_MUX("Right DAC Mode Mux", SND_SOC_NOPM, 0, 0, + &adau17x1_dac_mode_mux), + +- SND_SOC_DAPM_ADC("Left Decimator", NULL, ADAU17X1_ADC_CONTROL, 0, 0), ++ SND_SOC_DAPM_ADC_E("Left Decimator", NULL, ADAU17X1_ADC_CONTROL, 0, 0, ++ adau17x1_adc_fixup, SND_SOC_DAPM_POST_PMU), + SND_SOC_DAPM_ADC("Right Decimator", NULL, ADAU17X1_ADC_CONTROL, 1, 0), + SND_SOC_DAPM_DAC("Left DAC", NULL, ADAU17X1_DAC_CONTROL0, 0, 0), + SND_SOC_DAPM_DAC("Right DAC", NULL, ADAU17X1_DAC_CONTROL0, 1, 0), +diff --git a/sound/soc/codecs/adau17x1.h b/sound/soc/codecs/adau17x1.h +index e13583e6ff56..6b46461cdc03 100644 +--- a/sound/soc/codecs/adau17x1.h ++++ b/sound/soc/codecs/adau17x1.h +@@ -123,5 +123,7 @@ bool adau17x1_has_dsp(struct adau *adau); + + #define ADAU17X1_CONVERTER0_CONVSR_MASK 0x7 + ++#define ADAU17X1_CONVERTER0_ADOSR BIT(3) ++ + + #endif +diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Build b/tools/perf/scripts/perl/Perf-Trace-Util/Build +index 928e110179cb..34faecf774ae 100644 +--- a/tools/perf/scripts/perl/Perf-Trace-Util/Build ++++ b/tools/perf/scripts/perl/Perf-Trace-Util/Build +@@ -1,3 +1,5 @@ + libperf-y += Context.o + +-CFLAGS_Context.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default ++CFLAGS_Context.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes ++CFLAGS_Context.o += -Wno-unused-parameter -Wno-nested-externs -Wno-undef ++CFLAGS_Context.o += -Wno-switch-default -Wno-shadow +diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c +index 38304b7e4f81..e81dfb2e239c 100644 +--- a/tools/perf/util/parse-events.c ++++ b/tools/perf/util/parse-events.c +@@ -291,10 +291,11 @@ __add_event(struct list_head *list, int *idx, + + event_attr_init(attr); + +- evsel = perf_evsel__new_idx(attr, (*idx)++); ++ evsel = perf_evsel__new_idx(attr, *idx); + if (!evsel) + return NULL; + ++ (*idx)++; + evsel->cpus = cpu_map__get(cpus); + evsel->own_cpus = cpu_map__get(cpus); +
