Merge remote-tracking branch 'tip/auto-latest'

Conflicts:
	arch/x86/kernel/ldt.c
	arch/x86/vdso/vdso32-setup.c
	drivers/block/mtip32xx/mtip32xx.c
	kernel/sched/idle.c
	net/ipv4/tcp_output.c

diff --cc arch/arm/kernel/topology.c
Simple merge

diff --cc arch/arm64/include/asm/atomic.h
Simple merge

diff --cc arch/arm64/include/asm/barrier.h
Simple merge

diff --cc arch/metag/include/asm/barrier.h
Simple merge

diff --cc arch/s390/kernel/topology.c
Simple merge

diff --cc arch/sparc/include/asm/atomic_32.h
Simple merge

diff --cc arch/sparc/include/asm/atomic_64.h
index 0582c02a6b0cc16851e1ae3f963e0a7c751c9e15,8b2f1bde2889bee05cada1d71c19370dc52b5ee3..bb894c8bec562c337e3166c3509ba11334c864c2
--- 1/arch/sparc/include/asm/atomic_64.h
--- 2/arch/sparc/include/asm/atomic_64.h
+++ b/arch/sparc/include/asm/atomic_64.h
@@@ -106,12 -107,6 +107,6 @@@ static inline long atomic64_add_unless(
  
  #define atomic64_inc_not_zero(v) atomic64_add_unless((v), 1, 0)
  
 -extern long atomic64_dec_if_positive(atomic64_t *v);
 +long atomic64_dec_if_positive(atomic64_t *v);
  
- /* Atomic operations are already serializing */
- #define smp_mb__before_atomic_dec()   barrier()
- #define smp_mb__after_atomic_dec()    barrier()
- #define smp_mb__before_atomic_inc()   barrier()
- #define smp_mb__after_atomic_inc()    barrier()
- 
  #endif /* !(__ARCH_SPARC64_ATOMIC__) */

diff --cc arch/sparc/include/asm/bitops_32.h
Simple merge

diff --cc arch/sparc/include/asm/bitops_64.h
index 0135028e48299799ad69dc140bab02e04468ab04,f1a051ca301a472605915aee308980879ed11ab8..2d522402a9375ca22aac8f06276c2bc530b61107
--- 1/arch/sparc/include/asm/bitops_64.h
--- 2/arch/sparc/include/asm/bitops_64.h
+++ b/arch/sparc/include/asm/bitops_64.h
@@@ -13,13 -13,14 +13,14 @@@
  
  #include <linux/compiler.h>
  #include <asm/byteorder.h>
+ #include <asm/barrier.h>
  
 -extern int test_and_set_bit(unsigned long nr, volatile unsigned long *addr);
 -extern int test_and_clear_bit(unsigned long nr, volatile unsigned long *addr);
 -extern int test_and_change_bit(unsigned long nr, volatile unsigned long *addr);
 -extern void set_bit(unsigned long nr, volatile unsigned long *addr);
 -extern void clear_bit(unsigned long nr, volatile unsigned long *addr);
 -extern void change_bit(unsigned long nr, volatile unsigned long *addr);
 +int test_and_set_bit(unsigned long nr, volatile unsigned long *addr);
 +int test_and_clear_bit(unsigned long nr, volatile unsigned long *addr);
 +int test_and_change_bit(unsigned long nr, volatile unsigned long *addr);
 +void set_bit(unsigned long nr, volatile unsigned long *addr);
 +void clear_bit(unsigned long nr, volatile unsigned long *addr);
 +void change_bit(unsigned long nr, volatile unsigned long *addr);
  
  #include <asm-generic/bitops/non-atomic.h>
  

diff --cc arch/x86/Kconfig
Simple merge

diff --cc arch/x86/kernel/entry_32.S
Simple merge

diff --cc arch/x86/kernel/entry_64.S
Simple merge

diff --cc arch/x86/kernel/ldt.c
index dcbbaa165bdeed61dd2b504a13ca05ced99737c7,c37886d759ccac2736c36b357cc0f399786f2fb3..d01692b37e09a91b4de8521a67466a12b3b28e2a
--- 1/arch/x86/kernel/ldt.c
--- 2/arch/x86/kernel/ldt.c
+++ b/arch/x86/kernel/ldt.c
@@@ -231,12 -229,7 +231,7 @@@ static int write_ldt(void __user *ptr, 
                }
        }
  
-       /*
-        * On x86-64 we do not support 16-bit segments due to
-        * IRET leaking the high bits of the kernel stack address.
-        */
- #ifdef CONFIG_X86_64
-       if (!ldt_info.seg_32bit && !sysctl_ldt16) {
 -      if (!IS_ENABLED(CONFIG_X86_16BIT) && !ldt_info.seg_32bit) {
++      if (!IS_ENABLED(CONFIG_X86_16BIT) && !ldt_info.seg_32bit && !sysctl_ldt16) {
                error = -EINVAL;
                goto out_unlock;
        }

diff --cc arch/x86/vdso/vdso32-setup.c
index e1f220e3ca6899af1d542ce7d22903e961754c7c,c3ed708e50f4114ee7ae339f4cdb751efb6a0c12..f6be4afc6bc1bb58036489d5c97dc6ce41a7ba39
--- 1/arch/x86/vdso/vdso32-setup.c
--- 2/arch/x86/vdso/vdso32-setup.c
+++ b/arch/x86/vdso/vdso32-setup.c
@@@ -36,12 -21,6 +21,10 @@@
  #define VDSO_DEFAULT  1
  #endif
  
- #define vdso_enabled                  sysctl_vsyscall32
- #define arch_setup_additional_pages   syscall32_setup_pages
 +#ifdef CONFIG_X86_64
 +extern int sysctl_ldt16;
 +#endif
 +
  /*
   * Should the kernel map a VDSO page into processes and pass its
   * address down to glibc upon exec()?

diff --cc block/blk-iopoll.c
Simple merge

diff --cc drivers/gpu/drm/drm_irq.c
Simple merge

diff --cc drivers/gpu/drm/i915/i915_irq.c
Simple merge

diff --cc drivers/md/dm-snap.c
Simple merge

diff --cc drivers/md/dm.c
Simple merge

diff --cc drivers/md/raid5.c
Simple merge

diff --cc drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
Simple merge

diff --cc drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c
Simple merge

diff --cc drivers/net/ethernet/chelsio/cxgb/cxgb2.c
Simple merge

diff --cc drivers/net/ethernet/chelsio/cxgb4/sge.c
Simple merge

diff --cc drivers/net/ethernet/chelsio/cxgb4vf/sge.c
Simple merge

diff --cc drivers/net/ethernet/intel/i40e/i40e_main.c
Simple merge

diff --cc drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
Simple merge

diff --cc drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
Simple merge

diff --cc drivers/net/wireless/ti/wlcore/main.c
Simple merge

diff --cc fs/btrfs/inode.c
Simple merge

diff --cc fs/ext4/resize.c
Simple merge

diff --cc fs/gfs2/glops.c
Simple merge

diff --cc fs/gfs2/recovery.c
Simple merge

diff --cc fs/gfs2/sys.c
Simple merge

diff --cc fs/nfs/inode.c
Simple merge

diff --cc fs/nfs/write.c
Simple merge

diff --cc include/linux/netdevice.h
Simple merge

diff --cc init/main.c
Simple merge

diff --cc kernel/hrtimer.c
Simple merge

diff --cc kernel/sched/idle.c
index a8f12247ce7c015dc334fbbda54fee98039a0a88,34083c9ac976ecf7e26e1a08566e7eb18c5f04c2..acce6c0f84b8fdb87028d3547694330385d27fbb
--- 1/kernel/sched/idle.c
--- 2/kernel/sched/idle.c
+++ b/kernel/sched/idle.c
@@@ -101,77 -98,74 +98,69 @@@ static void cpuidle_idle_call(void
        rcu_idle_enter();
  
        /*
 -       * Check if the cpuidle framework is ready, otherwise fallback
 -       * to the default arch specific idle method
 +       * Ask the cpuidle framework to choose a convenient idle state.
 +       * Fall back to the default arch specific idle method on errors.
         */
 -      if (cpuidle_enabled(drv, dev)) {
 +      next_state = cpuidle_select(drv, dev);
 +
-       ret = next_state;
-       if (ret >= 0) {
++      if (next_state < 0) {
+ use_default:
                /*
-                * The idle task must be scheduled, it is pointless to
-                * go to idle, just update no idle residency and get
-                * out of this function
+                * We can't use the cpuidle framework, let's use the default
+                * idle routine.
                 */
-               if (current_clr_polling_and_test()) {
-                       dev->last_residency = 0;
-                       entered_state = next_state;
+               if (current_clr_polling_and_test())
                        local_irq_enable();
-               } else {
-                       broadcast = !!(drv->states[next_state].flags &
-                                      CPUIDLE_FLAG_TIMER_STOP);
- 
-                       if (broadcast)
-                               /*
-                                * Tell the time framework to switch
-                                * to a broadcast timer because our
-                                * local timer will be shutdown. If a
-                                * local timer is used from another
-                                * cpu as a broadcast timer, this call
-                                * may fail if it is not available
-                                */
-                               ret = clockevents_notify(
-                                       CLOCK_EVT_NOTIFY_BROADCAST_ENTER,
-                                       &dev->cpu);
- 
-                       if (ret >= 0) {
-                               trace_cpu_idle_rcuidle(next_state, dev->cpu);
- 
-                               /*
-                                * Enter the idle state previously
-                                * returned by the governor
-                                * decision. This function will block
-                                * until an interrupt occurs and will
-                                * take care of re-enabling the local
-                                * interrupts
-                                */
-                               entered_state = cpuidle_enter(drv, dev,
-                                                             next_state);
- 
-                               trace_cpu_idle_rcuidle(PWR_EVENT_EXIT,
-                                                      dev->cpu);
- 
-                               if (broadcast)
-                                       clockevents_notify(
-                                               CLOCK_EVT_NOTIFY_BROADCAST_EXIT,
-                                               &dev->cpu);
- 
-                               /*
-                                * Give the governor an opportunity to reflect on the
-                                * outcome
-                                */
-                               cpuidle_reflect(dev, entered_state);
-                       }
-               }
+               else
+                       arch_cpu_idle();
+ 
+               goto exit_idle;
+       }
+ 
 -      /*
 -       * Ask the governor to choose an idle state it thinks
 -       * it is convenient to go to. There is *always* a
 -       * convenient idle state
 -       */
 -      next_state = cpuidle_select(drv, dev);
 -
+       /*
+        * The idle task must be scheduled, it is pointless to
+        * go to idle, just update no idle residency and get
+        * out of this function
+        */
+       if (current_clr_polling_and_test()) {
+               dev->last_residency = 0;
+               entered_state = next_state;
+               local_irq_enable();
+               goto exit_idle;
        }
  
+       broadcast = !!(drv->states[next_state].flags & CPUIDLE_FLAG_TIMER_STOP);
+ 
        /*
-        * We can't use the cpuidle framework, let's use the default
-        * idle routine
+        * Tell the time framework to switch to a broadcast timer
+        * because our local timer will be shutdown. If a local timer
+        * is used from another cpu as a broadcast timer, this call may
+        * fail if it is not available
         */
-       if (ret < 0)
-               arch_cpu_idle();
+       if (broadcast &&
 -          clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu))
++          clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &dev->cpu) < 0)
+               goto use_default;
  
+       trace_cpu_idle_rcuidle(next_state, dev->cpu);
+ 
+       /*
+        * Enter the idle state previously returned by the governor decision.
+        * This function will block until an interrupt occurs and will take
+        * care of re-enabling the local interrupts
+        */
+       entered_state = cpuidle_enter(drv, dev, next_state);
+ 
+       trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, dev->cpu);
+ 
+       if (broadcast)
+               clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &dev->cpu);
+ 
+       /*
+        * Give the governor an opportunity to reflect on the outcome
+        */
+       cpuidle_reflect(dev, entered_state);
+ 
+ exit_idle:
        __current_set_polling();
  
        /*

diff --cc kernel/sysctl.c
Simple merge

diff --cc kernel/workqueue.c
Simple merge

diff --cc mm/filemap.c
Simple merge

diff --cc net/bluetooth/hci_event.c
Simple merge

diff --cc net/core/dev.c
Simple merge

diff --cc net/ipv4/inetpeer.c
Simple merge

diff --cc net/ipv4/tcp_output.c
index 3d61c52bdf79dad38099ca1f087e1f08d2b86c81,2d340bd2cd3d50d97da3e86b77de8117eabe0c10..e0c52a87fb600d7afc7d420407a5fcc78e9b8642
--- 1/net/ipv4/tcp_output.c
--- 2/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@@ -1946,18 -1930,10 +1946,16 @@@ static bool tcp_write_xmit(struct sock 
                        /* It is possible TX completion already happened
                         * before we set TSQ_THROTTLED, so we must
                         * test again the condition.
-                        * We abuse smp_mb__after_clear_bit() because
-                        * there is no smp_mb__after_set_bit() yet
                         */
-                       smp_mb__after_clear_bit();
+                       smp_mb__after_atomic();
 -                      if (atomic_read(&sk->sk_wmem_alloc) > limit)
 +                      if (atomic_read(&sk->sk_wmem_alloc) > limit) {
 +                              u32 unsent_bytes;
 +
 +compute_unsent_segs:
 +                              unsent_bytes = tp->write_seq - tp->snd_nxt;
 +                              unsent_segs = DIV_ROUND_UP(unsent_bytes, mss_now);
                                break;
 +                      }
                }
  
                limit = mss_now;

diff --cc net/unix/af_unix.c
Simple merge