Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-4.9/0264-4.9.165-all-fixes.patch

    Annotation of /trunk/kernel-alx/patches-4.9/0264-4.9.165-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3341 - (hide annotations) (download)
    Tue Jun 18 09:41:55 2019 UTC (5 years ago) by niro
    File size: 127195 byte(s) 
    -linux-4.9.165
    1 niro 3341 diff --git a/Makefile b/Makefile
    2     index e1bcc76388dc..9b61da532c42 100644
    3     --- a/Makefile
    4     +++ b/Makefile
    5     @@ -1,6 +1,6 @@
    6     VERSION = 4
    7     PATCHLEVEL = 9
    8     -SUBLEVEL = 164
    9     +SUBLEVEL = 165
    10     EXTRAVERSION =
    11     NAME = Roaring Lionus
    12    
    13     diff --git a/arch/arc/include/asm/uaccess.h b/arch/arc/include/asm/uaccess.h
    14     index 0684fd2f42e8..f82393f89215 100644
    15     --- a/arch/arc/include/asm/uaccess.h
    16     +++ b/arch/arc/include/asm/uaccess.h
    17     @@ -209,7 +209,7 @@ __arc_copy_from_user(void *to, const void __user *from, unsigned long n)
    18     */
    19     "=&r" (tmp), "+r" (to), "+r" (from)
    20     :
    21     - : "lp_count", "lp_start", "lp_end", "memory");
    22     + : "lp_count", "memory");
    23    
    24     return n;
    25     }
    26     @@ -438,7 +438,7 @@ __arc_copy_to_user(void __user *to, const void *from, unsigned long n)
    27     */
    28     "=&r" (tmp), "+r" (to), "+r" (from)
    29     :
    30     - : "lp_count", "lp_start", "lp_end", "memory");
    31     + : "lp_count", "memory");
    32    
    33     return n;
    34     }
    35     @@ -658,7 +658,7 @@ static inline unsigned long __arc_clear_user(void __user *to, unsigned long n)
    36     " .previous \n"
    37     : "+r"(d_char), "+r"(res)
    38     : "i"(0)
    39     - : "lp_count", "lp_start", "lp_end", "memory");
    40     + : "lp_count", "memory");
    41    
    42     return res;
    43     }
    44     @@ -691,7 +691,7 @@ __arc_strncpy_from_user(char *dst, const char __user *src, long count)
    45     " .previous \n"
    46     : "+r"(res), "+r"(dst), "+r"(src), "=r"(val)
    47     : "g"(-EFAULT), "r"(count)
    48     - : "lp_count", "lp_start", "lp_end", "memory");
    49     + : "lp_count", "memory");
    50    
    51     return res;
    52     }
    53     diff --git a/arch/arc/lib/memcpy-archs.S b/arch/arc/lib/memcpy-archs.S
    54     index d61044dd8b58..ea14b0bf3116 100644
    55     --- a/arch/arc/lib/memcpy-archs.S
    56     +++ b/arch/arc/lib/memcpy-archs.S
    57     @@ -25,15 +25,11 @@
    58     #endif
    59    
    60     #ifdef CONFIG_ARC_HAS_LL64
    61     -# define PREFETCH_READ(RX) prefetch [RX, 56]
    62     -# define PREFETCH_WRITE(RX) prefetchw [RX, 64]
    63     # define LOADX(DST,RX) ldd.ab DST, [RX, 8]
    64     # define STOREX(SRC,RX) std.ab SRC, [RX, 8]
    65     # define ZOLSHFT 5
    66     # define ZOLAND 0x1F
    67     #else
    68     -# define PREFETCH_READ(RX) prefetch [RX, 28]
    69     -# define PREFETCH_WRITE(RX) prefetchw [RX, 32]
    70     # define LOADX(DST,RX) ld.ab DST, [RX, 4]
    71     # define STOREX(SRC,RX) st.ab SRC, [RX, 4]
    72     # define ZOLSHFT 4
    73     @@ -41,8 +37,6 @@
    74     #endif
    75    
    76     ENTRY_CFI(memcpy)
    77     - prefetch [r1] ; Prefetch the read location
    78     - prefetchw [r0] ; Prefetch the write location
    79     mov.f 0, r2
    80     ;;; if size is zero
    81     jz.d [blink]
    82     @@ -72,8 +66,6 @@ ENTRY_CFI(memcpy)
    83     lpnz @.Lcopy32_64bytes
    84     ;; LOOP START
    85     LOADX (r6, r1)
    86     - PREFETCH_READ (r1)
    87     - PREFETCH_WRITE (r3)
    88     LOADX (r8, r1)
    89     LOADX (r10, r1)
    90     LOADX (r4, r1)
    91     @@ -117,9 +109,7 @@ ENTRY_CFI(memcpy)
    92     lpnz @.Lcopy8bytes_1
    93     ;; LOOP START
    94     ld.ab r6, [r1, 4]
    95     - prefetch [r1, 28] ;Prefetch the next read location
    96     ld.ab r8, [r1,4]
    97     - prefetchw [r3, 32] ;Prefetch the next write location
    98    
    99     SHIFT_1 (r7, r6, 24)
    100     or r7, r7, r5
    101     @@ -162,9 +152,7 @@ ENTRY_CFI(memcpy)
    102     lpnz @.Lcopy8bytes_2
    103     ;; LOOP START
    104     ld.ab r6, [r1, 4]
    105     - prefetch [r1, 28] ;Prefetch the next read location
    106     ld.ab r8, [r1,4]
    107     - prefetchw [r3, 32] ;Prefetch the next write location
    108    
    109     SHIFT_1 (r7, r6, 16)
    110     or r7, r7, r5
    111     @@ -204,9 +192,7 @@ ENTRY_CFI(memcpy)
    112     lpnz @.Lcopy8bytes_3
    113     ;; LOOP START
    114     ld.ab r6, [r1, 4]
    115     - prefetch [r1, 28] ;Prefetch the next read location
    116     ld.ab r8, [r1,4]
    117     - prefetchw [r3, 32] ;Prefetch the next write location
    118    
    119     SHIFT_1 (r7, r6, 8)
    120     or r7, r7, r5
    121     diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
    122     index b5d529fdffab..74a70f91b01a 100644
    123     --- a/arch/arm/Kconfig
    124     +++ b/arch/arm/Kconfig
    125     @@ -1457,6 +1457,7 @@ config NR_CPUS
    126     config HOTPLUG_CPU
    127     bool "Support for hot-pluggable CPUs"
    128     depends on SMP
    129     + select GENERIC_IRQ_MIGRATION
    130     help
    131     Say Y here to experiment with turning CPUs off and on. CPUs
    132     can be controlled through /sys/devices/system/cpu.
    133     diff --git a/arch/arm/include/asm/irq.h b/arch/arm/include/asm/irq.h
    134     index e53638c8ed8a..61e1d089ce1a 100644
    135     --- a/arch/arm/include/asm/irq.h
    136     +++ b/arch/arm/include/asm/irq.h
    137     @@ -24,7 +24,6 @@
    138     #ifndef __ASSEMBLY__
    139     struct irqaction;
    140     struct pt_regs;
    141     -extern void migrate_irqs(void);
    142    
    143     extern void asm_do_IRQ(unsigned int, struct pt_regs *);
    144     void handle_IRQ(unsigned int, struct pt_regs *);
    145     diff --git a/arch/arm/kernel/irq.c b/arch/arm/kernel/irq.c
    146     index ece04a457486..5b07c7a31c31 100644
    147     --- a/arch/arm/kernel/irq.c
    148     +++ b/arch/arm/kernel/irq.c
    149     @@ -31,7 +31,6 @@
    150     #include <linux/smp.h>
    151     #include <linux/init.h>
    152     #include <linux/seq_file.h>
    153     -#include <linux/ratelimit.h>
    154     #include <linux/errno.h>
    155     #include <linux/list.h>
    156     #include <linux/kallsyms.h>
    157     @@ -119,64 +118,3 @@ int __init arch_probe_nr_irqs(void)
    158     return nr_irqs;
    159     }
    160     #endif
    161     -
    162     -#ifdef CONFIG_HOTPLUG_CPU
    163     -static bool migrate_one_irq(struct irq_desc *desc)
    164     -{
    165     - struct irq_data *d = irq_desc_get_irq_data(desc);
    166     - const struct cpumask *affinity = irq_data_get_affinity_mask(d);
    167     - struct irq_chip *c;
    168     - bool ret = false;
    169     -
    170     - /*
    171     - * If this is a per-CPU interrupt, or the affinity does not
    172     - * include this CPU, then we have nothing to do.
    173     - */
    174     - if (irqd_is_per_cpu(d) || !cpumask_test_cpu(smp_processor_id(), affinity))
    175     - return false;
    176     -
    177     - if (cpumask_any_and(affinity, cpu_online_mask) >= nr_cpu_ids) {
    178     - affinity = cpu_online_mask;
    179     - ret = true;
    180     - }
    181     -
    182     - c = irq_data_get_irq_chip(d);
    183     - if (!c->irq_set_affinity)
    184     - pr_debug("IRQ%u: unable to set affinity\n", d->irq);
    185     - else if (c->irq_set_affinity(d, affinity, false) == IRQ_SET_MASK_OK && ret)
    186     - cpumask_copy(irq_data_get_affinity_mask(d), affinity);
    187     -
    188     - return ret;
    189     -}
    190     -
    191     -/*
    192     - * The current CPU has been marked offline. Migrate IRQs off this CPU.
    193     - * If the affinity settings do not allow other CPUs, force them onto any
    194     - * available CPU.
    195     - *
    196     - * Note: we must iterate over all IRQs, whether they have an attached
    197     - * action structure or not, as we need to get chained interrupts too.
    198     - */
    199     -void migrate_irqs(void)
    200     -{
    201     - unsigned int i;
    202     - struct irq_desc *desc;
    203     - unsigned long flags;
    204     -
    205     - local_irq_save(flags);
    206     -
    207     - for_each_irq_desc(i, desc) {
    208     - bool affinity_broken;
    209     -
    210     - raw_spin_lock(&desc->lock);
    211     - affinity_broken = migrate_one_irq(desc);
    212     - raw_spin_unlock(&desc->lock);
    213     -
    214     - if (affinity_broken)
    215     - pr_warn_ratelimited("IRQ%u no longer affine to CPU%u\n",
    216     - i, smp_processor_id());
    217     - }
    218     -
    219     - local_irq_restore(flags);
    220     -}
    221     -#endif /* CONFIG_HOTPLUG_CPU */
    222     diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
    223     index 8faf869e9fb2..bc83ec7ed53f 100644
    224     --- a/arch/arm/kernel/smp.c
    225     +++ b/arch/arm/kernel/smp.c
    226     @@ -253,7 +253,7 @@ int __cpu_disable(void)
    227     /*
    228     * OK - migrate IRQs away from this CPU
    229     */
    230     - migrate_irqs();
    231     + irq_migrate_all_off_this_cpu();
    232    
    233     /*
    234     * Flush user cache and TLB mappings, and then remove this CPU
    235     diff --git a/arch/arm/mach-omap2/display.c b/arch/arm/mach-omap2/display.c
    236     index 70b3eaf085e4..5ca7e29ad851 100644
    237     --- a/arch/arm/mach-omap2/display.c
    238     +++ b/arch/arm/mach-omap2/display.c
    239     @@ -115,6 +115,7 @@ static int omap4_dsi_mux_pads(int dsi_id, unsigned lanes)
    240     u32 enable_mask, enable_shift;
    241     u32 pipd_mask, pipd_shift;
    242     u32 reg;
    243     + int ret;
    244    
    245     if (dsi_id == 0) {
    246     enable_mask = OMAP4_DSI1_LANEENABLE_MASK;
    247     @@ -130,7 +131,11 @@ static int omap4_dsi_mux_pads(int dsi_id, unsigned lanes)
    248     return -ENODEV;
    249     }
    250    
    251     - regmap_read(omap4_dsi_mux_syscon, OMAP4_DSIPHY_SYSCON_OFFSET, &reg);
    252     + ret = regmap_read(omap4_dsi_mux_syscon,
    253     + OMAP4_DSIPHY_SYSCON_OFFSET,
    254     + &reg);
    255     + if (ret)
    256     + return ret;
    257    
    258     reg &= ~enable_mask;
    259     reg &= ~pipd_mask;
    260     diff --git a/arch/arm/mach-s3c24xx/mach-osiris-dvs.c b/arch/arm/mach-s3c24xx/mach-osiris-dvs.c
    261     index 262ab0744748..f4fdfca9439b 100644
    262     --- a/arch/arm/mach-s3c24xx/mach-osiris-dvs.c
    263     +++ b/arch/arm/mach-s3c24xx/mach-osiris-dvs.c
    264     @@ -70,16 +70,16 @@ static int osiris_dvs_notify(struct notifier_block *nb,
    265    
    266     switch (val) {
    267     case CPUFREQ_PRECHANGE:
    268     - if (old_dvs & !new_dvs ||
    269     - cur_dvs & !new_dvs) {
    270     + if ((old_dvs && !new_dvs) ||
    271     + (cur_dvs && !new_dvs)) {
    272     pr_debug("%s: exiting dvs\n", __func__);
    273     cur_dvs = false;
    274     gpio_set_value(OSIRIS_GPIO_DVS, 1);
    275     }
    276     break;
    277     case CPUFREQ_POSTCHANGE:
    278     - if (!old_dvs & new_dvs ||
    279     - !cur_dvs & new_dvs) {
    280     + if ((!old_dvs && new_dvs) ||
    281     + (!cur_dvs && new_dvs)) {
    282     pr_debug("entering dvs\n");
    283     cur_dvs = true;
    284     gpio_set_value(OSIRIS_GPIO_DVS, 0);
    285     diff --git a/arch/arm64/crypto/aes-ce-ccm-core.S b/arch/arm64/crypto/aes-ce-ccm-core.S
    286     index 3363560c79b7..7bc459d9235c 100644
    287     --- a/arch/arm64/crypto/aes-ce-ccm-core.S
    288     +++ b/arch/arm64/crypto/aes-ce-ccm-core.S
    289     @@ -74,12 +74,13 @@ ENTRY(ce_aes_ccm_auth_data)
    290     beq 10f
    291     ext v0.16b, v0.16b, v0.16b, #1 /* rotate out the mac bytes */
    292     b 7b
    293     -8: mov w7, w8
    294     +8: cbz w8, 91f
    295     + mov w7, w8
    296     add w8, w8, #16
    297     9: ext v1.16b, v1.16b, v1.16b, #1
    298     adds w7, w7, #1
    299     bne 9b
    300     - eor v0.16b, v0.16b, v1.16b
    301     +91: eor v0.16b, v0.16b, v1.16b
    302     st1 {v0.16b}, [x0]
    303     10: str w8, [x3]
    304     ret
    305     diff --git a/arch/arm64/kernel/head.S b/arch/arm64/kernel/head.S
    306     index 3289d1458791..db6ff1944c41 100644
    307     --- a/arch/arm64/kernel/head.S
    308     +++ b/arch/arm64/kernel/head.S
    309     @@ -534,8 +534,7 @@ set_hcr:
    310     /* GICv3 system register access */
    311     mrs x0, id_aa64pfr0_el1
    312     ubfx x0, x0, #24, #4
    313     - cmp x0, #1
    314     - b.ne 3f
    315     + cbz x0, 3f
    316    
    317     mrs_s x0, ICC_SRE_EL2
    318     orr x0, x0, #ICC_SRE_EL2_SRE // Set ICC_SRE_EL2.SRE==1
    319     diff --git a/arch/m68k/Makefile b/arch/m68k/Makefile
    320     index f0dd9fc84002..a229d28e14cc 100644
    321     --- a/arch/m68k/Makefile
    322     +++ b/arch/m68k/Makefile
    323     @@ -58,7 +58,10 @@ cpuflags-$(CONFIG_M5206e) := $(call cc-option,-mcpu=5206e,-m5200)
    324     cpuflags-$(CONFIG_M5206) := $(call cc-option,-mcpu=5206,-m5200)
    325    
    326     KBUILD_AFLAGS += $(cpuflags-y)
    327     -KBUILD_CFLAGS += $(cpuflags-y) -pipe
    328     +KBUILD_CFLAGS += $(cpuflags-y)
    329     +
    330     +KBUILD_CFLAGS += -pipe -ffreestanding
    331     +
    332     ifdef CONFIG_MMU
    333     # without -fno-strength-reduce the 53c7xx.c driver fails ;-(
    334     KBUILD_CFLAGS += -fno-strength-reduce -ffixed-a2
    335     diff --git a/arch/powerpc/kernel/entry_32.S b/arch/powerpc/kernel/entry_32.S
    336     index 3841d749a430..370645687cc7 100644
    337     --- a/arch/powerpc/kernel/entry_32.S
    338     +++ b/arch/powerpc/kernel/entry_32.S
    339     @@ -698,6 +698,9 @@ fast_exception_return:
    340     mtcr r10
    341     lwz r10,_LINK(r11)
    342     mtlr r10
    343     + /* Clear the exception_marker on the stack to avoid confusing stacktrace */
    344     + li r10, 0
    345     + stw r10, 8(r11)
    346     REST_GPR(10, r11)
    347     mtspr SPRN_SRR1,r9
    348     mtspr SPRN_SRR0,r12
    349     @@ -932,6 +935,9 @@ END_FTR_SECTION_IFSET(CPU_FTR_NEED_PAIRED_STWCX)
    350     mtcrf 0xFF,r10
    351     mtlr r11
    352    
    353     + /* Clear the exception_marker on the stack to avoid confusing stacktrace */
    354     + li r10, 0
    355     + stw r10, 8(r1)
    356     /*
    357     * Once we put values in SRR0 and SRR1, we are in a state
    358     * where exceptions are not recoverable, since taking an
    359     @@ -969,6 +975,9 @@ exc_exit_restart_end:
    360     mtlr r11
    361     lwz r10,_CCR(r1)
    362     mtcrf 0xff,r10
    363     + /* Clear the exception_marker on the stack to avoid confusing stacktrace */
    364     + li r10, 0
    365     + stw r10, 8(r1)
    366     REST_2GPRS(9, r1)
    367     .globl exc_exit_restart
    368     exc_exit_restart:
    369     diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
    370     index 1c141d50fbc6..609f0e87ced7 100644
    371     --- a/arch/powerpc/kernel/process.c
    372     +++ b/arch/powerpc/kernel/process.c
    373     @@ -153,7 +153,7 @@ void __giveup_fpu(struct task_struct *tsk)
    374    
    375     save_fpu(tsk);
    376     msr = tsk->thread.regs->msr;
    377     - msr &= ~MSR_FP;
    378     + msr &= ~(MSR_FP|MSR_FE0|MSR_FE1);
    379     #ifdef CONFIG_VSX
    380     if (cpu_has_feature(CPU_FTR_VSX))
    381     msr &= ~MSR_VSX;
    382     diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
    383     index adfa63e7df8c..4f2829634d79 100644
    384     --- a/arch/powerpc/kernel/ptrace.c
    385     +++ b/arch/powerpc/kernel/ptrace.c
    386     @@ -547,6 +547,7 @@ static int vr_get(struct task_struct *target, const struct user_regset *regset,
    387     /*
    388     * Copy out only the low-order word of vrsave.
    389     */
    390     + int start, end;
    391     union {
    392     elf_vrreg_t reg;
    393     u32 word;
    394     @@ -555,8 +556,10 @@ static int vr_get(struct task_struct *target, const struct user_regset *regset,
    395    
    396     vrsave.word = target->thread.vrsave;
    397    
    398     + start = 33 * sizeof(vector128);
    399     + end = start + sizeof(vrsave);
    400     ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &vrsave,
    401     - 33 * sizeof(vector128), -1);
    402     + start, end);
    403     }
    404    
    405     return ret;
    406     @@ -594,6 +597,7 @@ static int vr_set(struct task_struct *target, const struct user_regset *regset,
    407     /*
    408     * We use only the first word of vrsave.
    409     */
    410     + int start, end;
    411     union {
    412     elf_vrreg_t reg;
    413     u32 word;
    414     @@ -602,8 +606,10 @@ static int vr_set(struct task_struct *target, const struct user_regset *regset,
    415    
    416     vrsave.word = target->thread.vrsave;
    417    
    418     + start = 33 * sizeof(vector128);
    419     + end = start + sizeof(vrsave);
    420     ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &vrsave,
    421     - 33 * sizeof(vector128), -1);
    422     + start, end);
    423     if (!ret)
    424     target->thread.vrsave = vrsave.word;
    425     }
    426     diff --git a/arch/powerpc/platforms/83xx/suspend-asm.S b/arch/powerpc/platforms/83xx/suspend-asm.S
    427     index 3d1ecd211776..8137f77abad5 100644
    428     --- a/arch/powerpc/platforms/83xx/suspend-asm.S
    429     +++ b/arch/powerpc/platforms/83xx/suspend-asm.S
    430     @@ -26,13 +26,13 @@
    431     #define SS_MSR 0x74
    432     #define SS_SDR1 0x78
    433     #define SS_LR 0x7c
    434     -#define SS_SPRG 0x80 /* 4 SPRGs */
    435     -#define SS_DBAT 0x90 /* 8 DBATs */
    436     -#define SS_IBAT 0xd0 /* 8 IBATs */
    437     -#define SS_TB 0x110
    438     -#define SS_CR 0x118
    439     -#define SS_GPREG 0x11c /* r12-r31 */
    440     -#define STATE_SAVE_SIZE 0x16c
    441     +#define SS_SPRG 0x80 /* 8 SPRGs */
    442     +#define SS_DBAT 0xa0 /* 8 DBATs */
    443     +#define SS_IBAT 0xe0 /* 8 IBATs */
    444     +#define SS_TB 0x120
    445     +#define SS_CR 0x128
    446     +#define SS_GPREG 0x12c /* r12-r31 */
    447     +#define STATE_SAVE_SIZE 0x17c
    448    
    449     .section .data
    450     .align 5
    451     @@ -103,6 +103,16 @@ _GLOBAL(mpc83xx_enter_deep_sleep)
    452     stw r7, SS_SPRG+12(r3)
    453     stw r8, SS_SDR1(r3)
    454    
    455     + mfspr r4, SPRN_SPRG4
    456     + mfspr r5, SPRN_SPRG5
    457     + mfspr r6, SPRN_SPRG6
    458     + mfspr r7, SPRN_SPRG7
    459     +
    460     + stw r4, SS_SPRG+16(r3)
    461     + stw r5, SS_SPRG+20(r3)
    462     + stw r6, SS_SPRG+24(r3)
    463     + stw r7, SS_SPRG+28(r3)
    464     +
    465     mfspr r4, SPRN_DBAT0U
    466     mfspr r5, SPRN_DBAT0L
    467     mfspr r6, SPRN_DBAT1U
    468     @@ -493,6 +503,16 @@ mpc83xx_deep_resume:
    469     mtspr SPRN_IBAT7U, r6
    470     mtspr SPRN_IBAT7L, r7
    471    
    472     + lwz r4, SS_SPRG+16(r3)
    473     + lwz r5, SS_SPRG+20(r3)
    474     + lwz r6, SS_SPRG+24(r3)
    475     + lwz r7, SS_SPRG+28(r3)
    476     +
    477     + mtspr SPRN_SPRG4, r4
    478     + mtspr SPRN_SPRG5, r5
    479     + mtspr SPRN_SPRG6, r6
    480     + mtspr SPRN_SPRG7, r7
    481     +
    482     lwz r4, SS_SPRG+0(r3)
    483     lwz r5, SS_SPRG+4(r3)
    484     lwz r6, SS_SPRG+8(r3)
    485     diff --git a/arch/powerpc/platforms/embedded6xx/wii.c b/arch/powerpc/platforms/embedded6xx/wii.c
    486     index 3fd683e40bc9..2914529c0695 100644
    487     --- a/arch/powerpc/platforms/embedded6xx/wii.c
    488     +++ b/arch/powerpc/platforms/embedded6xx/wii.c
    489     @@ -104,6 +104,10 @@ unsigned long __init wii_mmu_mapin_mem2(unsigned long top)
    490     /* MEM2 64MB@0x10000000 */
    491     delta = wii_hole_start + wii_hole_size;
    492     size = top - delta;
    493     +
    494     + if (__map_without_bats)
    495     + return delta;
    496     +
    497     for (bl = 128<<10; bl < max_size; bl <<= 1) {
    498     if (bl * 2 > size)
    499     break;
    500     diff --git a/arch/powerpc/platforms/powernv/opal-msglog.c b/arch/powerpc/platforms/powernv/opal-msglog.c
    501     index 39d6ff9e5630..d10bad14097b 100644
    502     --- a/arch/powerpc/platforms/powernv/opal-msglog.c
    503     +++ b/arch/powerpc/platforms/powernv/opal-msglog.c
    504     @@ -98,7 +98,7 @@ static ssize_t opal_msglog_read(struct file *file, struct kobject *kobj,
    505     }
    506    
    507     static struct bin_attribute opal_msglog_attr = {
    508     - .attr = {.name = "msglog", .mode = 0444},
    509     + .attr = {.name = "msglog", .mode = 0400},
    510     .read = opal_msglog_read
    511     };
    512    
    513     diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
    514     index 1870fa7387b7..a34fb7284024 100644
    515     --- a/arch/x86/kvm/vmx.c
    516     +++ b/arch/x86/kvm/vmx.c
    517     @@ -5965,6 +5965,7 @@ static int handle_external_interrupt(struct kvm_vcpu *vcpu)
    518     static int handle_triple_fault(struct kvm_vcpu *vcpu)
    519     {
    520     vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
    521     + vcpu->mmio_needed = 0;
    522     return 0;
    523     }
    524    
    525     @@ -7046,6 +7047,10 @@ static int get_vmx_mem_address(struct kvm_vcpu *vcpu,
    526     /* Addr = segment_base + offset */
    527     /* offset = base + [index * scale] + displacement */
    528     off = exit_qualification; /* holds the displacement */
    529     + if (addr_size == 1)
    530     + off = (gva_t)sign_extend64(off, 31);
    531     + else if (addr_size == 0)
    532     + off = (gva_t)sign_extend64(off, 15);
    533     if (base_is_valid)
    534     off += kvm_register_read(vcpu, base_reg);
    535     if (index_is_valid)
    536     @@ -7088,10 +7093,16 @@ static int get_vmx_mem_address(struct kvm_vcpu *vcpu,
    537     /* Protected mode: #GP(0)/#SS(0) if the segment is unusable.
    538     */
    539     exn = (s.unusable != 0);
    540     - /* Protected mode: #GP(0)/#SS(0) if the memory
    541     - * operand is outside the segment limit.
    542     +
    543     + /*
    544     + * Protected mode: #GP(0)/#SS(0) if the memory operand is
    545     + * outside the segment limit. All CPUs that support VMX ignore
    546     + * limit checks for flat segments, i.e. segments with base==0,
    547     + * limit==0xffffffff and of type expand-up data or code.
    548     */
    549     - exn = exn || (off + sizeof(u64) > s.limit);
    550     + if (!(s.base == 0 && s.limit == 0xffffffff &&
    551     + ((s.type & 8) || !(s.type & 4))))
    552     + exn = exn || (off + sizeof(u64) > s.limit);
    553     }
    554     if (exn) {
    555     kvm_queue_exception_e(vcpu,
    556     diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
    557     index 5a35fee46620..a29df9ccbfde 100644
    558     --- a/arch/x86/kvm/x86.c
    559     +++ b/arch/x86/kvm/x86.c
    560     @@ -6769,6 +6769,7 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
    561     }
    562     if (kvm_check_request(KVM_REQ_TRIPLE_FAULT, vcpu)) {
    563     vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
    564     + vcpu->mmio_needed = 0;
    565     r = 0;
    566     goto out;
    567     }
    568     diff --git a/crypto/ahash.c b/crypto/ahash.c
    569     index 90d73a22f129..9a4e87755a0b 100644
    570     --- a/crypto/ahash.c
    571     +++ b/crypto/ahash.c
    572     @@ -85,17 +85,17 @@ static int hash_walk_new_entry(struct crypto_hash_walk *walk)
    573     int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
    574     {
    575     unsigned int alignmask = walk->alignmask;
    576     - unsigned int nbytes = walk->entrylen;
    577    
    578     walk->data -= walk->offset;
    579    
    580     - if (nbytes && walk->offset & alignmask && !err) {
    581     - walk->offset = ALIGN(walk->offset, alignmask + 1);
    582     - nbytes = min(nbytes,
    583     - ((unsigned int)(PAGE_SIZE)) - walk->offset);
    584     - walk->entrylen -= nbytes;
    585     + if (walk->entrylen && (walk->offset & alignmask) && !err) {
    586     + unsigned int nbytes;
    587    
    588     + walk->offset = ALIGN(walk->offset, alignmask + 1);
    589     + nbytes = min(walk->entrylen,
    590     + (unsigned int)(PAGE_SIZE - walk->offset));
    591     if (nbytes) {
    592     + walk->entrylen -= nbytes;
    593     walk->data += walk->offset;
    594     return nbytes;
    595     }
    596     @@ -115,7 +115,7 @@ int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
    597     if (err)
    598     return err;
    599    
    600     - if (nbytes) {
    601     + if (walk->entrylen) {
    602     walk->offset = 0;
    603     walk->pg++;
    604     return hash_walk_next(walk);
    605     @@ -189,6 +189,21 @@ static int ahash_setkey_unaligned(struct crypto_ahash *tfm, const u8 *key,
    606     return ret;
    607     }
    608    
    609     +static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
    610     + unsigned int keylen)
    611     +{
    612     + return -ENOSYS;
    613     +}
    614     +
    615     +static void ahash_set_needkey(struct crypto_ahash *tfm)
    616     +{
    617     + const struct hash_alg_common *alg = crypto_hash_alg_common(tfm);
    618     +
    619     + if (tfm->setkey != ahash_nosetkey &&
    620     + !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    621     + crypto_ahash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
    622     +}
    623     +
    624     int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
    625     unsigned int keylen)
    626     {
    627     @@ -200,20 +215,16 @@ int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
    628     else
    629     err = tfm->setkey(tfm, key, keylen);
    630    
    631     - if (err)
    632     + if (unlikely(err)) {
    633     + ahash_set_needkey(tfm);
    634     return err;
    635     + }
    636    
    637     crypto_ahash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
    638     return 0;
    639     }
    640     EXPORT_SYMBOL_GPL(crypto_ahash_setkey);
    641    
    642     -static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
    643     - unsigned int keylen)
    644     -{
    645     - return -ENOSYS;
    646     -}
    647     -
    648     static inline unsigned int ahash_align_buffer_size(unsigned len,
    649     unsigned long mask)
    650     {
    651     @@ -482,8 +493,7 @@ static int crypto_ahash_init_tfm(struct crypto_tfm *tfm)
    652    
    653     if (alg->setkey) {
    654     hash->setkey = alg->setkey;
    655     - if (!(alg->halg.base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    656     - crypto_ahash_set_flags(hash, CRYPTO_TFM_NEED_KEY);
    657     + ahash_set_needkey(hash);
    658     }
    659     if (alg->export)
    660     hash->export = alg->export;
    661     diff --git a/crypto/pcbc.c b/crypto/pcbc.c
    662     index f654965f0933..de81f716cf26 100644
    663     --- a/crypto/pcbc.c
    664     +++ b/crypto/pcbc.c
    665     @@ -52,7 +52,7 @@ static int crypto_pcbc_encrypt_segment(struct blkcipher_desc *desc,
    666     unsigned int nbytes = walk->nbytes;
    667     u8 *src = walk->src.virt.addr;
    668     u8 *dst = walk->dst.virt.addr;
    669     - u8 *iv = walk->iv;
    670     + u8 * const iv = walk->iv;
    671    
    672     do {
    673     crypto_xor(iv, src, bsize);
    674     @@ -76,7 +76,7 @@ static int crypto_pcbc_encrypt_inplace(struct blkcipher_desc *desc,
    675     int bsize = crypto_cipher_blocksize(tfm);
    676     unsigned int nbytes = walk->nbytes;
    677     u8 *src = walk->src.virt.addr;
    678     - u8 *iv = walk->iv;
    679     + u8 * const iv = walk->iv;
    680     u8 tmpbuf[bsize];
    681    
    682     do {
    683     @@ -89,8 +89,6 @@ static int crypto_pcbc_encrypt_inplace(struct blkcipher_desc *desc,
    684     src += bsize;
    685     } while ((nbytes -= bsize) >= bsize);
    686    
    687     - memcpy(walk->iv, iv, bsize);
    688     -
    689     return nbytes;
    690     }
    691    
    692     @@ -130,7 +128,7 @@ static int crypto_pcbc_decrypt_segment(struct blkcipher_desc *desc,
    693     unsigned int nbytes = walk->nbytes;
    694     u8 *src = walk->src.virt.addr;
    695     u8 *dst = walk->dst.virt.addr;
    696     - u8 *iv = walk->iv;
    697     + u8 * const iv = walk->iv;
    698    
    699     do {
    700     fn(crypto_cipher_tfm(tfm), dst, src);
    701     @@ -142,8 +140,6 @@ static int crypto_pcbc_decrypt_segment(struct blkcipher_desc *desc,
    702     dst += bsize;
    703     } while ((nbytes -= bsize) >= bsize);
    704    
    705     - memcpy(walk->iv, iv, bsize);
    706     -
    707     return nbytes;
    708     }
    709    
    710     @@ -156,7 +152,7 @@ static int crypto_pcbc_decrypt_inplace(struct blkcipher_desc *desc,
    711     int bsize = crypto_cipher_blocksize(tfm);
    712     unsigned int nbytes = walk->nbytes;
    713     u8 *src = walk->src.virt.addr;
    714     - u8 *iv = walk->iv;
    715     + u8 * const iv = walk->iv;
    716     u8 tmpbuf[bsize];
    717    
    718     do {
    719     @@ -169,8 +165,6 @@ static int crypto_pcbc_decrypt_inplace(struct blkcipher_desc *desc,
    720     src += bsize;
    721     } while ((nbytes -= bsize) >= bsize);
    722    
    723     - memcpy(walk->iv, iv, bsize);
    724     -
    725     return nbytes;
    726     }
    727    
    728     diff --git a/crypto/shash.c b/crypto/shash.c
    729     index 4f047c7eeca7..a1c7609578ea 100644
    730     --- a/crypto/shash.c
    731     +++ b/crypto/shash.c
    732     @@ -52,6 +52,13 @@ static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
    733     return err;
    734     }
    735    
    736     +static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
    737     +{
    738     + if (crypto_shash_alg_has_setkey(alg) &&
    739     + !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    740     + crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
    741     +}
    742     +
    743     int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
    744     unsigned int keylen)
    745     {
    746     @@ -64,8 +71,10 @@ int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
    747     else
    748     err = shash->setkey(tfm, key, keylen);
    749    
    750     - if (err)
    751     + if (unlikely(err)) {
    752     + shash_set_needkey(tfm, shash);
    753     return err;
    754     + }
    755    
    756     crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
    757     return 0;
    758     @@ -367,7 +376,8 @@ int crypto_init_shash_ops_async(struct crypto_tfm *tfm)
    759     crt->final = shash_async_final;
    760     crt->finup = shash_async_finup;
    761     crt->digest = shash_async_digest;
    762     - crt->setkey = shash_async_setkey;
    763     + if (crypto_shash_alg_has_setkey(alg))
    764     + crt->setkey = shash_async_setkey;
    765    
    766     crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
    767     CRYPTO_TFM_NEED_KEY);
    768     @@ -389,9 +399,7 @@ static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
    769    
    770     hash->descsize = alg->descsize;
    771    
    772     - if (crypto_shash_alg_has_setkey(alg) &&
    773     - !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    774     - crypto_shash_set_flags(hash, CRYPTO_TFM_NEED_KEY);
    775     + shash_set_needkey(hash, alg);
    776    
    777     return 0;
    778     }
    779     diff --git a/drivers/acpi/device_sysfs.c b/drivers/acpi/device_sysfs.c
    780     index 201c7ceb7052..98b513d049f6 100644
    781     --- a/drivers/acpi/device_sysfs.c
    782     +++ b/drivers/acpi/device_sysfs.c
    783     @@ -202,11 +202,15 @@ static int create_of_modalias(struct acpi_device *acpi_dev, char *modalias,
    784     {
    785     struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
    786     const union acpi_object *of_compatible, *obj;
    787     + acpi_status status;
    788     int len, count;
    789     int i, nval;
    790     char *c;
    791    
    792     - acpi_get_name(acpi_dev->handle, ACPI_SINGLE_NAME, &buf);
    793     + status = acpi_get_name(acpi_dev->handle, ACPI_SINGLE_NAME, &buf);
    794     + if (ACPI_FAILURE(status))
    795     + return -ENODEV;
    796     +
    797     /* DT strings are all in lower case */
    798     for (c = buf.pointer; *c != '\0'; c++)
    799     *c = tolower(*c);
    800     diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
    801     index 06cf7427d0c4..31a07609f7a2 100644
    802     --- a/drivers/acpi/nfit/core.c
    803     +++ b/drivers/acpi/nfit/core.c
    804     @@ -307,6 +307,13 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
    805     return -EINVAL;
    806     }
    807    
    808     + if (out_obj->type != ACPI_TYPE_BUFFER) {
    809     + dev_dbg(dev, "%s unexpected output object type cmd: %s type: %d\n",
    810     + dimm_name, cmd_name, out_obj->type);
    811     + rc = -EINVAL;
    812     + goto out;
    813     + }
    814     +
    815     if (call_pkg) {
    816     call_pkg->nd_fw_size = out_obj->buffer.length;
    817     memcpy(call_pkg->nd_payload + call_pkg->nd_size_in,
    818     @@ -325,13 +332,6 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
    819     return 0;
    820     }
    821    
    822     - if (out_obj->package.type != ACPI_TYPE_BUFFER) {
    823     - dev_dbg(dev, "%s:%s unexpected output object type cmd: %s type: %d\n",
    824     - __func__, dimm_name, cmd_name, out_obj->type);
    825     - rc = -EINVAL;
    826     - goto out;
    827     - }
    828     -
    829     if (IS_ENABLED(CONFIG_ACPI_NFIT_DEBUG)) {
    830     dev_dbg(dev, "%s:%s cmd: %s output length: %d\n", __func__,
    831     dimm_name, cmd_name, out_obj->buffer.length);
    832     diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
    833     index f98121f11f7c..9f51a167bf4e 100644
    834     --- a/drivers/base/power/wakeup.c
    835     +++ b/drivers/base/power/wakeup.c
    836     @@ -113,7 +113,6 @@ void wakeup_source_drop(struct wakeup_source *ws)
    837     if (!ws)
    838     return;
    839    
    840     - del_timer_sync(&ws->timer);
    841     __pm_relax(ws);
    842     }
    843     EXPORT_SYMBOL_GPL(wakeup_source_drop);
    844     @@ -201,6 +200,13 @@ void wakeup_source_remove(struct wakeup_source *ws)
    845     list_del_rcu(&ws->entry);
    846     spin_unlock_irqrestore(&events_lock, flags);
    847     synchronize_srcu(&wakeup_srcu);
    848     +
    849     + del_timer_sync(&ws->timer);
    850     + /*
    851     + * Clear timer.function to make wakeup_source_not_registered() treat
    852     + * this wakeup source as not registered.
    853     + */
    854     + ws->timer.function = NULL;
    855     }
    856     EXPORT_SYMBOL_GPL(wakeup_source_remove);
    857    
    858     diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
    859     index 326b9ba4518e..6914c6e1e1a8 100644
    860     --- a/drivers/block/floppy.c
    861     +++ b/drivers/block/floppy.c
    862     @@ -3752,7 +3752,7 @@ static unsigned int floppy_check_events(struct gendisk *disk,
    863    
    864     if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
    865     if (lock_fdc(drive))
    866     - return -EINTR;
    867     + return 0;
    868     poll_drive(false, 0);
    869     process_fd_request();
    870     }
    871     diff --git a/drivers/clk/clk-twl6040.c b/drivers/clk/clk-twl6040.c
    872     index 7b222a5db931..82d615fe2947 100644
    873     --- a/drivers/clk/clk-twl6040.c
    874     +++ b/drivers/clk/clk-twl6040.c
    875     @@ -41,6 +41,43 @@ static int twl6040_pdmclk_is_prepared(struct clk_hw *hw)
    876     return pdmclk->enabled;
    877     }
    878    
    879     +static int twl6040_pdmclk_reset_one_clock(struct twl6040_pdmclk *pdmclk,
    880     + unsigned int reg)
    881     +{
    882     + const u8 reset_mask = TWL6040_HPLLRST; /* Same for HPPLL and LPPLL */
    883     + int ret;
    884     +
    885     + ret = twl6040_set_bits(pdmclk->twl6040, reg, reset_mask);
    886     + if (ret < 0)
    887     + return ret;
    888     +
    889     + ret = twl6040_clear_bits(pdmclk->twl6040, reg, reset_mask);
    890     + if (ret < 0)
    891     + return ret;
    892     +
    893     + return 0;
    894     +}
    895     +
    896     +/*
    897     + * TWL6040A2 Phoenix Audio IC erratum #6: "PDM Clock Generation Issue At
    898     + * Cold Temperature". This affects cold boot and deeper idle states it
    899     + * seems. The workaround consists of resetting HPPLL and LPPLL.
    900     + */
    901     +static int twl6040_pdmclk_quirk_reset_clocks(struct twl6040_pdmclk *pdmclk)
    902     +{
    903     + int ret;
    904     +
    905     + ret = twl6040_pdmclk_reset_one_clock(pdmclk, TWL6040_REG_HPPLLCTL);
    906     + if (ret)
    907     + return ret;
    908     +
    909     + ret = twl6040_pdmclk_reset_one_clock(pdmclk, TWL6040_REG_LPPLLCTL);
    910     + if (ret)
    911     + return ret;
    912     +
    913     + return 0;
    914     +}
    915     +
    916     static int twl6040_pdmclk_prepare(struct clk_hw *hw)
    917     {
    918     struct twl6040_pdmclk *pdmclk = container_of(hw, struct twl6040_pdmclk,
    919     @@ -48,8 +85,20 @@ static int twl6040_pdmclk_prepare(struct clk_hw *hw)
    920     int ret;
    921    
    922     ret = twl6040_power(pdmclk->twl6040, 1);
    923     - if (!ret)
    924     - pdmclk->enabled = 1;
    925     + if (ret)
    926     + return ret;
    927     +
    928     + ret = twl6040_pdmclk_quirk_reset_clocks(pdmclk);
    929     + if (ret)
    930     + goto out_err;
    931     +
    932     + pdmclk->enabled = 1;
    933     +
    934     + return 0;
    935     +
    936     +out_err:
    937     + dev_err(pdmclk->dev, "%s: error %i\n", __func__, ret);
    938     + twl6040_power(pdmclk->twl6040, 0);
    939    
    940     return ret;
    941     }
    942     diff --git a/drivers/clk/ingenic/cgu.c b/drivers/clk/ingenic/cgu.c
    943     index e8248f9185f7..4dec9e9ccffe 100644
    944     --- a/drivers/clk/ingenic/cgu.c
    945     +++ b/drivers/clk/ingenic/cgu.c
    946     @@ -364,16 +364,16 @@ ingenic_clk_round_rate(struct clk_hw *hw, unsigned long req_rate,
    947     struct ingenic_clk *ingenic_clk = to_ingenic_clk(hw);
    948     struct ingenic_cgu *cgu = ingenic_clk->cgu;
    949     const struct ingenic_cgu_clk_info *clk_info;
    950     - long rate = *parent_rate;
    951     + unsigned int div = 1;
    952    
    953     clk_info = &cgu->clock_info[ingenic_clk->idx];
    954    
    955     if (clk_info->type & CGU_CLK_DIV)
    956     - rate /= ingenic_clk_calc_div(clk_info, *parent_rate, req_rate);
    957     + div = ingenic_clk_calc_div(clk_info, *parent_rate, req_rate);
    958     else if (clk_info->type & CGU_CLK_FIXDIV)
    959     - rate /= clk_info->fixdiv.div;
    960     + div = clk_info->fixdiv.div;
    961    
    962     - return rate;
    963     + return DIV_ROUND_UP(*parent_rate, div);
    964     }
    965    
    966     static int
    967     @@ -393,7 +393,7 @@ ingenic_clk_set_rate(struct clk_hw *hw, unsigned long req_rate,
    968    
    969     if (clk_info->type & CGU_CLK_DIV) {
    970     div = ingenic_clk_calc_div(clk_info, parent_rate, req_rate);
    971     - rate = parent_rate / div;
    972     + rate = DIV_ROUND_UP(parent_rate, div);
    973    
    974     if (rate != req_rate)
    975     return -EINVAL;
    976     diff --git a/drivers/clk/ingenic/cgu.h b/drivers/clk/ingenic/cgu.h
    977     index 09700b2c555d..a22f654b2900 100644
    978     --- a/drivers/clk/ingenic/cgu.h
    979     +++ b/drivers/clk/ingenic/cgu.h
    980     @@ -78,7 +78,7 @@ struct ingenic_cgu_mux_info {
    981     * @reg: offset of the divider control register within the CGU
    982     * @shift: number of bits to left shift the divide value by (ie. the index of
    983     * the lowest bit of the divide value within its control register)
    984     - * @div: number of bits to divide the divider value by (i.e. if the
    985     + * @div: number to divide the divider value by (i.e. if the
    986     * effective divider value is the value written to the register
    987     * multiplied by some constant)
    988     * @bits: the size of the divide value in bits
    989     diff --git a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
    990     index 6ea5401e6881..7f1281298651 100644
    991     --- a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
    992     +++ b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
    993     @@ -252,9 +252,9 @@ static SUNXI_CCU_GATE(ahb1_mmc1_clk, "ahb1-mmc1", "ahb1",
    994     static SUNXI_CCU_GATE(ahb1_mmc2_clk, "ahb1-mmc2", "ahb1",
    995     0x060, BIT(10), 0);
    996     static SUNXI_CCU_GATE(ahb1_mmc3_clk, "ahb1-mmc3", "ahb1",
    997     - 0x060, BIT(12), 0);
    998     + 0x060, BIT(11), 0);
    999     static SUNXI_CCU_GATE(ahb1_nand1_clk, "ahb1-nand1", "ahb1",
    1000     - 0x060, BIT(13), 0);
    1001     + 0x060, BIT(12), 0);
    1002     static SUNXI_CCU_GATE(ahb1_nand0_clk, "ahb1-nand0", "ahb1",
    1003     0x060, BIT(13), 0);
    1004     static SUNXI_CCU_GATE(ahb1_sdram_clk, "ahb1-sdram", "ahb1",
    1005     diff --git a/drivers/clocksource/exynos_mct.c b/drivers/clocksource/exynos_mct.c
    1006     index 7f6fed9f0703..fb0cf8b74516 100644
    1007     --- a/drivers/clocksource/exynos_mct.c
    1008     +++ b/drivers/clocksource/exynos_mct.c
    1009     @@ -388,6 +388,13 @@ static void exynos4_mct_tick_start(unsigned long cycles,
    1010     exynos4_mct_write(tmp, mevt->base + MCT_L_TCON_OFFSET);
    1011     }
    1012    
    1013     +static void exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
    1014     +{
    1015     + /* Clear the MCT tick interrupt */
    1016     + if (readl_relaxed(reg_base + mevt->base + MCT_L_INT_CSTAT_OFFSET) & 1)
    1017     + exynos4_mct_write(0x1, mevt->base + MCT_L_INT_CSTAT_OFFSET);
    1018     +}
    1019     +
    1020     static int exynos4_tick_set_next_event(unsigned long cycles,
    1021     struct clock_event_device *evt)
    1022     {
    1023     @@ -404,6 +411,7 @@ static int set_state_shutdown(struct clock_event_device *evt)
    1024    
    1025     mevt = container_of(evt, struct mct_clock_event_device, evt);
    1026     exynos4_mct_tick_stop(mevt);
    1027     + exynos4_mct_tick_clear(mevt);
    1028     return 0;
    1029     }
    1030    
    1031     @@ -420,8 +428,11 @@ static int set_state_periodic(struct clock_event_device *evt)
    1032     return 0;
    1033     }
    1034    
    1035     -static void exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
    1036     +static irqreturn_t exynos4_mct_tick_isr(int irq, void *dev_id)
    1037     {
    1038     + struct mct_clock_event_device *mevt = dev_id;
    1039     + struct clock_event_device *evt = &mevt->evt;
    1040     +
    1041     /*
    1042     * This is for supporting oneshot mode.
    1043     * Mct would generate interrupt periodically
    1044     @@ -430,16 +441,6 @@ static void exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
    1045     if (!clockevent_state_periodic(&mevt->evt))
    1046     exynos4_mct_tick_stop(mevt);
    1047    
    1048     - /* Clear the MCT tick interrupt */
    1049     - if (readl_relaxed(reg_base + mevt->base + MCT_L_INT_CSTAT_OFFSET) & 1)
    1050     - exynos4_mct_write(0x1, mevt->base + MCT_L_INT_CSTAT_OFFSET);
    1051     -}
    1052     -
    1053     -static irqreturn_t exynos4_mct_tick_isr(int irq, void *dev_id)
    1054     -{
    1055     - struct mct_clock_event_device *mevt = dev_id;
    1056     - struct clock_event_device *evt = &mevt->evt;
    1057     -
    1058     exynos4_mct_tick_clear(mevt);
    1059    
    1060     evt->event_handler(evt);
    1061     diff --git a/drivers/cpufreq/pxa2xx-cpufreq.c b/drivers/cpufreq/pxa2xx-cpufreq.c
    1062     index ce345bf34d5d..a24e9f037865 100644
    1063     --- a/drivers/cpufreq/pxa2xx-cpufreq.c
    1064     +++ b/drivers/cpufreq/pxa2xx-cpufreq.c
    1065     @@ -192,7 +192,7 @@ static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
    1066     return ret;
    1067     }
    1068    
    1069     -static void __init pxa_cpufreq_init_voltages(void)
    1070     +static void pxa_cpufreq_init_voltages(void)
    1071     {
    1072     vcc_core = regulator_get(NULL, "vcc_core");
    1073     if (IS_ERR(vcc_core)) {
    1074     @@ -208,7 +208,7 @@ static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
    1075     return 0;
    1076     }
    1077    
    1078     -static void __init pxa_cpufreq_init_voltages(void) { }
    1079     +static void pxa_cpufreq_init_voltages(void) { }
    1080     #endif
    1081    
    1082     static void find_freq_tables(struct cpufreq_frequency_table **freq_table,
    1083     diff --git a/drivers/cpufreq/tegra124-cpufreq.c b/drivers/cpufreq/tegra124-cpufreq.c
    1084     index 43530254201a..4bb154f6c54c 100644
    1085     --- a/drivers/cpufreq/tegra124-cpufreq.c
    1086     +++ b/drivers/cpufreq/tegra124-cpufreq.c
    1087     @@ -134,6 +134,8 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
    1088    
    1089     platform_set_drvdata(pdev, priv);
    1090    
    1091     + of_node_put(np);
    1092     +
    1093     return 0;
    1094    
    1095     out_switch_to_pllx:
    1096     diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c
    1097     index 0d743c634f25..88caca3370f2 100644
    1098     --- a/drivers/crypto/caam/caamalg.c
    1099     +++ b/drivers/crypto/caam/caamalg.c
    1100     @@ -2131,6 +2131,7 @@ static void init_aead_job(struct aead_request *req,
    1101     if (unlikely(req->src != req->dst)) {
    1102     if (!edesc->dst_nents) {
    1103     dst_dma = sg_dma_address(req->dst);
    1104     + out_options = 0;
    1105     } else {
    1106     dst_dma = edesc->sec4_sg_dma +
    1107     sec4_sg_index *
    1108     diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
    1109     index 6509031098d5..26c4befcd234 100644
    1110     --- a/drivers/gpu/drm/i915/i915_gem.c
    1111     +++ b/drivers/gpu/drm/i915/i915_gem.c
    1112     @@ -1600,7 +1600,8 @@ __vma_matches(struct vm_area_struct *vma, struct file *filp,
    1113     if (vma->vm_file != filp)
    1114     return false;
    1115    
    1116     - return vma->vm_start == addr && (vma->vm_end - vma->vm_start) == size;
    1117     + return vma->vm_start == addr &&
    1118     + (vma->vm_end - vma->vm_start) == PAGE_ALIGN(size);
    1119     }
    1120    
    1121     /**
    1122     diff --git a/drivers/gpu/drm/radeon/evergreen_cs.c b/drivers/gpu/drm/radeon/evergreen_cs.c
    1123     index d960d3915408..f09388e00523 100644
    1124     --- a/drivers/gpu/drm/radeon/evergreen_cs.c
    1125     +++ b/drivers/gpu/drm/radeon/evergreen_cs.c
    1126     @@ -1299,6 +1299,7 @@ static int evergreen_cs_handle_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
    1127     return -EINVAL;
    1128     }
    1129     ib[idx] += (u32)((reloc->gpu_offset >> 8) & 0xffffffff);
    1130     + break;
    1131     case CB_TARGET_MASK:
    1132     track->cb_target_mask = radeon_get_ib_value(p, idx);
    1133     track->cb_dirty = true;
    1134     diff --git a/drivers/gpu/ipu-v3/ipu-common.c b/drivers/gpu/ipu-v3/ipu-common.c
    1135     index 99c813a4ec1f..57d22bc963b5 100644
    1136     --- a/drivers/gpu/ipu-v3/ipu-common.c
    1137     +++ b/drivers/gpu/ipu-v3/ipu-common.c
    1138     @@ -884,8 +884,8 @@ static struct ipu_devtype ipu_type_imx51 = {
    1139     .cpmem_ofs = 0x1f000000,
    1140     .srm_ofs = 0x1f040000,
    1141     .tpm_ofs = 0x1f060000,
    1142     - .csi0_ofs = 0x1f030000,
    1143     - .csi1_ofs = 0x1f038000,
    1144     + .csi0_ofs = 0x1e030000,
    1145     + .csi1_ofs = 0x1e038000,
    1146     .ic_ofs = 0x1e020000,
    1147     .disp0_ofs = 0x1e040000,
    1148     .disp1_ofs = 0x1e048000,
    1149     @@ -900,8 +900,8 @@ static struct ipu_devtype ipu_type_imx53 = {
    1150     .cpmem_ofs = 0x07000000,
    1151     .srm_ofs = 0x07040000,
    1152     .tpm_ofs = 0x07060000,
    1153     - .csi0_ofs = 0x07030000,
    1154     - .csi1_ofs = 0x07038000,
    1155     + .csi0_ofs = 0x06030000,
    1156     + .csi1_ofs = 0x06038000,
    1157     .ic_ofs = 0x06020000,
    1158     .disp0_ofs = 0x06040000,
    1159     .disp1_ofs = 0x06048000,
    1160     diff --git a/drivers/hwtracing/intel_th/gth.c b/drivers/hwtracing/intel_th/gth.c
    1161     index 33e09369a491..b0502e2782c1 100644
    1162     --- a/drivers/hwtracing/intel_th/gth.c
    1163     +++ b/drivers/hwtracing/intel_th/gth.c
    1164     @@ -599,11 +599,15 @@ static void intel_th_gth_unassign(struct intel_th_device *thdev,
    1165     {
    1166     struct gth_device *gth = dev_get_drvdata(&thdev->dev);
    1167     int port = othdev->output.port;
    1168     + int master;
    1169    
    1170     spin_lock(&gth->gth_lock);
    1171     othdev->output.port = -1;
    1172     othdev->output.active = false;
    1173     gth->output[port].output = NULL;
    1174     + for (master = 0; master < TH_CONFIGURABLE_MASTERS; master++)
    1175     + if (gth->master[master] == port)
    1176     + gth->master[master] = -1;
    1177     spin_unlock(&gth->gth_lock);
    1178     }
    1179    
    1180     diff --git a/drivers/hwtracing/stm/core.c b/drivers/hwtracing/stm/core.c
    1181     index c38645106783..3c45c1c15f7e 100644
    1182     --- a/drivers/hwtracing/stm/core.c
    1183     +++ b/drivers/hwtracing/stm/core.c
    1184     @@ -252,6 +252,9 @@ static int find_free_channels(unsigned long *bitmap, unsigned int start,
    1185     ;
    1186     if (i == width)
    1187     return pos;
    1188     +
    1189     + /* step over [pos..pos+i) to continue search */
    1190     + pos += i;
    1191     }
    1192    
    1193     return -1;
    1194     @@ -558,7 +561,7 @@ static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg)
    1195     {
    1196     struct stm_device *stm = stmf->stm;
    1197     struct stp_policy_id *id;
    1198     - int ret = -EINVAL;
    1199     + int ret = -EINVAL, wlimit = 1;
    1200     u32 size;
    1201    
    1202     if (stmf->output.nr_chans)
    1203     @@ -586,8 +589,10 @@ static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg)
    1204     if (id->__reserved_0 || id->__reserved_1)
    1205     goto err_free;
    1206    
    1207     - if (id->width < 1 ||
    1208     - id->width > PAGE_SIZE / stm->data->sw_mmiosz)
    1209     + if (stm->data->sw_mmiosz)
    1210     + wlimit = PAGE_SIZE / stm->data->sw_mmiosz;
    1211     +
    1212     + if (id->width < 1 || id->width > wlimit)
    1213     goto err_free;
    1214    
    1215     ret = stm_file_assign(stmf, id->id, id->width);
    1216     diff --git a/drivers/i2c/busses/i2c-cadence.c b/drivers/i2c/busses/i2c-cadence.c
    1217     index 45d6771fac8c..59c08d5b75d6 100644
    1218     --- a/drivers/i2c/busses/i2c-cadence.c
    1219     +++ b/drivers/i2c/busses/i2c-cadence.c
    1220     @@ -382,8 +382,10 @@ static void cdns_i2c_mrecv(struct cdns_i2c *id)
    1221     * Check for the message size against FIFO depth and set the
    1222     * 'hold bus' bit if it is greater than FIFO depth.
    1223     */
    1224     - if (id->recv_count > CDNS_I2C_FIFO_DEPTH)
    1225     + if ((id->recv_count > CDNS_I2C_FIFO_DEPTH) || id->bus_hold_flag)
    1226     ctrl_reg |= CDNS_I2C_CR_HOLD;
    1227     + else
    1228     + ctrl_reg = ctrl_reg & ~CDNS_I2C_CR_HOLD;
    1229    
    1230     cdns_i2c_writereg(ctrl_reg, CDNS_I2C_CR_OFFSET);
    1231    
    1232     @@ -440,8 +442,11 @@ static void cdns_i2c_msend(struct cdns_i2c *id)
    1233     * Check for the message size against FIFO depth and set the
    1234     * 'hold bus' bit if it is greater than FIFO depth.
    1235     */
    1236     - if (id->send_count > CDNS_I2C_FIFO_DEPTH)
    1237     + if ((id->send_count > CDNS_I2C_FIFO_DEPTH) || id->bus_hold_flag)
    1238     ctrl_reg |= CDNS_I2C_CR_HOLD;
    1239     + else
    1240     + ctrl_reg = ctrl_reg & ~CDNS_I2C_CR_HOLD;
    1241     +
    1242     cdns_i2c_writereg(ctrl_reg, CDNS_I2C_CR_OFFSET);
    1243    
    1244     /* Clear the interrupts in interrupt status register. */
    1245     diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
    1246     index 586e557e113a..36100f453f31 100644
    1247     --- a/drivers/i2c/busses/i2c-tegra.c
    1248     +++ b/drivers/i2c/busses/i2c-tegra.c
    1249     @@ -794,7 +794,7 @@ static const struct i2c_algorithm tegra_i2c_algo = {
    1250     /* payload size is only 12 bit */
    1251     static struct i2c_adapter_quirks tegra_i2c_quirks = {
    1252     .max_read_len = 4096,
    1253     - .max_write_len = 4096,
    1254     + .max_write_len = 4096 - 12,
    1255     };
    1256    
    1257     static const struct tegra_i2c_hw_feature tegra20_i2c_hw = {
    1258     diff --git a/drivers/iio/adc/exynos_adc.c b/drivers/iio/adc/exynos_adc.c
    1259     index c15756d7bf7f..eb8b735ca12b 100644
    1260     --- a/drivers/iio/adc/exynos_adc.c
    1261     +++ b/drivers/iio/adc/exynos_adc.c
    1262     @@ -916,7 +916,7 @@ static int exynos_adc_remove(struct platform_device *pdev)
    1263     struct iio_dev *indio_dev = platform_get_drvdata(pdev);
    1264     struct exynos_adc *info = iio_priv(indio_dev);
    1265    
    1266     - if (IS_REACHABLE(CONFIG_INPUT)) {
    1267     + if (IS_REACHABLE(CONFIG_INPUT) && info->input) {
    1268     free_irq(info->tsirq, info);
    1269     input_unregister_device(info->input);
    1270     }
    1271     diff --git a/drivers/input/keyboard/cap11xx.c b/drivers/input/keyboard/cap11xx.c
    1272     index 4401be225d64..3c53aa5d5c0c 100644
    1273     --- a/drivers/input/keyboard/cap11xx.c
    1274     +++ b/drivers/input/keyboard/cap11xx.c
    1275     @@ -75,9 +75,7 @@
    1276     struct cap11xx_led {
    1277     struct cap11xx_priv *priv;
    1278     struct led_classdev cdev;
    1279     - struct work_struct work;
    1280     u32 reg;
    1281     - enum led_brightness new_brightness;
    1282     };
    1283     #endif
    1284    
    1285     @@ -233,30 +231,21 @@ static void cap11xx_input_close(struct input_dev *idev)
    1286     }
    1287    
    1288     #ifdef CONFIG_LEDS_CLASS
    1289     -static void cap11xx_led_work(struct work_struct *work)
    1290     +static int cap11xx_led_set(struct led_classdev *cdev,
    1291     + enum led_brightness value)
    1292     {
    1293     - struct cap11xx_led *led = container_of(work, struct cap11xx_led, work);
    1294     + struct cap11xx_led *led = container_of(cdev, struct cap11xx_led, cdev);
    1295     struct cap11xx_priv *priv = led->priv;
    1296     - int value = led->new_brightness;
    1297    
    1298     /*
    1299     - * All LEDs share the same duty cycle as this is a HW limitation.
    1300     - * Brightness levels per LED are either 0 (OFF) and 1 (ON).
    1301     + * All LEDs share the same duty cycle as this is a HW
    1302     + * limitation. Brightness levels per LED are either
    1303     + * 0 (OFF) and 1 (ON).
    1304     */
    1305     - regmap_update_bits(priv->regmap, CAP11XX_REG_LED_OUTPUT_CONTROL,
    1306     - BIT(led->reg), value ? BIT(led->reg) : 0);
    1307     -}
    1308     -
    1309     -static void cap11xx_led_set(struct led_classdev *cdev,
    1310     - enum led_brightness value)
    1311     -{
    1312     - struct cap11xx_led *led = container_of(cdev, struct cap11xx_led, cdev);
    1313     -
    1314     - if (led->new_brightness == value)
    1315     - return;
    1316     -
    1317     - led->new_brightness = value;
    1318     - schedule_work(&led->work);
    1319     + return regmap_update_bits(priv->regmap,
    1320     + CAP11XX_REG_LED_OUTPUT_CONTROL,
    1321     + BIT(led->reg),
    1322     + value ? BIT(led->reg) : 0);
    1323     }
    1324    
    1325     static int cap11xx_init_leds(struct device *dev,
    1326     @@ -299,7 +288,7 @@ static int cap11xx_init_leds(struct device *dev,
    1327     led->cdev.default_trigger =
    1328     of_get_property(child, "linux,default-trigger", NULL);
    1329     led->cdev.flags = 0;
    1330     - led->cdev.brightness_set = cap11xx_led_set;
    1331     + led->cdev.brightness_set_blocking = cap11xx_led_set;
    1332     led->cdev.max_brightness = 1;
    1333     led->cdev.brightness = LED_OFF;
    1334    
    1335     @@ -312,8 +301,6 @@ static int cap11xx_init_leds(struct device *dev,
    1336     led->reg = reg;
    1337     led->priv = priv;
    1338    
    1339     - INIT_WORK(&led->work, cap11xx_led_work);
    1340     -
    1341     error = devm_led_classdev_register(dev, &led->cdev);
    1342     if (error) {
    1343     of_node_put(child);
    1344     diff --git a/drivers/input/keyboard/matrix_keypad.c b/drivers/input/keyboard/matrix_keypad.c
    1345     index c64d87442a62..2e12e31f45c5 100644
    1346     --- a/drivers/input/keyboard/matrix_keypad.c
    1347     +++ b/drivers/input/keyboard/matrix_keypad.c
    1348     @@ -220,7 +220,7 @@ static void matrix_keypad_stop(struct input_dev *dev)
    1349     keypad->stopped = true;
    1350     spin_unlock_irq(&keypad->lock);
    1351    
    1352     - flush_work(&keypad->work.work);
    1353     + flush_delayed_work(&keypad->work);
    1354     /*
    1355     * matrix_keypad_scan() will leave IRQs enabled;
    1356     * we should disable them now.
    1357     diff --git a/drivers/input/keyboard/st-keyscan.c b/drivers/input/keyboard/st-keyscan.c
    1358     index de7be4f03d91..ebf9f643d910 100644
    1359     --- a/drivers/input/keyboard/st-keyscan.c
    1360     +++ b/drivers/input/keyboard/st-keyscan.c
    1361     @@ -153,6 +153,8 @@ static int keyscan_probe(struct platform_device *pdev)
    1362    
    1363     input_dev->id.bustype = BUS_HOST;
    1364    
    1365     + keypad_data->input_dev = input_dev;
    1366     +
    1367     error = keypad_matrix_key_parse_dt(keypad_data);
    1368     if (error)
    1369     return error;
    1370     @@ -168,8 +170,6 @@ static int keyscan_probe(struct platform_device *pdev)
    1371    
    1372     input_set_drvdata(input_dev, keypad_data);
    1373    
    1374     - keypad_data->input_dev = input_dev;
    1375     -
    1376     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    1377     keypad_data->base = devm_ioremap_resource(&pdev->dev, res);
    1378     if (IS_ERR(keypad_data->base))
    1379     diff --git a/drivers/md/bcache/writeback.h b/drivers/md/bcache/writeback.h
    1380     index cdf8d253209e..6fb6dd600970 100644
    1381     --- a/drivers/md/bcache/writeback.h
    1382     +++ b/drivers/md/bcache/writeback.h
    1383     @@ -68,6 +68,9 @@ static inline bool should_writeback(struct cached_dev *dc, struct bio *bio,
    1384     in_use > CUTOFF_WRITEBACK_SYNC)
    1385     return false;
    1386    
    1387     + if (bio_op(bio) == REQ_OP_DISCARD)
    1388     + return false;
    1389     +
    1390     if (dc->partial_stripes_expensive &&
    1391     bcache_dev_stripe_dirty(dc, bio->bi_iter.bi_sector,
    1392     bio_sectors(bio)))
    1393     diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
    1394     index 67414616eb35..717787d09e0f 100644
    1395     --- a/drivers/md/raid10.c
    1396     +++ b/drivers/md/raid10.c
    1397     @@ -3798,6 +3798,8 @@ static int raid10_run(struct mddev *mddev)
    1398     set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
    1399     mddev->sync_thread = md_register_thread(md_do_sync, mddev,
    1400     "reshape");
    1401     + if (!mddev->sync_thread)
    1402     + goto out_free_conf;
    1403     }
    1404    
    1405     return 0;
    1406     diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
    1407     index 4afc419da60f..9ec74dfe94f4 100644
    1408     --- a/drivers/md/raid5.c
    1409     +++ b/drivers/md/raid5.c
    1410     @@ -6977,6 +6977,8 @@ static int raid5_run(struct mddev *mddev)
    1411     set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
    1412     mddev->sync_thread = md_register_thread(md_do_sync, mddev,
    1413     "reshape");
    1414     + if (!mddev->sync_thread)
    1415     + goto abort;
    1416     }
    1417    
    1418     /* Ok, everything is just fine now */
    1419     diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
    1420     index 48503f30b3a2..dcca723f7155 100644
    1421     --- a/drivers/media/usb/uvc/uvc_video.c
    1422     +++ b/drivers/media/usb/uvc/uvc_video.c
    1423     @@ -638,6 +638,14 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
    1424     if (!uvc_hw_timestamps_param)
    1425     return;
    1426    
    1427     + /*
    1428     + * We will get called from __vb2_queue_cancel() if there are buffers
    1429     + * done but not dequeued by the user, but the sample array has already
    1430     + * been released at that time. Just bail out in that case.
    1431     + */
    1432     + if (!clock->samples)
    1433     + return;
    1434     +
    1435     spin_lock_irqsave(&clock->lock, flags);
    1436    
    1437     if (clock->count < clock->size)
    1438     diff --git a/drivers/media/v4l2-core/videobuf2-v4l2.c b/drivers/media/v4l2-core/videobuf2-v4l2.c
    1439     index 52ef8833f6b6..7e45da4d52e1 100644
    1440     --- a/drivers/media/v4l2-core/videobuf2-v4l2.c
    1441     +++ b/drivers/media/v4l2-core/videobuf2-v4l2.c
    1442     @@ -146,7 +146,6 @@ static void vb2_warn_zero_bytesused(struct vb2_buffer *vb)
    1443     return;
    1444    
    1445     check_once = true;
    1446     - WARN_ON(1);
    1447    
    1448     pr_warn("use of bytesused == 0 is deprecated and will be removed in the future,\n");
    1449     if (vb->vb2_queue->allow_zero_bytesused)
    1450     diff --git a/drivers/net/ethernet/atheros/atlx/atl2.c b/drivers/net/ethernet/atheros/atlx/atl2.c
    1451     index 2ff465848b65..097a0bf592ab 100644
    1452     --- a/drivers/net/ethernet/atheros/atlx/atl2.c
    1453     +++ b/drivers/net/ethernet/atheros/atlx/atl2.c
    1454     @@ -1338,13 +1338,11 @@ static int atl2_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
    1455     {
    1456     struct net_device *netdev;
    1457     struct atl2_adapter *adapter;
    1458     - static int cards_found;
    1459     + static int cards_found = 0;
    1460     unsigned long mmio_start;
    1461     int mmio_len;
    1462     int err;
    1463    
    1464     - cards_found = 0;
    1465     -
    1466     err = pci_enable_device(pdev);
    1467     if (err)
    1468     return err;
    1469     diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
    1470     index 53a506b0d790..95874c10c23b 100644
    1471     --- a/drivers/net/ethernet/broadcom/bcmsysport.c
    1472     +++ b/drivers/net/ethernet/broadcom/bcmsysport.c
    1473     @@ -104,6 +104,10 @@ static int bcm_sysport_set_rx_csum(struct net_device *dev,
    1474    
    1475     priv->rx_chk_en = !!(wanted & NETIF_F_RXCSUM);
    1476     reg = rxchk_readl(priv, RXCHK_CONTROL);
    1477     + /* Clear L2 header checks, which would prevent BPDUs
    1478     + * from being received.
    1479     + */
    1480     + reg &= ~RXCHK_L2_HDR_DIS;
    1481     if (priv->rx_chk_en)
    1482     reg |= RXCHK_EN;
    1483     else
    1484     diff --git a/drivers/net/ethernet/cavium/thunder/nic_main.c b/drivers/net/ethernet/cavium/thunder/nic_main.c
    1485     index da142f6bd0c3..18ddd243dfa1 100644
    1486     --- a/drivers/net/ethernet/cavium/thunder/nic_main.c
    1487     +++ b/drivers/net/ethernet/cavium/thunder/nic_main.c
    1488     @@ -999,7 +999,7 @@ static void nic_handle_mbx_intr(struct nicpf *nic, int vf)
    1489     case NIC_MBOX_MSG_CFG_DONE:
    1490     /* Last message of VF config msg sequence */
    1491     nic_enable_vf(nic, vf, true);
    1492     - goto unlock;
    1493     + break;
    1494     case NIC_MBOX_MSG_SHUTDOWN:
    1495     /* First msg in VF teardown sequence */
    1496     if (vf >= nic->num_vf_en)
    1497     diff --git a/drivers/net/ethernet/cavium/thunder/nicvf_main.c b/drivers/net/ethernet/cavium/thunder/nicvf_main.c
    1498     index c75d4ea9342b..71f228cece03 100644
    1499     --- a/drivers/net/ethernet/cavium/thunder/nicvf_main.c
    1500     +++ b/drivers/net/ethernet/cavium/thunder/nicvf_main.c
    1501     @@ -162,6 +162,17 @@ static int nicvf_check_pf_ready(struct nicvf *nic)
    1502     return 1;
    1503     }
    1504    
    1505     +static void nicvf_send_cfg_done(struct nicvf *nic)
    1506     +{
    1507     + union nic_mbx mbx = {};
    1508     +
    1509     + mbx.msg.msg = NIC_MBOX_MSG_CFG_DONE;
    1510     + if (nicvf_send_msg_to_pf(nic, &mbx)) {
    1511     + netdev_err(nic->netdev,
    1512     + "PF didn't respond to CFG DONE msg\n");
    1513     + }
    1514     +}
    1515     +
    1516     static void nicvf_read_bgx_stats(struct nicvf *nic, struct bgx_stats_msg *bgx)
    1517     {
    1518     if (bgx->rx)
    1519     @@ -1178,7 +1189,6 @@ int nicvf_open(struct net_device *netdev)
    1520     struct nicvf *nic = netdev_priv(netdev);
    1521     struct queue_set *qs = nic->qs;
    1522     struct nicvf_cq_poll *cq_poll = NULL;
    1523     - union nic_mbx mbx = {};
    1524    
    1525     netif_carrier_off(netdev);
    1526    
    1527     @@ -1267,8 +1277,7 @@ int nicvf_open(struct net_device *netdev)
    1528     nicvf_enable_intr(nic, NICVF_INTR_RBDR, qidx);
    1529    
    1530     /* Send VF config done msg to PF */
    1531     - mbx.msg.msg = NIC_MBOX_MSG_CFG_DONE;
    1532     - nicvf_write_to_mbx(nic, &mbx);
    1533     + nicvf_send_cfg_done(nic);
    1534    
    1535     return 0;
    1536     cleanup:
    1537     diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
    1538     index 5bb019d49409..551b2a9ebf0f 100644
    1539     --- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
    1540     +++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
    1541     @@ -2820,6 +2820,7 @@ int hns_dsaf_roce_reset(struct fwnode_handle *dsaf_fwnode, bool dereset)
    1542     dsaf_dev = dev_get_drvdata(&pdev->dev);
    1543     if (!dsaf_dev) {
    1544     dev_err(&pdev->dev, "dsaf_dev is NULL\n");
    1545     + put_device(&pdev->dev);
    1546     return -ENODEV;
    1547     }
    1548    
    1549     @@ -2827,6 +2828,7 @@ int hns_dsaf_roce_reset(struct fwnode_handle *dsaf_fwnode, bool dereset)
    1550     if (AE_IS_VER1(dsaf_dev->dsaf_ver)) {
    1551     dev_err(dsaf_dev->dev, "%s v1 chip doesn't support RoCE!\n",
    1552     dsaf_dev->ae_dev.name);
    1553     + put_device(&pdev->dev);
    1554     return -ENODEV;
    1555     }
    1556    
    1557     diff --git a/drivers/net/ethernet/marvell/mv643xx_eth.c b/drivers/net/ethernet/marvell/mv643xx_eth.c
    1558     index 5b12022adf1f..526d07e02bbc 100644
    1559     --- a/drivers/net/ethernet/marvell/mv643xx_eth.c
    1560     +++ b/drivers/net/ethernet/marvell/mv643xx_eth.c
    1561     @@ -2886,7 +2886,7 @@ static int mv643xx_eth_shared_probe(struct platform_device *pdev)
    1562    
    1563     ret = mv643xx_eth_shared_of_probe(pdev);
    1564     if (ret)
    1565     - return ret;
    1566     + goto err_put_clk;
    1567     pd = dev_get_platdata(&pdev->dev);
    1568    
    1569     msp->tx_csum_limit = (pd != NULL && pd->tx_csum_limit) ?
    1570     @@ -2894,6 +2894,11 @@ static int mv643xx_eth_shared_probe(struct platform_device *pdev)
    1571     infer_hw_params(msp);
    1572    
    1573     return 0;
    1574     +
    1575     +err_put_clk:
    1576     + if (!IS_ERR(msp->clk))
    1577     + clk_disable_unprepare(msp->clk);
    1578     + return ret;
    1579     }
    1580    
    1581     static int mv643xx_eth_shared_remove(struct platform_device *pdev)
    1582     diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
    1583     index c92ffdf91065..d98b874a7238 100644
    1584     --- a/drivers/net/ethernet/marvell/mvneta.c
    1585     +++ b/drivers/net/ethernet/marvell/mvneta.c
    1586     @@ -2050,7 +2050,7 @@ err_drop_frame:
    1587     if (unlikely(!skb))
    1588     goto err_drop_frame_ret_pool;
    1589    
    1590     - dma_sync_single_range_for_cpu(dev->dev.parent,
    1591     + dma_sync_single_range_for_cpu(&pp->bm_priv->pdev->dev,
    1592     rx_desc->buf_phys_addr,
    1593     MVNETA_MH_SIZE + NET_SKB_PAD,
    1594     rx_bytes,
    1595     diff --git a/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c b/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c
    1596     index f8df5300f49c..73087770d72f 100644
    1597     --- a/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c
    1598     +++ b/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c
    1599     @@ -756,15 +756,10 @@ wrp_alu64_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
    1600    
    1601     static int
    1602     wrp_alu32_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
    1603     - enum alu_op alu_op, bool skip)
    1604     + enum alu_op alu_op)
    1605     {
    1606     const struct bpf_insn *insn = &meta->insn;
    1607    
    1608     - if (skip) {
    1609     - meta->skip = true;
    1610     - return 0;
    1611     - }
    1612     -
    1613     wrp_alu_imm(nfp_prog, insn->dst_reg * 2, alu_op, insn->imm);
    1614     wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2 + 1), 0);
    1615    
    1616     @@ -1017,7 +1012,7 @@ static int xor_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1617    
    1618     static int xor_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1619     {
    1620     - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_XOR, !~meta->insn.imm);
    1621     + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_XOR);
    1622     }
    1623    
    1624     static int and_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1625     @@ -1027,7 +1022,7 @@ static int and_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1626    
    1627     static int and_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1628     {
    1629     - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_AND, !~meta->insn.imm);
    1630     + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_AND);
    1631     }
    1632    
    1633     static int or_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1634     @@ -1037,7 +1032,7 @@ static int or_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1635    
    1636     static int or_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1637     {
    1638     - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_OR, !meta->insn.imm);
    1639     + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_OR);
    1640     }
    1641    
    1642     static int add_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1643     @@ -1047,7 +1042,7 @@ static int add_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1644    
    1645     static int add_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1646     {
    1647     - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_ADD, !meta->insn.imm);
    1648     + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_ADD);
    1649     }
    1650    
    1651     static int sub_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1652     @@ -1057,7 +1052,7 @@ static int sub_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1653    
    1654     static int sub_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1655     {
    1656     - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_SUB, !meta->insn.imm);
    1657     + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_SUB);
    1658     }
    1659    
    1660     static int shl_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1661     diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
    1662     index 134eb184fa22..16e5c8cd104d 100644
    1663     --- a/drivers/net/usb/qmi_wwan.c
    1664     +++ b/drivers/net/usb/qmi_wwan.c
    1665     @@ -895,8 +895,8 @@ static const struct usb_device_id products[] = {
    1666     {QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */
    1667     {QMI_FIXED_INTF(0x1199, 0x68a2, 8)}, /* Sierra Wireless MC7710 in QMI mode */
    1668     {QMI_FIXED_INTF(0x1199, 0x68a2, 19)}, /* Sierra Wireless MC7710 in QMI mode */
    1669     - {QMI_FIXED_INTF(0x1199, 0x68c0, 8)}, /* Sierra Wireless MC7304/MC7354 */
    1670     - {QMI_FIXED_INTF(0x1199, 0x68c0, 10)}, /* Sierra Wireless MC7304/MC7354 */
    1671     + {QMI_QUIRK_SET_DTR(0x1199, 0x68c0, 8)}, /* Sierra Wireless MC7304/MC7354, WP76xx */
    1672     + {QMI_QUIRK_SET_DTR(0x1199, 0x68c0, 10)},/* Sierra Wireless MC7304/MC7354 */
    1673     {QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */
    1674     {QMI_FIXED_INTF(0x1199, 0x901f, 8)}, /* Sierra Wireless EM7355 */
    1675     {QMI_FIXED_INTF(0x1199, 0x9041, 8)}, /* Sierra Wireless MC7305/MC7355 */
    1676     diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
    1677     index 780acf23fd19..e9ec1da9935d 100644
    1678     --- a/drivers/net/wireless/mac80211_hwsim.c
    1679     +++ b/drivers/net/wireless/mac80211_hwsim.c
    1680     @@ -3167,7 +3167,7 @@ static int hwsim_get_radio_nl(struct sk_buff *msg, struct genl_info *info)
    1681     goto out_err;
    1682     }
    1683    
    1684     - genlmsg_reply(skb, info);
    1685     + res = genlmsg_reply(skb, info);
    1686     break;
    1687     }
    1688    
    1689     diff --git a/drivers/net/wireless/marvell/libertas_tf/if_usb.c b/drivers/net/wireless/marvell/libertas_tf/if_usb.c
    1690     index e0ade40d9497..4b539209999b 100644
    1691     --- a/drivers/net/wireless/marvell/libertas_tf/if_usb.c
    1692     +++ b/drivers/net/wireless/marvell/libertas_tf/if_usb.c
    1693     @@ -433,8 +433,6 @@ static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
    1694     skb_tail_pointer(skb),
    1695     MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, cardp);
    1696    
    1697     - cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
    1698     -
    1699     lbtf_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n",
    1700     cardp->rx_urb);
    1701     ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC);
    1702     diff --git a/drivers/nvdimm/label.c b/drivers/nvdimm/label.c
    1703     index d8d189d14834..66a089d561cf 100644
    1704     --- a/drivers/nvdimm/label.c
    1705     +++ b/drivers/nvdimm/label.c
    1706     @@ -492,7 +492,7 @@ static unsigned long nd_label_offset(struct nvdimm_drvdata *ndd,
    1707    
    1708     static int __pmem_label_update(struct nd_region *nd_region,
    1709     struct nd_mapping *nd_mapping, struct nd_namespace_pmem *nspm,
    1710     - int pos)
    1711     + int pos, unsigned long flags)
    1712     {
    1713     u64 cookie = nd_region_interleave_set_cookie(nd_region);
    1714     struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
    1715     @@ -530,7 +530,7 @@ static int __pmem_label_update(struct nd_region *nd_region,
    1716     memcpy(nd_label->uuid, nspm->uuid, NSLABEL_UUID_LEN);
    1717     if (nspm->alt_name)
    1718     memcpy(nd_label->name, nspm->alt_name, NSLABEL_NAME_LEN);
    1719     - nd_label->flags = __cpu_to_le32(NSLABEL_FLAG_UPDATING);
    1720     + nd_label->flags = __cpu_to_le32(flags);
    1721     nd_label->nlabel = __cpu_to_le16(nd_region->ndr_mappings);
    1722     nd_label->position = __cpu_to_le16(pos);
    1723     nd_label->isetcookie = __cpu_to_le64(cookie);
    1724     @@ -922,13 +922,13 @@ static int del_labels(struct nd_mapping *nd_mapping, u8 *uuid)
    1725     int nd_pmem_namespace_label_update(struct nd_region *nd_region,
    1726     struct nd_namespace_pmem *nspm, resource_size_t size)
    1727     {
    1728     - int i;
    1729     + int i, rc;
    1730    
    1731     for (i = 0; i < nd_region->ndr_mappings; i++) {
    1732     struct nd_mapping *nd_mapping = &nd_region->mapping[i];
    1733     struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
    1734     struct resource *res;
    1735     - int rc, count = 0;
    1736     + int count = 0;
    1737    
    1738     if (size == 0) {
    1739     rc = del_labels(nd_mapping, nspm->uuid);
    1740     @@ -946,7 +946,20 @@ int nd_pmem_namespace_label_update(struct nd_region *nd_region,
    1741     if (rc < 0)
    1742     return rc;
    1743    
    1744     - rc = __pmem_label_update(nd_region, nd_mapping, nspm, i);
    1745     + rc = __pmem_label_update(nd_region, nd_mapping, nspm, i,
    1746     + NSLABEL_FLAG_UPDATING);
    1747     + if (rc)
    1748     + return rc;
    1749     + }
    1750     +
    1751     + if (size == 0)
    1752     + return 0;
    1753     +
    1754     + /* Clear the UPDATING flag per UEFI 2.7 expectations */
    1755     + for (i = 0; i < nd_region->ndr_mappings; i++) {
    1756     + struct nd_mapping *nd_mapping = &nd_region->mapping[i];
    1757     +
    1758     + rc = __pmem_label_update(nd_region, nd_mapping, nspm, i, 0);
    1759     if (rc)
    1760     return rc;
    1761     }
    1762     diff --git a/drivers/nvdimm/namespace_devs.c b/drivers/nvdimm/namespace_devs.c
    1763     index 74257ac92490..9bc5f555ee68 100644
    1764     --- a/drivers/nvdimm/namespace_devs.c
    1765     +++ b/drivers/nvdimm/namespace_devs.c
    1766     @@ -138,6 +138,7 @@ bool nd_is_uuid_unique(struct device *dev, u8 *uuid)
    1767     bool pmem_should_map_pages(struct device *dev)
    1768     {
    1769     struct nd_region *nd_region = to_nd_region(dev->parent);
    1770     + struct nd_namespace_common *ndns = to_ndns(dev);
    1771     struct nd_namespace_io *nsio;
    1772    
    1773     if (!IS_ENABLED(CONFIG_ZONE_DEVICE))
    1774     @@ -149,6 +150,9 @@ bool pmem_should_map_pages(struct device *dev)
    1775     if (is_nd_pfn(dev) || is_nd_btt(dev))
    1776     return false;
    1777    
    1778     + if (ndns->force_raw)
    1779     + return false;
    1780     +
    1781     nsio = to_nd_namespace_io(dev);
    1782     if (region_intersects(nsio->res.start, resource_size(&nsio->res),
    1783     IORESOURCE_SYSTEM_RAM,
    1784     diff --git a/drivers/nvdimm/pfn_devs.c b/drivers/nvdimm/pfn_devs.c
    1785     index d6aa59ca68b9..ba9aa8475e6d 100644
    1786     --- a/drivers/nvdimm/pfn_devs.c
    1787     +++ b/drivers/nvdimm/pfn_devs.c
    1788     @@ -515,7 +515,7 @@ static unsigned long init_altmap_base(resource_size_t base)
    1789    
    1790     static unsigned long init_altmap_reserve(resource_size_t base)
    1791     {
    1792     - unsigned long reserve = PHYS_PFN(SZ_8K);
    1793     + unsigned long reserve = PFN_UP(SZ_8K);
    1794     unsigned long base_pfn = PHYS_PFN(base);
    1795    
    1796     reserve += base_pfn - PFN_SECTION_ALIGN_DOWN(base_pfn);
    1797     diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
    1798     index bdce0679674c..02e6485c1ed5 100644
    1799     --- a/drivers/parport/parport_pc.c
    1800     +++ b/drivers/parport/parport_pc.c
    1801     @@ -1377,7 +1377,7 @@ static struct superio_struct *find_superio(struct parport *p)
    1802     {
    1803     int i;
    1804     for (i = 0; i < NR_SUPERIOS; i++)
    1805     - if (superios[i].io != p->base)
    1806     + if (superios[i].io == p->base)
    1807     return &superios[i];
    1808     return NULL;
    1809     }
    1810     diff --git a/drivers/pinctrl/meson/pinctrl-meson8b.c b/drivers/pinctrl/meson/pinctrl-meson8b.c
    1811     index cbe5f5cbddb8..e1b689f840ab 100644
    1812     --- a/drivers/pinctrl/meson/pinctrl-meson8b.c
    1813     +++ b/drivers/pinctrl/meson/pinctrl-meson8b.c
    1814     @@ -662,7 +662,7 @@ static const char * const sd_a_groups[] = {
    1815    
    1816     static const char * const sdxc_a_groups[] = {
    1817     "sdxc_d0_0_a", "sdxc_d13_0_a", "sdxc_d47_a", "sdxc_clk_a",
    1818     - "sdxc_cmd_a", "sdxc_d0_1_a", "sdxc_d0_13_1_a"
    1819     + "sdxc_cmd_a", "sdxc_d0_1_a", "sdxc_d13_1_a"
    1820     };
    1821    
    1822     static const char * const pcm_a_groups[] = {
    1823     diff --git a/drivers/regulator/s2mpa01.c b/drivers/regulator/s2mpa01.c
    1824     index 92f88753bfed..2daf751c26c7 100644
    1825     --- a/drivers/regulator/s2mpa01.c
    1826     +++ b/drivers/regulator/s2mpa01.c
    1827     @@ -303,13 +303,13 @@ static const struct regulator_desc regulators[] = {
    1828     regulator_desc_ldo(2, STEP_50_MV),
    1829     regulator_desc_ldo(3, STEP_50_MV),
    1830     regulator_desc_ldo(4, STEP_50_MV),
    1831     - regulator_desc_ldo(5, STEP_50_MV),
    1832     + regulator_desc_ldo(5, STEP_25_MV),
    1833     regulator_desc_ldo(6, STEP_25_MV),
    1834     regulator_desc_ldo(7, STEP_50_MV),
    1835     regulator_desc_ldo(8, STEP_50_MV),
    1836     regulator_desc_ldo(9, STEP_50_MV),
    1837     regulator_desc_ldo(10, STEP_50_MV),
    1838     - regulator_desc_ldo(11, STEP_25_MV),
    1839     + regulator_desc_ldo(11, STEP_50_MV),
    1840     regulator_desc_ldo(12, STEP_50_MV),
    1841     regulator_desc_ldo(13, STEP_50_MV),
    1842     regulator_desc_ldo(14, STEP_50_MV),
    1843     @@ -320,11 +320,11 @@ static const struct regulator_desc regulators[] = {
    1844     regulator_desc_ldo(19, STEP_50_MV),
    1845     regulator_desc_ldo(20, STEP_50_MV),
    1846     regulator_desc_ldo(21, STEP_50_MV),
    1847     - regulator_desc_ldo(22, STEP_25_MV),
    1848     - regulator_desc_ldo(23, STEP_25_MV),
    1849     + regulator_desc_ldo(22, STEP_50_MV),
    1850     + regulator_desc_ldo(23, STEP_50_MV),
    1851     regulator_desc_ldo(24, STEP_50_MV),
    1852     regulator_desc_ldo(25, STEP_50_MV),
    1853     - regulator_desc_ldo(26, STEP_50_MV),
    1854     + regulator_desc_ldo(26, STEP_25_MV),
    1855     regulator_desc_buck1_4(1),
    1856     regulator_desc_buck1_4(2),
    1857     regulator_desc_buck1_4(3),
    1858     diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
    1859     index d838e77dd947..1fe1c18cc27b 100644
    1860     --- a/drivers/regulator/s2mps11.c
    1861     +++ b/drivers/regulator/s2mps11.c
    1862     @@ -376,7 +376,7 @@ static const struct regulator_desc s2mps11_regulators[] = {
    1863     regulator_desc_s2mps11_ldo(32, STEP_50_MV),
    1864     regulator_desc_s2mps11_ldo(33, STEP_50_MV),
    1865     regulator_desc_s2mps11_ldo(34, STEP_50_MV),
    1866     - regulator_desc_s2mps11_ldo(35, STEP_50_MV),
    1867     + regulator_desc_s2mps11_ldo(35, STEP_25_MV),
    1868     regulator_desc_s2mps11_ldo(36, STEP_50_MV),
    1869     regulator_desc_s2mps11_ldo(37, STEP_50_MV),
    1870     regulator_desc_s2mps11_ldo(38, STEP_50_MV),
    1871     @@ -386,8 +386,8 @@ static const struct regulator_desc s2mps11_regulators[] = {
    1872     regulator_desc_s2mps11_buck1_4(4),
    1873     regulator_desc_s2mps11_buck5,
    1874     regulator_desc_s2mps11_buck67810(6, MIN_600_MV, STEP_6_25_MV),
    1875     - regulator_desc_s2mps11_buck67810(7, MIN_600_MV, STEP_6_25_MV),
    1876     - regulator_desc_s2mps11_buck67810(8, MIN_600_MV, STEP_6_25_MV),
    1877     + regulator_desc_s2mps11_buck67810(7, MIN_600_MV, STEP_12_5_MV),
    1878     + regulator_desc_s2mps11_buck67810(8, MIN_600_MV, STEP_12_5_MV),
    1879     regulator_desc_s2mps11_buck9,
    1880     regulator_desc_s2mps11_buck67810(10, MIN_750_MV, STEP_12_5_MV),
    1881     };
    1882     diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
    1883     index be17de9807b6..11c6335b1951 100644
    1884     --- a/drivers/s390/block/dasd_eckd.c
    1885     +++ b/drivers/s390/block/dasd_eckd.c
    1886     @@ -4508,6 +4508,14 @@ static int dasd_symm_io(struct dasd_device *device, void __user *argp)
    1887     usrparm.psf_data &= 0x7fffffffULL;
    1888     usrparm.rssd_result &= 0x7fffffffULL;
    1889     }
    1890     + /* at least 2 bytes are accessed and should be allocated */
    1891     + if (usrparm.psf_data_len < 2) {
    1892     + DBF_DEV_EVENT(DBF_WARNING, device,
    1893     + "Symmetrix ioctl invalid data length %d",
    1894     + usrparm.psf_data_len);
    1895     + rc = -EINVAL;
    1896     + goto out;
    1897     + }
    1898     /* alloc I/O data area */
    1899     psf_data = kzalloc(usrparm.psf_data_len, GFP_KERNEL | GFP_DMA);
    1900     rssd_result = kzalloc(usrparm.rssd_result_len, GFP_KERNEL | GFP_DMA);
    1901     diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
    1902     index 3493d449911c..d5e510ff5437 100644
    1903     --- a/drivers/s390/virtio/virtio_ccw.c
    1904     +++ b/drivers/s390/virtio/virtio_ccw.c
    1905     @@ -283,6 +283,8 @@ static void virtio_ccw_drop_indicators(struct virtio_ccw_device *vcdev)
    1906     {
    1907     struct virtio_ccw_vq_info *info;
    1908    
    1909     + if (!vcdev->airq_info)
    1910     + return;
    1911     list_for_each_entry(info, &vcdev->virtqueues, node)
    1912     drop_airq_indicator(info->vq, vcdev->airq_info);
    1913     }
    1914     @@ -424,7 +426,7 @@ static int virtio_ccw_read_vq_conf(struct virtio_ccw_device *vcdev,
    1915     ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_VQ_CONF);
    1916     if (ret)
    1917     return ret;
    1918     - return vcdev->config_block->num;
    1919     + return vcdev->config_block->num ?: -ENOENT;
    1920     }
    1921    
    1922     static void virtio_ccw_del_vq(struct virtqueue *vq, struct ccw1 *ccw)
    1923     diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
    1924     index c79743de48f9..2ffe10453e30 100644
    1925     --- a/drivers/scsi/libiscsi.c
    1926     +++ b/drivers/scsi/libiscsi.c
    1927     @@ -1448,7 +1448,13 @@ static int iscsi_xmit_task(struct iscsi_conn *conn)
    1928     if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx))
    1929     return -ENODATA;
    1930    
    1931     + spin_lock_bh(&conn->session->back_lock);
    1932     + if (conn->task == NULL) {
    1933     + spin_unlock_bh(&conn->session->back_lock);
    1934     + return -ENODATA;
    1935     + }
    1936     __iscsi_get_task(task);
    1937     + spin_unlock_bh(&conn->session->back_lock);
    1938     spin_unlock_bh(&conn->session->frwd_lock);
    1939     rc = conn->session->tt->xmit_task(task);
    1940     spin_lock_bh(&conn->session->frwd_lock);
    1941     diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
    1942     index 867ae76f93f2..3e9cbba41464 100644
    1943     --- a/drivers/scsi/sd.c
    1944     +++ b/drivers/scsi/sd.c
    1945     @@ -2834,6 +2834,55 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
    1946     sdkp->ws10 = 1;
    1947     }
    1948    
    1949     +/*
    1950     + * Determine the device's preferred I/O size for reads and writes
    1951     + * unless the reported value is unreasonably small, large, not a
    1952     + * multiple of the physical block size, or simply garbage.
    1953     + */
    1954     +static bool sd_validate_opt_xfer_size(struct scsi_disk *sdkp,
    1955     + unsigned int dev_max)
    1956     +{
    1957     + struct scsi_device *sdp = sdkp->device;
    1958     + unsigned int opt_xfer_bytes =
    1959     + logical_to_bytes(sdp, sdkp->opt_xfer_blocks);
    1960     +
    1961     + if (sdkp->opt_xfer_blocks > dev_max) {
    1962     + sd_first_printk(KERN_WARNING, sdkp,
    1963     + "Optimal transfer size %u logical blocks " \
    1964     + "> dev_max (%u logical blocks)\n",
    1965     + sdkp->opt_xfer_blocks, dev_max);
    1966     + return false;
    1967     + }
    1968     +
    1969     + if (sdkp->opt_xfer_blocks > SD_DEF_XFER_BLOCKS) {
    1970     + sd_first_printk(KERN_WARNING, sdkp,
    1971     + "Optimal transfer size %u logical blocks " \
    1972     + "> sd driver limit (%u logical blocks)\n",
    1973     + sdkp->opt_xfer_blocks, SD_DEF_XFER_BLOCKS);
    1974     + return false;
    1975     + }
    1976     +
    1977     + if (opt_xfer_bytes < PAGE_SIZE) {
    1978     + sd_first_printk(KERN_WARNING, sdkp,
    1979     + "Optimal transfer size %u bytes < " \
    1980     + "PAGE_SIZE (%u bytes)\n",
    1981     + opt_xfer_bytes, (unsigned int)PAGE_SIZE);
    1982     + return false;
    1983     + }
    1984     +
    1985     + if (opt_xfer_bytes & (sdkp->physical_block_size - 1)) {
    1986     + sd_first_printk(KERN_WARNING, sdkp,
    1987     + "Optimal transfer size %u bytes not a " \
    1988     + "multiple of physical block size (%u bytes)\n",
    1989     + opt_xfer_bytes, sdkp->physical_block_size);
    1990     + return false;
    1991     + }
    1992     +
    1993     + sd_first_printk(KERN_INFO, sdkp, "Optimal transfer size %u bytes\n",
    1994     + opt_xfer_bytes);
    1995     + return true;
    1996     +}
    1997     +
    1998     /**
    1999     * sd_revalidate_disk - called the first time a new disk is seen,
    2000     * performs disk spin up, read_capacity, etc.
    2001     @@ -2898,15 +2947,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
    2002     dev_max = min_not_zero(dev_max, sdkp->max_xfer_blocks);
    2003     q->limits.max_dev_sectors = logical_to_sectors(sdp, dev_max);
    2004    
    2005     - /*
    2006     - * Determine the device's preferred I/O size for reads and writes
    2007     - * unless the reported value is unreasonably small, large, or
    2008     - * garbage.
    2009     - */
    2010     - if (sdkp->opt_xfer_blocks &&
    2011     - sdkp->opt_xfer_blocks <= dev_max &&
    2012     - sdkp->opt_xfer_blocks <= SD_DEF_XFER_BLOCKS &&
    2013     - logical_to_bytes(sdp, sdkp->opt_xfer_blocks) >= PAGE_SIZE) {
    2014     + if (sd_validate_opt_xfer_size(sdkp, dev_max)) {
    2015     q->limits.io_opt = logical_to_bytes(sdp, sdkp->opt_xfer_blocks);
    2016     rw_max = logical_to_sectors(sdp, sdkp->opt_xfer_blocks);
    2017     } else
    2018     diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
    2019     index cbc8e9388268..7ba0031d3a73 100644
    2020     --- a/drivers/scsi/virtio_scsi.c
    2021     +++ b/drivers/scsi/virtio_scsi.c
    2022     @@ -693,7 +693,6 @@ static int virtscsi_device_reset(struct scsi_cmnd *sc)
    2023     return FAILED;
    2024    
    2025     memset(cmd, 0, sizeof(*cmd));
    2026     - cmd->sc = sc;
    2027     cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
    2028     .type = VIRTIO_SCSI_T_TMF,
    2029     .subtype = cpu_to_virtio32(vscsi->vdev,
    2030     @@ -752,7 +751,6 @@ static int virtscsi_abort(struct scsi_cmnd *sc)
    2031     return FAILED;
    2032    
    2033     memset(cmd, 0, sizeof(*cmd));
    2034     - cmd->sc = sc;
    2035     cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
    2036     .type = VIRTIO_SCSI_T_TMF,
    2037     .subtype = VIRTIO_SCSI_T_TMF_ABORT_TASK,
    2038     diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c
    2039     index 3f3751e2b521..f2209ec4cb68 100644
    2040     --- a/drivers/spi/spi-pxa2xx.c
    2041     +++ b/drivers/spi/spi-pxa2xx.c
    2042     @@ -1668,6 +1668,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
    2043     platform_info->enable_dma = false;
    2044     } else {
    2045     master->can_dma = pxa2xx_spi_can_dma;
    2046     + master->max_dma_len = MAX_DMA_LEN;
    2047     }
    2048     }
    2049    
    2050     diff --git a/drivers/spi/spi-ti-qspi.c b/drivers/spi/spi-ti-qspi.c
    2051     index caeac66a3977..4cb72a8e4646 100644
    2052     --- a/drivers/spi/spi-ti-qspi.c
    2053     +++ b/drivers/spi/spi-ti-qspi.c
    2054     @@ -457,8 +457,8 @@ static void ti_qspi_enable_memory_map(struct spi_device *spi)
    2055     ti_qspi_write(qspi, MM_SWITCH, QSPI_SPI_SWITCH_REG);
    2056     if (qspi->ctrl_base) {
    2057     regmap_update_bits(qspi->ctrl_base, qspi->ctrl_reg,
    2058     - MEM_CS_EN(spi->chip_select),
    2059     - MEM_CS_MASK);
    2060     + MEM_CS_MASK,
    2061     + MEM_CS_EN(spi->chip_select));
    2062     }
    2063     qspi->mmap_enabled = true;
    2064     }
    2065     @@ -470,7 +470,7 @@ static void ti_qspi_disable_memory_map(struct spi_device *spi)
    2066     ti_qspi_write(qspi, 0, QSPI_SPI_SWITCH_REG);
    2067     if (qspi->ctrl_base)
    2068     regmap_update_bits(qspi->ctrl_base, qspi->ctrl_reg,
    2069     - 0, MEM_CS_MASK);
    2070     + MEM_CS_MASK, 0);
    2071     qspi->mmap_enabled = false;
    2072     }
    2073    
    2074     diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
    2075     index 80205f3362d4..b6c4f55f79e7 100644
    2076     --- a/drivers/target/iscsi/iscsi_target.c
    2077     +++ b/drivers/target/iscsi/iscsi_target.c
    2078     @@ -4084,9 +4084,9 @@ static void iscsit_release_commands_from_conn(struct iscsi_conn *conn)
    2079     struct se_cmd *se_cmd = &cmd->se_cmd;
    2080    
    2081     if (se_cmd->se_tfo != NULL) {
    2082     - spin_lock(&se_cmd->t_state_lock);
    2083     + spin_lock_irq(&se_cmd->t_state_lock);
    2084     se_cmd->transport_state |= CMD_T_FABRIC_STOP;
    2085     - spin_unlock(&se_cmd->t_state_lock);
    2086     + spin_unlock_irq(&se_cmd->t_state_lock);
    2087     }
    2088     }
    2089     spin_unlock_bh(&conn->cmd_lock);
    2090     diff --git a/drivers/tty/serial/8250/8250_of.c b/drivers/tty/serial/8250/8250_of.c
    2091     index 7a8b5fc81a19..f89dfde934a3 100644
    2092     --- a/drivers/tty/serial/8250/8250_of.c
    2093     +++ b/drivers/tty/serial/8250/8250_of.c
    2094     @@ -97,6 +97,10 @@ static int of_platform_serial_setup(struct platform_device *ofdev,
    2095     if (of_property_read_u32(np, "reg-offset", &prop) == 0)
    2096     port->mapbase += prop;
    2097    
    2098     + /* Compatibility with the deprecated pxa driver and 8250_pxa drivers. */
    2099     + if (of_device_is_compatible(np, "mrvl,mmp-uart"))
    2100     + port->regshift = 2;
    2101     +
    2102     /* Check for registers offset within the devices address range */
    2103     if (of_property_read_u32(np, "reg-shift", &prop) == 0)
    2104     port->regshift = prop;
    2105     diff --git a/drivers/tty/serial/8250/8250_pci.c b/drivers/tty/serial/8250/8250_pci.c
    2106     index e82b3473b6b8..2c38b3a1d518 100644
    2107     --- a/drivers/tty/serial/8250/8250_pci.c
    2108     +++ b/drivers/tty/serial/8250/8250_pci.c
    2109     @@ -1330,6 +1330,30 @@ static int pci_default_setup(struct serial_private *priv,
    2110     return setup_port(priv, port, bar, offset, board->reg_shift);
    2111     }
    2112    
    2113     +static int pci_pericom_setup(struct serial_private *priv,
    2114     + const struct pciserial_board *board,
    2115     + struct uart_8250_port *port, int idx)
    2116     +{
    2117     + unsigned int bar, offset = board->first_offset, maxnr;
    2118     +
    2119     + bar = FL_GET_BASE(board->flags);
    2120     + if (board->flags & FL_BASE_BARS)
    2121     + bar += idx;
    2122     + else
    2123     + offset += idx * board->uart_offset;
    2124     +
    2125     + if (idx==3)
    2126     + offset = 0x38;
    2127     +
    2128     + maxnr = (pci_resource_len(priv->dev, bar) - board->first_offset) >>
    2129     + (board->reg_shift + 3);
    2130     +
    2131     + if (board->flags & FL_REGION_SZ_CAP && idx >= maxnr)
    2132     + return 1;
    2133     +
    2134     + return setup_port(priv, port, bar, offset, board->reg_shift);
    2135     +}
    2136     +
    2137     static int
    2138     ce4100_serial_setup(struct serial_private *priv,
    2139     const struct pciserial_board *board,
    2140     @@ -2096,6 +2120,16 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
    2141     .setup = pci_default_setup,
    2142     .exit = pci_plx9050_exit,
    2143     },
    2144     + /*
    2145     + * Pericom (Only 7954 - It have a offset jump for port 4)
    2146     + */
    2147     + {
    2148     + .vendor = PCI_VENDOR_ID_PERICOM,
    2149     + .device = PCI_DEVICE_ID_PERICOM_PI7C9X7954,
    2150     + .subvendor = PCI_ANY_ID,
    2151     + .subdevice = PCI_ANY_ID,
    2152     + .setup = pci_pericom_setup,
    2153     + },
    2154     /*
    2155     * PLX
    2156     */
    2157     @@ -2126,6 +2160,111 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
    2158     .setup = pci_default_setup,
    2159     .exit = pci_plx9050_exit,
    2160     },
    2161     + {
    2162     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2163     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SDB,
    2164     + .subvendor = PCI_ANY_ID,
    2165     + .subdevice = PCI_ANY_ID,
    2166     + .setup = pci_pericom_setup,
    2167     + },
    2168     + {
    2169     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2170     + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_COM_4S,
    2171     + .subvendor = PCI_ANY_ID,
    2172     + .subdevice = PCI_ANY_ID,
    2173     + .setup = pci_pericom_setup,
    2174     + },
    2175     + {
    2176     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2177     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4DB,
    2178     + .subvendor = PCI_ANY_ID,
    2179     + .subdevice = PCI_ANY_ID,
    2180     + .setup = pci_pericom_setup,
    2181     + },
    2182     + {
    2183     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2184     + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_COM232_4,
    2185     + .subvendor = PCI_ANY_ID,
    2186     + .subdevice = PCI_ANY_ID,
    2187     + .setup = pci_pericom_setup,
    2188     + },
    2189     + {
    2190     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2191     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SMDB,
    2192     + .subvendor = PCI_ANY_ID,
    2193     + .subdevice = PCI_ANY_ID,
    2194     + .setup = pci_pericom_setup,
    2195     + },
    2196     + {
    2197     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2198     + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_COM_4SM,
    2199     + .subvendor = PCI_ANY_ID,
    2200     + .subdevice = PCI_ANY_ID,
    2201     + .setup = pci_pericom_setup,
    2202     + },
    2203     + {
    2204     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2205     + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM422_4,
    2206     + .subvendor = PCI_ANY_ID,
    2207     + .subdevice = PCI_ANY_ID,
    2208     + .setup = pci_pericom_setup,
    2209     + },
    2210     + {
    2211     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2212     + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM485_4,
    2213     + .subvendor = PCI_ANY_ID,
    2214     + .subdevice = PCI_ANY_ID,
    2215     + .setup = pci_pericom_setup,
    2216     + },
    2217     + {
    2218     + .vendor = PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4S,
    2219     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_4,
    2220     + .subvendor = PCI_ANY_ID,
    2221     + .subdevice = PCI_ANY_ID,
    2222     + .setup = pci_pericom_setup,
    2223     + },
    2224     + {
    2225     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2226     + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM232_4,
    2227     + .subvendor = PCI_ANY_ID,
    2228     + .subdevice = PCI_ANY_ID,
    2229     + .setup = pci_pericom_setup,
    2230     + },
    2231     + {
    2232     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2233     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM422_4,
    2234     + .subvendor = PCI_ANY_ID,
    2235     + .subdevice = PCI_ANY_ID,
    2236     + .setup = pci_pericom_setup,
    2237     + },
    2238     + {
    2239     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2240     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM485_4,
    2241     + .subvendor = PCI_ANY_ID,
    2242     + .subdevice = PCI_ANY_ID,
    2243     + .setup = pci_pericom_setup,
    2244     + },
    2245     + {
    2246     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2247     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4,
    2248     + .subvendor = PCI_ANY_ID,
    2249     + .subdevice = PCI_ANY_ID,
    2250     + .setup = pci_pericom_setup,
    2251     + },
    2252     + {
    2253     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2254     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SM,
    2255     + .subvendor = PCI_ANY_ID,
    2256     + .subdevice = PCI_ANY_ID,
    2257     + .setup = pci_pericom_setup,
    2258     + },
    2259     + {
    2260     + .vendor = PCI_VENDOR_ID_ACCESIO,
    2261     + .device = PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4SM,
    2262     + .subvendor = PCI_ANY_ID,
    2263     + .subdevice = PCI_ANY_ID,
    2264     + .setup = pci_pericom_setup,
    2265     + },
    2266     /*
    2267     * SBS Technologies, Inc., PMC-OCTALPRO 232
    2268     */
    2269     @@ -4976,10 +5115,10 @@ static struct pci_device_id serial_pci_tbl[] = {
    2270     */
    2271     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_2SDB,
    2272     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2273     - pbn_pericom_PI7C9X7954 },
    2274     + pbn_pericom_PI7C9X7952 },
    2275     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_COM_2S,
    2276     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2277     - pbn_pericom_PI7C9X7954 },
    2278     + pbn_pericom_PI7C9X7952 },
    2279     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SDB,
    2280     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2281     pbn_pericom_PI7C9X7954 },
    2282     @@ -4988,10 +5127,10 @@ static struct pci_device_id serial_pci_tbl[] = {
    2283     pbn_pericom_PI7C9X7954 },
    2284     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_2DB,
    2285     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2286     - pbn_pericom_PI7C9X7954 },
    2287     + pbn_pericom_PI7C9X7952 },
    2288     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_COM232_2,
    2289     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2290     - pbn_pericom_PI7C9X7954 },
    2291     + pbn_pericom_PI7C9X7952 },
    2292     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4DB,
    2293     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2294     pbn_pericom_PI7C9X7954 },
    2295     @@ -5000,10 +5139,10 @@ static struct pci_device_id serial_pci_tbl[] = {
    2296     pbn_pericom_PI7C9X7954 },
    2297     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_2SMDB,
    2298     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2299     - pbn_pericom_PI7C9X7954 },
    2300     + pbn_pericom_PI7C9X7952 },
    2301     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_COM_2SM,
    2302     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2303     - pbn_pericom_PI7C9X7954 },
    2304     + pbn_pericom_PI7C9X7952 },
    2305     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SMDB,
    2306     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2307     pbn_pericom_PI7C9X7954 },
    2308     @@ -5012,13 +5151,13 @@ static struct pci_device_id serial_pci_tbl[] = {
    2309     pbn_pericom_PI7C9X7954 },
    2310     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM485_1,
    2311     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2312     - pbn_pericom_PI7C9X7954 },
    2313     + pbn_pericom_PI7C9X7951 },
    2314     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM422_2,
    2315     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2316     - pbn_pericom_PI7C9X7954 },
    2317     + pbn_pericom_PI7C9X7952 },
    2318     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM485_2,
    2319     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2320     - pbn_pericom_PI7C9X7954 },
    2321     + pbn_pericom_PI7C9X7952 },
    2322     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM422_4,
    2323     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2324     pbn_pericom_PI7C9X7954 },
    2325     @@ -5027,16 +5166,16 @@ static struct pci_device_id serial_pci_tbl[] = {
    2326     pbn_pericom_PI7C9X7954 },
    2327     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_2S,
    2328     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2329     - pbn_pericom_PI7C9X7954 },
    2330     + pbn_pericom_PI7C9X7952 },
    2331     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4S,
    2332     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2333     pbn_pericom_PI7C9X7954 },
    2334     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_2,
    2335     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2336     - pbn_pericom_PI7C9X7954 },
    2337     + pbn_pericom_PI7C9X7952 },
    2338     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM232_2,
    2339     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2340     - pbn_pericom_PI7C9X7954 },
    2341     + pbn_pericom_PI7C9X7952 },
    2342     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_4,
    2343     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2344     pbn_pericom_PI7C9X7954 },
    2345     @@ -5045,13 +5184,13 @@ static struct pci_device_id serial_pci_tbl[] = {
    2346     pbn_pericom_PI7C9X7954 },
    2347     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_2SM,
    2348     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2349     - pbn_pericom_PI7C9X7954 },
    2350     + pbn_pericom_PI7C9X7952 },
    2351     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM422_4,
    2352     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2353     - pbn_pericom_PI7C9X7958 },
    2354     + pbn_pericom_PI7C9X7954 },
    2355     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM485_4,
    2356     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2357     - pbn_pericom_PI7C9X7958 },
    2358     + pbn_pericom_PI7C9X7954 },
    2359     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM422_8,
    2360     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2361     pbn_pericom_PI7C9X7958 },
    2362     @@ -5060,19 +5199,19 @@ static struct pci_device_id serial_pci_tbl[] = {
    2363     pbn_pericom_PI7C9X7958 },
    2364     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4,
    2365     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2366     - pbn_pericom_PI7C9X7958 },
    2367     + pbn_pericom_PI7C9X7954 },
    2368     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_8,
    2369     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2370     pbn_pericom_PI7C9X7958 },
    2371     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SM,
    2372     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2373     - pbn_pericom_PI7C9X7958 },
    2374     + pbn_pericom_PI7C9X7954 },
    2375     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_8SM,
    2376     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2377     pbn_pericom_PI7C9X7958 },
    2378     { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4SM,
    2379     PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2380     - pbn_pericom_PI7C9X7958 },
    2381     + pbn_pericom_PI7C9X7954 },
    2382     /*
    2383     * Topic TP560 Data/Fax/Voice 56k modem (reported by Evan Clarke)
    2384     */
    2385     diff --git a/drivers/tty/serial/xilinx_uartps.c b/drivers/tty/serial/xilinx_uartps.c
    2386     index 7333d64f68f2..ffb474c49f0f 100644
    2387     --- a/drivers/tty/serial/xilinx_uartps.c
    2388     +++ b/drivers/tty/serial/xilinx_uartps.c
    2389     @@ -362,7 +362,13 @@ static irqreturn_t cdns_uart_isr(int irq, void *dev_id)
    2390     cdns_uart_handle_tx(dev_id);
    2391     isrstatus &= ~CDNS_UART_IXR_TXEMPTY;
    2392     }
    2393     - if (isrstatus & CDNS_UART_IXR_RXMASK)
    2394     +
    2395     + /*
    2396     + * Skip RX processing if RX is disabled as RXEMPTY will never be set
    2397     + * as read bytes will not be removed from the FIFO.
    2398     + */
    2399     + if (isrstatus & CDNS_UART_IXR_RXMASK &&
    2400     + !(readl(port->membase + CDNS_UART_CR) & CDNS_UART_CR_RX_DIS))
    2401     cdns_uart_handle_rx(dev_id, isrstatus);
    2402    
    2403     spin_unlock(&port->lock);
    2404     diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
    2405     index 5a0db6dec8d1..aaee1e6584e6 100644
    2406     --- a/fs/9p/v9fs_vfs.h
    2407     +++ b/fs/9p/v9fs_vfs.h
    2408     @@ -40,6 +40,9 @@
    2409     */
    2410     #define P9_LOCK_TIMEOUT (30*HZ)
    2411    
    2412     +/* flags for v9fs_stat2inode() & v9fs_stat2inode_dotl() */
    2413     +#define V9FS_STAT2INODE_KEEP_ISIZE 1
    2414     +
    2415     extern struct file_system_type v9fs_fs_type;
    2416     extern const struct address_space_operations v9fs_addr_operations;
    2417     extern const struct file_operations v9fs_file_operations;
    2418     @@ -61,8 +64,10 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
    2419     struct inode *inode, umode_t mode, dev_t);
    2420     void v9fs_evict_inode(struct inode *inode);
    2421     ino_t v9fs_qid2ino(struct p9_qid *qid);
    2422     -void v9fs_stat2inode(struct p9_wstat *, struct inode *, struct super_block *);
    2423     -void v9fs_stat2inode_dotl(struct p9_stat_dotl *, struct inode *);
    2424     +void v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
    2425     + struct super_block *sb, unsigned int flags);
    2426     +void v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
    2427     + unsigned int flags);
    2428     int v9fs_dir_release(struct inode *inode, struct file *filp);
    2429     int v9fs_file_open(struct inode *inode, struct file *file);
    2430     void v9fs_inode2stat(struct inode *inode, struct p9_wstat *stat);
    2431     @@ -83,4 +88,18 @@ static inline void v9fs_invalidate_inode_attr(struct inode *inode)
    2432     }
    2433    
    2434     int v9fs_open_to_dotl_flags(int flags);
    2435     +
    2436     +static inline void v9fs_i_size_write(struct inode *inode, loff_t i_size)
    2437     +{
    2438     + /*
    2439     + * 32-bit need the lock, concurrent updates could break the
    2440     + * sequences and make i_size_read() loop forever.
    2441     + * 64-bit updates are atomic and can skip the locking.
    2442     + */
    2443     + if (sizeof(i_size) > sizeof(long))
    2444     + spin_lock(&inode->i_lock);
    2445     + i_size_write(inode, i_size);
    2446     + if (sizeof(i_size) > sizeof(long))
    2447     + spin_unlock(&inode->i_lock);
    2448     +}
    2449     #endif
    2450     diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
    2451     index 398a3eddb2df..2f035b15180e 100644
    2452     --- a/fs/9p/vfs_file.c
    2453     +++ b/fs/9p/vfs_file.c
    2454     @@ -442,7 +442,11 @@ v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
    2455     i_size = i_size_read(inode);
    2456     if (iocb->ki_pos > i_size) {
    2457     inode_add_bytes(inode, iocb->ki_pos - i_size);
    2458     - i_size_write(inode, iocb->ki_pos);
    2459     + /*
    2460     + * Need to serialize against i_size_write() in
    2461     + * v9fs_stat2inode()
    2462     + */
    2463     + v9fs_i_size_write(inode, iocb->ki_pos);
    2464     }
    2465     return retval;
    2466     }
    2467     diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
    2468     index f8ab4a66acaf..ddd1eb6aedee 100644
    2469     --- a/fs/9p/vfs_inode.c
    2470     +++ b/fs/9p/vfs_inode.c
    2471     @@ -538,7 +538,7 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
    2472     if (retval)
    2473     goto error;
    2474    
    2475     - v9fs_stat2inode(st, inode, sb);
    2476     + v9fs_stat2inode(st, inode, sb, 0);
    2477     v9fs_cache_inode_get_cookie(inode);
    2478     unlock_new_inode(inode);
    2479     return inode;
    2480     @@ -1078,7 +1078,7 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
    2481     if (IS_ERR(st))
    2482     return PTR_ERR(st);
    2483    
    2484     - v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb);
    2485     + v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);
    2486     generic_fillattr(d_inode(dentry), stat);
    2487    
    2488     p9stat_free(st);
    2489     @@ -1156,12 +1156,13 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
    2490     * @stat: Plan 9 metadata (mistat) structure
    2491     * @inode: inode to populate
    2492     * @sb: superblock of filesystem
    2493     + * @flags: control flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
    2494     *
    2495     */
    2496    
    2497     void
    2498     v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
    2499     - struct super_block *sb)
    2500     + struct super_block *sb, unsigned int flags)
    2501     {
    2502     umode_t mode;
    2503     char ext[32];
    2504     @@ -1202,10 +1203,11 @@ v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
    2505     mode = p9mode2perm(v9ses, stat);
    2506     mode |= inode->i_mode & ~S_IALLUGO;
    2507     inode->i_mode = mode;
    2508     - i_size_write(inode, stat->length);
    2509    
    2510     + if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
    2511     + v9fs_i_size_write(inode, stat->length);
    2512     /* not real number of blocks, but 512 byte ones ... */
    2513     - inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
    2514     + inode->i_blocks = (stat->length + 512 - 1) >> 9;
    2515     v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
    2516     }
    2517    
    2518     @@ -1402,9 +1404,9 @@ int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
    2519     {
    2520     int umode;
    2521     dev_t rdev;
    2522     - loff_t i_size;
    2523     struct p9_wstat *st;
    2524     struct v9fs_session_info *v9ses;
    2525     + unsigned int flags;
    2526    
    2527     v9ses = v9fs_inode2v9ses(inode);
    2528     st = p9_client_stat(fid);
    2529     @@ -1417,16 +1419,13 @@ int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
    2530     if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
    2531     goto out;
    2532    
    2533     - spin_lock(&inode->i_lock);
    2534     /*
    2535     * We don't want to refresh inode->i_size,
    2536     * because we may have cached data
    2537     */
    2538     - i_size = inode->i_size;
    2539     - v9fs_stat2inode(st, inode, inode->i_sb);
    2540     - if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
    2541     - inode->i_size = i_size;
    2542     - spin_unlock(&inode->i_lock);
    2543     + flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
    2544     + V9FS_STAT2INODE_KEEP_ISIZE : 0;
    2545     + v9fs_stat2inode(st, inode, inode->i_sb, flags);
    2546     out:
    2547     p9stat_free(st);
    2548     kfree(st);
    2549     diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
    2550     index c3dd0d42bb3a..425bc1a2b8c1 100644
    2551     --- a/fs/9p/vfs_inode_dotl.c
    2552     +++ b/fs/9p/vfs_inode_dotl.c
    2553     @@ -143,7 +143,7 @@ static struct inode *v9fs_qid_iget_dotl(struct super_block *sb,
    2554     if (retval)
    2555     goto error;
    2556    
    2557     - v9fs_stat2inode_dotl(st, inode);
    2558     + v9fs_stat2inode_dotl(st, inode, 0);
    2559     v9fs_cache_inode_get_cookie(inode);
    2560     retval = v9fs_get_acl(inode, fid);
    2561     if (retval)
    2562     @@ -496,7 +496,7 @@ v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
    2563     if (IS_ERR(st))
    2564     return PTR_ERR(st);
    2565    
    2566     - v9fs_stat2inode_dotl(st, d_inode(dentry));
    2567     + v9fs_stat2inode_dotl(st, d_inode(dentry), 0);
    2568     generic_fillattr(d_inode(dentry), stat);
    2569     /* Change block size to what the server returned */
    2570     stat->blksize = st->st_blksize;
    2571     @@ -607,11 +607,13 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
    2572     * v9fs_stat2inode_dotl - populate an inode structure with stat info
    2573     * @stat: stat structure
    2574     * @inode: inode to populate
    2575     + * @flags: ctrl flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
    2576     *
    2577     */
    2578    
    2579     void
    2580     -v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
    2581     +v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
    2582     + unsigned int flags)
    2583     {
    2584     umode_t mode;
    2585     struct v9fs_inode *v9inode = V9FS_I(inode);
    2586     @@ -631,7 +633,8 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
    2587     mode |= inode->i_mode & ~S_IALLUGO;
    2588     inode->i_mode = mode;
    2589    
    2590     - i_size_write(inode, stat->st_size);
    2591     + if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
    2592     + v9fs_i_size_write(inode, stat->st_size);
    2593     inode->i_blocks = stat->st_blocks;
    2594     } else {
    2595     if (stat->st_result_mask & P9_STATS_ATIME) {
    2596     @@ -661,8 +664,9 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
    2597     }
    2598     if (stat->st_result_mask & P9_STATS_RDEV)
    2599     inode->i_rdev = new_decode_dev(stat->st_rdev);
    2600     - if (stat->st_result_mask & P9_STATS_SIZE)
    2601     - i_size_write(inode, stat->st_size);
    2602     + if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE) &&
    2603     + stat->st_result_mask & P9_STATS_SIZE)
    2604     + v9fs_i_size_write(inode, stat->st_size);
    2605     if (stat->st_result_mask & P9_STATS_BLOCKS)
    2606     inode->i_blocks = stat->st_blocks;
    2607     }
    2608     @@ -928,9 +932,9 @@ v9fs_vfs_get_link_dotl(struct dentry *dentry,
    2609    
    2610     int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
    2611     {
    2612     - loff_t i_size;
    2613     struct p9_stat_dotl *st;
    2614     struct v9fs_session_info *v9ses;
    2615     + unsigned int flags;
    2616    
    2617     v9ses = v9fs_inode2v9ses(inode);
    2618     st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
    2619     @@ -942,16 +946,13 @@ int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
    2620     if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT))
    2621     goto out;
    2622    
    2623     - spin_lock(&inode->i_lock);
    2624     /*
    2625     * We don't want to refresh inode->i_size,
    2626     * because we may have cached data
    2627     */
    2628     - i_size = inode->i_size;
    2629     - v9fs_stat2inode_dotl(st, inode);
    2630     - if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
    2631     - inode->i_size = i_size;
    2632     - spin_unlock(&inode->i_lock);
    2633     + flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
    2634     + V9FS_STAT2INODE_KEEP_ISIZE : 0;
    2635     + v9fs_stat2inode_dotl(st, inode, flags);
    2636     out:
    2637     kfree(st);
    2638     return 0;
    2639     diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
    2640     index de3ed8629196..06ff1a9089e8 100644
    2641     --- a/fs/9p/vfs_super.c
    2642     +++ b/fs/9p/vfs_super.c
    2643     @@ -165,7 +165,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
    2644     goto release_sb;
    2645     }
    2646     d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
    2647     - v9fs_stat2inode_dotl(st, d_inode(root));
    2648     + v9fs_stat2inode_dotl(st, d_inode(root), 0);
    2649     kfree(st);
    2650     } else {
    2651     struct p9_wstat *st = NULL;
    2652     @@ -176,7 +176,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
    2653     }
    2654    
    2655     d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
    2656     - v9fs_stat2inode(st, d_inode(root), sb);
    2657     + v9fs_stat2inode(st, d_inode(root), sb, 0);
    2658    
    2659     p9stat_free(st);
    2660     kfree(st);
    2661     diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
    2662     index 5c5c389d8fed..4d901200be13 100644
    2663     --- a/fs/btrfs/extent_io.c
    2664     +++ b/fs/btrfs/extent_io.c
    2665     @@ -3018,11 +3018,11 @@ static int __do_readpage(struct extent_io_tree *tree,
    2666     */
    2667     if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) &&
    2668     prev_em_start && *prev_em_start != (u64)-1 &&
    2669     - *prev_em_start != em->orig_start)
    2670     + *prev_em_start != em->start)
    2671     force_bio_submit = true;
    2672    
    2673     if (prev_em_start)
    2674     - *prev_em_start = em->orig_start;
    2675     + *prev_em_start = em->start;
    2676    
    2677     free_extent_map(em);
    2678     em = NULL;
    2679     diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
    2680     index 5aa2749eaf42..c063ac57c30e 100644
    2681     --- a/fs/btrfs/volumes.c
    2682     +++ b/fs/btrfs/volumes.c
    2683     @@ -6439,10 +6439,10 @@ static int btrfs_check_chunk_valid(struct btrfs_root *root,
    2684     }
    2685    
    2686     if ((type & BTRFS_BLOCK_GROUP_RAID10 && sub_stripes != 2) ||
    2687     - (type & BTRFS_BLOCK_GROUP_RAID1 && num_stripes < 1) ||
    2688     + (type & BTRFS_BLOCK_GROUP_RAID1 && num_stripes != 2) ||
    2689     (type & BTRFS_BLOCK_GROUP_RAID5 && num_stripes < 2) ||
    2690     (type & BTRFS_BLOCK_GROUP_RAID6 && num_stripes < 3) ||
    2691     - (type & BTRFS_BLOCK_GROUP_DUP && num_stripes > 2) ||
    2692     + (type & BTRFS_BLOCK_GROUP_DUP && num_stripes != 2) ||
    2693     ((type & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 &&
    2694     num_stripes != 1)) {
    2695     btrfs_err(root->fs_info,
    2696     diff --git a/fs/cifs/file.c b/fs/cifs/file.c
    2697     index 8ec296308729..1c5099fffaec 100644
    2698     --- a/fs/cifs/file.c
    2699     +++ b/fs/cifs/file.c
    2700     @@ -2797,14 +2797,16 @@ cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
    2701     * these pages but not on the region from pos to ppos+len-1.
    2702     */
    2703     written = cifs_user_writev(iocb, from);
    2704     - if (written > 0 && CIFS_CACHE_READ(cinode)) {
    2705     + if (CIFS_CACHE_READ(cinode)) {
    2706     /*
    2707     - * Windows 7 server can delay breaking level2 oplock if a write
    2708     - * request comes - break it on the client to prevent reading
    2709     - * an old data.
    2710     + * We have read level caching and we have just sent a write
    2711     + * request to the server thus making data in the cache stale.
    2712     + * Zap the cache and set oplock/lease level to NONE to avoid
    2713     + * reading stale data from the cache. All subsequent read
    2714     + * operations will read new data from the server.
    2715     */
    2716     cifs_zap_mapping(inode);
    2717     - cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
    2718     + cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
    2719     inode);
    2720     cinode->oplock = 0;
    2721     }
    2722     diff --git a/fs/cifs/smb2misc.c b/fs/cifs/smb2misc.c
    2723     index e96a74da756f..244d27bb8fba 100644
    2724     --- a/fs/cifs/smb2misc.c
    2725     +++ b/fs/cifs/smb2misc.c
    2726     @@ -474,7 +474,6 @@ smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp,
    2727     __u8 lease_state;
    2728     struct list_head *tmp;
    2729     struct cifsFileInfo *cfile;
    2730     - struct TCP_Server_Info *server = tcon->ses->server;
    2731     struct cifs_pending_open *open;
    2732     struct cifsInodeInfo *cinode;
    2733     int ack_req = le32_to_cpu(rsp->Flags &
    2734     @@ -494,13 +493,25 @@ smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp,
    2735     cifs_dbg(FYI, "lease key match, lease break 0x%x\n",
    2736     le32_to_cpu(rsp->NewLeaseState));
    2737    
    2738     - server->ops->set_oplock_level(cinode, lease_state, 0, NULL);
    2739     -
    2740     if (ack_req)
    2741     cfile->oplock_break_cancelled = false;
    2742     else
    2743     cfile->oplock_break_cancelled = true;
    2744    
    2745     + set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, &cinode->flags);
    2746     +
    2747     + /*
    2748     + * Set or clear flags depending on the lease state being READ.
    2749     + * HANDLE caching flag should be added when the client starts
    2750     + * to defer closing remote file handles with HANDLE leases.
    2751     + */
    2752     + if (lease_state & SMB2_LEASE_READ_CACHING_HE)
    2753     + set_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
    2754     + &cinode->flags);
    2755     + else
    2756     + clear_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
    2757     + &cinode->flags);
    2758     +
    2759     queue_work(cifsoplockd_wq, &cfile->oplock_break);
    2760     kfree(lw);
    2761     return true;
    2762     diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
    2763     index 2db7968febfe..97d8e2a3df9b 100644
    2764     --- a/fs/cifs/smb2ops.c
    2765     +++ b/fs/cifs/smb2ops.c
    2766     @@ -1376,6 +1376,15 @@ smb2_downgrade_oplock(struct TCP_Server_Info *server,
    2767     server->ops->set_oplock_level(cinode, 0, 0, NULL);
    2768     }
    2769    
    2770     +static void
    2771     +smb21_downgrade_oplock(struct TCP_Server_Info *server,
    2772     + struct cifsInodeInfo *cinode, bool set_level2)
    2773     +{
    2774     + server->ops->set_oplock_level(cinode,
    2775     + set_level2 ? SMB2_LEASE_READ_CACHING_HE :
    2776     + 0, 0, NULL);
    2777     +}
    2778     +
    2779     static void
    2780     smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
    2781     unsigned int epoch, bool *purge_cache)
    2782     @@ -1681,7 +1690,7 @@ struct smb_version_operations smb21_operations = {
    2783     .print_stats = smb2_print_stats,
    2784     .is_oplock_break = smb2_is_valid_oplock_break,
    2785     .handle_cancelled_mid = smb2_handle_cancelled_mid,
    2786     - .downgrade_oplock = smb2_downgrade_oplock,
    2787     + .downgrade_oplock = smb21_downgrade_oplock,
    2788     .need_neg = smb2_need_neg,
    2789     .negotiate = smb2_negotiate,
    2790     .negotiate_wsize = smb2_negotiate_wsize,
    2791     @@ -1765,7 +1774,7 @@ struct smb_version_operations smb30_operations = {
    2792     .dump_share_caps = smb2_dump_share_caps,
    2793     .is_oplock_break = smb2_is_valid_oplock_break,
    2794     .handle_cancelled_mid = smb2_handle_cancelled_mid,
    2795     - .downgrade_oplock = smb2_downgrade_oplock,
    2796     + .downgrade_oplock = smb21_downgrade_oplock,
    2797     .need_neg = smb2_need_neg,
    2798     .negotiate = smb2_negotiate,
    2799     .negotiate_wsize = smb2_negotiate_wsize,
    2800     @@ -1855,7 +1864,7 @@ struct smb_version_operations smb311_operations = {
    2801     .dump_share_caps = smb2_dump_share_caps,
    2802     .is_oplock_break = smb2_is_valid_oplock_break,
    2803     .handle_cancelled_mid = smb2_handle_cancelled_mid,
    2804     - .downgrade_oplock = smb2_downgrade_oplock,
    2805     + .downgrade_oplock = smb21_downgrade_oplock,
    2806     .need_neg = smb2_need_neg,
    2807     .negotiate = smb2_negotiate,
    2808     .negotiate_wsize = smb2_negotiate_wsize,
    2809     diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
    2810     index 108df2e3602c..81be3ba17cbf 100644
    2811     --- a/fs/devpts/inode.c
    2812     +++ b/fs/devpts/inode.c
    2813     @@ -396,6 +396,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
    2814     s->s_blocksize_bits = 10;
    2815     s->s_magic = DEVPTS_SUPER_MAGIC;
    2816     s->s_op = &devpts_sops;
    2817     + s->s_d_op = &simple_dentry_operations;
    2818     s->s_time_gran = 1;
    2819    
    2820     error = -ENOMEM;
    2821     diff --git a/fs/ext2/super.c b/fs/ext2/super.c
    2822     index 6cb042b53b5b..6fcb29b393d3 100644
    2823     --- a/fs/ext2/super.c
    2824     +++ b/fs/ext2/super.c
    2825     @@ -724,7 +724,8 @@ static loff_t ext2_max_size(int bits)
    2826     {
    2827     loff_t res = EXT2_NDIR_BLOCKS;
    2828     int meta_blocks;
    2829     - loff_t upper_limit;
    2830     + unsigned int upper_limit;
    2831     + unsigned int ppb = 1 << (bits-2);
    2832    
    2833     /* This is calculated to be the largest file size for a
    2834     * dense, file such that the total number of
    2835     @@ -738,24 +739,34 @@ static loff_t ext2_max_size(int bits)
    2836     /* total blocks in file system block size */
    2837     upper_limit >>= (bits - 9);
    2838    
    2839     + /* Compute how many blocks we can address by block tree */
    2840     + res += 1LL << (bits-2);
    2841     + res += 1LL << (2*(bits-2));
    2842     + res += 1LL << (3*(bits-2));
    2843     + /* Does block tree limit file size? */
    2844     + if (res < upper_limit)
    2845     + goto check_lfs;
    2846    
    2847     + res = upper_limit;
    2848     + /* How many metadata blocks are needed for addressing upper_limit? */
    2849     + upper_limit -= EXT2_NDIR_BLOCKS;
    2850     /* indirect blocks */
    2851     meta_blocks = 1;
    2852     + upper_limit -= ppb;
    2853     /* double indirect blocks */
    2854     - meta_blocks += 1 + (1LL << (bits-2));
    2855     - /* tripple indirect blocks */
    2856     - meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
    2857     -
    2858     - upper_limit -= meta_blocks;
    2859     - upper_limit <<= bits;
    2860     -
    2861     - res += 1LL << (bits-2);
    2862     - res += 1LL << (2*(bits-2));
    2863     - res += 1LL << (3*(bits-2));
    2864     + if (upper_limit < ppb * ppb) {
    2865     + meta_blocks += 1 + DIV_ROUND_UP(upper_limit, ppb);
    2866     + res -= meta_blocks;
    2867     + goto check_lfs;
    2868     + }
    2869     + meta_blocks += 1 + ppb;
    2870     + upper_limit -= ppb * ppb;
    2871     + /* tripple indirect blocks for the rest */
    2872     + meta_blocks += 1 + DIV_ROUND_UP(upper_limit, ppb) +
    2873     + DIV_ROUND_UP(upper_limit, ppb*ppb);
    2874     + res -= meta_blocks;
    2875     +check_lfs:
    2876     res <<= bits;
    2877     - if (res > upper_limit)
    2878     - res = upper_limit;
    2879     -
    2880     if (res > MAX_LFS_FILESIZE)
    2881     res = MAX_LFS_FILESIZE;
    2882    
    2883     diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
    2884     index 58e6b8a03e90..67b359629a66 100644
    2885     --- a/fs/ext4/resize.c
    2886     +++ b/fs/ext4/resize.c
    2887     @@ -1928,7 +1928,8 @@ retry:
    2888     le16_to_cpu(es->s_reserved_gdt_blocks);
    2889     n_group = n_desc_blocks * EXT4_DESC_PER_BLOCK(sb);
    2890     n_blocks_count = (ext4_fsblk_t)n_group *
    2891     - EXT4_BLOCKS_PER_GROUP(sb);
    2892     + EXT4_BLOCKS_PER_GROUP(sb) +
    2893     + le32_to_cpu(es->s_first_data_block);
    2894     n_group--; /* set to last group number */
    2895     }
    2896    
    2897     diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
    2898     index b320c1ba7fdc..799f96c67211 100644
    2899     --- a/fs/jbd2/transaction.c
    2900     +++ b/fs/jbd2/transaction.c
    2901     @@ -1211,11 +1211,12 @@ int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
    2902     struct journal_head *jh;
    2903     char *committed_data = NULL;
    2904    
    2905     - JBUFFER_TRACE(jh, "entry");
    2906     if (jbd2_write_access_granted(handle, bh, true))
    2907     return 0;
    2908    
    2909     jh = jbd2_journal_add_journal_head(bh);
    2910     + JBUFFER_TRACE(jh, "entry");
    2911     +
    2912     /*
    2913     * Do this first --- it can drop the journal lock, so we want to
    2914     * make sure that obtaining the committed_data is done
    2915     @@ -1326,15 +1327,17 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
    2916    
    2917     if (is_handle_aborted(handle))
    2918     return -EROFS;
    2919     - if (!buffer_jbd(bh)) {
    2920     - ret = -EUCLEAN;
    2921     - goto out;
    2922     - }
    2923     + if (!buffer_jbd(bh))
    2924     + return -EUCLEAN;
    2925     +
    2926     /*
    2927     * We don't grab jh reference here since the buffer must be part
    2928     * of the running transaction.
    2929     */
    2930     jh = bh2jh(bh);
    2931     + jbd_debug(5, "journal_head %p\n", jh);
    2932     + JBUFFER_TRACE(jh, "entry");
    2933     +
    2934     /*
    2935     * This and the following assertions are unreliable since we may see jh
    2936     * in inconsistent state unless we grab bh_state lock. But this is
    2937     @@ -1368,9 +1371,6 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
    2938     }
    2939    
    2940     journal = transaction->t_journal;
    2941     - jbd_debug(5, "journal_head %p\n", jh);
    2942     - JBUFFER_TRACE(jh, "entry");
    2943     -
    2944     jbd_lock_bh_state(bh);
    2945    
    2946     if (jh->b_modified == 0) {
    2947     @@ -1568,14 +1568,21 @@ int jbd2_journal_forget (handle_t *handle, struct buffer_head *bh)
    2948     /* However, if the buffer is still owned by a prior
    2949     * (committing) transaction, we can't drop it yet... */
    2950     JBUFFER_TRACE(jh, "belongs to older transaction");
    2951     - /* ... but we CAN drop it from the new transaction if we
    2952     - * have also modified it since the original commit. */
    2953     + /* ... but we CAN drop it from the new transaction through
    2954     + * marking the buffer as freed and set j_next_transaction to
    2955     + * the new transaction, so that not only the commit code
    2956     + * knows it should clear dirty bits when it is done with the
    2957     + * buffer, but also the buffer can be checkpointed only
    2958     + * after the new transaction commits. */
    2959    
    2960     - if (jh->b_next_transaction) {
    2961     - J_ASSERT(jh->b_next_transaction == transaction);
    2962     + set_buffer_freed(bh);
    2963     +
    2964     + if (!jh->b_next_transaction) {
    2965     spin_lock(&journal->j_list_lock);
    2966     - jh->b_next_transaction = NULL;
    2967     + jh->b_next_transaction = transaction;
    2968     spin_unlock(&journal->j_list_lock);
    2969     + } else {
    2970     + J_ASSERT(jh->b_next_transaction == transaction);
    2971    
    2972     /*
    2973     * only drop a reference if this transaction modified
    2974     diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
    2975     index 892c88542ebd..fad4d5188aaf 100644
    2976     --- a/fs/nfs/pagelist.c
    2977     +++ b/fs/nfs/pagelist.c
    2978     @@ -975,6 +975,17 @@ static void nfs_pageio_doio(struct nfs_pageio_descriptor *desc)
    2979     }
    2980     }
    2981    
    2982     +static void
    2983     +nfs_pageio_cleanup_request(struct nfs_pageio_descriptor *desc,
    2984     + struct nfs_page *req)
    2985     +{
    2986     + LIST_HEAD(head);
    2987     +
    2988     + nfs_list_remove_request(req);
    2989     + nfs_list_add_request(req, &head);
    2990     + desc->pg_completion_ops->error_cleanup(&head);
    2991     +}
    2992     +
    2993     /**
    2994     * nfs_pageio_add_request - Attempt to coalesce a request into a page list.
    2995     * @desc: destination io descriptor
    2996     @@ -1012,10 +1023,8 @@ static int __nfs_pageio_add_request(struct nfs_pageio_descriptor *desc,
    2997     nfs_page_group_unlock(req);
    2998     desc->pg_moreio = 1;
    2999     nfs_pageio_doio(desc);
    3000     - if (desc->pg_error < 0)
    3001     - return 0;
    3002     - if (mirror->pg_recoalesce)
    3003     - return 0;
    3004     + if (desc->pg_error < 0 || mirror->pg_recoalesce)
    3005     + goto out_cleanup_subreq;
    3006     /* retry add_request for this subreq */
    3007     nfs_page_group_lock(req, false);
    3008     continue;
    3009     @@ -1048,6 +1057,10 @@ err_ptr:
    3010     desc->pg_error = PTR_ERR(subreq);
    3011     nfs_page_group_unlock(req);
    3012     return 0;
    3013     +out_cleanup_subreq:
    3014     + if (req != subreq)
    3015     + nfs_pageio_cleanup_request(desc, subreq);
    3016     + return 0;
    3017     }
    3018    
    3019     static int nfs_do_recoalesce(struct nfs_pageio_descriptor *desc)
    3020     @@ -1066,7 +1079,6 @@ static int nfs_do_recoalesce(struct nfs_pageio_descriptor *desc)
    3021     struct nfs_page *req;
    3022    
    3023     req = list_first_entry(&head, struct nfs_page, wb_list);
    3024     - nfs_list_remove_request(req);
    3025     if (__nfs_pageio_add_request(desc, req))
    3026     continue;
    3027     if (desc->pg_error < 0) {
    3028     @@ -1141,11 +1153,14 @@ int nfs_pageio_add_request(struct nfs_pageio_descriptor *desc,
    3029     if (nfs_pgio_has_mirroring(desc))
    3030     desc->pg_mirror_idx = midx;
    3031     if (!nfs_pageio_add_request_mirror(desc, dupreq))
    3032     - goto out_failed;
    3033     + goto out_cleanup_subreq;
    3034     }
    3035    
    3036     return 1;
    3037    
    3038     +out_cleanup_subreq:
    3039     + if (req != dupreq)
    3040     + nfs_pageio_cleanup_request(desc, dupreq);
    3041     out_failed:
    3042     /*
    3043     * We might have failed before sending any reqs over wire.
    3044     @@ -1185,7 +1200,7 @@ static void nfs_pageio_complete_mirror(struct nfs_pageio_descriptor *desc,
    3045     desc->pg_mirror_idx = mirror_idx;
    3046     for (;;) {
    3047     nfs_pageio_doio(desc);
    3048     - if (!mirror->pg_recoalesce)
    3049     + if (desc->pg_error < 0 || !mirror->pg_recoalesce)
    3050     break;
    3051     if (!nfs_do_recoalesce(desc))
    3052     break;
    3053     diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
    3054     index d818e4ffd79f..00b472fe77c1 100644
    3055     --- a/fs/nfsd/nfs3proc.c
    3056     +++ b/fs/nfsd/nfs3proc.c
    3057     @@ -431,8 +431,19 @@ nfsd3_proc_readdir(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
    3058     &resp->common, nfs3svc_encode_entry);
    3059     memcpy(resp->verf, argp->verf, 8);
    3060     resp->count = resp->buffer - argp->buffer;
    3061     - if (resp->offset)
    3062     - xdr_encode_hyper(resp->offset, argp->cookie);
    3063     + if (resp->offset) {
    3064     + loff_t offset = argp->cookie;
    3065     +
    3066     + if (unlikely(resp->offset1)) {
    3067     + /* we ended up with offset on a page boundary */
    3068     + *resp->offset = htonl(offset >> 32);
    3069     + *resp->offset1 = htonl(offset & 0xffffffff);
    3070     + resp->offset1 = NULL;
    3071     + } else {
    3072     + xdr_encode_hyper(resp->offset, offset);
    3073     + }
    3074     + resp->offset = NULL;
    3075     + }
    3076    
    3077     RETURN_STATUS(nfserr);
    3078     }
    3079     @@ -500,6 +511,7 @@ nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
    3080     } else {
    3081     xdr_encode_hyper(resp->offset, offset);
    3082     }
    3083     + resp->offset = NULL;
    3084     }
    3085    
    3086     RETURN_STATUS(nfserr);
    3087     diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
    3088     index 452334694a5d..7e50248ca432 100644
    3089     --- a/fs/nfsd/nfs3xdr.c
    3090     +++ b/fs/nfsd/nfs3xdr.c
    3091     @@ -899,6 +899,7 @@ encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
    3092     } else {
    3093     xdr_encode_hyper(cd->offset, offset64);
    3094     }
    3095     + cd->offset = NULL;
    3096     }
    3097    
    3098     /*
    3099     diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
    3100     index 797a155c9a67..f704f90db36c 100644
    3101     --- a/fs/nfsd/nfsctl.c
    3102     +++ b/fs/nfsd/nfsctl.c
    3103     @@ -1103,7 +1103,7 @@ static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size)
    3104     case 'Y':
    3105     case 'y':
    3106     case '1':
    3107     - if (nn->nfsd_serv)
    3108     + if (!nn->nfsd_serv)
    3109     return -EBUSY;
    3110     nfsd4_end_grace(nn);
    3111     break;
    3112     diff --git a/fs/pipe.c b/fs/pipe.c
    3113     index 34345535f63d..388e09a689de 100644
    3114     --- a/fs/pipe.c
    3115     +++ b/fs/pipe.c
    3116     @@ -238,6 +238,14 @@ static const struct pipe_buf_operations anon_pipe_buf_ops = {
    3117     .get = generic_pipe_buf_get,
    3118     };
    3119    
    3120     +static const struct pipe_buf_operations anon_pipe_buf_nomerge_ops = {
    3121     + .can_merge = 0,
    3122     + .confirm = generic_pipe_buf_confirm,
    3123     + .release = anon_pipe_buf_release,
    3124     + .steal = anon_pipe_buf_steal,
    3125     + .get = generic_pipe_buf_get,
    3126     +};
    3127     +
    3128     static const struct pipe_buf_operations packet_pipe_buf_ops = {
    3129     .can_merge = 0,
    3130     .confirm = generic_pipe_buf_confirm,
    3131     @@ -246,6 +254,12 @@ static const struct pipe_buf_operations packet_pipe_buf_ops = {
    3132     .get = generic_pipe_buf_get,
    3133     };
    3134    
    3135     +void pipe_buf_mark_unmergeable(struct pipe_buffer *buf)
    3136     +{
    3137     + if (buf->ops == &anon_pipe_buf_ops)
    3138     + buf->ops = &anon_pipe_buf_nomerge_ops;
    3139     +}
    3140     +
    3141     static ssize_t
    3142     pipe_read(struct kiocb *iocb, struct iov_iter *to)
    3143     {
    3144     diff --git a/fs/splice.c b/fs/splice.c
    3145     index 8dd79ecfd383..01983bea760c 100644
    3146     --- a/fs/splice.c
    3147     +++ b/fs/splice.c
    3148     @@ -1594,6 +1594,8 @@ retry:
    3149     */
    3150     obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
    3151    
    3152     + pipe_buf_mark_unmergeable(obuf);
    3153     +
    3154     obuf->len = len;
    3155     opipe->nrbufs++;
    3156     ibuf->offset += obuf->len;
    3157     @@ -1668,6 +1670,8 @@ static int link_pipe(struct pipe_inode_info *ipipe,
    3158     */
    3159     obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
    3160    
    3161     + pipe_buf_mark_unmergeable(obuf);
    3162     +
    3163     if (obuf->len > len)
    3164     obuf->len = len;
    3165    
    3166     diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
    3167     index ef7962e84444..9661bb2fbe22 100644
    3168     --- a/include/linux/device-mapper.h
    3169     +++ b/include/linux/device-mapper.h
    3170     @@ -627,7 +627,7 @@ extern struct ratelimit_state dm_ratelimit_state;
    3171     */
    3172     #define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
    3173    
    3174     -static inline sector_t to_sector(unsigned long n)
    3175     +static inline sector_t to_sector(unsigned long long n)
    3176     {
    3177     return (n >> SECTOR_SHIFT);
    3178     }
    3179     diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
    3180     index e7497c9dde7f..4f7129389855 100644
    3181     --- a/include/linux/pipe_fs_i.h
    3182     +++ b/include/linux/pipe_fs_i.h
    3183     @@ -182,6 +182,7 @@ void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
    3184     int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
    3185     int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
    3186     void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
    3187     +void pipe_buf_mark_unmergeable(struct pipe_buffer *buf);
    3188    
    3189     extern const struct pipe_buf_operations nosteal_pipe_buf_ops;
    3190    
    3191     diff --git a/include/linux/property.h b/include/linux/property.h
    3192     index 459337fb44d0..d5c7ebda4113 100644
    3193     --- a/include/linux/property.h
    3194     +++ b/include/linux/property.h
    3195     @@ -233,7 +233,7 @@ struct property_entry {
    3196     #define PROPERTY_ENTRY_STRING(_name_, _val_) \
    3197     (struct property_entry) { \
    3198     .name = _name_, \
    3199     - .length = sizeof(_val_), \
    3200     + .length = sizeof(const char *), \
    3201     .is_string = true, \
    3202     { .value = { .str = _val_ } }, \
    3203     }
    3204     diff --git a/include/net/phonet/pep.h b/include/net/phonet/pep.h
    3205     index b669fe6dbc3b..98f31c7ea23d 100644
    3206     --- a/include/net/phonet/pep.h
    3207     +++ b/include/net/phonet/pep.h
    3208     @@ -63,10 +63,11 @@ struct pnpipehdr {
    3209     u8 state_after_reset; /* reset request */
    3210     u8 error_code; /* any response */
    3211     u8 pep_type; /* status indication */
    3212     - u8 data[1];
    3213     + u8 data0; /* anything else */
    3214     };
    3215     + u8 data[];
    3216     };
    3217     -#define other_pep_type data[1]
    3218     +#define other_pep_type data[0]
    3219    
    3220     static inline struct pnpipehdr *pnp_hdr(struct sk_buff *skb)
    3221     {
    3222     diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
    3223     index d1a02877a42c..d0b113de3316 100644
    3224     --- a/kernel/rcu/tree.c
    3225     +++ b/kernel/rcu/tree.c
    3226     @@ -1718,15 +1718,23 @@ static int rcu_future_gp_cleanup(struct rcu_state *rsp, struct rcu_node *rnp)
    3227     }
    3228    
    3229     /*
    3230     - * Awaken the grace-period kthread for the specified flavor of RCU.
    3231     - * Don't do a self-awaken, and don't bother awakening when there is
    3232     - * nothing for the grace-period kthread to do (as in several CPUs
    3233     - * raced to awaken, and we lost), and finally don't try to awaken
    3234     - * a kthread that has not yet been created.
    3235     + * Awaken the grace-period kthread. Don't do a self-awaken (unless in
    3236     + * an interrupt or softirq handler), and don't bother awakening when there
    3237     + * is nothing for the grace-period kthread to do (as in several CPUs raced
    3238     + * to awaken, and we lost), and finally don't try to awaken a kthread that
    3239     + * has not yet been created. If all those checks are passed, track some
    3240     + * debug information and awaken.
    3241     + *
    3242     + * So why do the self-wakeup when in an interrupt or softirq handler
    3243     + * in the grace-period kthread's context? Because the kthread might have
    3244     + * been interrupted just as it was going to sleep, and just after the final
    3245     + * pre-sleep check of the awaken condition. In this case, a wakeup really
    3246     + * is required, and is therefore supplied.
    3247     */
    3248     static void rcu_gp_kthread_wake(struct rcu_state *rsp)
    3249     {
    3250     - if (current == rsp->gp_kthread ||
    3251     + if ((current == rsp->gp_kthread &&
    3252     + !in_interrupt() && !in_serving_softirq()) ||
    3253     !READ_ONCE(rsp->gp_flags) ||
    3254     !rsp->gp_kthread)
    3255     return;
    3256     diff --git a/kernel/sysctl.c b/kernel/sysctl.c
    3257     index 93c7b02279b9..efd340a510a9 100644
    3258     --- a/kernel/sysctl.c
    3259     +++ b/kernel/sysctl.c
    3260     @@ -2377,7 +2377,16 @@ static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
    3261     {
    3262     struct do_proc_dointvec_minmax_conv_param *param = data;
    3263     if (write) {
    3264     - int val = *negp ? -*lvalp : *lvalp;
    3265     + int val;
    3266     + if (*negp) {
    3267     + if (*lvalp > (unsigned long) INT_MAX + 1)
    3268     + return -EINVAL;
    3269     + val = -*lvalp;
    3270     + } else {
    3271     + if (*lvalp > (unsigned long) INT_MAX)
    3272     + return -EINVAL;
    3273     + val = *lvalp;
    3274     + }
    3275     if ((param->min && *param->min > val) ||
    3276     (param->max && *param->max < val))
    3277     return -EINVAL;
    3278     diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
    3279     index 6786c507f1f9..f18dedf9195e 100644
    3280     --- a/kernel/trace/trace.c
    3281     +++ b/kernel/trace/trace.c
    3282     @@ -5057,7 +5057,6 @@ out:
    3283     return ret;
    3284    
    3285     fail:
    3286     - kfree(iter->trace);
    3287     kfree(iter);
    3288     __trace_array_put(tr);
    3289     mutex_unlock(&trace_types_lock);
    3290     diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_hist.c
    3291     index 0664044ade06..766e5ccad60a 100644
    3292     --- a/kernel/trace/trace_events_hist.c
    3293     +++ b/kernel/trace/trace_events_hist.c
    3294     @@ -871,9 +871,10 @@ static inline void add_to_key(char *compound_key, void *key,
    3295     /* ensure NULL-termination */
    3296     if (size > key_field->size - 1)
    3297     size = key_field->size - 1;
    3298     - }
    3299    
    3300     - memcpy(compound_key + key_field->offset, key, size);
    3301     + strncpy(compound_key + key_field->offset, (char *)key, size);
    3302     + } else
    3303     + memcpy(compound_key + key_field->offset, key, size);
    3304     }
    3305    
    3306     static void event_hist_trigger(struct event_trigger_data *data, void *rec)
    3307     diff --git a/lib/assoc_array.c b/lib/assoc_array.c
    3308     index 5cd093589c5a..3b46c5433b7a 100644
    3309     --- a/lib/assoc_array.c
    3310     +++ b/lib/assoc_array.c
    3311     @@ -781,9 +781,11 @@ all_leaves_cluster_together:
    3312     new_s0->index_key[i] =
    3313     ops->get_key_chunk(index_key, i * ASSOC_ARRAY_KEY_CHUNK_SIZE);
    3314    
    3315     - blank = ULONG_MAX << (level & ASSOC_ARRAY_KEY_CHUNK_MASK);
    3316     - pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, level, blank);
    3317     - new_s0->index_key[keylen - 1] &= ~blank;
    3318     + if (level & ASSOC_ARRAY_KEY_CHUNK_MASK) {
    3319     + blank = ULONG_MAX << (level & ASSOC_ARRAY_KEY_CHUNK_MASK);
    3320     + pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, level, blank);
    3321     + new_s0->index_key[keylen - 1] &= ~blank;
    3322     + }
    3323    
    3324     /* This now reduces to a node splitting exercise for which we'll need
    3325     * to regenerate the disparity table.
    3326     diff --git a/mm/gup.c b/mm/gup.c
    3327     index d71da7216c6e..99c2f10188c0 100644
    3328     --- a/mm/gup.c
    3329     +++ b/mm/gup.c
    3330     @@ -1423,7 +1423,8 @@ static int gup_pmd_range(pud_t pud, unsigned long addr, unsigned long end,
    3331     if (pmd_none(pmd))
    3332     return 0;
    3333    
    3334     - if (unlikely(pmd_trans_huge(pmd) || pmd_huge(pmd))) {
    3335     + if (unlikely(pmd_trans_huge(pmd) || pmd_huge(pmd) ||
    3336     + pmd_devmap(pmd))) {
    3337     /*
    3338     * NUMA hinting faults need to be handled in the GUP
    3339     * slowpath for accounting purposes and so that they
    3340     diff --git a/mm/memory-failure.c b/mm/memory-failure.c
    3341     index 4f1f5fd12042..d6524dce43b2 100644
    3342     --- a/mm/memory-failure.c
    3343     +++ b/mm/memory-failure.c
    3344     @@ -1705,19 +1705,17 @@ static int soft_offline_in_use_page(struct page *page, int flags)
    3345     struct page *hpage = compound_head(page);
    3346    
    3347     if (!PageHuge(page) && PageTransHuge(hpage)) {
    3348     - lock_page(hpage);
    3349     - if (!PageAnon(hpage) || unlikely(split_huge_page(hpage))) {
    3350     - unlock_page(hpage);
    3351     - if (!PageAnon(hpage))
    3352     + lock_page(page);
    3353     + if (!PageAnon(page) || unlikely(split_huge_page(page))) {
    3354     + unlock_page(page);
    3355     + if (!PageAnon(page))
    3356     pr_info("soft offline: %#lx: non anonymous thp\n", page_to_pfn(page));
    3357     else
    3358     pr_info("soft offline: %#lx: thp split failed\n", page_to_pfn(page));
    3359     - put_hwpoison_page(hpage);
    3360     + put_hwpoison_page(page);
    3361     return -EBUSY;
    3362     }
    3363     - unlock_page(hpage);
    3364     - get_hwpoison_page(page);
    3365     - put_hwpoison_page(hpage);
    3366     + unlock_page(page);
    3367     }
    3368    
    3369     if (PageHuge(page))
    3370     diff --git a/mm/page_alloc.c b/mm/page_alloc.c
    3371     index 3af727d95c17..05f141e39ac1 100644
    3372     --- a/mm/page_alloc.c
    3373     +++ b/mm/page_alloc.c
    3374     @@ -3955,11 +3955,11 @@ refill:
    3375     /* Even if we own the page, we do not use atomic_set().
    3376     * This would break get_page_unless_zero() users.
    3377     */
    3378     - page_ref_add(page, size - 1);
    3379     + page_ref_add(page, size);
    3380    
    3381     /* reset page count bias and offset to start of new frag */
    3382     nc->pfmemalloc = page_is_pfmemalloc(page);
    3383     - nc->pagecnt_bias = size;
    3384     + nc->pagecnt_bias = size + 1;
    3385     nc->offset = size;
    3386     }
    3387    
    3388     @@ -3975,10 +3975,10 @@ refill:
    3389     size = nc->size;
    3390     #endif
    3391     /* OK, page count is 0, we can safely set it */
    3392     - set_page_count(page, size);
    3393     + set_page_count(page, size + 1);
    3394    
    3395     /* reset page count bias and offset to start of new frag */
    3396     - nc->pagecnt_bias = size;
    3397     + nc->pagecnt_bias = size + 1;
    3398     offset = size - fragsz;
    3399     }
    3400    
    3401     diff --git a/mm/shmem.c b/mm/shmem.c
    3402     index 9b17bd4cbc5e..944242491059 100644
    3403     --- a/mm/shmem.c
    3404     +++ b/mm/shmem.c
    3405     @@ -2896,16 +2896,20 @@ static int shmem_create(struct inode *dir, struct dentry *dentry, umode_t mode,
    3406     static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
    3407     {
    3408     struct inode *inode = d_inode(old_dentry);
    3409     - int ret;
    3410     + int ret = 0;
    3411    
    3412     /*
    3413     * No ordinary (disk based) filesystem counts links as inodes;
    3414     * but each new link needs a new dentry, pinning lowmem, and
    3415     * tmpfs dentries cannot be pruned until they are unlinked.
    3416     + * But if an O_TMPFILE file is linked into the tmpfs, the
    3417     + * first link must skip that, to get the accounting right.
    3418     */
    3419     - ret = shmem_reserve_inode(inode->i_sb);
    3420     - if (ret)
    3421     - goto out;
    3422     + if (inode->i_nlink) {
    3423     + ret = shmem_reserve_inode(inode->i_sb);
    3424     + if (ret)
    3425     + goto out;
    3426     + }
    3427    
    3428     dir->i_size += BOGO_DIRENT_SIZE;
    3429     inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
    3430     diff --git a/mm/vmalloc.c b/mm/vmalloc.c
    3431     index fa598162dbf0..e6aa073f01df 100644
    3432     --- a/mm/vmalloc.c
    3433     +++ b/mm/vmalloc.c
    3434     @@ -2191,7 +2191,7 @@ int remap_vmalloc_range_partial(struct vm_area_struct *vma, unsigned long uaddr,
    3435     if (!(area->flags & VM_USERMAP))
    3436     return -EINVAL;
    3437    
    3438     - if (kaddr + size > area->addr + area->size)
    3439     + if (kaddr + size > area->addr + get_vm_area_size(area))
    3440     return -EINVAL;
    3441    
    3442     do {
    3443     diff --git a/net/9p/client.c b/net/9p/client.c
    3444     index 142afe70edb9..f1517ca8aba3 100644
    3445     --- a/net/9p/client.c
    3446     +++ b/net/9p/client.c
    3447     @@ -1058,7 +1058,7 @@ struct p9_client *p9_client_create(const char *dev_name, char *options)
    3448     p9_debug(P9_DEBUG_ERROR,
    3449     "Please specify a msize of at least 4k\n");
    3450     err = -EINVAL;
    3451     - goto free_client;
    3452     + goto close_trans;
    3453     }
    3454    
    3455     err = p9_client_version(clnt);
    3456     diff --git a/net/phonet/pep.c b/net/phonet/pep.c
    3457     index 850a86cde0b3..f6aa532bcbf6 100644
    3458     --- a/net/phonet/pep.c
    3459     +++ b/net/phonet/pep.c
    3460     @@ -131,7 +131,7 @@ static int pep_indicate(struct sock *sk, u8 id, u8 code,
    3461     ph->utid = 0;
    3462     ph->message_id = id;
    3463     ph->pipe_handle = pn->pipe_handle;
    3464     - ph->data[0] = code;
    3465     + ph->error_code = code;
    3466     return pn_skb_send(sk, skb, NULL);
    3467     }
    3468    
    3469     @@ -152,7 +152,7 @@ static int pipe_handler_request(struct sock *sk, u8 id, u8 code,
    3470     ph->utid = id; /* whatever */
    3471     ph->message_id = id;
    3472     ph->pipe_handle = pn->pipe_handle;
    3473     - ph->data[0] = code;
    3474     + ph->error_code = code;
    3475     return pn_skb_send(sk, skb, NULL);
    3476     }
    3477    
    3478     @@ -207,7 +207,7 @@ static int pep_ctrlreq_error(struct sock *sk, struct sk_buff *oskb, u8 code,
    3479     struct pnpipehdr *ph;
    3480     struct sockaddr_pn dst;
    3481     u8 data[4] = {
    3482     - oph->data[0], /* PEP type */
    3483     + oph->pep_type, /* PEP type */
    3484     code, /* error code, at an unusual offset */
    3485     PAD, PAD,
    3486     };
    3487     @@ -220,7 +220,7 @@ static int pep_ctrlreq_error(struct sock *sk, struct sk_buff *oskb, u8 code,
    3488     ph->utid = oph->utid;
    3489     ph->message_id = PNS_PEP_CTRL_RESP;
    3490     ph->pipe_handle = oph->pipe_handle;
    3491     - ph->data[0] = oph->data[1]; /* CTRL id */
    3492     + ph->data0 = oph->data[0]; /* CTRL id */
    3493    
    3494     pn_skb_get_src_sockaddr(oskb, &dst);
    3495     return pn_skb_send(sk, skb, &dst);
    3496     @@ -271,17 +271,17 @@ static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
    3497     return -EINVAL;
    3498    
    3499     hdr = pnp_hdr(skb);
    3500     - if (hdr->data[0] != PN_PEP_TYPE_COMMON) {
    3501     + if (hdr->pep_type != PN_PEP_TYPE_COMMON) {
    3502     net_dbg_ratelimited("Phonet unknown PEP type: %u\n",
    3503     - (unsigned int)hdr->data[0]);
    3504     + (unsigned int)hdr->pep_type);
    3505     return -EOPNOTSUPP;
    3506     }
    3507    
    3508     - switch (hdr->data[1]) {
    3509     + switch (hdr->data[0]) {
    3510     case PN_PEP_IND_FLOW_CONTROL:
    3511     switch (pn->tx_fc) {
    3512     case PN_LEGACY_FLOW_CONTROL:
    3513     - switch (hdr->data[4]) {
    3514     + switch (hdr->data[3]) {
    3515     case PEP_IND_BUSY:
    3516     atomic_set(&pn->tx_credits, 0);
    3517     break;
    3518     @@ -291,7 +291,7 @@ static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
    3519     }
    3520     break;
    3521     case PN_ONE_CREDIT_FLOW_CONTROL:
    3522     - if (hdr->data[4] == PEP_IND_READY)
    3523     + if (hdr->data[3] == PEP_IND_READY)
    3524     atomic_set(&pn->tx_credits, wake = 1);
    3525     break;
    3526     }
    3527     @@ -300,12 +300,12 @@ static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
    3528     case PN_PEP_IND_ID_MCFC_GRANT_CREDITS:
    3529     if (pn->tx_fc != PN_MULTI_CREDIT_FLOW_CONTROL)
    3530     break;
    3531     - atomic_add(wake = hdr->data[4], &pn->tx_credits);
    3532     + atomic_add(wake = hdr->data[3], &pn->tx_credits);
    3533     break;
    3534    
    3535     default:
    3536     net_dbg_ratelimited("Phonet unknown PEP indication: %u\n",
    3537     - (unsigned int)hdr->data[1]);
    3538     + (unsigned int)hdr->data[0]);
    3539     return -EOPNOTSUPP;
    3540     }
    3541     if (wake)
    3542     @@ -317,7 +317,7 @@ static int pipe_rcv_created(struct sock *sk, struct sk_buff *skb)
    3543     {
    3544     struct pep_sock *pn = pep_sk(sk);
    3545     struct pnpipehdr *hdr = pnp_hdr(skb);
    3546     - u8 n_sb = hdr->data[0];
    3547     + u8 n_sb = hdr->data0;
    3548    
    3549     pn->rx_fc = pn->tx_fc = PN_LEGACY_FLOW_CONTROL;
    3550     __skb_pull(skb, sizeof(*hdr));
    3551     @@ -505,7 +505,7 @@ static int pep_connresp_rcv(struct sock *sk, struct sk_buff *skb)
    3552     return -ECONNREFUSED;
    3553    
    3554     /* Parse sub-blocks */
    3555     - n_sb = hdr->data[4];
    3556     + n_sb = hdr->data[3];
    3557     while (n_sb > 0) {
    3558     u8 type, buf[6], len = sizeof(buf);
    3559     const u8 *data = pep_get_sb(skb, &type, &len, buf);
    3560     @@ -738,7 +738,7 @@ static int pipe_do_remove(struct sock *sk)
    3561     ph->utid = 0;
    3562     ph->message_id = PNS_PIPE_REMOVE_REQ;
    3563     ph->pipe_handle = pn->pipe_handle;
    3564     - ph->data[0] = PAD;
    3565     + ph->data0 = PAD;
    3566     return pn_skb_send(sk, skb, NULL);
    3567     }
    3568    
    3569     @@ -815,7 +815,7 @@ static struct sock *pep_sock_accept(struct sock *sk, int flags, int *errp)
    3570     peer_type = hdr->other_pep_type << 8;
    3571    
    3572     /* Parse sub-blocks (options) */
    3573     - n_sb = hdr->data[4];
    3574     + n_sb = hdr->data[3];
    3575     while (n_sb > 0) {
    3576     u8 type, buf[1], len = sizeof(buf);
    3577     const u8 *data = pep_get_sb(skb, &type, &len, buf);
    3578     @@ -1106,7 +1106,7 @@ static int pipe_skb_send(struct sock *sk, struct sk_buff *skb)
    3579     ph->utid = 0;
    3580     if (pn->aligned) {
    3581     ph->message_id = PNS_PIPE_ALIGNED_DATA;
    3582     - ph->data[0] = 0; /* padding */
    3583     + ph->data0 = 0; /* padding */
    3584     } else
    3585     ph->message_id = PNS_PIPE_DATA;
    3586     ph->pipe_handle = pn->pipe_handle;
    3587     diff --git a/sound/soc/fsl/fsl_esai.c b/sound/soc/fsl/fsl_esai.c
    3588     index 3ef174531344..23ab0d169c11 100644
    3589     --- a/sound/soc/fsl/fsl_esai.c
    3590     +++ b/sound/soc/fsl/fsl_esai.c
    3591     @@ -396,7 +396,8 @@ static int fsl_esai_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
    3592     break;
    3593     case SND_SOC_DAIFMT_RIGHT_J:
    3594     /* Data on rising edge of bclk, frame high, right aligned */
    3595     - xccr |= ESAI_xCCR_xCKP | ESAI_xCCR_xHCKP | ESAI_xCR_xWA;
    3596     + xccr |= ESAI_xCCR_xCKP | ESAI_xCCR_xHCKP;
    3597     + xcr |= ESAI_xCR_xWA;
    3598     break;
    3599     case SND_SOC_DAIFMT_DSP_A:
    3600     /* Data on rising edge of bclk, frame high, 1clk before data */
    3601     @@ -453,12 +454,12 @@ static int fsl_esai_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
    3602     return -EINVAL;
    3603     }
    3604    
    3605     - mask = ESAI_xCR_xFSL | ESAI_xCR_xFSR;
    3606     + mask = ESAI_xCR_xFSL | ESAI_xCR_xFSR | ESAI_xCR_xWA;
    3607     regmap_update_bits(esai_priv->regmap, REG_ESAI_TCR, mask, xcr);
    3608     regmap_update_bits(esai_priv->regmap, REG_ESAI_RCR, mask, xcr);
    3609    
    3610     mask = ESAI_xCCR_xCKP | ESAI_xCCR_xHCKP | ESAI_xCCR_xFSP |
    3611     - ESAI_xCCR_xFSD | ESAI_xCCR_xCKD | ESAI_xCR_xWA;
    3612     + ESAI_xCCR_xFSD | ESAI_xCCR_xCKD;
    3613     regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR, mask, xccr);
    3614     regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR, mask, xccr);
    3615    
    3616     diff --git a/sound/soc/soc-topology.c b/sound/soc/soc-topology.c
    3617     index d6b48c796bfc..086fe4d27f60 100644
    3618     --- a/sound/soc/soc-topology.c
    3619     +++ b/sound/soc/soc-topology.c
    3620     @@ -1989,6 +1989,7 @@ int snd_soc_tplg_component_load(struct snd_soc_component *comp,
    3621     struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id)
    3622     {
    3623     struct soc_tplg tplg;
    3624     + int ret;
    3625    
    3626     /* setup parsing context */
    3627     memset(&tplg, 0, sizeof(tplg));
    3628     @@ -2002,7 +2003,12 @@ int snd_soc_tplg_component_load(struct snd_soc_component *comp,
    3629     tplg.bytes_ext_ops = ops->bytes_ext_ops;
    3630     tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count;
    3631    
    3632     - return soc_tplg_load(&tplg);
    3633     + ret = soc_tplg_load(&tplg);
    3634     + /* free the created components if fail to load topology */
    3635     + if (ret)
    3636     + snd_soc_tplg_component_remove(comp, SND_SOC_TPLG_INDEX_ALL);
    3637     +
    3638     + return ret;
    3639     }
    3640     EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load);
    3641    
    3642     diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
    3643     index 29d015e2d900..b87221efdf7e 100644
    3644     --- a/tools/perf/util/auxtrace.c
    3645     +++ b/tools/perf/util/auxtrace.c
    3646     @@ -1244,9 +1244,9 @@ static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
    3647     }
    3648    
    3649     /* padding must be written by fn() e.g. record__process_auxtrace() */
    3650     - padding = size & 7;
    3651     + padding = size & (PERF_AUXTRACE_RECORD_ALIGNMENT - 1);
    3652     if (padding)
    3653     - padding = 8 - padding;
    3654     + padding = PERF_AUXTRACE_RECORD_ALIGNMENT - padding;
    3655    
    3656     memset(&ev, 0, sizeof(ev));
    3657     ev.auxtrace.header.type = PERF_RECORD_AUXTRACE;
    3658     diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
    3659     index 26fb1ee5746a..1b6963e09934 100644
    3660     --- a/tools/perf/util/auxtrace.h
    3661     +++ b/tools/perf/util/auxtrace.h
    3662     @@ -37,6 +37,9 @@ struct record_opts;
    3663     struct auxtrace_info_event;
    3664     struct events_stats;
    3665    
    3666     +/* Auxtrace records must have the same alignment as perf event records */
    3667     +#define PERF_AUXTRACE_RECORD_ALIGNMENT 8
    3668     +
    3669     enum auxtrace_type {
    3670     PERF_AUXTRACE_UNKNOWN,
    3671     PERF_AUXTRACE_INTEL_PT,
    3672     diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
    3673     index d27715ff9a5f..94764efb0a6a 100644
    3674     --- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
    3675     +++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
    3676     @@ -26,6 +26,7 @@
    3677    
    3678     #include "../cache.h"
    3679     #include "../util.h"
    3680     +#include "../auxtrace.h"
    3681    
    3682     #include "intel-pt-insn-decoder.h"
    3683     #include "intel-pt-pkt-decoder.h"
    3684     @@ -1311,7 +1312,6 @@ static int intel_pt_overflow(struct intel_pt_decoder *decoder)
    3685     {
    3686     intel_pt_log("ERROR: Buffer overflow\n");
    3687     intel_pt_clear_tx_flags(decoder);
    3688     - decoder->cbr = 0;
    3689     decoder->timestamp_insn_cnt = 0;
    3690     decoder->pkt_state = INTEL_PT_STATE_ERR_RESYNC;
    3691     decoder->overflow = true;
    3692     @@ -2351,6 +2351,34 @@ static int intel_pt_tsc_cmp(uint64_t tsc1, uint64_t tsc2)
    3693     }
    3694     }
    3695    
    3696     +#define MAX_PADDING (PERF_AUXTRACE_RECORD_ALIGNMENT - 1)
    3697     +
    3698     +/**
    3699     + * adj_for_padding - adjust overlap to account for padding.
    3700     + * @buf_b: second buffer
    3701     + * @buf_a: first buffer
    3702     + * @len_a: size of first buffer
    3703     + *
    3704     + * @buf_a might have up to 7 bytes of padding appended. Adjust the overlap
    3705     + * accordingly.
    3706     + *
    3707     + * Return: A pointer into @buf_b from where non-overlapped data starts
    3708     + */
    3709     +static unsigned char *adj_for_padding(unsigned char *buf_b,
    3710     + unsigned char *buf_a, size_t len_a)
    3711     +{
    3712     + unsigned char *p = buf_b - MAX_PADDING;
    3713     + unsigned char *q = buf_a + len_a - MAX_PADDING;
    3714     + int i;
    3715     +
    3716     + for (i = MAX_PADDING; i; i--, p++, q++) {
    3717     + if (*p != *q)
    3718     + break;
    3719     + }
    3720     +
    3721     + return p;
    3722     +}
    3723     +
    3724     /**
    3725     * intel_pt_find_overlap_tsc - determine start of non-overlapped trace data
    3726     * using TSC.
    3727     @@ -2401,8 +2429,11 @@ static unsigned char *intel_pt_find_overlap_tsc(unsigned char *buf_a,
    3728    
    3729     /* Same TSC, so buffers are consecutive */
    3730     if (!cmp && rem_b >= rem_a) {
    3731     + unsigned char *start;
    3732     +
    3733     *consecutive = true;
    3734     - return buf_b + len_b - (rem_b - rem_a);
    3735     + start = buf_b + len_b - (rem_b - rem_a);
    3736     + return adj_for_padding(start, buf_a, len_a);
    3737     }
    3738     if (cmp < 0)
    3739     return buf_b; /* tsc_a < tsc_b => no overlap */
    3740     @@ -2465,7 +2496,7 @@ unsigned char *intel_pt_find_overlap(unsigned char *buf_a, size_t len_a,
    3741     found = memmem(buf_a, len_a, buf_b, len_a);
    3742     if (found) {
    3743     *consecutive = true;
    3744     - return buf_b + len_a;
    3745     + return adj_for_padding(buf_b + len_a, buf_a, len_a);
    3746     }
    3747    
    3748     /* Try again at next PSB in buffer 'a' */
    3749     diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c
    3750     index d40ab4cf8932..24c6621e2d95 100644
    3751     --- a/tools/perf/util/intel-pt.c
    3752     +++ b/tools/perf/util/intel-pt.c
    3753     @@ -2259,6 +2259,8 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
    3754     }
    3755    
    3756     pt->timeless_decoding = intel_pt_timeless_decoding(pt);
    3757     + if (pt->timeless_decoding && !pt->tc.time_mult)
    3758     + pt->tc.time_mult = 1;
    3759     pt->have_tsc = intel_pt_have_tsc(pt);
    3760     pt->sampling_mode = false;
    3761     pt->est_tsc = !pt->timeless_decoding;