17 files changed, 27 insertions, 26 deletions

diff --git a/fs/aio.c b/fs/aio.c
index 5a2487217072..e6de7715228c 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -576,7 +576,7 @@ static int kiocb_cancel(struct aio_kiocb *kiocb)
          * actually has a cancel function, hence the cmpxchg()
          */
 
-        cancel = ACCESS_ONCE(kiocb->ki_cancel);
+        cancel = READ_ONCE(kiocb->ki_cancel);
         do {
                 if (!cancel || cancel == KIOCB_CANCELLED)
                         return -EINVAL;
diff --git a/fs/buffer.c b/fs/buffer.c
index 170df856bdb9..32ce01f0f95f 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1692,7 +1692,8 @@ static struct buffer_head *create_page_buffers(struct page *page, struct inode *
         BUG_ON(!PageLocked(page));
 
         if (!page_has_buffers(page))
-                create_empty_buffers(page, 1 << ACCESS_ONCE(inode->i_blkbits), b_state);
+                create_empty_buffers(page, 1 << READ_ONCE(inode->i_blkbits),
+                                     b_state);
         return page_buffers(page);
 }
 
diff --git a/fs/crypto/keyinfo.c b/fs/crypto/keyinfo.c
index 8e704d12a1cf..0083bd4fcaa5 100644
--- a/fs/crypto/keyinfo.c
+++ b/fs/crypto/keyinfo.c
@@ -373,7 +373,7 @@ void fscrypt_put_encryption_info(struct inode *inode, struct fscrypt_info *ci)
         struct fscrypt_info *prev;
 
         if (ci == NULL)
-                ci = ACCESS_ONCE(inode->i_crypt_info);
+                ci = READ_ONCE(inode->i_crypt_info);
         if (ci == NULL)
                 return;
 
diff --git a/fs/direct-io.c b/fs/direct-io.c
index b53e66d9abd7..98fe1325da9d 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -1152,7 +1152,7 @@ do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
                       get_block_t get_block, dio_iodone_t end_io,
                       dio_submit_t submit_io, int flags)
 {
-        unsigned i_blkbits = ACCESS_ONCE(inode->i_blkbits);
+        unsigned i_blkbits = READ_ONCE(inode->i_blkbits);
         unsigned blkbits = i_blkbits;
         unsigned blocksize_mask = (1 << blkbits) - 1;
         ssize_t retval = -EINVAL;
diff --git a/fs/exec.c b/fs/exec.c
index 3e14ba25f678..1d6243d9f2b6 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1911,7 +1911,7 @@ void set_dumpable(struct mm_struct *mm, int value)
                 return;
 
         do {
-                old = ACCESS_ONCE(mm->flags);
+                old = READ_ONCE(mm->flags);
                 new = (old & ~MMF_DUMPABLE_MASK) | value;
         } while (cmpxchg(&mm->flags, old, new) != old);
 }
diff --git a/fs/fcntl.c b/fs/fcntl.c
index 448a1119f0be..57bf2964bb83 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -724,7 +724,7 @@ static void send_sigio_to_task(struct task_struct *p,
          * F_SETSIG can change ->signum lockless in parallel, make
          * sure we read it once and use the same value throughout.
          */
-        int signum = ACCESS_ONCE(fown->signum);
+        int signum = READ_ONCE(fown->signum);
 
         if (!sigio_perm(p, fown, signum))
                 return;
diff --git a/fs/fs_pin.c b/fs/fs_pin.c
index e747b3d720ee..2d07f292b625 100644
--- a/fs/fs_pin.c
+++ b/fs/fs_pin.c
@@ -78,7 +78,7 @@ void mnt_pin_kill(struct mount *m)
         while (1) {
                 struct hlist_node *p;
                 rcu_read_lock();
-                p = ACCESS_ONCE(m->mnt_pins.first);
+                p = READ_ONCE(m->mnt_pins.first);
                 if (!p) {
                         rcu_read_unlock();
                         break;
@@ -92,7 +92,7 @@ void group_pin_kill(struct hlist_head *p)
         while (1) {
                 struct hlist_node *q;
                 rcu_read_lock();
-                q = ACCESS_ONCE(p->first);
+                q = READ_ONCE(p->first);
                 if (!q) {
                         rcu_read_unlock();
                         break;
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 13c65dd2d37d..a42d89371748 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -33,7 +33,7 @@ static struct fuse_dev *fuse_get_dev(struct file *file)
          * Lockless access is OK, because file->private data is set
          * once during mount and is valid until the file is released.
          */
-        return ACCESS_ONCE(file->private_data);
+        return READ_ONCE(file->private_data);
 }
 
 static void fuse_request_init(struct fuse_req *req, struct page **pages,
diff --git a/fs/inode.c b/fs/inode.c
index d1e35b53bb23..fd401028a309 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -2090,7 +2090,7 @@ void inode_set_flags(struct inode *inode, unsigned int flags,
 
         WARN_ON_ONCE(flags & ~mask);
         do {
-                old_flags = ACCESS_ONCE(inode->i_flags);
+                old_flags = READ_ONCE(inode->i_flags);
                 new_flags = (old_flags & ~mask) | flags;
         } while (unlikely(cmpxchg(&inode->i_flags, old_flags,
                                   new_flags) != old_flags));
diff --git a/fs/namei.c b/fs/namei.c
index c75ea03ca147..40a0f34bf990 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1209,7 +1209,7 @@ static int follow_managed(struct path *path, struct nameidata *nd)
         /* Given that we're not holding a lock here, we retain the value in a
          * local variable for each dentry as we look at it so that we don't see
          * the components of that value change under us */
-        while (managed = ACCESS_ONCE(path->dentry->d_flags),
+        while (managed = READ_ONCE(path->dentry->d_flags),
                managed &= DCACHE_MANAGED_DENTRY,
                unlikely(managed != 0)) {
                 /* Allow the filesystem to manage the transit without i_mutex
@@ -1394,7 +1394,7 @@ int follow_down(struct path *path)
         unsigned managed;
         int ret;
 
-        while (managed = ACCESS_ONCE(path->dentry->d_flags),
+        while (managed = READ_ONCE(path->dentry->d_flags),
                unlikely(managed & DCACHE_MANAGED_DENTRY)) {
                 /* Allow the filesystem to manage the transit without i_mutex
                  * being held.
diff --git a/fs/namespace.c b/fs/namespace.c
index d18deb4c410b..e158ec6b527b 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -353,7 +353,7 @@ int __mnt_want_write(struct vfsmount *m)
          * incremented count after it has set MNT_WRITE_HOLD.
          */
         smp_mb();
-        while (ACCESS_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD)
+        while (READ_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD)
                 cpu_relax();
         /*
          * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 5ceaeb1f6fb6..f439f1c45008 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1081,7 +1081,7 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags)
         int error;
 
         if (flags & LOOKUP_RCU) {
-                parent = ACCESS_ONCE(dentry->d_parent);
+                parent = READ_ONCE(dentry->d_parent);
                 dir = d_inode_rcu(parent);
                 if (!dir)
                         return -ECHILD;
@@ -1168,7 +1168,7 @@ out_set_verifier:
         nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
  out_valid:
         if (flags & LOOKUP_RCU) {
-                if (parent != ACCESS_ONCE(dentry->d_parent))
+                if (parent != READ_ONCE(dentry->d_parent))
                         return -ECHILD;
         } else
                 dput(parent);
@@ -1582,7 +1582,7 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
                 struct inode *dir;
 
                 if (flags & LOOKUP_RCU) {
-                        parent = ACCESS_ONCE(dentry->d_parent);
+                        parent = READ_ONCE(dentry->d_parent);
                         dir = d_inode_rcu(parent);
                         if (!dir)
                                 return -ECHILD;
@@ -1596,7 +1596,7 @@ static int nfs4_lookup_revalidate(struct dentry *dentry, unsigned int flags)
                         ret = -ECHILD;
                 if (!(flags & LOOKUP_RCU))
                         dput(parent);
-                else if (parent != ACCESS_ONCE(dentry->d_parent))
+                else if (parent != READ_ONCE(dentry->d_parent))
                         return -ECHILD;
                 goto out;
         }
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 77a8eacbe032..375e8bf0dd24 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -453,7 +453,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
                 cutime = sig->cutime;
                 cstime = sig->cstime;
                 cgtime = sig->cgtime;
-                rsslim = ACCESS_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
+                rsslim = READ_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
 
                 /* add up live thread stats at the group level */
                 if (whole) {
diff --git a/fs/proc_namespace.c b/fs/proc_namespace.c
index 99dff222fe67..03afd5150916 100644
--- a/fs/proc_namespace.c
+++ b/fs/proc_namespace.c
@@ -27,7 +27,7 @@ static unsigned mounts_poll(struct file *file, poll_table *wait)
 
         poll_wait(file, &p->ns->poll, wait);
 
-        event = ACCESS_ONCE(ns->event);
+        event = READ_ONCE(ns->event);
         if (m->poll_event != event) {
                 m->poll_event = event;
                 res |= POLLERR | POLLPRI;
diff --git a/fs/splice.c b/fs/splice.c
index f3084cce0ea6..39e2dc01ac12 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -253,7 +253,7 @@ EXPORT_SYMBOL(add_to_pipe);
  */
 int splice_grow_spd(const struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
 {
-        unsigned int buffers = ACCESS_ONCE(pipe->buffers);
+        unsigned int buffers = READ_ONCE(pipe->buffers);
 
         spd->nr_pages_max = buffers;
         if (buffers <= PIPE_DEF_BUFFERS)
diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c
index 1c713fd5b3e6..f46d133c0949 100644
--- a/fs/userfaultfd.c
+++ b/fs/userfaultfd.c
@@ -381,7 +381,7 @@ int handle_userfault(struct vm_fault *vmf, unsigned long reason)
          * in __get_user_pages if userfaultfd_release waits on the
          * caller of handle_userfault to release the mmap_sem.
          */
-        if (unlikely(ACCESS_ONCE(ctx->released))) {
+        if (unlikely(READ_ONCE(ctx->released))) {
                 /*
                  * Don't return VM_FAULT_SIGBUS in this case, so a non
                  * cooperative manager can close the uffd after the
@@ -477,7 +477,7 @@ int handle_userfault(struct vm_fault *vmf, unsigned long reason)
                                                        vmf->flags, reason);
         up_read(&mm->mmap_sem);
 
-        if (likely(must_wait && !ACCESS_ONCE(ctx->released) &&
+        if (likely(must_wait && !READ_ONCE(ctx->released) &&
                    (return_to_userland ? !signal_pending(current) :
                     !fatal_signal_pending(current)))) {
                 wake_up_poll(&ctx->fd_wqh, POLLIN);
@@ -586,7 +586,7 @@ static void userfaultfd_event_wait_completion(struct userfaultfd_ctx *ctx,
                 set_current_state(TASK_KILLABLE);
                 if (ewq->msg.event == 0)
                         break;
-                if (ACCESS_ONCE(ctx->released) ||
+                if (READ_ONCE(ctx->released) ||
                     fatal_signal_pending(current)) {
                         /*
                          * &ewq->wq may be queued in fork_event, but
@@ -833,7 +833,7 @@ static int userfaultfd_release(struct inode *inode, struct file *file)
         struct userfaultfd_wake_range range = { .len = 0, };
         unsigned long new_flags;
 
-        ACCESS_ONCE(ctx->released) = true;
+        WRITE_ONCE(ctx->released, true);
 
         if (!mmget_not_zero(mm))
                 goto wakeup;
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 51bf7b827387..129975970d99 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -592,9 +592,9 @@ xlog_valid_lsn(
          * a transiently forward state. Instead, we can see the LSN in a
          * transiently behind state if we happen to race with a cycle wrap.
          */
-        cur_cycle = ACCESS_ONCE(log->l_curr_cycle);
+        cur_cycle = READ_ONCE(log->l_curr_cycle);
         smp_rmb();
-        cur_block = ACCESS_ONCE(log->l_curr_block);
+        cur_block = READ_ONCE(log->l_curr_block);
 
         if ((CYCLE_LSN(lsn) > cur_cycle) ||
             (CYCLE_LSN(lsn) == cur_cycle && BLOCK_LSN(lsn) > cur_block)) {