Merge branch 'locking-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip into next

Pull core locking updates from Ingo Molnar:
 "The main changes in this cycle were:

   - reduced/streamlined smp_mb__*() interface that allows more usecases
     and makes the existing ones less buggy, especially in rarer
     architectures

   - add rwsem implementation comments

   - bump up lockdep limits"

* 'locking-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (33 commits)
  rwsem: Add comments to explain the meaning of the rwsem's count field
  lockdep: Increase static allocations
  arch: Mass conversion of smp_mb__*()
  arch,doc: Convert smp_mb__*()
  arch,xtensa: Convert smp_mb__*()
  arch,x86: Convert smp_mb__*()
  arch,tile: Convert smp_mb__*()
  arch,sparc: Convert smp_mb__*()
  arch,sh: Convert smp_mb__*()
  arch,score: Convert smp_mb__*()
  arch,s390: Convert smp_mb__*()
  arch,powerpc: Convert smp_mb__*()
  arch,parisc: Convert smp_mb__*()
  arch,openrisc: Convert smp_mb__*()
  arch,mn10300: Convert smp_mb__*()
  arch,mips: Convert smp_mb__*()
  arch,metag: Convert smp_mb__*()
  arch,m68k: Convert smp_mb__*()
  arch,m32r: Convert smp_mb__*()
  arch,ia64: Convert smp_mb__*()
  ...

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 9abc503b19b7..8b07db37dc10 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);
@@ -3341,7 +3341,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);
@@ -3351,7 +3351,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);
                                 }
@@ -4243,7 +4243,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);