22 files changed, 43 insertions, 43 deletions

diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index c9a24444ec9a..2256e9cceec5 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -279,7 +279,7 @@ static inline void btrfs_inode_block_unlocked_dio(struct inode *inode)
 
 static inline void btrfs_inode_resume_unlocked_dio(struct inode *inode)
 {
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(BTRFS_INODE_READDIO_NEED_LOCK,
                   &BTRFS_I(inode)->runtime_flags);
 }
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 3955e475ceec..f29a54e454d4 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3458,7 +3458,7 @@ static int lock_extent_buffer_for_io(struct extent_buffer *eb,
 static void end_extent_buffer_writeback(struct extent_buffer *eb)
 {
         clear_bit(EXTENT_BUFFER_WRITEBACK, &eb->bflags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&eb->bflags, EXTENT_BUFFER_WRITEBACK);
 }
 
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 5f805bc944fa..5a3b8371772e 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -7126,7 +7126,7 @@ static void btrfs_end_dio_bio(struct bio *bio, int err)
                  * before atomic variable goto zero, we must make sure
                  * dip->errors is perceived to be set.
                  */
-                smp_mb__before_atomic_dec();
+                smp_mb__before_atomic();
         }
 
         /* if there are more bios still pending for this dio, just exit */
@@ -7306,7 +7306,7 @@ out_err:
          * before atomic variable goto zero, we must
          * make sure dip->errors is perceived to be set.
          */
-        smp_mb__before_atomic_dec();
+        smp_mb__before_atomic();
         if (atomic_dec_and_test(&dip->pending_bios))
                 bio_io_error(dip->orig_bio);
 
@@ -7449,7 +7449,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
                 return 0;
 
         atomic_inc(&inode->i_dio_count);
-        smp_mb__after_atomic_inc();
+        smp_mb__after_atomic();
 
         /*
          * The generic stuff only does filemap_write_and_wait_range, which
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index e79ff6b90cb7..f45040a4bb76 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -642,7 +642,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
                 return -EINVAL;
 
         atomic_inc(&root->will_be_snapshoted);
-        smp_mb__after_atomic_inc();
+        smp_mb__after_atomic();
         btrfs_wait_nocow_write(root);
 
         ret = btrfs_start_delalloc_inodes(root, 0);
diff --git a/fs/buffer.c b/fs/buffer.c
index 9ddb9fc7d923..6a8110c03a47 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -77,7 +77,7 @@ EXPORT_SYMBOL(__lock_buffer);
 void unlock_buffer(struct buffer_head *bh)
 {
         clear_bit_unlock(BH_Lock, &bh->b_state);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&bh->b_state, BH_Lock);
 }
 EXPORT_SYMBOL(unlock_buffer);
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index f3b84cd9de56..08b3c116915b 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -42,7 +42,7 @@ int ext4_resize_begin(struct super_block *sb)
 void ext4_resize_end(struct super_block *sb)
 {
         clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
 }
 
 static ext4_group_t ext4_meta_bg_first_group(struct super_block *sb,
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index aec7f73832f0..c355f7320e44 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -277,7 +277,7 @@ static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holde
 static void gfs2_holder_wake(struct gfs2_holder *gh)
 {
         clear_bit(HIF_WAIT, &gh->gh_iflags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&gh->gh_iflags, HIF_WAIT);
 }
 
@@ -411,7 +411,7 @@ static void gfs2_demote_wake(struct gfs2_glock *gl)
 {
         gl->gl_demote_state = LM_ST_EXCLUSIVE;
         clear_bit(GLF_DEMOTE, &gl->gl_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&gl->gl_flags, GLF_DEMOTE);
 }
 
@@ -620,7 +620,7 @@ out:
 
 out_sched:
         clear_bit(GLF_LOCK, &gl->gl_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         gl->gl_lockref.count++;
         if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
                 gl->gl_lockref.count--;
@@ -628,7 +628,7 @@ out_sched:
 
 out_unlock:
         clear_bit(GLF_LOCK, &gl->gl_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         return;
 }
 
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index 54b66809e818..74d9a3dbf16f 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -221,7 +221,7 @@ static void inode_go_sync(struct gfs2_glock *gl)
          * Writeback of the data mapping may cause the dirty flag to be set
          * so we have to clear it again here.
          */
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(GLF_DIRTY, &gl->gl_flags);
 }
 
diff --git a/fs/gfs2/lock_dlm.c b/fs/gfs2/lock_dlm.c
index c1eb555dc588..91f274de1246 100644
--- a/fs/gfs2/lock_dlm.c
+++ b/fs/gfs2/lock_dlm.c
@@ -1134,7 +1134,7 @@ static void gdlm_recover_done(void *arg, struct dlm_slot *slots, int num_slots,
                 queue_delayed_work(gfs2_control_wq, &sdp->sd_control_work, 0);
 
         clear_bit(DFL_DLM_RECOVERY, &ls->ls_recover_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&ls->ls_recover_flags, DFL_DLM_RECOVERY);
         spin_unlock(&ls->ls_recover_spin);
 }
@@ -1271,7 +1271,7 @@ static int gdlm_mount(struct gfs2_sbd *sdp, const char *table)
 
         ls->ls_first = !!test_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags);
         clear_bit(SDF_NOJOURNALID, &sdp->sd_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&sdp->sd_flags, SDF_NOJOURNALID);
         return 0;
 
diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
index 7ad4094d68c0..fe7a56fb6084 100644
--- a/fs/gfs2/recovery.c
+++ b/fs/gfs2/recovery.c
@@ -587,7 +587,7 @@ fail:
         gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
 done:
         clear_bit(JDF_RECOVERY, &jd->jd_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&jd->jd_flags, JDF_RECOVERY);
 }
 
diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index de25d5577e5d..529d9a9eb897 100644
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -333,7 +333,7 @@ static ssize_t block_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
                 set_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
         else if (val == 0) {
                 clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 gfs2_glock_thaw(sdp);
         } else {
                 ret = -EINVAL;
@@ -482,7 +482,7 @@ static ssize_t jid_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
                 rv = jid = -EINVAL;
         sdp->sd_lockstruct.ls_jid = jid;
         clear_bit(SDF_NOJOURNALID, &sdp->sd_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&sdp->sd_flags, SDF_NOJOURNALID);
 out:
         spin_unlock(&sdp->sd_jindex_spin);
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 5f26139a165a..6fac74349856 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -43,7 +43,7 @@ static void journal_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
                 clear_buffer_uptodate(bh);
         if (orig_bh) {
                 clear_bit_unlock(BH_Shadow, &orig_bh->b_state);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 wake_up_bit(&orig_bh->b_state, BH_Shadow);
         }
         unlock_buffer(bh);
@@ -239,7 +239,7 @@ static int journal_submit_data_buffers(journal_t *journal,
                 spin_lock(&journal->j_list_lock);
                 J_ASSERT(jinode->i_transaction == commit_transaction);
                 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
         }
         spin_unlock(&journal->j_list_lock);
@@ -277,7 +277,7 @@ static int journal_finish_inode_data_buffers(journal_t *journal,
                 }
                 spin_lock(&journal->j_list_lock);
                 clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
         }
 
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index d9f3d067cd15..4a3d4ef76127 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -2032,9 +2032,9 @@ static void nfs_access_free_entry(struct nfs_access_entry *entry)
 {
         put_rpccred(entry->cred);
         kfree(entry);
-        smp_mb__before_atomic_dec();
+        smp_mb__before_atomic();
         atomic_long_dec(&nfs_access_nr_entries);
-        smp_mb__after_atomic_dec();
+        smp_mb__after_atomic();
 }
 
 static void nfs_access_free_list(struct list_head *head)
@@ -2082,9 +2082,9 @@ nfs_access_cache_scan(struct shrinker *shrink, struct shrink_control *sc)
                 else {
 remove_lru_entry:
                         list_del_init(&nfsi->access_cache_inode_lru);
-                        smp_mb__before_clear_bit();
+                        smp_mb__before_atomic();
                         clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
-                        smp_mb__after_clear_bit();
+                        smp_mb__after_atomic();
                 }
                 spin_unlock(&inode->i_lock);
         }
@@ -2232,9 +2232,9 @@ void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)
         nfs_access_add_rbtree(inode, cache);
 
         /* Update accounting */
-        smp_mb__before_atomic_inc();
+        smp_mb__before_atomic();
         atomic_long_inc(&nfs_access_nr_entries);
-        smp_mb__after_atomic_inc();
+        smp_mb__after_atomic();
 
         /* Add inode to global LRU list */
         if (!test_bit(NFS_INO_ACL_LRU_SET, &NFS_I(inode)->flags)) {
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 0c438973f3c8..e6f7398d2b3c 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1085,7 +1085,7 @@ int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
         trace_nfs_invalidate_mapping_exit(inode, ret);
 
         clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(bitlock, NFS_INO_INVALIDATING);
 out:
         return ret;
diff --git a/fs/nfs/nfs4filelayoutdev.c b/fs/nfs/nfs4filelayoutdev.c
index efac602edb37..b9c61efe9660 100644
--- a/fs/nfs/nfs4filelayoutdev.c
+++ b/fs/nfs/nfs4filelayoutdev.c
@@ -789,9 +789,9 @@ static void nfs4_wait_ds_connect(struct nfs4_pnfs_ds *ds)
 
 static void nfs4_clear_ds_conn_bit(struct nfs4_pnfs_ds *ds)
 {
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(NFS4DS_CONNECTING, &ds->ds_state);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&ds->ds_state, NFS4DS_CONNECTING);
 }
 
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 2349518eef2c..c0583b9bef71 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1140,9 +1140,9 @@ static int nfs4_run_state_manager(void *);
 
 static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
 {
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
         rpc_wake_up(&clp->cl_rpcwaitq);
 }
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index 2ffebf2081ce..03ed984ab4d8 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -95,7 +95,7 @@ nfs_iocounter_dec(struct nfs_io_counter *c)
 {
         if (atomic_dec_and_test(&c->io_count)) {
                 clear_bit(NFS_IO_INPROGRESS, &c->flags);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 wake_up_bit(&c->flags, NFS_IO_INPROGRESS);
         }
 }
@@ -193,9 +193,9 @@ void nfs_unlock_request(struct nfs_page *req)
                 printk(KERN_ERR "NFS: Invalid unlock attempted\n");
                 BUG();
         }
-        smp_mb__before_clear_bit();
+        smp_mb__before_atomic();
         clear_bit(PG_BUSY, &req->wb_flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&req->wb_flags, PG_BUSY);
 }
 
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index cb53d450ae32..fd9536e494bc 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -1810,7 +1810,7 @@ static void pnfs_clear_layoutcommitting(struct inode *inode)
         unsigned long *bitlock = &NFS_I(inode)->flags;
 
         clear_bit_unlock(NFS_INO_LAYOUTCOMMITTING, bitlock);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(bitlock, NFS_INO_LAYOUTCOMMITTING);
 }
 
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index 023793909778..c3058a076596 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -275,7 +275,7 @@ pnfs_get_lseg(struct pnfs_layout_segment *lseg)
 {
         if (lseg) {
                 atomic_inc(&lseg->pls_refcount);
-                smp_mb__after_atomic_inc();
+                smp_mb__after_atomic();
         }
         return lseg;
 }
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 9a3b6a4cd6b9..ffb9459f180b 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -405,7 +405,7 @@ int nfs_writepages(struct address_space *mapping, struct writeback_control *wbc)
         nfs_pageio_complete(&pgio);
 
         clear_bit_unlock(NFS_INO_FLUSHING, bitlock);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(bitlock, NFS_INO_FLUSHING);
 
         if (err < 0)
@@ -1458,7 +1458,7 @@ static int nfs_commit_set_lock(struct nfs_inode *nfsi, int may_wait)
 static void nfs_commit_clear_lock(struct nfs_inode *nfsi)
 {
         clear_bit(NFS_INO_COMMIT, &nfsi->flags);
-        smp_mb__after_clear_bit();
+        smp_mb__after_atomic();
         wake_up_bit(&nfsi->flags, NFS_INO_COMMIT);
 }
 
diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index 4b826abb1528..45d4e96a6bac 100644
--- a/fs/ubifs/lpt_commit.c
+++ b/fs/ubifs/lpt_commit.c
@@ -460,9 +460,9 @@ static int write_cnodes(struct ubifs_info *c)
                  * important.
                  */
                 clear_bit(DIRTY_CNODE, &cnode->flags);
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 clear_bit(COW_CNODE, &cnode->flags);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
                 offs += len;
                 dbg_chk_lpt_sz(c, 1, len);
                 cnode = cnode->cnext;
diff --git a/fs/ubifs/tnc_commit.c b/fs/ubifs/tnc_commit.c
index 52a6559275c4..3600994f8411 100644
--- a/fs/ubifs/tnc_commit.c
+++ b/fs/ubifs/tnc_commit.c
@@ -895,9 +895,9 @@ static int write_index(struct ubifs_info *c)
                  * the reason for the second barrier.
                  */
                 clear_bit(DIRTY_ZNODE, &znode->flags);
-                smp_mb__before_clear_bit();
+                smp_mb__before_atomic();
                 clear_bit(COW_ZNODE, &znode->flags);
-                smp_mb__after_clear_bit();
+                smp_mb__after_atomic();
 
                 /*
                  * We have marked the znode as clean but have not updated the