Merge branch 'next' (accumulated 3.16 merge window patches) into master

Now that 3.15 is released, this merges the 'next' branch into 'master',
bringing us to the normal situation where my 'master' branch is the
merge window.

* accumulated work in next: (6809 commits)
  ufs: sb mutex merge + mutex_destroy
  powerpc: update comments for generic idle conversion
  cris: update comments for generic idle conversion
  idle: remove cpu_idle() forward declarations
  nbd: zero from and len fields in NBD_CMD_DISCONNECT.
  mm: convert some level-less printks to pr_*
  MAINTAINERS: adi-buildroot-devel is moderated
  MAINTAINERS: add linux-api for review of API/ABI changes
  mm/kmemleak-test.c: use pr_fmt for logging
  fs/dlm/debug_fs.c: replace seq_printf by seq_puts
  fs/dlm/lockspace.c: convert simple_str to kstr
  fs/dlm/config.c: convert simple_str to kstr
  mm: mark remap_file_pages() syscall as deprecated
  mm: memcontrol: remove unnecessary memcg argument from soft limit functions
  mm: memcontrol: clean up memcg zoneinfo lookup
  mm/memblock.c: call kmemleak directly from memblock_(alloc|free)
  mm/mempool.c: update the kmemleak stack trace for mempool allocations
  lib/radix-tree.c: update the kmemleak stack trace for radix tree allocations
  mm: introduce kmemleak_update_trace()
  mm/kmemleak.c: use %u to print ->checksum
  ...

17 files changed, 34 insertions, 36 deletions

diff --git a/net/atm/pppoatm.c b/net/atm/pppoatm.c
index 8c93267ce969..c4e09846d1de 100644
--- a/net/atm/pppoatm.c
+++ b/net/atm/pppoatm.c
@@ -252,7 +252,7 @@ static int pppoatm_may_send(struct pppoatm_vcc *pvcc, int size)
          * we need to ensure there's a memory barrier after it. The bit
          * *must* be set before we do the atomic_inc() on pvcc->inflight.
          * There's no smp_mb__after_set_bit(), so it's this or abuse
-         * smp_mb__after_clear_bit().
+         * smp_mb__after_atomic().
          */
         test_and_set_bit(BLOCKED, &pvcc->blocked);
 
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 15010a230b6d..682f33a38366 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -45,7 +45,7 @@ static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
                 return;
 
         clear_bit(HCI_INQUIRY, &hdev->flags);
-        smp_mb__after_clear_bit(); /* wake_up_bit advises about this barrier */
+        smp_mb__after_atomic(); /* wake_up_bit advises about this barrier */
         wake_up_bit(&hdev->flags, HCI_INQUIRY);
 
         hci_conn_check_pending(hdev);
@@ -1768,7 +1768,7 @@ static void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
         if (!test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
                 return;
 
-        smp_mb__after_clear_bit(); /* wake_up_bit advises about this barrier */
+        smp_mb__after_atomic(); /* wake_up_bit advises about this barrier */
         wake_up_bit(&hdev->flags, HCI_INQUIRY);
 
         if (!test_bit(HCI_MGMT, &hdev->dev_flags))
diff --git a/net/core/dev.c b/net/core/dev.c
index fb8b0546485b..8908a68db449 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1326,7 +1326,7 @@ static int __dev_close_many(struct list_head *head)
                  * dev->stop() will invoke napi_disable() on all of it's
                  * napi_struct instances on this device.
                  */
-                smp_mb__after_clear_bit(); /* Commit netif_running(). */
+                smp_mb__after_atomic(); /* Commit netif_running(). */
         }
 
         dev_deactivate_many(head);
@@ -3356,7 +3356,7 @@ static void net_tx_action(struct softirq_action *h)
 
                         root_lock = qdisc_lock(q);
                         if (spin_trylock(root_lock)) {
-                                smp_mb__before_clear_bit();
+                                smp_mb__before_atomic();
                                 clear_bit(__QDISC_STATE_SCHED,
                                           &q->state);
                                 qdisc_run(q);
@@ -3366,7 +3366,7 @@ static void net_tx_action(struct softirq_action *h)
                                               &q->state)) {
                                         __netif_reschedule(q);
                                 } else {
-                                        smp_mb__before_clear_bit();
+                                        smp_mb__before_atomic();
                                         clear_bit(__QDISC_STATE_SCHED,
                                                   &q->state);
                                 }
@@ -4258,7 +4258,7 @@ void __napi_complete(struct napi_struct *n)
         BUG_ON(n->gro_list);
 
         list_del(&n->poll_list);
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(NAPI_STATE_SCHED, &n->state);
 }
 EXPORT_SYMBOL(__napi_complete);
diff --git a/net/core/link_watch.c b/net/core/link_watch.c
index 9c3a839322ba..bd0767e6b2b3 100644
--- a/net/core/link_watch.c
+++ b/net/core/link_watch.c
@@ -147,7 +147,7 @@ static void linkwatch_do_dev(struct net_device *dev)
          * Make sure the above read is complete since it can be
          * rewritten as soon as we clear the bit below.
          */
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
 
         /* We are about to handle this device,
          * so new events can be accepted
diff --git a/net/ipv4/inetpeer.c b/net/ipv4/inetpeer.c
index 48f424465112..56cd458a1b8c 100644
--- a/net/ipv4/inetpeer.c
+++ b/net/ipv4/inetpeer.c
@@ -522,7 +522,7 @@ EXPORT_SYMBOL_GPL(inet_getpeer);
 void inet_putpeer(struct inet_peer *p)
 {
         p->dtime = (__u32)jiffies;
-        smp_mb__before_atomic_dec();
+        smp_mb__before_atomic();
         atomic_dec(&p->refcnt);
 }
 EXPORT_SYMBOL_GPL(inet_putpeer);
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 12d6016bdd9a..2d340bd2cd3d 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1930,10 +1930,8 @@ static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
                         /* 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)
                                 break;
                 }
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index 75421f2ba8be..1f4f954c4b47 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -914,7 +914,7 @@ void nf_conntrack_free(struct nf_conn *ct)
         nf_ct_ext_destroy(ct);
         nf_ct_ext_free(ct);
         kmem_cache_free(net->ct.nf_conntrack_cachep, ct);
-        smp_mb__before_atomic_dec();
+        smp_mb__before_atomic();
         atomic_dec(&net->ct.count);
 }
 EXPORT_SYMBOL_GPL(nf_conntrack_free);
diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c
index b7ebe23cdedf..d67de453c35a 100644
--- a/net/rds/ib_recv.c
+++ b/net/rds/ib_recv.c
@@ -598,7 +598,7 @@ static void rds_ib_set_ack(struct rds_ib_connection *ic, u64 seq,
 {
         atomic64_set(&ic->i_ack_next, seq);
         if (ack_required) {
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 set_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
         }
 }
@@ -606,7 +606,7 @@ static void rds_ib_set_ack(struct rds_ib_connection *ic, u64 seq,
 static u64 rds_ib_get_ack(struct rds_ib_connection *ic)
 {
         clear_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
 
         return atomic64_read(&ic->i_ack_next);
 }
diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c
index 45033358358e..aa8bf6786008 100644
--- a/net/rds/iw_recv.c
+++ b/net/rds/iw_recv.c
@@ -429,7 +429,7 @@ static void rds_iw_set_ack(struct rds_iw_connection *ic, u64 seq,
 {
         atomic64_set(&ic->i_ack_next, seq);
         if (ack_required) {
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 set_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
         }
 }
@@ -437,7 +437,7 @@ static void rds_iw_set_ack(struct rds_iw_connection *ic, u64 seq,
 static u64 rds_iw_get_ack(struct rds_iw_connection *ic)
 {
         clear_bit(IB_ACK_REQUESTED, &ic->i_ack_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
 
         return atomic64_read(&ic->i_ack_next);
 }
diff --git a/net/rds/send.c b/net/rds/send.c
index a82fb660ec00..23718160d71e 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -107,7 +107,7 @@ static int acquire_in_xmit(struct rds_connection *conn)
 static void release_in_xmit(struct rds_connection *conn)
 {
         clear_bit(RDS_IN_XMIT, &conn->c_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         /*
          * We don't use wait_on_bit()/wake_up_bit() because our waking is in a
          * hot path and finding waiters is very rare.  We don't want to walk
@@ -661,7 +661,7 @@ void rds_send_drop_acked(struct rds_connection *conn, u64 ack,
 
         /* order flag updates with spin locks */
         if (!list_empty(&list))
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
 
         spin_unlock_irqrestore(&conn->c_lock, flags);
 
@@ -691,7 +691,7 @@ void rds_send_drop_to(struct rds_sock *rs, struct sockaddr_in *dest)
         }
 
         /* order flag updates with the rs lock */
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
 
         spin_unlock_irqrestore(&rs->rs_lock, flags);
 
diff --git a/net/rds/tcp_send.c b/net/rds/tcp_send.c
index 81cf5a4c5e40..53b17ca0dff5 100644
--- a/net/rds/tcp_send.c
+++ b/net/rds/tcp_send.c
@@ -93,7 +93,7 @@ int rds_tcp_xmit(struct rds_connection *conn, struct rds_message *rm,
                 rm->m_ack_seq = tc->t_last_sent_nxt +
                                 sizeof(struct rds_header) +
                                 be32_to_cpu(rm->m_inc.i_hdr.h_len) - 1;
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 set_bit(RDS_MSG_HAS_ACK_SEQ, &rm->m_flags);
                 tc->t_last_expected_una = rm->m_ack_seq + 1;
 
diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index 5285ead196c0..247e973544bf 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -296,7 +296,7 @@ static void
 rpcauth_unhash_cred_locked(struct rpc_cred *cred)
 {
         hlist_del_rcu(&cred->cr_hash);
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(RPCAUTH_CRED_HASHED, &cred->cr_flags);
 }
 
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 36e431ee1c90..b6e440baccc3 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -143,7 +143,7 @@ gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)
         gss_get_ctx(ctx);
         rcu_assign_pointer(gss_cred->gc_ctx, ctx);
         set_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags);
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(RPCAUTH_CRED_NEW, &cred->cr_flags);
 }
 
diff --git a/net/sunrpc/backchannel_rqst.c b/net/sunrpc/backchannel_rqst.c
index 3513d559bc45..9761a0da964d 100644
--- a/net/sunrpc/backchannel_rqst.c
+++ b/net/sunrpc/backchannel_rqst.c
@@ -244,10 +244,10 @@ void xprt_free_bc_request(struct rpc_rqst *req)
         dprintk("RPC:       free backchannel req=%p\n", req);
 
         req->rq_connect_cookie = xprt->connect_cookie - 1;
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         WARN_ON_ONCE(!test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state));
         clear_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
 
         if (!xprt_need_to_requeue(xprt)) {
                 /*
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index d173f79947c6..89d051de6b3e 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -230,9 +230,9 @@ static void xprt_clear_locked(struct rpc_xprt *xprt)
 {
         xprt->snd_task = NULL;
         if (!test_bit(XPRT_CLOSE_WAIT, &xprt->state)) {
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 clear_bit(XPRT_LOCKED, &xprt->state);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
         } else
                 queue_work(rpciod_workqueue, &xprt->task_cleanup);
 }
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 25a3dcf15cae..402a7e9a16b7 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -893,11 +893,11 @@ static void xs_close(struct rpc_xprt *xprt)
         xs_reset_transport(transport);
         xprt->reestablish_timeout = 0;
 
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
         clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
         clear_bit(XPRT_CLOSING, &xprt->state);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         xprt_disconnect_done(xprt);
 }
 
@@ -1497,12 +1497,12 @@ static void xs_tcp_cancel_linger_timeout(struct rpc_xprt *xprt)
 
 static void xs_sock_reset_connection_flags(struct rpc_xprt *xprt)
 {
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
         clear_bit(XPRT_CONNECTION_CLOSE, &xprt->state);
         clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
         clear_bit(XPRT_CLOSING, &xprt->state);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
 }
 
 static void xs_sock_mark_closed(struct rpc_xprt *xprt)
@@ -1556,10 +1556,10 @@ static void xs_tcp_state_change(struct sock *sk)
                 xprt->connect_cookie++;
                 xprt->reestablish_timeout = 0;
                 set_bit(XPRT_CLOSING, &xprt->state);
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 clear_bit(XPRT_CONNECTED, &xprt->state);
                 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
                 break;
         case TCP_CLOSE_WAIT:
@@ -1578,9 +1578,9 @@ static void xs_tcp_state_change(struct sock *sk)
         case TCP_LAST_ACK:
                 set_bit(XPRT_CLOSING, &xprt->state);
                 xs_tcp_schedule_linger_timeout(xprt, xs_tcp_fin_timeout);
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 clear_bit(XPRT_CONNECTED, &xprt->state);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 break;
         case TCP_CLOSE:
                 xs_tcp_cancel_linger_timeout(xprt);
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index bb7e8ba821f4..749f80c21e22 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -1207,7 +1207,7 @@ restart:
         sk->sk_state    = TCP_ESTABLISHED;
         sock_hold(newsk);
 
-        smp_mb__after_atomic_inc();     /* sock_hold() does an atomic_inc() */
+        smp_mb__after_atomic(); /* sock_hold() does an atomic_inc() */
         unix_peer(sk)   = newsk;
 
         unix_state_unlock(sk);