Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-3.12/0118-3.12.19-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-3.12/0118-3.12.19-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2433 - (show annotations) (download)
    Tue May 13 11:02:53 2014 UTC (10 years, 6 months ago) by niro
    File size: 57798 byte(s) 
    -linux-3.12.19
    1 diff --git a/Documentation/i2c/busses/i2c-i801 b/Documentation/i2c/busses/i2c-i801
    2 index 7b0dcdb57173..babe2ef16139 100644
    3 --- a/Documentation/i2c/busses/i2c-i801
    4 +++ b/Documentation/i2c/busses/i2c-i801
    5 @@ -26,6 +26,7 @@ Supported adapters:
    6 * Intel Wellsburg (PCH)
    7 * Intel Coleto Creek (PCH)
    8 * Intel Wildcat Point-LP (PCH)
    9 + * Intel BayTrail (SOC)
    10 Datasheets: Publicly available at the Intel website
    11
    12 On Intel Patsburg and later chipsets, both the normal host SMBus controller
    13 diff --git a/Makefile b/Makefile
    14 index fc0dcf63a8d9..cf5d97e60b39 100644
    15 --- a/Makefile
    16 +++ b/Makefile
    17 @@ -1,6 +1,6 @@
    18 VERSION = 3
    19 PATCHLEVEL = 12
    20 -SUBLEVEL = 18
    21 +SUBLEVEL = 19
    22 EXTRAVERSION =
    23 NAME = One Giant Leap for Frogkind
    24
    25 diff --git a/arch/arm/mm/mmap.c b/arch/arm/mm/mmap.c
    26 index 304661d21369..5e85ed371364 100644
    27 --- a/arch/arm/mm/mmap.c
    28 +++ b/arch/arm/mm/mmap.c
    29 @@ -202,13 +202,11 @@ int valid_phys_addr_range(phys_addr_t addr, size_t size)
    30 }
    31
    32 /*
    33 - * We don't use supersection mappings for mmap() on /dev/mem, which
    34 - * means that we can't map the memory area above the 4G barrier into
    35 - * userspace.
    36 + * Do not allow /dev/mem mappings beyond the supported physical range.
    37 */
    38 int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
    39 {
    40 - return !(pfn + (size >> PAGE_SHIFT) > 0x00100000);
    41 + return (pfn + (size >> PAGE_SHIFT)) <= (1 + (PHYS_MASK >> PAGE_SHIFT));
    42 }
    43
    44 #ifdef CONFIG_STRICT_DEVMEM
    45 diff --git a/arch/parisc/kernel/syscall_table.S b/arch/parisc/kernel/syscall_table.S
    46 index 0c9107285e66..10a0c2aad8cf 100644
    47 --- a/arch/parisc/kernel/syscall_table.S
    48 +++ b/arch/parisc/kernel/syscall_table.S
    49 @@ -392,7 +392,7 @@
    50 ENTRY_COMP(vmsplice)
    51 ENTRY_COMP(move_pages) /* 295 */
    52 ENTRY_SAME(getcpu)
    53 - ENTRY_SAME(epoll_pwait)
    54 + ENTRY_COMP(epoll_pwait)
    55 ENTRY_COMP(statfs64)
    56 ENTRY_COMP(fstatfs64)
    57 ENTRY_COMP(kexec_load) /* 300 */
    58 diff --git a/arch/powerpc/boot/util.S b/arch/powerpc/boot/util.S
    59 index 5143228e3e5f..6636b1d7821b 100644
    60 --- a/arch/powerpc/boot/util.S
    61 +++ b/arch/powerpc/boot/util.S
    62 @@ -71,18 +71,32 @@ udelay:
    63 add r4,r4,r5
    64 addi r4,r4,-1
    65 divw r4,r4,r5 /* BUS ticks */
    66 +#ifdef CONFIG_8xx
    67 +1: mftbu r5
    68 + mftb r6
    69 + mftbu r7
    70 +#else
    71 1: mfspr r5, SPRN_TBRU
    72 mfspr r6, SPRN_TBRL
    73 mfspr r7, SPRN_TBRU
    74 +#endif
    75 cmpw 0,r5,r7
    76 bne 1b /* Get [synced] base time */
    77 addc r9,r6,r4 /* Compute end time */
    78 addze r8,r5
    79 +#ifdef CONFIG_8xx
    80 +2: mftbu r5
    81 +#else
    82 2: mfspr r5, SPRN_TBRU
    83 +#endif
    84 cmpw 0,r5,r8
    85 blt 2b
    86 bgt 3f
    87 +#ifdef CONFIG_8xx
    88 + mftb r6
    89 +#else
    90 mfspr r6, SPRN_TBRL
    91 +#endif
    92 cmpw 0,r6,r9
    93 blt 2b
    94 3: blr
    95 diff --git a/arch/powerpc/include/asm/ppc_asm.h b/arch/powerpc/include/asm/ppc_asm.h
    96 index c2dcfaa51987..0d2d0f03163b 100644
    97 --- a/arch/powerpc/include/asm/ppc_asm.h
    98 +++ b/arch/powerpc/include/asm/ppc_asm.h
    99 @@ -438,6 +438,8 @@ BEGIN_FTR_SECTION_NESTED(96); \
    100 cmpwi dest,0; \
    101 beq- 90b; \
    102 END_FTR_SECTION_NESTED(CPU_FTR_CELL_TB_BUG, CPU_FTR_CELL_TB_BUG, 96)
    103 +#elif defined(CONFIG_8xx)
    104 +#define MFTB(dest) mftb dest
    105 #else
    106 #define MFTB(dest) mfspr dest, SPRN_TBRL
    107 #endif
    108 diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h
    109 index 10d1ef016bf1..7ca729cac073 100644
    110 --- a/arch/powerpc/include/asm/reg.h
    111 +++ b/arch/powerpc/include/asm/reg.h
    112 @@ -1154,12 +1154,19 @@
    113
    114 #else /* __powerpc64__ */
    115
    116 +#if defined(CONFIG_8xx)
    117 +#define mftbl() ({unsigned long rval; \
    118 + asm volatile("mftbl %0" : "=r" (rval)); rval;})
    119 +#define mftbu() ({unsigned long rval; \
    120 + asm volatile("mftbu %0" : "=r" (rval)); rval;})
    121 +#else
    122 #define mftbl() ({unsigned long rval; \
    123 asm volatile("mfspr %0, %1" : "=r" (rval) : \
    124 "i" (SPRN_TBRL)); rval;})
    125 #define mftbu() ({unsigned long rval; \
    126 asm volatile("mfspr %0, %1" : "=r" (rval) : \
    127 "i" (SPRN_TBRU)); rval;})
    128 +#endif
    129 #endif /* !__powerpc64__ */
    130
    131 #define mttbl(v) asm volatile("mttbl %0":: "r"(v))
    132 diff --git a/arch/powerpc/include/asm/timex.h b/arch/powerpc/include/asm/timex.h
    133 index 18908caa1f3b..2cf846edb3fc 100644
    134 --- a/arch/powerpc/include/asm/timex.h
    135 +++ b/arch/powerpc/include/asm/timex.h
    136 @@ -29,7 +29,11 @@ static inline cycles_t get_cycles(void)
    137 ret = 0;
    138
    139 __asm__ __volatile__(
    140 +#ifdef CONFIG_8xx
    141 + "97: mftb %0\n"
    142 +#else
    143 "97: mfspr %0, %2\n"
    144 +#endif
    145 "99:\n"
    146 ".section __ftr_fixup,\"a\"\n"
    147 ".align 2\n"
    148 @@ -41,7 +45,11 @@ static inline cycles_t get_cycles(void)
    149 " .long 0\n"
    150 " .long 0\n"
    151 ".previous"
    152 +#ifdef CONFIG_8xx
    153 + : "=r" (ret) : "i" (CPU_FTR_601));
    154 +#else
    155 : "=r" (ret) : "i" (CPU_FTR_601), "i" (SPRN_TBRL));
    156 +#endif
    157 return ret;
    158 #endif
    159 }
    160 diff --git a/arch/powerpc/kernel/vdso32/gettimeofday.S b/arch/powerpc/kernel/vdso32/gettimeofday.S
    161 index 6b1f2a6d5517..6b2b69616e77 100644
    162 --- a/arch/powerpc/kernel/vdso32/gettimeofday.S
    163 +++ b/arch/powerpc/kernel/vdso32/gettimeofday.S
    164 @@ -232,9 +232,15 @@ __do_get_tspec:
    165 lwz r6,(CFG_TB_ORIG_STAMP+4)(r9)
    166
    167 /* Get a stable TB value */
    168 +#ifdef CONFIG_8xx
    169 +2: mftbu r3
    170 + mftbl r4
    171 + mftbu r0
    172 +#else
    173 2: mfspr r3, SPRN_TBRU
    174 mfspr r4, SPRN_TBRL
    175 mfspr r0, SPRN_TBRU
    176 +#endif
    177 cmplw cr0,r3,r0
    178 bne- 2b
    179
    180 diff --git a/arch/sparc/Kconfig b/arch/sparc/Kconfig
    181 index 78c4fdb91bc5..4e5683877b93 100644
    182 --- a/arch/sparc/Kconfig
    183 +++ b/arch/sparc/Kconfig
    184 @@ -25,7 +25,7 @@ config SPARC
    185 select RTC_DRV_M48T59
    186 select HAVE_DMA_ATTRS
    187 select HAVE_DMA_API_DEBUG
    188 - select HAVE_ARCH_JUMP_LABEL
    189 + select HAVE_ARCH_JUMP_LABEL if SPARC64
    190 select GENERIC_IRQ_SHOW
    191 select ARCH_WANT_IPC_PARSE_VERSION
    192 select USE_GENERIC_SMP_HELPERS if SMP
    193 diff --git a/arch/sparc/kernel/process_64.c b/arch/sparc/kernel/process_64.c
    194 index baebab215492..b9cc9763faf4 100644
    195 --- a/arch/sparc/kernel/process_64.c
    196 +++ b/arch/sparc/kernel/process_64.c
    197 @@ -57,9 +57,12 @@ void arch_cpu_idle(void)
    198 {
    199 if (tlb_type != hypervisor) {
    200 touch_nmi_watchdog();
    201 + local_irq_enable();
    202 } else {
    203 unsigned long pstate;
    204
    205 + local_irq_enable();
    206 +
    207 /* The sun4v sleeping code requires that we have PSTATE.IE cleared over
    208 * the cpu sleep hypervisor call.
    209 */
    210 @@ -81,7 +84,6 @@ void arch_cpu_idle(void)
    211 : "=&r" (pstate)
    212 : "i" (PSTATE_IE));
    213 }
    214 - local_irq_enable();
    215 }
    216
    217 #ifdef CONFIG_HOTPLUG_CPU
    218 diff --git a/arch/sparc/kernel/syscalls.S b/arch/sparc/kernel/syscalls.S
    219 index d950197a17e1..6dee79575791 100644
    220 --- a/arch/sparc/kernel/syscalls.S
    221 +++ b/arch/sparc/kernel/syscalls.S
    222 @@ -189,7 +189,8 @@ linux_sparc_syscall32:
    223 mov %i0, %l5 ! IEU1
    224 5: call %l7 ! CTI Group brk forced
    225 srl %i5, 0, %o5 ! IEU1
    226 - ba,a,pt %xcc, 3f
    227 + ba,pt %xcc, 3f
    228 + sra %o0, 0, %o0
    229
    230 /* Linux native system calls enter here... */
    231 .align 32
    232 @@ -217,7 +218,6 @@ linux_sparc_syscall:
    233 3: stx %o0, [%sp + PTREGS_OFF + PT_V9_I0]
    234 ret_sys_call:
    235 ldx [%sp + PTREGS_OFF + PT_V9_TSTATE], %g3
    236 - sra %o0, 0, %o0
    237 mov %ulo(TSTATE_XCARRY | TSTATE_ICARRY), %g2
    238 sllx %g2, 32, %g2
    239
    240 diff --git a/arch/x86/kernel/early-quirks.c b/arch/x86/kernel/early-quirks.c
    241 index b3cd3ebae077..7eb30af8c7a2 100644
    242 --- a/arch/x86/kernel/early-quirks.c
    243 +++ b/arch/x86/kernel/early-quirks.c
    244 @@ -203,18 +203,15 @@ static void __init intel_remapping_check(int num, int slot, int func)
    245 revision = read_pci_config_byte(num, slot, func, PCI_REVISION_ID);
    246
    247 /*
    248 - * Revision 13 of all triggering devices id in this quirk have
    249 - * a problem draining interrupts when irq remapping is enabled,
    250 - * and should be flagged as broken. Additionally revisions 0x12
    251 - * and 0x22 of device id 0x3405 has this problem.
    252 + * Revision <= 13 of all triggering devices id in this quirk
    253 + * have a problem draining interrupts when irq remapping is
    254 + * enabled, and should be flagged as broken. Additionally
    255 + * revision 0x22 of device id 0x3405 has this problem.
    256 */
    257 - if (revision == 0x13)
    258 + if (revision <= 0x13)
    259 set_irq_remapping_broken();
    260 - else if ((device == 0x3405) &&
    261 - ((revision == 0x12) ||
    262 - (revision == 0x22)))
    263 + else if (device == 0x3405 && revision == 0x22)
    264 set_irq_remapping_broken();
    265 -
    266 }
    267
    268 /*
    269 diff --git a/arch/x86/kernel/quirks.c b/arch/x86/kernel/quirks.c
    270 index 52dbf1e400dc..ff898bbf579d 100644
    271 --- a/arch/x86/kernel/quirks.c
    272 +++ b/arch/x86/kernel/quirks.c
    273 @@ -571,3 +571,40 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_15H_NB_F5,
    274 quirk_amd_nb_node);
    275
    276 #endif
    277 +
    278 +#ifdef CONFIG_PCI
    279 +/*
    280 + * Processor does not ensure DRAM scrub read/write sequence
    281 + * is atomic wrt accesses to CC6 save state area. Therefore
    282 + * if a concurrent scrub read/write access is to same address
    283 + * the entry may appear as if it is not written. This quirk
    284 + * applies to Fam16h models 00h-0Fh
    285 + *
    286 + * See "Revision Guide" for AMD F16h models 00h-0fh,
    287 + * document 51810 rev. 3.04, Nov 2013
    288 + */
    289 +static void amd_disable_seq_and_redirect_scrub(struct pci_dev *dev)
    290 +{
    291 + u32 val;
    292 +
    293 + /*
    294 + * Suggested workaround:
    295 + * set D18F3x58[4:0] = 00h and set D18F3x5C[0] = 0b
    296 + */
    297 + pci_read_config_dword(dev, 0x58, &val);
    298 + if (val & 0x1F) {
    299 + val &= ~(0x1F);
    300 + pci_write_config_dword(dev, 0x58, val);
    301 + }
    302 +
    303 + pci_read_config_dword(dev, 0x5C, &val);
    304 + if (val & BIT(0)) {
    305 + val &= ~BIT(0);
    306 + pci_write_config_dword(dev, 0x5c, val);
    307 + }
    308 +}
    309 +
    310 +DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_16H_NB_F3,
    311 + amd_disable_seq_and_redirect_scrub);
    312 +
    313 +#endif
    314 diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
    315 index a55773801c5f..3aa89eb8dbbd 100644
    316 --- a/drivers/acpi/button.c
    317 +++ b/drivers/acpi/button.c
    318 @@ -302,6 +302,10 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
    319 input_sync(input);
    320
    321 pm_wakeup_event(&device->dev, 0);
    322 + acpi_bus_generate_netlink_event(
    323 + device->pnp.device_class,
    324 + dev_name(&device->dev),
    325 + event, ++button->pushed);
    326 }
    327 break;
    328 default:
    329 diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
    330 index 3cc0b92e3544..51b700838f64 100644
    331 --- a/drivers/acpi/ec.c
    332 +++ b/drivers/acpi/ec.c
    333 @@ -213,13 +213,13 @@ unlock:
    334 spin_unlock_irqrestore(&ec->lock, flags);
    335 }
    336
    337 -static int acpi_ec_sync_query(struct acpi_ec *ec);
    338 +static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data);
    339
    340 static int ec_check_sci_sync(struct acpi_ec *ec, u8 state)
    341 {
    342 if (state & ACPI_EC_FLAG_SCI) {
    343 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
    344 - return acpi_ec_sync_query(ec);
    345 + return acpi_ec_sync_query(ec, NULL);
    346 }
    347 return 0;
    348 }
    349 @@ -471,10 +471,8 @@ acpi_handle ec_get_handle(void)
    350
    351 EXPORT_SYMBOL(ec_get_handle);
    352
    353 -static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 *data);
    354 -
    355 /*
    356 - * Clears stale _Q events that might have accumulated in the EC.
    357 + * Process _Q events that might have accumulated in the EC.
    358 * Run with locked ec mutex.
    359 */
    360 static void acpi_ec_clear(struct acpi_ec *ec)
    361 @@ -483,7 +481,7 @@ static void acpi_ec_clear(struct acpi_ec *ec)
    362 u8 value = 0;
    363
    364 for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
    365 - status = acpi_ec_query_unlocked(ec, &value);
    366 + status = acpi_ec_sync_query(ec, &value);
    367 if (status || !value)
    368 break;
    369 }
    370 @@ -610,13 +608,18 @@ static void acpi_ec_run(void *cxt)
    371 kfree(handler);
    372 }
    373
    374 -static int acpi_ec_sync_query(struct acpi_ec *ec)
    375 +static int acpi_ec_sync_query(struct acpi_ec *ec, u8 *data)
    376 {
    377 u8 value = 0;
    378 int status;
    379 struct acpi_ec_query_handler *handler, *copy;
    380 - if ((status = acpi_ec_query_unlocked(ec, &value)))
    381 +
    382 + status = acpi_ec_query_unlocked(ec, &value);
    383 + if (data)
    384 + *data = value;
    385 + if (status)
    386 return status;
    387 +
    388 list_for_each_entry(handler, &ec->list, node) {
    389 if (value == handler->query_bit) {
    390 /* have custom handler for this bit */
    391 @@ -639,7 +642,7 @@ static void acpi_ec_gpe_query(void *ec_cxt)
    392 if (!ec)
    393 return;
    394 mutex_lock(&ec->mutex);
    395 - acpi_ec_sync_query(ec);
    396 + acpi_ec_sync_query(ec, NULL);
    397 mutex_unlock(&ec->mutex);
    398 }
    399
    400 diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
    401 index 99e5158456d8..c09e6f646fe4 100644
    402 --- a/drivers/acpi/sleep.c
    403 +++ b/drivers/acpi/sleep.c
    404 @@ -675,11 +675,8 @@ static void acpi_hibernation_leave(void)
    405 /* Reprogram control registers */
    406 acpi_leave_sleep_state_prep(ACPI_STATE_S4);
    407 /* Check the hardware signature */
    408 - if (facs && s4_hardware_signature != facs->hardware_signature) {
    409 - printk(KERN_EMERG "ACPI: Hardware changed while hibernated, "
    410 - "cannot resume!\n");
    411 - panic("ACPI S4 hardware signature mismatch");
    412 - }
    413 + if (facs && s4_hardware_signature != facs->hardware_signature)
    414 + pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
    415 /* Restore the NVS memory area */
    416 suspend_nvs_restore();
    417 /* Allow EC transactions to happen. */
    418 diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
    419 index d593c99121c3..6e30356d3e42 100644
    420 --- a/drivers/bluetooth/btusb.c
    421 +++ b/drivers/bluetooth/btusb.c
    422 @@ -223,6 +223,7 @@ static struct usb_device_id blacklist_table[] = {
    423
    424 /* Intel Bluetooth device */
    425 { USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },
    426 + { USB_DEVICE(0x8087, 0x0a2a), .driver_info = BTUSB_INTEL },
    427
    428 { } /* Terminating entry */
    429 };
    430 diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
    431 index 15e4a6031934..e5bdd1a2f541 100644
    432 --- a/drivers/char/ipmi/ipmi_si_intf.c
    433 +++ b/drivers/char/ipmi/ipmi_si_intf.c
    434 @@ -249,6 +249,9 @@ struct smi_info {
    435 /* The timer for this si. */
    436 struct timer_list si_timer;
    437
    438 + /* This flag is set, if the timer is running (timer_pending() isn't enough) */
    439 + bool timer_running;
    440 +
    441 /* The time (in jiffies) the last timeout occurred at. */
    442 unsigned long last_timeout_jiffies;
    443
    444 @@ -435,6 +438,13 @@ static void start_clear_flags(struct smi_info *smi_info)
    445 smi_info->si_state = SI_CLEARING_FLAGS;
    446 }
    447
    448 +static void smi_mod_timer(struct smi_info *smi_info, unsigned long new_val)
    449 +{
    450 + smi_info->last_timeout_jiffies = jiffies;
    451 + mod_timer(&smi_info->si_timer, new_val);
    452 + smi_info->timer_running = true;
    453 +}
    454 +
    455 /*
    456 * When we have a situtaion where we run out of memory and cannot
    457 * allocate messages, we just leave them in the BMC and run the system
    458 @@ -447,8 +457,7 @@ static inline void disable_si_irq(struct smi_info *smi_info)
    459 start_disable_irq(smi_info);
    460 smi_info->interrupt_disabled = 1;
    461 if (!atomic_read(&smi_info->stop_operation))
    462 - mod_timer(&smi_info->si_timer,
    463 - jiffies + SI_TIMEOUT_JIFFIES);
    464 + smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
    465 }
    466 }
    467
    468 @@ -908,15 +917,7 @@ static void sender(void *send_info,
    469 list_add_tail(&msg->link, &smi_info->xmit_msgs);
    470
    471 if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL) {
    472 - /*
    473 - * last_timeout_jiffies is updated here to avoid
    474 - * smi_timeout() handler passing very large time_diff
    475 - * value to smi_event_handler() that causes
    476 - * the send command to abort.
    477 - */
    478 - smi_info->last_timeout_jiffies = jiffies;
    479 -
    480 - mod_timer(&smi_info->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
    481 + smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
    482
    483 if (smi_info->thread)
    484 wake_up_process(smi_info->thread);
    485 @@ -1005,6 +1006,17 @@ static int ipmi_thread(void *data)
    486
    487 spin_lock_irqsave(&(smi_info->si_lock), flags);
    488 smi_result = smi_event_handler(smi_info, 0);
    489 +
    490 + /*
    491 + * If the driver is doing something, there is a possible
    492 + * race with the timer. If the timer handler see idle,
    493 + * and the thread here sees something else, the timer
    494 + * handler won't restart the timer even though it is
    495 + * required. So start it here if necessary.
    496 + */
    497 + if (smi_result != SI_SM_IDLE && !smi_info->timer_running)
    498 + smi_mod_timer(smi_info, jiffies + SI_TIMEOUT_JIFFIES);
    499 +
    500 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
    501 busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
    502 &busy_until);
    503 @@ -1074,10 +1086,6 @@ static void smi_timeout(unsigned long data)
    504 * SI_USEC_PER_JIFFY);
    505 smi_result = smi_event_handler(smi_info, time_diff);
    506
    507 - spin_unlock_irqrestore(&(smi_info->si_lock), flags);
    508 -
    509 - smi_info->last_timeout_jiffies = jiffies_now;
    510 -
    511 if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
    512 /* Running with interrupts, only do long timeouts. */
    513 timeout = jiffies + SI_TIMEOUT_JIFFIES;
    514 @@ -1099,7 +1107,10 @@ static void smi_timeout(unsigned long data)
    515
    516 do_mod_timer:
    517 if (smi_result != SI_SM_IDLE)
    518 - mod_timer(&(smi_info->si_timer), timeout);
    519 + smi_mod_timer(smi_info, timeout);
    520 + else
    521 + smi_info->timer_running = false;
    522 + spin_unlock_irqrestore(&(smi_info->si_lock), flags);
    523 }
    524
    525 static irqreturn_t si_irq_handler(int irq, void *data)
    526 @@ -1147,8 +1158,7 @@ static int smi_start_processing(void *send_info,
    527
    528 /* Set up the timer that drives the interface. */
    529 setup_timer(&new_smi->si_timer, smi_timeout, (long)new_smi);
    530 - new_smi->last_timeout_jiffies = jiffies;
    531 - mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
    532 + smi_mod_timer(new_smi, jiffies + SI_TIMEOUT_JIFFIES);
    533
    534 /*
    535 * Check if the user forcefully enabled the daemon.
    536 diff --git a/drivers/char/mem.c b/drivers/char/mem.c
    537 index f895a8c8a244..d1f4675809f8 100644
    538 --- a/drivers/char/mem.c
    539 +++ b/drivers/char/mem.c
    540 @@ -100,6 +100,9 @@ static ssize_t read_mem(struct file *file, char __user *buf,
    541 ssize_t read, sz;
    542 char *ptr;
    543
    544 + if (p != *ppos)
    545 + return 0;
    546 +
    547 if (!valid_phys_addr_range(p, count))
    548 return -EFAULT;
    549 read = 0;
    550 @@ -158,6 +161,9 @@ static ssize_t write_mem(struct file *file, const char __user *buf,
    551 unsigned long copied;
    552 void *ptr;
    553
    554 + if (p != *ppos)
    555 + return -EFBIG;
    556 +
    557 if (!valid_phys_addr_range(p, count))
    558 return -EFAULT;
    559
    560 diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
    561 index 3c9e4e98c651..d43a6202a5c5 100644
    562 --- a/drivers/edac/amd64_edac.c
    563 +++ b/drivers/edac/amd64_edac.c
    564 @@ -1238,9 +1238,17 @@ static u8 f15_m30h_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
    565 if (num_dcts_intlv == 2) {
    566 select = (sys_addr >> 8) & 0x3;
    567 channel = select ? 0x3 : 0;
    568 - } else if (num_dcts_intlv == 4)
    569 - channel = (sys_addr >> 8) & 0x7;
    570 -
    571 + } else if (num_dcts_intlv == 4) {
    572 + u8 intlv_addr = dct_sel_interleave_addr(pvt);
    573 + switch (intlv_addr) {
    574 + case 0x4:
    575 + channel = (sys_addr >> 8) & 0x3;
    576 + break;
    577 + case 0x5:
    578 + channel = (sys_addr >> 9) & 0x3;
    579 + break;
    580 + }
    581 + }
    582 return channel;
    583 }
    584
    585 diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
    586 index 4e901081e287..01892bdfa7b7 100644
    587 --- a/drivers/i2c/busses/Kconfig
    588 +++ b/drivers/i2c/busses/Kconfig
    589 @@ -110,6 +110,7 @@ config I2C_I801
    590 Wellsburg (PCH)
    591 Coleto Creek (PCH)
    592 Wildcat Point-LP (PCH)
    593 + BayTrail (SOC)
    594
    595 This driver can also be built as a module. If so, the module
    596 will be called i2c-i801.
    597 diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
    598 index 737e29866887..0444f7aa1046 100644
    599 --- a/drivers/i2c/busses/i2c-i801.c
    600 +++ b/drivers/i2c/busses/i2c-i801.c
    601 @@ -60,6 +60,7 @@
    602 Wellsburg (PCH) MS 0x8d7f 32 hard yes yes yes
    603 Coleto Creek (PCH) 0x23b0 32 hard yes yes yes
    604 Wildcat Point-LP (PCH) 0x9ca2 32 hard yes yes yes
    605 + BayTrail (SOC) 0x0f12 32 hard yes yes yes
    606
    607 Features supported by this driver:
    608 Software PEC no
    609 @@ -161,6 +162,7 @@
    610 STATUS_ERROR_FLAGS)
    611
    612 /* Older devices have their ID defined in <linux/pci_ids.h> */
    613 +#define PCI_DEVICE_ID_INTEL_BAYTRAIL_SMBUS 0x0f12
    614 #define PCI_DEVICE_ID_INTEL_COUGARPOINT_SMBUS 0x1c22
    615 #define PCI_DEVICE_ID_INTEL_PATSBURG_SMBUS 0x1d22
    616 /* Patsburg also has three 'Integrated Device Function' SMBus controllers */
    617 @@ -822,6 +824,7 @@ static DEFINE_PCI_DEVICE_TABLE(i801_ids) = {
    618 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WELLSBURG_SMBUS_MS2) },
    619 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_COLETOCREEK_SMBUS) },
    620 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_WILDCATPOINT_LP_SMBUS) },
    621 + { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BAYTRAIL_SMBUS) },
    622 { 0, }
    623 };
    624
    625 diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
    626 index 72531f008a5e..5d2edb4b60aa 100644
    627 --- a/drivers/iommu/amd_iommu.c
    628 +++ b/drivers/iommu/amd_iommu.c
    629 @@ -982,10 +982,10 @@ static void build_inv_iotlb_pasid(struct iommu_cmd *cmd, u16 devid, int pasid,
    630 address &= ~(0xfffULL);
    631
    632 cmd->data[0] = devid;
    633 - cmd->data[0] |= (pasid & 0xff) << 16;
    634 + cmd->data[0] |= ((pasid >> 8) & 0xff) << 16;
    635 cmd->data[0] |= (qdep & 0xff) << 24;
    636 cmd->data[1] = devid;
    637 - cmd->data[1] |= ((pasid >> 8) & 0xfff) << 16;
    638 + cmd->data[1] |= (pasid & 0xff) << 16;
    639 cmd->data[2] = lower_32_bits(address);
    640 cmd->data[2] |= CMD_INV_IOMMU_PAGES_GN_MASK;
    641 cmd->data[3] = upper_32_bits(address);
    642 diff --git a/drivers/net/ethernet/dec/tulip/tulip_core.c b/drivers/net/ethernet/dec/tulip/tulip_core.c
    643 index 4e8cfa2ac803..779016068a82 100644
    644 --- a/drivers/net/ethernet/dec/tulip/tulip_core.c
    645 +++ b/drivers/net/ethernet/dec/tulip/tulip_core.c
    646 @@ -1940,6 +1940,7 @@ static void tulip_remove_one(struct pci_dev *pdev)
    647 free_netdev (dev);
    648 pci_release_regions (pdev);
    649 pci_set_drvdata (pdev, NULL);
    650 + pci_disable_device(pdev);
    651
    652 /* pci_power_off (pdev, -1); */
    653 }
    654 diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
    655 index 4ef786775acb..9cb400c4cbaa 100644
    656 --- a/drivers/net/ethernet/intel/e1000e/netdev.c
    657 +++ b/drivers/net/ethernet/intel/e1000e/netdev.c
    658 @@ -2976,11 +2976,21 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
    659 u32 rctl, rfctl;
    660 u32 pages = 0;
    661
    662 - /* Workaround Si errata on PCHx - configure jumbo frame flow */
    663 - if ((hw->mac.type >= e1000_pch2lan) &&
    664 - (adapter->netdev->mtu > ETH_DATA_LEN) &&
    665 - e1000_lv_jumbo_workaround_ich8lan(hw, true))
    666 - e_dbg("failed to enable jumbo frame workaround mode\n");
    667 + /* Workaround Si errata on PCHx - configure jumbo frame flow.
    668 + * If jumbo frames not set, program related MAC/PHY registers
    669 + * to h/w defaults
    670 + */
    671 + if (hw->mac.type >= e1000_pch2lan) {
    672 + s32 ret_val;
    673 +
    674 + if (adapter->netdev->mtu > ETH_DATA_LEN)
    675 + ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, true);
    676 + else
    677 + ret_val = e1000_lv_jumbo_workaround_ich8lan(hw, false);
    678 +
    679 + if (ret_val)
    680 + e_dbg("failed to enable|disable jumbo frame workaround mode\n");
    681 + }
    682
    683 /* Program MC offset vector base */
    684 rctl = er32(RCTL);
    685 diff --git a/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c b/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
    686 index edc5d105ff98..03a56dfba2db 100644
    687 --- a/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
    688 +++ b/drivers/net/wireless/brcm80211/brcmsmac/mac80211_if.c
    689 @@ -426,6 +426,12 @@ static int brcms_ops_start(struct ieee80211_hw *hw)
    690 bool blocked;
    691 int err;
    692
    693 + if (!wl->ucode.bcm43xx_bomminor) {
    694 + err = brcms_request_fw(wl, wl->wlc->hw->d11core);
    695 + if (err)
    696 + return -ENOENT;
    697 + }
    698 +
    699 ieee80211_wake_queues(hw);
    700 spin_lock_bh(&wl->lock);
    701 blocked = brcms_rfkill_set_hw_state(wl);
    702 @@ -433,14 +439,6 @@ static int brcms_ops_start(struct ieee80211_hw *hw)
    703 if (!blocked)
    704 wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy);
    705
    706 - if (!wl->ucode.bcm43xx_bomminor) {
    707 - err = brcms_request_fw(wl, wl->wlc->hw->d11core);
    708 - if (err) {
    709 - brcms_remove(wl->wlc->hw->d11core);
    710 - return -ENOENT;
    711 - }
    712 - }
    713 -
    714 spin_lock_bh(&wl->lock);
    715 /* avoid acknowledging frames before a non-monitor device is added */
    716 wl->mute_tx = true;
    717 diff --git a/drivers/pci/host/pcie-designware.c b/drivers/pci/host/pcie-designware.c
    718 index c10e9ac9bbbc..510994a7eca0 100644
    719 --- a/drivers/pci/host/pcie-designware.c
    720 +++ b/drivers/pci/host/pcie-designware.c
    721 @@ -268,13 +268,13 @@ static void dw_pcie_prog_viewport_cfg1(struct pcie_port *pp, u32 busdev)
    722 dw_pcie_writel_rc(pp, PCIE_ATU_REGION_OUTBOUND | PCIE_ATU_REGION_INDEX1,
    723 PCIE_ATU_VIEWPORT);
    724 dw_pcie_writel_rc(pp, PCIE_ATU_TYPE_CFG1, PCIE_ATU_CR1);
    725 - dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
    726 dw_pcie_writel_rc(pp, pp->cfg1_base, PCIE_ATU_LOWER_BASE);
    727 dw_pcie_writel_rc(pp, (pp->cfg1_base >> 32), PCIE_ATU_UPPER_BASE);
    728 dw_pcie_writel_rc(pp, pp->cfg1_base + pp->config.cfg1_size - 1,
    729 PCIE_ATU_LIMIT);
    730 dw_pcie_writel_rc(pp, busdev, PCIE_ATU_LOWER_TARGET);
    731 dw_pcie_writel_rc(pp, 0, PCIE_ATU_UPPER_TARGET);
    732 + dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
    733 }
    734
    735 static void dw_pcie_prog_viewport_mem_outbound(struct pcie_port *pp)
    736 @@ -283,7 +283,6 @@ static void dw_pcie_prog_viewport_mem_outbound(struct pcie_port *pp)
    737 dw_pcie_writel_rc(pp, PCIE_ATU_REGION_OUTBOUND | PCIE_ATU_REGION_INDEX0,
    738 PCIE_ATU_VIEWPORT);
    739 dw_pcie_writel_rc(pp, PCIE_ATU_TYPE_MEM, PCIE_ATU_CR1);
    740 - dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
    741 dw_pcie_writel_rc(pp, pp->mem_base, PCIE_ATU_LOWER_BASE);
    742 dw_pcie_writel_rc(pp, (pp->mem_base >> 32), PCIE_ATU_UPPER_BASE);
    743 dw_pcie_writel_rc(pp, pp->mem_base + pp->config.mem_size - 1,
    744 @@ -291,6 +290,7 @@ static void dw_pcie_prog_viewport_mem_outbound(struct pcie_port *pp)
    745 dw_pcie_writel_rc(pp, pp->config.mem_bus_addr, PCIE_ATU_LOWER_TARGET);
    746 dw_pcie_writel_rc(pp, upper_32_bits(pp->config.mem_bus_addr),
    747 PCIE_ATU_UPPER_TARGET);
    748 + dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
    749 }
    750
    751 static void dw_pcie_prog_viewport_io_outbound(struct pcie_port *pp)
    752 @@ -299,7 +299,6 @@ static void dw_pcie_prog_viewport_io_outbound(struct pcie_port *pp)
    753 dw_pcie_writel_rc(pp, PCIE_ATU_REGION_OUTBOUND | PCIE_ATU_REGION_INDEX1,
    754 PCIE_ATU_VIEWPORT);
    755 dw_pcie_writel_rc(pp, PCIE_ATU_TYPE_IO, PCIE_ATU_CR1);
    756 - dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
    757 dw_pcie_writel_rc(pp, pp->io_base, PCIE_ATU_LOWER_BASE);
    758 dw_pcie_writel_rc(pp, (pp->io_base >> 32), PCIE_ATU_UPPER_BASE);
    759 dw_pcie_writel_rc(pp, pp->io_base + pp->config.io_size - 1,
    760 @@ -307,6 +306,7 @@ static void dw_pcie_prog_viewport_io_outbound(struct pcie_port *pp)
    761 dw_pcie_writel_rc(pp, pp->config.io_bus_addr, PCIE_ATU_LOWER_TARGET);
    762 dw_pcie_writel_rc(pp, upper_32_bits(pp->config.io_bus_addr),
    763 PCIE_ATU_UPPER_TARGET);
    764 + dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2);
    765 }
    766
    767 static int dw_pcie_rd_other_conf(struct pcie_port *pp, struct pci_bus *bus,
    768 @@ -532,7 +532,7 @@ void dw_pcie_setup_rc(struct pcie_port *pp)
    769
    770 /* setup RC BARs */
    771 dw_pcie_writel_rc(pp, 0x00000004, PCI_BASE_ADDRESS_0);
    772 - dw_pcie_writel_rc(pp, 0x00000004, PCI_BASE_ADDRESS_1);
    773 + dw_pcie_writel_rc(pp, 0x00000000, PCI_BASE_ADDRESS_1);
    774
    775 /* setup interrupt pins */
    776 dw_pcie_readl_rc(pp, PCI_INTERRUPT_LINE, &val);
    777 diff --git a/drivers/staging/comedi/drivers/8255_pci.c b/drivers/staging/comedi/drivers/8255_pci.c
    778 index c55f234b29e6..26321f9f5caf 100644
    779 --- a/drivers/staging/comedi/drivers/8255_pci.c
    780 +++ b/drivers/staging/comedi/drivers/8255_pci.c
    781 @@ -56,6 +56,7 @@ Configuration Options: not applicable, uses PCI auto config
    782 #include "../comedidev.h"
    783
    784 #include "8255.h"
    785 +#include "mite.h"
    786
    787 enum pci_8255_boardid {
    788 BOARD_ADLINK_PCI7224,
    789 @@ -79,6 +80,7 @@ struct pci_8255_boardinfo {
    790 const char *name;
    791 int dio_badr;
    792 int n_8255;
    793 + unsigned int has_mite:1;
    794 };
    795
    796 static const struct pci_8255_boardinfo pci_8255_boards[] = {
    797 @@ -126,36 +128,43 @@ static const struct pci_8255_boardinfo pci_8255_boards[] = {
    798 .name = "ni_pci-dio-96",
    799 .dio_badr = 1,
    800 .n_8255 = 4,
    801 + .has_mite = 1,
    802 },
    803 [BOARD_NI_PCIDIO96B] = {
    804 .name = "ni_pci-dio-96b",
    805 .dio_badr = 1,
    806 .n_8255 = 4,
    807 + .has_mite = 1,
    808 },
    809 [BOARD_NI_PXI6508] = {
    810 .name = "ni_pxi-6508",
    811 .dio_badr = 1,
    812 .n_8255 = 4,
    813 + .has_mite = 1,
    814 },
    815 [BOARD_NI_PCI6503] = {
    816 .name = "ni_pci-6503",
    817 .dio_badr = 1,
    818 .n_8255 = 1,
    819 + .has_mite = 1,
    820 },
    821 [BOARD_NI_PCI6503B] = {
    822 .name = "ni_pci-6503b",
    823 .dio_badr = 1,
    824 .n_8255 = 1,
    825 + .has_mite = 1,
    826 },
    827 [BOARD_NI_PCI6503X] = {
    828 .name = "ni_pci-6503x",
    829 .dio_badr = 1,
    830 .n_8255 = 1,
    831 + .has_mite = 1,
    832 },
    833 [BOARD_NI_PXI_6503] = {
    834 .name = "ni_pxi-6503",
    835 .dio_badr = 1,
    836 .n_8255 = 1,
    837 + .has_mite = 1,
    838 },
    839 };
    840
    841 @@ -163,6 +172,25 @@ struct pci_8255_private {
    842 void __iomem *mmio_base;
    843 };
    844
    845 +static int pci_8255_mite_init(struct pci_dev *pcidev)
    846 +{
    847 + void __iomem *mite_base;
    848 + u32 main_phys_addr;
    849 +
    850 + /* ioremap the MITE registers (BAR 0) temporarily */
    851 + mite_base = pci_ioremap_bar(pcidev, 0);
    852 + if (!mite_base)
    853 + return -ENOMEM;
    854 +
    855 + /* set data window to main registers (BAR 1) */
    856 + main_phys_addr = pci_resource_start(pcidev, 1);
    857 + writel(main_phys_addr | WENAB, mite_base + MITE_IODWBSR);
    858 +
    859 + /* finished with MITE registers */
    860 + iounmap(mite_base);
    861 + return 0;
    862 +}
    863 +
    864 static int pci_8255_mmio(int dir, int port, int data, unsigned long iobase)
    865 {
    866 void __iomem *mmio_base = (void __iomem *)iobase;
    867 @@ -201,6 +229,12 @@ static int pci_8255_auto_attach(struct comedi_device *dev,
    868 if (ret)
    869 return ret;
    870
    871 + if (board->has_mite) {
    872 + ret = pci_8255_mite_init(pcidev);
    873 + if (ret)
    874 + return ret;
    875 + }
    876 +
    877 is_mmio = (pci_resource_flags(pcidev, board->dio_badr) &
    878 IORESOURCE_MEM) != 0;
    879 if (is_mmio) {
    880 diff --git a/drivers/tty/ipwireless/tty.c b/drivers/tty/ipwireless/tty.c
    881 index 8fd72ff9436e..d917a34e94bb 100644
    882 --- a/drivers/tty/ipwireless/tty.c
    883 +++ b/drivers/tty/ipwireless/tty.c
    884 @@ -177,9 +177,6 @@ void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
    885 ": %d chars not inserted to flip buffer!\n",
    886 length - work);
    887
    888 - /*
    889 - * This may sleep if ->low_latency is set
    890 - */
    891 if (work)
    892 tty_flip_buffer_push(&tty->port);
    893 }
    894 diff --git a/drivers/tty/tty_buffer.c b/drivers/tty/tty_buffer.c
    895 index c043136fbe51..2b52d807934e 100644
    896 --- a/drivers/tty/tty_buffer.c
    897 +++ b/drivers/tty/tty_buffer.c
    898 @@ -332,14 +332,11 @@ EXPORT_SYMBOL(tty_insert_flip_string_flags);
    899 * Takes any pending buffers and transfers their ownership to the
    900 * ldisc side of the queue. It then schedules those characters for
    901 * processing by the line discipline.
    902 - * Note that this function can only be used when the low_latency flag
    903 - * is unset. Otherwise the workqueue won't be flushed.
    904 */
    905
    906 void tty_schedule_flip(struct tty_port *port)
    907 {
    908 struct tty_bufhead *buf = &port->buf;
    909 - WARN_ON(port->low_latency);
    910
    911 buf->tail->commit = buf->tail->used;
    912 schedule_work(&buf->work);
    913 @@ -487,17 +484,15 @@ static void flush_to_ldisc(struct work_struct *work)
    914 */
    915 void tty_flush_to_ldisc(struct tty_struct *tty)
    916 {
    917 - if (!tty->port->low_latency)
    918 - flush_work(&tty->port->buf.work);
    919 + flush_work(&tty->port->buf.work);
    920 }
    921
    922 /**
    923 * tty_flip_buffer_push - terminal
    924 * @port: tty port to push
    925 *
    926 - * Queue a push of the terminal flip buffers to the line discipline. This
    927 - * function must not be called from IRQ context if port->low_latency is
    928 - * set.
    929 + * Queue a push of the terminal flip buffers to the line discipline.
    930 + * Can be called from IRQ/atomic context.
    931 *
    932 * In the event of the queue being busy for flipping the work will be
    933 * held off and retried later.
    934 @@ -505,14 +500,7 @@ void tty_flush_to_ldisc(struct tty_struct *tty)
    935
    936 void tty_flip_buffer_push(struct tty_port *port)
    937 {
    938 - struct tty_bufhead *buf = &port->buf;
    939 -
    940 - buf->tail->commit = buf->tail->used;
    941 -
    942 - if (port->low_latency)
    943 - flush_to_ldisc(&buf->work);
    944 - else
    945 - schedule_work(&buf->work);
    946 + tty_schedule_flip(port);
    947 }
    948 EXPORT_SYMBOL(tty_flip_buffer_push);
    949
    950 diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
    951 index c74a00ad7add..d3448a90f0f9 100644
    952 --- a/drivers/tty/tty_io.c
    953 +++ b/drivers/tty/tty_io.c
    954 @@ -1271,12 +1271,13 @@ static void pty_line_name(struct tty_driver *driver, int index, char *p)
    955 *
    956 * Locking: None
    957 */
    958 -static void tty_line_name(struct tty_driver *driver, int index, char *p)
    959 +static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
    960 {
    961 if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
    962 - strcpy(p, driver->name);
    963 + return sprintf(p, "%s", driver->name);
    964 else
    965 - sprintf(p, "%s%d", driver->name, index + driver->name_base);
    966 + return sprintf(p, "%s%d", driver->name,
    967 + index + driver->name_base);
    968 }
    969
    970 /**
    971 @@ -3545,9 +3546,19 @@ static ssize_t show_cons_active(struct device *dev,
    972 if (i >= ARRAY_SIZE(cs))
    973 break;
    974 }
    975 - while (i--)
    976 - count += sprintf(buf + count, "%s%d%c",
    977 - cs[i]->name, cs[i]->index, i ? ' ':'\n');
    978 + while (i--) {
    979 + int index = cs[i]->index;
    980 + struct tty_driver *drv = cs[i]->device(cs[i], &index);
    981 +
    982 + /* don't resolve tty0 as some programs depend on it */
    983 + if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
    984 + count += tty_line_name(drv, index, buf + count);
    985 + else
    986 + count += sprintf(buf + count, "%s%d",
    987 + cs[i]->name, cs[i]->index);
    988 +
    989 + count += sprintf(buf + count, "%c", i ? ' ':'\n');
    990 + }
    991 console_unlock();
    992
    993 return count;
    994 diff --git a/drivers/usb/atm/usbatm.h b/drivers/usb/atm/usbatm.h
    995 index 5651231a7437..f3eecd967a8a 100644
    996 --- a/drivers/usb/atm/usbatm.h
    997 +++ b/drivers/usb/atm/usbatm.h
    998 @@ -34,6 +34,7 @@
    999 #include <linux/stringify.h>
    1000 #include <linux/usb.h>
    1001 #include <linux/mutex.h>
    1002 +#include <linux/ratelimit.h>
    1003
    1004 /*
    1005 #define VERBOSE_DEBUG
    1006 @@ -59,13 +60,12 @@
    1007 atm_printk(KERN_INFO, instance , format , ## arg)
    1008 #define atm_warn(instance, format, arg...) \
    1009 atm_printk(KERN_WARNING, instance , format , ## arg)
    1010 -#define atm_dbg(instance, format, arg...) \
    1011 - dynamic_pr_debug("ATM dev %d: " format , \
    1012 - (instance)->atm_dev->number , ## arg)
    1013 -#define atm_rldbg(instance, format, arg...) \
    1014 - if (printk_ratelimit()) \
    1015 - atm_dbg(instance , format , ## arg)
    1016 -
    1017 +#define atm_dbg(instance, format, ...) \
    1018 + pr_debug("ATM dev %d: " format, \
    1019 + (instance)->atm_dev->number, ##__VA_ARGS__)
    1020 +#define atm_rldbg(instance, format, ...) \
    1021 + pr_debug_ratelimited("ATM dev %d: " format, \
    1022 + (instance)->atm_dev->number, ##__VA_ARGS__)
    1023
    1024 /* flags, set by mini-driver in bind() */
    1025
    1026 diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
    1027 index b369292d4b90..ad0aca812002 100644
    1028 --- a/drivers/usb/gadget/u_serial.c
    1029 +++ b/drivers/usb/gadget/u_serial.c
    1030 @@ -549,8 +549,8 @@ static void gs_rx_push(unsigned long _port)
    1031 port->read_started--;
    1032 }
    1033
    1034 - /* Push from tty to ldisc; without low_latency set this is handled by
    1035 - * a workqueue, so we won't get callbacks and can hold port_lock
    1036 + /* Push from tty to ldisc; this is handled by a workqueue,
    1037 + * so we won't get callbacks and can hold port_lock
    1038 */
    1039 if (do_push)
    1040 tty_flip_buffer_push(&port->port);
    1041 diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
    1042 index 1f572c00a1be..cfda0a6c07a7 100644
    1043 --- a/drivers/virtio/virtio_balloon.c
    1044 +++ b/drivers/virtio/virtio_balloon.c
    1045 @@ -312,6 +312,12 @@ static int balloon(void *_vballoon)
    1046 else if (diff < 0)
    1047 leak_balloon(vb, -diff);
    1048 update_balloon_size(vb);
    1049 +
    1050 + /*
    1051 + * For large balloon changes, we could spend a lot of time
    1052 + * and always have work to do. Be nice if preempt disabled.
    1053 + */
    1054 + cond_resched();
    1055 }
    1056 return 0;
    1057 }
    1058 diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
    1059 index 62176ad89846..84d590a9e4ad 100644
    1060 --- a/fs/btrfs/disk-io.c
    1061 +++ b/fs/btrfs/disk-io.c
    1062 @@ -3246,6 +3246,8 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
    1063 /* send down all the barriers */
    1064 head = &info->fs_devices->devices;
    1065 list_for_each_entry_rcu(dev, head, dev_list) {
    1066 + if (dev->missing)
    1067 + continue;
    1068 if (!dev->bdev) {
    1069 errors_send++;
    1070 continue;
    1071 @@ -3260,6 +3262,8 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
    1072
    1073 /* wait for all the barriers */
    1074 list_for_each_entry_rcu(dev, head, dev_list) {
    1075 + if (dev->missing)
    1076 + continue;
    1077 if (!dev->bdev) {
    1078 errors_wait++;
    1079 continue;
    1080 diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
    1081 index b791cfb9a050..25d64e8e8e47 100644
    1082 --- a/fs/btrfs/transaction.c
    1083 +++ b/fs/btrfs/transaction.c
    1084 @@ -663,7 +663,8 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
    1085 int lock = (trans->type != TRANS_JOIN_NOLOCK);
    1086 int err = 0;
    1087
    1088 - if (--trans->use_count) {
    1089 + if (trans->use_count > 1) {
    1090 + trans->use_count--;
    1091 trans->block_rsv = trans->orig_rsv;
    1092 return 0;
    1093 }
    1094 @@ -711,17 +712,10 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
    1095 }
    1096
    1097 if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) {
    1098 - if (throttle) {
    1099 - /*
    1100 - * We may race with somebody else here so end up having
    1101 - * to call end_transaction on ourselves again, so inc
    1102 - * our use_count.
    1103 - */
    1104 - trans->use_count++;
    1105 + if (throttle)
    1106 return btrfs_commit_transaction(trans, root);
    1107 - } else {
    1108 + else
    1109 wake_up_process(info->transaction_kthread);
    1110 - }
    1111 }
    1112
    1113 if (trans->type & __TRANS_FREEZABLE)
    1114 diff --git a/fs/dcache.c b/fs/dcache.c
    1115 index 30b38e23caa7..8ef74f3d8fe5 100644
    1116 --- a/fs/dcache.c
    1117 +++ b/fs/dcache.c
    1118 @@ -2893,6 +2893,7 @@ static int prepend_path(const struct path *path,
    1119 restart:
    1120 bptr = *buffer;
    1121 blen = *buflen;
    1122 + error = 0;
    1123 dentry = path->dentry;
    1124 vfsmnt = path->mnt;
    1125 mnt = real_mount(vfsmnt);
    1126 @@ -3121,19 +3122,22 @@ char *simple_dname(struct dentry *dentry, char *buffer, int buflen)
    1127 /*
    1128 * Write full pathname from the root of the filesystem into the buffer.
    1129 */
    1130 -static char *__dentry_path(struct dentry *dentry, char *buf, int buflen)
    1131 +static char *__dentry_path(struct dentry *d, char *buf, int buflen)
    1132 {
    1133 + struct dentry *dentry;
    1134 char *end, *retval;
    1135 int len, seq = 0;
    1136 int error = 0;
    1137
    1138 + if (buflen < 2)
    1139 + goto Elong;
    1140 +
    1141 rcu_read_lock();
    1142 restart:
    1143 + dentry = d;
    1144 end = buf + buflen;
    1145 len = buflen;
    1146 prepend(&end, &len, "\0", 1);
    1147 - if (buflen < 1)
    1148 - goto Elong;
    1149 /* Get '/' right */
    1150 retval = end-1;
    1151 *retval = '/';
    1152 diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
    1153 index e678549ec994..8dd96591b2f8 100644
    1154 --- a/fs/ext4/extents.c
    1155 +++ b/fs/ext4/extents.c
    1156 @@ -2616,6 +2616,27 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
    1157 ex_ee_block = le32_to_cpu(ex->ee_block);
    1158 ex_ee_len = ext4_ext_get_actual_len(ex);
    1159
    1160 + /*
    1161 + * If we're starting with an extent other than the last one in the
    1162 + * node, we need to see if it shares a cluster with the extent to
    1163 + * the right (towards the end of the file). If its leftmost cluster
    1164 + * is this extent's rightmost cluster and it is not cluster aligned,
    1165 + * we'll mark it as a partial that is not to be deallocated.
    1166 + */
    1167 +
    1168 + if (ex != EXT_LAST_EXTENT(eh)) {
    1169 + ext4_fsblk_t current_pblk, right_pblk;
    1170 + long long current_cluster, right_cluster;
    1171 +
    1172 + current_pblk = ext4_ext_pblock(ex) + ex_ee_len - 1;
    1173 + current_cluster = (long long)EXT4_B2C(sbi, current_pblk);
    1174 + right_pblk = ext4_ext_pblock(ex + 1);
    1175 + right_cluster = (long long)EXT4_B2C(sbi, right_pblk);
    1176 + if (current_cluster == right_cluster &&
    1177 + EXT4_PBLK_COFF(sbi, right_pblk))
    1178 + *partial_cluster = -right_cluster;
    1179 + }
    1180 +
    1181 trace_ext4_ext_rm_leaf(inode, start, ex, *partial_cluster);
    1182
    1183 while (ex >= EXT_FIRST_EXTENT(eh) &&
    1184 @@ -2741,10 +2762,15 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
    1185 err = ext4_ext_correct_indexes(handle, inode, path);
    1186
    1187 /*
    1188 - * Free the partial cluster only if the current extent does not
    1189 - * reference it. Otherwise we might free used cluster.
    1190 + * If there's a partial cluster and at least one extent remains in
    1191 + * the leaf, free the partial cluster if it isn't shared with the
    1192 + * current extent. If there's a partial cluster and no extents
    1193 + * remain in the leaf, it can't be freed here. It can only be
    1194 + * freed when it's possible to determine if it's not shared with
    1195 + * any other extent - when the next leaf is processed or when space
    1196 + * removal is complete.
    1197 */
    1198 - if (*partial_cluster > 0 &&
    1199 + if (*partial_cluster > 0 && eh->eh_entries &&
    1200 (EXT4_B2C(sbi, ext4_ext_pblock(ex) + ex_ee_len - 1) !=
    1201 *partial_cluster)) {
    1202 int flags = get_default_free_blocks_flags(inode);
    1203 @@ -4159,7 +4185,7 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
    1204 struct ext4_extent newex, *ex, *ex2;
    1205 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
    1206 ext4_fsblk_t newblock = 0;
    1207 - int free_on_err = 0, err = 0, depth;
    1208 + int free_on_err = 0, err = 0, depth, ret;
    1209 unsigned int allocated = 0, offset = 0;
    1210 unsigned int allocated_clusters = 0;
    1211 struct ext4_allocation_request ar;
    1212 @@ -4220,9 +4246,13 @@ int ext4_ext_map_blocks(handle_t *handle, struct inode *inode,
    1213 if (!ext4_ext_is_uninitialized(ex))
    1214 goto out;
    1215
    1216 - allocated = ext4_ext_handle_uninitialized_extents(
    1217 + ret = ext4_ext_handle_uninitialized_extents(
    1218 handle, inode, map, path, flags,
    1219 allocated, newblock);
    1220 + if (ret < 0)
    1221 + err = ret;
    1222 + else
    1223 + allocated = ret;
    1224 goto out3;
    1225 }
    1226 }
    1227 diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
    1228 index 3595180b62ac..5bbec31440a4 100644
    1229 --- a/fs/fs-writeback.c
    1230 +++ b/fs/fs-writeback.c
    1231 @@ -88,16 +88,29 @@ static inline struct inode *wb_inode(struct list_head *head)
    1232 #define CREATE_TRACE_POINTS
    1233 #include <trace/events/writeback.h>
    1234
    1235 +static void bdi_wakeup_thread(struct backing_dev_info *bdi)
    1236 +{
    1237 + spin_lock_bh(&bdi->wb_lock);
    1238 + if (test_bit(BDI_registered, &bdi->state))
    1239 + mod_delayed_work(bdi_wq, &bdi->wb.dwork, 0);
    1240 + spin_unlock_bh(&bdi->wb_lock);
    1241 +}
    1242 +
    1243 static void bdi_queue_work(struct backing_dev_info *bdi,
    1244 struct wb_writeback_work *work)
    1245 {
    1246 trace_writeback_queue(bdi, work);
    1247
    1248 spin_lock_bh(&bdi->wb_lock);
    1249 + if (!test_bit(BDI_registered, &bdi->state)) {
    1250 + if (work->done)
    1251 + complete(work->done);
    1252 + goto out_unlock;
    1253 + }
    1254 list_add_tail(&work->list, &bdi->work_list);
    1255 - spin_unlock_bh(&bdi->wb_lock);
    1256 -
    1257 mod_delayed_work(bdi_wq, &bdi->wb.dwork, 0);
    1258 +out_unlock:
    1259 + spin_unlock_bh(&bdi->wb_lock);
    1260 }
    1261
    1262 static void
    1263 @@ -113,7 +126,7 @@ __bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages,
    1264 work = kzalloc(sizeof(*work), GFP_ATOMIC);
    1265 if (!work) {
    1266 trace_writeback_nowork(bdi);
    1267 - mod_delayed_work(bdi_wq, &bdi->wb.dwork, 0);
    1268 + bdi_wakeup_thread(bdi);
    1269 return;
    1270 }
    1271
    1272 @@ -160,7 +173,7 @@ void bdi_start_background_writeback(struct backing_dev_info *bdi)
    1273 * writeback as soon as there is no other work to do.
    1274 */
    1275 trace_writeback_wake_background(bdi);
    1276 - mod_delayed_work(bdi_wq, &bdi->wb.dwork, 0);
    1277 + bdi_wakeup_thread(bdi);
    1278 }
    1279
    1280 /*
    1281 @@ -1016,7 +1029,7 @@ void bdi_writeback_workfn(struct work_struct *work)
    1282 current->flags |= PF_SWAPWRITE;
    1283
    1284 if (likely(!current_is_workqueue_rescuer() ||
    1285 - list_empty(&bdi->bdi_list))) {
    1286 + !test_bit(BDI_registered, &bdi->state))) {
    1287 /*
    1288 * The normal path. Keep writing back @bdi until its
    1289 * work_list is empty. Note that this path is also taken
    1290 @@ -1038,10 +1051,10 @@ void bdi_writeback_workfn(struct work_struct *work)
    1291 trace_writeback_pages_written(pages_written);
    1292 }
    1293
    1294 - if (!list_empty(&bdi->work_list) ||
    1295 - (wb_has_dirty_io(wb) && dirty_writeback_interval))
    1296 - queue_delayed_work(bdi_wq, &wb->dwork,
    1297 - msecs_to_jiffies(dirty_writeback_interval * 10));
    1298 + if (!list_empty(&bdi->work_list))
    1299 + mod_delayed_work(bdi_wq, &wb->dwork, 0);
    1300 + else if (wb_has_dirty_io(wb) && dirty_writeback_interval)
    1301 + bdi_wakeup_thread_delayed(bdi);
    1302
    1303 current->flags &= ~PF_SWAPWRITE;
    1304 }
    1305 diff --git a/fs/jffs2/compr_rtime.c b/fs/jffs2/compr_rtime.c
    1306 index 16a5047903a6..406d9cc84ba8 100644
    1307 --- a/fs/jffs2/compr_rtime.c
    1308 +++ b/fs/jffs2/compr_rtime.c
    1309 @@ -33,7 +33,7 @@ static int jffs2_rtime_compress(unsigned char *data_in,
    1310 unsigned char *cpage_out,
    1311 uint32_t *sourcelen, uint32_t *dstlen)
    1312 {
    1313 - short positions[256];
    1314 + unsigned short positions[256];
    1315 int outpos = 0;
    1316 int pos=0;
    1317
    1318 @@ -74,7 +74,7 @@ static int jffs2_rtime_decompress(unsigned char *data_in,
    1319 unsigned char *cpage_out,
    1320 uint32_t srclen, uint32_t destlen)
    1321 {
    1322 - short positions[256];
    1323 + unsigned short positions[256];
    1324 int outpos = 0;
    1325 int pos=0;
    1326
    1327 diff --git a/fs/jffs2/nodelist.h b/fs/jffs2/nodelist.h
    1328 index e4619b00f7c5..fa35ff79ab35 100644
    1329 --- a/fs/jffs2/nodelist.h
    1330 +++ b/fs/jffs2/nodelist.h
    1331 @@ -231,7 +231,7 @@ struct jffs2_tmp_dnode_info
    1332 uint32_t version;
    1333 uint32_t data_crc;
    1334 uint32_t partial_crc;
    1335 - uint16_t csize;
    1336 + uint32_t csize;
    1337 uint16_t overlapped;
    1338 };
    1339
    1340 diff --git a/fs/jffs2/nodemgmt.c b/fs/jffs2/nodemgmt.c
    1341 index 03310721712f..b6bd4affd9ad 100644
    1342 --- a/fs/jffs2/nodemgmt.c
    1343 +++ b/fs/jffs2/nodemgmt.c
    1344 @@ -179,6 +179,7 @@ int jffs2_reserve_space(struct jffs2_sb_info *c, uint32_t minsize,
    1345 spin_unlock(&c->erase_completion_lock);
    1346
    1347 schedule();
    1348 + remove_wait_queue(&c->erase_wait, &wait);
    1349 } else
    1350 spin_unlock(&c->erase_completion_lock);
    1351 } else if (ret)
    1352 @@ -211,20 +212,25 @@ out:
    1353 int jffs2_reserve_space_gc(struct jffs2_sb_info *c, uint32_t minsize,
    1354 uint32_t *len, uint32_t sumsize)
    1355 {
    1356 - int ret = -EAGAIN;
    1357 + int ret;
    1358 minsize = PAD(minsize);
    1359
    1360 jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize);
    1361
    1362 - spin_lock(&c->erase_completion_lock);
    1363 - while(ret == -EAGAIN) {
    1364 + while (true) {
    1365 + spin_lock(&c->erase_completion_lock);
    1366 ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
    1367 if (ret) {
    1368 jffs2_dbg(1, "%s(): looping, ret is %d\n",
    1369 __func__, ret);
    1370 }
    1371 + spin_unlock(&c->erase_completion_lock);
    1372 +
    1373 + if (ret == -EAGAIN)
    1374 + cond_resched();
    1375 + else
    1376 + break;
    1377 }
    1378 - spin_unlock(&c->erase_completion_lock);
    1379 if (!ret)
    1380 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
    1381
    1382 diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
    1383 index 20bf8e8002d6..a6fcbd220f6b 100644
    1384 --- a/fs/xfs/xfs_da_btree.c
    1385 +++ b/fs/xfs/xfs_da_btree.c
    1386 @@ -1335,7 +1335,7 @@ xfs_da3_fixhashpath(
    1387 node = blk->bp->b_addr;
    1388 xfs_da3_node_hdr_from_disk(&nodehdr, node);
    1389 btree = xfs_da3_node_tree_p(node);
    1390 - if (be32_to_cpu(btree->hashval) == lasthash)
    1391 + if (be32_to_cpu(btree[blk->index].hashval) == lasthash)
    1392 break;
    1393 blk->hashval = lasthash;
    1394 btree[blk->index].hashval = cpu_to_be32(lasthash);
    1395 diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
    1396 index 5f66d519a726..a4cf599ecfc8 100644
    1397 --- a/include/linux/backing-dev.h
    1398 +++ b/include/linux/backing-dev.h
    1399 @@ -95,7 +95,7 @@ struct backing_dev_info {
    1400 unsigned int max_ratio, max_prop_frac;
    1401
    1402 struct bdi_writeback wb; /* default writeback info for this bdi */
    1403 - spinlock_t wb_lock; /* protects work_list */
    1404 + spinlock_t wb_lock; /* protects work_list & wb.dwork scheduling */
    1405
    1406 struct list_head work_list;
    1407
    1408 diff --git a/include/linux/printk.h b/include/linux/printk.h
    1409 index e6131a782481..694925837a16 100644
    1410 --- a/include/linux/printk.h
    1411 +++ b/include/linux/printk.h
    1412 @@ -233,6 +233,8 @@ extern asmlinkage void dump_stack(void) __cold;
    1413 no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
    1414 #endif
    1415
    1416 +#include <linux/dynamic_debug.h>
    1417 +
    1418 /* If you are writing a driver, please use dev_dbg instead */
    1419 #if defined(CONFIG_DYNAMIC_DEBUG)
    1420 /* dynamic_pr_debug() uses pr_fmt() internally so we don't need it here */
    1421 @@ -343,7 +345,19 @@ extern asmlinkage void dump_stack(void) __cold;
    1422 #endif
    1423
    1424 /* If you are writing a driver, please use dev_dbg instead */
    1425 -#if defined(DEBUG)
    1426 +#if defined(CONFIG_DYNAMIC_DEBUG)
    1427 +/* descriptor check is first to prevent flooding with "callbacks suppressed" */
    1428 +#define pr_debug_ratelimited(fmt, ...) \
    1429 +do { \
    1430 + static DEFINE_RATELIMIT_STATE(_rs, \
    1431 + DEFAULT_RATELIMIT_INTERVAL, \
    1432 + DEFAULT_RATELIMIT_BURST); \
    1433 + DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
    1434 + if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \
    1435 + __ratelimit(&_rs)) \
    1436 + __dynamic_pr_debug(&descriptor, fmt, ##__VA_ARGS__); \
    1437 +} while (0)
    1438 +#elif defined(DEBUG)
    1439 #define pr_debug_ratelimited(fmt, ...) \
    1440 printk_ratelimited(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
    1441 #else
    1442 diff --git a/include/linux/tty.h b/include/linux/tty.h
    1443 index 64f864651d86..96c23247a332 100644
    1444 --- a/include/linux/tty.h
    1445 +++ b/include/linux/tty.h
    1446 @@ -203,7 +203,7 @@ struct tty_port {
    1447 wait_queue_head_t delta_msr_wait; /* Modem status change */
    1448 unsigned long flags; /* TTY flags ASY_*/
    1449 unsigned char console:1, /* port is a console */
    1450 - low_latency:1; /* direct buffer flush */
    1451 + low_latency:1; /* optional: tune for latency */
    1452 struct mutex mutex; /* Locking */
    1453 struct mutex buf_mutex; /* Buffer alloc lock */
    1454 unsigned char *xmit_buf; /* Optional buffer */
    1455 diff --git a/kernel/exit.c b/kernel/exit.c
    1456 index a949819055d5..dcde2c4b61d0 100644
    1457 --- a/kernel/exit.c
    1458 +++ b/kernel/exit.c
    1459 @@ -559,9 +559,6 @@ static void reparent_leader(struct task_struct *father, struct task_struct *p,
    1460 struct list_head *dead)
    1461 {
    1462 list_move_tail(&p->sibling, &p->real_parent->children);
    1463 -
    1464 - if (p->exit_state == EXIT_DEAD)
    1465 - return;
    1466 /*
    1467 * If this is a threaded reparent there is no need to
    1468 * notify anyone anything has happened.
    1469 @@ -569,9 +566,19 @@ static void reparent_leader(struct task_struct *father, struct task_struct *p,
    1470 if (same_thread_group(p->real_parent, father))
    1471 return;
    1472
    1473 - /* We don't want people slaying init. */
    1474 + /*
    1475 + * We don't want people slaying init.
    1476 + *
    1477 + * Note: we do this even if it is EXIT_DEAD, wait_task_zombie()
    1478 + * can change ->exit_state to EXIT_ZOMBIE. If this is the final
    1479 + * state, do_notify_parent() was already called and ->exit_signal
    1480 + * doesn't matter.
    1481 + */
    1482 p->exit_signal = SIGCHLD;
    1483
    1484 + if (p->exit_state == EXIT_DEAD)
    1485 + return;
    1486 +
    1487 /* If it has exited notify the new parent about this child's death. */
    1488 if (!p->ptrace &&
    1489 p->exit_state == EXIT_ZOMBIE && thread_group_empty(p)) {
    1490 @@ -783,6 +790,8 @@ void do_exit(long code)
    1491 exit_shm(tsk);
    1492 exit_files(tsk);
    1493 exit_fs(tsk);
    1494 + if (group_dead)
    1495 + disassociate_ctty(1);
    1496 exit_task_namespaces(tsk);
    1497 exit_task_work(tsk);
    1498 check_stack_usage();
    1499 @@ -798,13 +807,9 @@ void do_exit(long code)
    1500
    1501 cgroup_exit(tsk, 1);
    1502
    1503 - if (group_dead)
    1504 - disassociate_ctty(1);
    1505 -
    1506 module_put(task_thread_info(tsk)->exec_domain->module);
    1507
    1508 proc_exit_connector(tsk);
    1509 -
    1510 /*
    1511 * FIXME: do that only when needed, using sched_exit tracepoint
    1512 */
    1513 diff --git a/kernel/pid_namespace.c b/kernel/pid_namespace.c
    1514 index 42086551a24a..55e956056987 100644
    1515 --- a/kernel/pid_namespace.c
    1516 +++ b/kernel/pid_namespace.c
    1517 @@ -312,7 +312,9 @@ static void *pidns_get(struct task_struct *task)
    1518 struct pid_namespace *ns;
    1519
    1520 rcu_read_lock();
    1521 - ns = get_pid_ns(task_active_pid_ns(task));
    1522 + ns = task_active_pid_ns(task);
    1523 + if (ns)
    1524 + get_pid_ns(ns);
    1525 rcu_read_unlock();
    1526
    1527 return ns;
    1528 diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
    1529 index 13fb1134ba58..6991139e3303 100644
    1530 --- a/kernel/user_namespace.c
    1531 +++ b/kernel/user_namespace.c
    1532 @@ -146,7 +146,7 @@ static u32 map_id_range_down(struct uid_gid_map *map, u32 id, u32 count)
    1533
    1534 /* Find the matching extent */
    1535 extents = map->nr_extents;
    1536 - smp_read_barrier_depends();
    1537 + smp_rmb();
    1538 for (idx = 0; idx < extents; idx++) {
    1539 first = map->extent[idx].first;
    1540 last = first + map->extent[idx].count - 1;
    1541 @@ -170,7 +170,7 @@ static u32 map_id_down(struct uid_gid_map *map, u32 id)
    1542
    1543 /* Find the matching extent */
    1544 extents = map->nr_extents;
    1545 - smp_read_barrier_depends();
    1546 + smp_rmb();
    1547 for (idx = 0; idx < extents; idx++) {
    1548 first = map->extent[idx].first;
    1549 last = first + map->extent[idx].count - 1;
    1550 @@ -193,7 +193,7 @@ static u32 map_id_up(struct uid_gid_map *map, u32 id)
    1551
    1552 /* Find the matching extent */
    1553 extents = map->nr_extents;
    1554 - smp_read_barrier_depends();
    1555 + smp_rmb();
    1556 for (idx = 0; idx < extents; idx++) {
    1557 first = map->extent[idx].lower_first;
    1558 last = first + map->extent[idx].count - 1;
    1559 @@ -609,9 +609,8 @@ static ssize_t map_write(struct file *file, const char __user *buf,
    1560 * were written before the count of the extents.
    1561 *
    1562 * To achieve this smp_wmb() is used on guarantee the write
    1563 - * order and smp_read_barrier_depends() is guaranteed that we
    1564 - * don't have crazy architectures returning stale data.
    1565 - *
    1566 + * order and smp_rmb() is guaranteed that we don't have crazy
    1567 + * architectures returning stale data.
    1568 */
    1569 mutex_lock(&id_map_mutex);
    1570
    1571 diff --git a/mm/backing-dev.c b/mm/backing-dev.c
    1572 index ce682f7a4f29..09d9591b7708 100644
    1573 --- a/mm/backing-dev.c
    1574 +++ b/mm/backing-dev.c
    1575 @@ -288,13 +288,19 @@ int bdi_has_dirty_io(struct backing_dev_info *bdi)
    1576 * Note, we wouldn't bother setting up the timer, but this function is on the
    1577 * fast-path (used by '__mark_inode_dirty()'), so we save few context switches
    1578 * by delaying the wake-up.
    1579 + *
    1580 + * We have to be careful not to postpone flush work if it is scheduled for
    1581 + * earlier. Thus we use queue_delayed_work().
    1582 */
    1583 void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi)
    1584 {
    1585 unsigned long timeout;
    1586
    1587 timeout = msecs_to_jiffies(dirty_writeback_interval * 10);
    1588 - mod_delayed_work(bdi_wq, &bdi->wb.dwork, timeout);
    1589 + spin_lock_bh(&bdi->wb_lock);
    1590 + if (test_bit(BDI_registered, &bdi->state))
    1591 + queue_delayed_work(bdi_wq, &bdi->wb.dwork, timeout);
    1592 + spin_unlock_bh(&bdi->wb_lock);
    1593 }
    1594
    1595 /*
    1596 @@ -307,9 +313,6 @@ static void bdi_remove_from_list(struct backing_dev_info *bdi)
    1597 spin_unlock_bh(&bdi_lock);
    1598
    1599 synchronize_rcu_expedited();
    1600 -
    1601 - /* bdi_list is now unused, clear it to mark @bdi dying */
    1602 - INIT_LIST_HEAD(&bdi->bdi_list);
    1603 }
    1604
    1605 int bdi_register(struct backing_dev_info *bdi, struct device *parent,
    1606 @@ -360,6 +363,11 @@ static void bdi_wb_shutdown(struct backing_dev_info *bdi)
    1607 */
    1608 bdi_remove_from_list(bdi);
    1609
    1610 + /* Make sure nobody queues further work */
    1611 + spin_lock_bh(&bdi->wb_lock);
    1612 + clear_bit(BDI_registered, &bdi->state);
    1613 + spin_unlock_bh(&bdi->wb_lock);
    1614 +
    1615 /*
    1616 * Drain work list and shutdown the delayed_work. At this point,
    1617 * @bdi->bdi_list is empty telling bdi_Writeback_workfn() that @bdi
    1618 diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
    1619 index 8db3e89fae35..a3af2b750e96 100644
    1620 --- a/net/bluetooth/hci_event.c
    1621 +++ b/net/bluetooth/hci_event.c
    1622 @@ -3565,7 +3565,13 @@ static void hci_le_ltk_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
    1623
    1624 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
    1625
    1626 - if (ltk->type & HCI_SMP_STK) {
    1627 + /* Ref. Bluetooth Core SPEC pages 1975 and 2004. STK is a
    1628 + * temporary key used to encrypt a connection following
    1629 + * pairing. It is used during the Encrypted Session Setup to
    1630 + * distribute the keys. Later, security can be re-established
    1631 + * using a distributed LTK.
    1632 + */
    1633 + if (ltk->type == HCI_SMP_STK_SLAVE) {
    1634 list_del(&ltk->list);
    1635 kfree(ltk);
    1636 }
    1637 diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
    1638 index c482f7c7dd32..c211607b79b3 100644
    1639 --- a/net/ipv4/ping.c
    1640 +++ b/net/ipv4/ping.c
    1641 @@ -249,26 +249,33 @@ int ping_init_sock(struct sock *sk)
    1642 {
    1643 struct net *net = sock_net(sk);
    1644 kgid_t group = current_egid();
    1645 - struct group_info *group_info = get_current_groups();
    1646 - int i, j, count = group_info->ngroups;
    1647 + struct group_info *group_info;
    1648 + int i, j, count;
    1649 kgid_t low, high;
    1650 + int ret = 0;
    1651
    1652 inet_get_ping_group_range_net(net, &low, &high);
    1653 if (gid_lte(low, group) && gid_lte(group, high))
    1654 return 0;
    1655
    1656 + group_info = get_current_groups();
    1657 + count = group_info->ngroups;
    1658 for (i = 0; i < group_info->nblocks; i++) {
    1659 int cp_count = min_t(int, NGROUPS_PER_BLOCK, count);
    1660 for (j = 0; j < cp_count; j++) {
    1661 kgid_t gid = group_info->blocks[i][j];
    1662 if (gid_lte(low, gid) && gid_lte(gid, high))
    1663 - return 0;
    1664 + goto out_release_group;
    1665 }
    1666
    1667 count -= cp_count;
    1668 }
    1669
    1670 - return -EACCES;
    1671 + ret = -EACCES;
    1672 +
    1673 +out_release_group:
    1674 + put_group_info(group_info);
    1675 + return ret;
    1676 }
    1677 EXPORT_SYMBOL_GPL(ping_init_sock);
    1678
    1679 diff --git a/net/openvswitch/dp_notify.c b/net/openvswitch/dp_notify.c
    1680 index c3235675f359..5c2dab276109 100644
    1681 --- a/net/openvswitch/dp_notify.c
    1682 +++ b/net/openvswitch/dp_notify.c
    1683 @@ -65,8 +65,7 @@ void ovs_dp_notify_wq(struct work_struct *work)
    1684 continue;
    1685
    1686 netdev_vport = netdev_vport_priv(vport);
    1687 - if (netdev_vport->dev->reg_state == NETREG_UNREGISTERED ||
    1688 - netdev_vport->dev->reg_state == NETREG_UNREGISTERING)
    1689 + if (!(netdev_vport->dev->priv_flags & IFF_OVS_DATAPATH))
    1690 dp_detach_port_notify(vport);
    1691 }
    1692 }
    1693 @@ -88,6 +87,10 @@ static int dp_device_event(struct notifier_block *unused, unsigned long event,
    1694 return NOTIFY_DONE;
    1695
    1696 if (event == NETDEV_UNREGISTER) {
    1697 + /* upper_dev_unlink and decrement promisc immediately */
    1698 + ovs_netdev_detach_dev(vport);
    1699 +
    1700 + /* schedule vport destroy, dev_put and genl notification */
    1701 ovs_net = net_generic(dev_net(dev), ovs_net_id);
    1702 queue_work(system_wq, &ovs_net->dp_notify_work);
    1703 }
    1704 diff --git a/net/openvswitch/vport-netdev.c b/net/openvswitch/vport-netdev.c
    1705 index 09d93c13cfd6..d21f77d875ba 100644
    1706 --- a/net/openvswitch/vport-netdev.c
    1707 +++ b/net/openvswitch/vport-netdev.c
    1708 @@ -150,15 +150,25 @@ static void free_port_rcu(struct rcu_head *rcu)
    1709 ovs_vport_free(vport_from_priv(netdev_vport));
    1710 }
    1711
    1712 -static void netdev_destroy(struct vport *vport)
    1713 +void ovs_netdev_detach_dev(struct vport *vport)
    1714 {
    1715 struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
    1716
    1717 - rtnl_lock();
    1718 + ASSERT_RTNL();
    1719 netdev_vport->dev->priv_flags &= ~IFF_OVS_DATAPATH;
    1720 netdev_rx_handler_unregister(netdev_vport->dev);
    1721 - netdev_upper_dev_unlink(netdev_vport->dev, get_dpdev(vport->dp));
    1722 + netdev_upper_dev_unlink(netdev_vport->dev,
    1723 + netdev_master_upper_dev_get(netdev_vport->dev));
    1724 dev_set_promiscuity(netdev_vport->dev, -1);
    1725 +}
    1726 +
    1727 +static void netdev_destroy(struct vport *vport)
    1728 +{
    1729 + struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
    1730 +
    1731 + rtnl_lock();
    1732 + if (netdev_vport->dev->priv_flags & IFF_OVS_DATAPATH)
    1733 + ovs_netdev_detach_dev(vport);
    1734 rtnl_unlock();
    1735
    1736 call_rcu(&netdev_vport->rcu, free_port_rcu);
    1737 diff --git a/net/openvswitch/vport-netdev.h b/net/openvswitch/vport-netdev.h
    1738 index dd298b5c5cdb..8df01c1127e5 100644
    1739 --- a/net/openvswitch/vport-netdev.h
    1740 +++ b/net/openvswitch/vport-netdev.h
    1741 @@ -39,5 +39,6 @@ netdev_vport_priv(const struct vport *vport)
    1742 }
    1743
    1744 const char *ovs_netdev_get_name(const struct vport *);
    1745 +void ovs_netdev_detach_dev(struct vport *);
    1746
    1747 #endif /* vport_netdev.h */
    1748 diff --git a/virt/kvm/ioapic.c b/virt/kvm/ioapic.c
    1749 index 2d682977ce82..39dc5bc742e0 100644
    1750 --- a/virt/kvm/ioapic.c
    1751 +++ b/virt/kvm/ioapic.c
    1752 @@ -306,7 +306,7 @@ static int ioapic_deliver(struct kvm_ioapic *ioapic, int irq, bool line_status)
    1753 BUG_ON(ioapic->rtc_status.pending_eoi != 0);
    1754 ret = kvm_irq_delivery_to_apic(ioapic->kvm, NULL, &irqe,
    1755 ioapic->rtc_status.dest_map);
    1756 - ioapic->rtc_status.pending_eoi = ret;
    1757 + ioapic->rtc_status.pending_eoi = (ret < 0 ? 0 : ret);
    1758 } else
    1759 ret = kvm_irq_delivery_to_apic(ioapic->kvm, NULL, &irqe, NULL);
    1760