sched: remove wait bookmarks

There are no users of wait bookmarks left, so simplify the wait
code by removing them.

Link: https://lkml.kernel.org/r/20231010035829.544242-2-willy@infradead.org
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Acked-by: Ingo Molnar <mingo@kernel.org>
Cc: Benjamin Segall <bsegall@google.com>
Cc: Bin Lai <sclaibin@gmail.com>
Cc: Daniel Bristot de Oliveira <bristot@redhat.com>
Cc: Dietmar Eggemann <dietmar.eggemann@arm.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Juri Lelli <juri.lelli@redhat.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Steven Rostedt (Google) <rostedt@goodmis.org>
Cc: Valentin Schneider <vschneid@redhat.com>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/wait.h b/include/linux/wait.h
index 5ec7739400f4d7b923734f66fb50dfcb58243f2a..3473b663176f11073ab574fdefa6cced0c137303 100644 (file)
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -19,10 +19,9 @@ int default_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int
 /* wait_queue_entry::flags */
 #define WQ_FLAG_EXCLUSIVE      0x01
 #define WQ_FLAG_WOKEN          0x02
-#define WQ_FLAG_BOOKMARK       0x04
-#define WQ_FLAG_CUSTOM         0x08
-#define WQ_FLAG_DONE           0x10
-#define WQ_FLAG_PRIORITY       0x20
+#define WQ_FLAG_CUSTOM         0x04
+#define WQ_FLAG_DONE           0x08
+#define WQ_FLAG_PRIORITY       0x10
 
 /*
  * A single wait-queue entry structure:
@@ -212,8 +211,6 @@ __remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq
 int __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr, void *key);
 void __wake_up_on_current_cpu(struct wait_queue_head *wq_head, unsigned int mode, void *key);
 void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
-void __wake_up_locked_key_bookmark(struct wait_queue_head *wq_head,
-               unsigned int mode, void *key, wait_queue_entry_t *bookmark);
 void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
 void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
 void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);

diff --git a/kernel/sched/wait.c b/kernel/sched/wait.c
index 802d98cf2de317aa601100f4b153aabc0bb236b3..51e38f5f47018c953e31c834dc6385c182359359 100644 (file)
--- a/kernel/sched/wait.c
+++ b/kernel/sched/wait.c
@@ -57,13 +57,6 @@ void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry
 }
 EXPORT_SYMBOL(remove_wait_queue);
 
-/*
- * Scan threshold to break wait queue walk.
- * This allows a waker to take a break from holding the
- * wait queue lock during the wait queue walk.
- */
-#define WAITQUEUE_WALK_BREAK_CNT 64
-
 /*
  * The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
  * wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
@@ -78,21 +71,13 @@ EXPORT_SYMBOL(remove_wait_queue);
  * zero in this (rare) case, and we handle it by continuing to scan the queue.
  */
 static int __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
-                       int nr_exclusive, int wake_flags, void *key,
-                       wait_queue_entry_t *bookmark)
+                       int nr_exclusive, int wake_flags, void *key)
 {
        wait_queue_entry_t *curr, *next;
-       int cnt = 0;
 
        lockdep_assert_held(&wq_head->lock);
 
-       if (bookmark && (bookmark->flags & WQ_FLAG_BOOKMARK)) {
-               curr = list_next_entry(bookmark, entry);
-
-               list_del(&bookmark->entry);
-               bookmark->flags = 0;
-       } else
-               curr = list_first_entry(&wq_head->head, wait_queue_entry_t, entry);
+       curr = list_first_entry(&wq_head->head, wait_queue_entry_t, entry);
 
        if (&curr->entry == &wq_head->head)
                return nr_exclusive;
@@ -101,21 +86,11 @@ static int __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
                unsigned flags = curr->flags;
                int ret;
 
-               if (flags & WQ_FLAG_BOOKMARK)
-                       continue;
-
                ret = curr->func(curr, mode, wake_flags, key);
                if (ret < 0)
                        break;
                if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
                        break;
-
-               if (bookmark && (++cnt > WAITQUEUE_WALK_BREAK_CNT) &&
-                               (&next->entry != &wq_head->head)) {
-                       bookmark->flags = WQ_FLAG_BOOKMARK;
-                       list_add_tail(&bookmark->entry, &next->entry);
-                       break;
-               }
        }
 
        return nr_exclusive;
@@ -125,20 +100,12 @@ static int __wake_up_common_lock(struct wait_queue_head *wq_head, unsigned int m
                        int nr_exclusive, int wake_flags, void *key)
 {
        unsigned long flags;
-       wait_queue_entry_t bookmark;
-       int remaining = nr_exclusive;
+       int remaining;
 
-       bookmark.flags = 0;
-       bookmark.private = NULL;
-       bookmark.func = NULL;
-       INIT_LIST_HEAD(&bookmark.entry);
-
-       do {
-               spin_lock_irqsave(&wq_head->lock, flags);
-               remaining = __wake_up_common(wq_head, mode, remaining,
-                                               wake_flags, key, &bookmark);
-               spin_unlock_irqrestore(&wq_head->lock, flags);
-       } while (bookmark.flags & WQ_FLAG_BOOKMARK);
+       spin_lock_irqsave(&wq_head->lock, flags);
+       remaining = __wake_up_common(wq_head, mode, nr_exclusive, wake_flags,
+                       key);
+       spin_unlock_irqrestore(&wq_head->lock, flags);
 
        return nr_exclusive - remaining;
 }
@@ -171,23 +138,16 @@ void __wake_up_on_current_cpu(struct wait_queue_head *wq_head, unsigned int mode
  */
 void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr)
 {
-       __wake_up_common(wq_head, mode, nr, 0, NULL, NULL);
+       __wake_up_common(wq_head, mode, nr, 0, NULL);
 }
 EXPORT_SYMBOL_GPL(__wake_up_locked);
 
 void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)
 {
-       __wake_up_common(wq_head, mode, 1, 0, key, NULL);
+       __wake_up_common(wq_head, mode, 1, 0, key);
 }
 EXPORT_SYMBOL_GPL(__wake_up_locked_key);
 
-void __wake_up_locked_key_bookmark(struct wait_queue_head *wq_head,
-               unsigned int mode, void *key, wait_queue_entry_t *bookmark)
-{
-       __wake_up_common(wq_head, mode, 1, 0, key, bookmark);
-}
-EXPORT_SYMBOL_GPL(__wake_up_locked_key_bookmark);
-
 /**
  * __wake_up_sync_key - wake up threads blocked on a waitqueue.
  * @wq_head: the waitqueue
@@ -233,7 +193,7 @@ EXPORT_SYMBOL_GPL(__wake_up_sync_key);
 void __wake_up_locked_sync_key(struct wait_queue_head *wq_head,
                               unsigned int mode, void *key)
 {
-        __wake_up_common(wq_head, mode, 1, WF_SYNC, key, NULL);
+        __wake_up_common(wq_head, mode, 1, WF_SYNC, key);
 }
 EXPORT_SYMBOL_GPL(__wake_up_locked_sync_key);