sched/wait: Rename wait_queue_t => wait_queue_entry_t

Rename:

	wait_queue_t		=>	wait_queue_entry_t

'wait_queue_t' was always a slight misnomer: its name implies that it's a "queue",
but in reality it's a queue *entry*. The 'real' queue is the wait queue head,
which had to carry the name.

Start sorting this out by renaming it to 'wait_queue_entry_t'.

This also allows the real structure name 'struct __wait_queue' to
lose its double underscore and become 'struct wait_queue_entry',
which is the more canonical nomenclature for such data types.

Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>

16 files changed, 35 insertions, 35 deletions

diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index beef981aa54f..974f5346458a 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -83,7 +83,7 @@ struct autofs_info {
 struct autofs_wait_queue {
         wait_queue_head_t queue;
         struct autofs_wait_queue *next;
-        autofs_wqt_t wait_queue_token;
+        autofs_wqt_t wait_queue_entry_token;
         /* We use the following to see what we are waiting for */
         struct qstr name;
         u32 dev;
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index 24a58bf9ca72..7071895b0678 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -104,7 +104,7 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
         size_t pktsz;
 
         pr_debug("wait id = 0x%08lx, name = %.*s, type=%d\n",
-                 (unsigned long) wq->wait_queue_token,
+                 (unsigned long) wq->wait_queue_entry_token,
                  wq->name.len, wq->name.name, type);
 
         memset(&pkt, 0, sizeof(pkt)); /* For security reasons */
@@ -120,7 +120,7 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
 
                 pktsz = sizeof(*mp);
 
-                mp->wait_queue_token = wq->wait_queue_token;
+                mp->wait_queue_entry_token = wq->wait_queue_entry_token;
                 mp->len = wq->name.len;
                 memcpy(mp->name, wq->name.name, wq->name.len);
                 mp->name[wq->name.len] = '\0';
@@ -133,7 +133,7 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
 
                 pktsz = sizeof(*ep);
 
-                ep->wait_queue_token = wq->wait_queue_token;
+                ep->wait_queue_entry_token = wq->wait_queue_entry_token;
                 ep->len = wq->name.len;
                 memcpy(ep->name, wq->name.name, wq->name.len);
                 ep->name[wq->name.len] = '\0';
@@ -153,7 +153,7 @@ static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
 
                 pktsz = sizeof(*packet);
 
-                packet->wait_queue_token = wq->wait_queue_token;
+                packet->wait_queue_entry_token = wq->wait_queue_entry_token;
                 packet->len = wq->name.len;
                 memcpy(packet->name, wq->name.name, wq->name.len);
                 packet->name[wq->name.len] = '\0';
@@ -428,7 +428,7 @@ int autofs4_wait(struct autofs_sb_info *sbi,
                         return -ENOMEM;
                 }
 
-                wq->wait_queue_token = autofs4_next_wait_queue;
+                wq->wait_queue_entry_token = autofs4_next_wait_queue;
                 if (++autofs4_next_wait_queue == 0)
                         autofs4_next_wait_queue = 1;
                 wq->next = sbi->queues;
@@ -461,7 +461,7 @@ int autofs4_wait(struct autofs_sb_info *sbi,
                 }
 
                 pr_debug("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
-                         (unsigned long) wq->wait_queue_token, wq->name.len,
+                         (unsigned long) wq->wait_queue_entry_token, wq->name.len,
                          wq->name.name, notify);
 
                 /*
@@ -471,7 +471,7 @@ int autofs4_wait(struct autofs_sb_info *sbi,
         } else {
                 wq->wait_ctr++;
                 pr_debug("existing wait id = 0x%08lx, name = %.*s, nfy=%d\n",
-                         (unsigned long) wq->wait_queue_token, wq->name.len,
+                         (unsigned long) wq->wait_queue_entry_token, wq->name.len,
                          wq->name.name, notify);
                 mutex_unlock(&sbi->wq_mutex);
                 kfree(qstr.name);
@@ -550,13 +550,13 @@ int autofs4_wait(struct autofs_sb_info *sbi,
 }
 
 
-int autofs4_wait_release(struct autofs_sb_info *sbi, autofs_wqt_t wait_queue_token, int status)
+int autofs4_wait_release(struct autofs_sb_info *sbi, autofs_wqt_t wait_queue_entry_token, int status)
 {
         struct autofs_wait_queue *wq, **wql;
 
         mutex_lock(&sbi->wq_mutex);
         for (wql = &sbi->queues; (wq = *wql) != NULL; wql = &wq->next) {
-                if (wq->wait_queue_token == wait_queue_token)
+                if (wq->wait_queue_entry_token == wait_queue_entry_token)
                         break;
         }
 
diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h
index 9bf90bcc56ac..54a4fcd679ed 100644
--- a/fs/cachefiles/internal.h
+++ b/fs/cachefiles/internal.h
@@ -97,7 +97,7 @@ struct cachefiles_cache {
  * backing file read tracking
  */
 struct cachefiles_one_read {
-        wait_queue_t                    monitor;        /* link into monitored waitqueue */
+        wait_queue_entry_t                      monitor;        /* link into monitored waitqueue */
         struct page                     *back_page;     /* backing file page we're waiting for */
         struct page                     *netfs_page;    /* netfs page we're going to fill */
         struct fscache_retrieval        *op;            /* retrieval op covering this */
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index 41df8a27d7eb..3978b324cbca 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -204,7 +204,7 @@ wait_for_old_object:
                 wait_queue_head_t *wq;
 
                 signed long timeout = 60 * HZ;
-                wait_queue_t wait;
+                wait_queue_entry_t wait;
                 bool requeue;
 
                 /* if the object we're waiting for is queued for processing,
diff --git a/fs/cachefiles/rdwr.c b/fs/cachefiles/rdwr.c
index afbdc418966d..8be33b33b981 100644
--- a/fs/cachefiles/rdwr.c
+++ b/fs/cachefiles/rdwr.c
@@ -21,7 +21,7 @@
  * - we use this to detect read completion of backing pages
  * - the caller holds the waitqueue lock
  */
-static int cachefiles_read_waiter(wait_queue_t *wait, unsigned mode,
+static int cachefiles_read_waiter(wait_queue_entry_t *wait, unsigned mode,
                                   int sync, void *_key)
 {
         struct cachefiles_one_read *monitor =
diff --git a/fs/dax.c b/fs/dax.c
index 2a6889b3585f..323ea481d4a8 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -84,7 +84,7 @@ struct exceptional_entry_key {
 };
 
 struct wait_exceptional_entry_queue {
-        wait_queue_t wait;
+        wait_queue_entry_t wait;
         struct exceptional_entry_key key;
 };
 
@@ -108,7 +108,7 @@ static wait_queue_head_t *dax_entry_waitqueue(struct address_space *mapping,
         return wait_table + hash;
 }
 
-static int wake_exceptional_entry_func(wait_queue_t *wait, unsigned int mode,
+static int wake_exceptional_entry_func(wait_queue_entry_t *wait, unsigned int mode,
                                        int sync, void *keyp)
 {
         struct exceptional_entry_key *key = keyp;
diff --git a/fs/eventfd.c b/fs/eventfd.c
index 68b9fffcb2c8..9736df2ce89d 100644
--- a/fs/eventfd.c
+++ b/fs/eventfd.c
@@ -191,7 +191,7 @@ static void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt)
  * This is used to atomically remove a wait queue entry from the eventfd wait
  * queue head, and read/reset the counter value.
  */
-int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_t *wait,
+int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *wait,
                                   __u64 *cnt)
 {
         unsigned long flags;
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 5420767c9b68..5ac1cba5ef72 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -244,7 +244,7 @@ struct eppoll_entry {
          * Wait queue item that will be linked to the target file wait
          * queue head.
          */
-        wait_queue_t wait;
+        wait_queue_entry_t wait;
 
         /* The wait queue head that linked the "wait" wait queue item */
         wait_queue_head_t *whead;
@@ -347,13 +347,13 @@ static inline int ep_is_linked(struct list_head *p)
         return !list_empty(p);
 }
 
-static inline struct eppoll_entry *ep_pwq_from_wait(wait_queue_t *p)
+static inline struct eppoll_entry *ep_pwq_from_wait(wait_queue_entry_t *p)
 {
         return container_of(p, struct eppoll_entry, wait);
 }
 
 /* Get the "struct epitem" from a wait queue pointer */
-static inline struct epitem *ep_item_from_wait(wait_queue_t *p)
+static inline struct epitem *ep_item_from_wait(wait_queue_entry_t *p)
 {
         return container_of(p, struct eppoll_entry, wait)->base;
 }
@@ -1078,7 +1078,7 @@ static struct epitem *ep_find(struct eventpoll *ep, struct file *file, int fd)
  * mechanism. It is called by the stored file descriptors when they
  * have events to report.
  */
-static int ep_poll_callback(wait_queue_t *wait, unsigned mode, int sync, void *key)
+static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
 {
         int pwake = 0;
         unsigned long flags;
@@ -1699,7 +1699,7 @@ static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events,
         int res = 0, eavail, timed_out = 0;
         unsigned long flags;
         u64 slack = 0;
-        wait_queue_t wait;
+        wait_queue_entry_t wait;
         ktime_t expires, *to = NULL;
 
         if (timeout > 0) {
diff --git a/fs/fs_pin.c b/fs/fs_pin.c
index 611b5408f6ec..7b447a245760 100644
--- a/fs/fs_pin.c
+++ b/fs/fs_pin.c
@@ -34,7 +34,7 @@ void pin_insert(struct fs_pin *pin, struct vfsmount *m)
 
 void pin_kill(struct fs_pin *p)
 {
-        wait_queue_t wait;
+        wait_queue_entry_t wait;
 
         if (!p) {
                 rcu_read_unlock();
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index c08c46a3b8cd..be5a8f84e5bb 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -6372,7 +6372,7 @@ struct nfs4_lock_waiter {
 };
 
 static int
-nfs4_wake_lock_waiter(wait_queue_t *wait, unsigned int mode, int flags, void *key)
+nfs4_wake_lock_waiter(wait_queue_entry_t *wait, unsigned int mode, int flags, void *key)
 {
         int ret;
         struct cb_notify_lock_args *cbnl = key;
@@ -6415,7 +6415,7 @@ nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
                                            .inode = state->inode,
                                            .owner = &owner,
                                            .notified = false };
-        wait_queue_t wait;
+        wait_queue_entry_t wait;
 
         /* Don't bother with waitqueue if we don't expect a callback */
         if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags))
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index febed1217b3f..775304e7f96f 100644
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -2161,7 +2161,7 @@ void nilfs_flush_segment(struct super_block *sb, ino_t ino)
 }
 
 struct nilfs_segctor_wait_request {
-        wait_queue_t    wq;
+        wait_queue_entry_t      wq;
         __u32           seq;
         int             err;
         atomic_t        done;
diff --git a/fs/orangefs/orangefs-bufmap.c b/fs/orangefs/orangefs-bufmap.c
index 83b506020718..9e37b7028ea4 100644
--- a/fs/orangefs/orangefs-bufmap.c
+++ b/fs/orangefs/orangefs-bufmap.c
@@ -47,7 +47,7 @@ static void run_down(struct slot_map *m)
         if (m->c != -1) {
                 for (;;) {
                         if (likely(list_empty(&wait.task_list)))
-                                __add_wait_queue_tail(&m->q, &wait);
+                                __add_wait_queue_entry_tail(&m->q, &wait);
                         set_current_state(TASK_UNINTERRUPTIBLE);
 
                         if (m->c == -1)
@@ -85,7 +85,7 @@ static int wait_for_free(struct slot_map *m)
         do {
                 long n = left, t;
                 if (likely(list_empty(&wait.task_list)))
-                        __add_wait_queue_tail_exclusive(&m->q, &wait);
+                        __add_wait_queue_entry_tail_exclusive(&m->q, &wait);
                 set_current_state(TASK_INTERRUPTIBLE);
 
                 if (m->c > 0)
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 39bb1e838d8d..a11d773e5ff3 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -2956,7 +2956,7 @@ void reiserfs_wait_on_write_block(struct super_block *s)
 
 static void queue_log_writer(struct super_block *s)
 {
-        wait_queue_t wait;
+        wait_queue_entry_t wait;
         struct reiserfs_journal *journal = SB_JOURNAL(s);
         set_bit(J_WRITERS_QUEUED, &journal->j_state);
 
diff --git a/fs/select.c b/fs/select.c
index d6c652a31e99..5b524a977d91 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -180,7 +180,7 @@ static struct poll_table_entry *poll_get_entry(struct poll_wqueues *p)
         return table->entry++;
 }
 
-static int __pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)
+static int __pollwake(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
 {
         struct poll_wqueues *pwq = wait->private;
         DECLARE_WAITQUEUE(dummy_wait, pwq->polling_task);
@@ -206,7 +206,7 @@ static int __pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)
         return default_wake_function(&dummy_wait, mode, sync, key);
 }
 
-static int pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)
+static int pollwake(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
 {
         struct poll_table_entry *entry;
 
diff --git a/fs/signalfd.c b/fs/signalfd.c
index 7e3d71109f51..593b022ac11b 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -43,7 +43,7 @@ void signalfd_cleanup(struct sighand_struct *sighand)
         if (likely(!waitqueue_active(wqh)))
                 return;
 
-        /* wait_queue_t->func(POLLFREE) should do remove_wait_queue() */
+        /* wait_queue_entry_t->func(POLLFREE) should do remove_wait_queue() */
         wake_up_poll(wqh, POLLHUP | POLLFREE);
 }
 
diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c
index 1d622f276e3a..bda64fcd8a0c 100644
--- a/fs/userfaultfd.c
+++ b/fs/userfaultfd.c
@@ -81,7 +81,7 @@ struct userfaultfd_unmap_ctx {
 
 struct userfaultfd_wait_queue {
         struct uffd_msg msg;
-        wait_queue_t wq;
+        wait_queue_entry_t wq;
         struct userfaultfd_ctx *ctx;
         bool waken;
 };
@@ -91,7 +91,7 @@ struct userfaultfd_wake_range {
         unsigned long len;
 };
 
-static int userfaultfd_wake_function(wait_queue_t *wq, unsigned mode,
+static int userfaultfd_wake_function(wait_queue_entry_t *wq, unsigned mode,
                                      int wake_flags, void *key)
 {
         struct userfaultfd_wake_range *range = key;
@@ -860,7 +860,7 @@ wakeup:
 static inline struct userfaultfd_wait_queue *find_userfault_in(
                 wait_queue_head_t *wqh)
 {
-        wait_queue_t *wq;
+        wait_queue_entry_t *wq;
         struct userfaultfd_wait_queue *uwq;
 
         VM_BUG_ON(!spin_is_locked(&wqh->lock));
@@ -1747,7 +1747,7 @@ static long userfaultfd_ioctl(struct file *file, unsigned cmd,
 static void userfaultfd_show_fdinfo(struct seq_file *m, struct file *f)
 {
         struct userfaultfd_ctx *ctx = f->private_data;
-        wait_queue_t *wq;
+        wait_queue_entry_t *wq;
         struct userfaultfd_wait_queue *uwq;
         unsigned long pending = 0, total = 0;