Commit fd26b0a9 authored by Matthew Wilcox (Oracle)'s avatar Matthew Wilcox (Oracle) Committed by Zizhi Wo
Browse files

sched: remove wait bookmarks 

mainline inclusion
from mainline-v6.7-rc1
commit 37acade0ce8938f00d6979bd02b8043b5b7089ae
category: bugfix
bugzilla: https://gitee.com/openeuler/kernel/issues/I93R1D
CVE: NA

Reference: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=37acade0ce8938f00d6979bd02b8043b5b7089ae

--------------------------------

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: default avatarMatthew Wilcox (Oracle) <willy@infradead.org>
Acked-by: default avatarIngo 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: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarZizhi Wo <wozizhi@huawei.com>

Conflicts:
	include/linux/wait.h
	kernel/sched/wait.c
parent ab22590f

include/linux/wait.h

+2 −5
Original line number Diff line number Diff line
@@ -19,9 +19,8 @@ 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_CUSTOM		0x04

#define WQ_FLAG_DONE		0x08



/*

 * A single wait-queue entry structure:
@@ -201,8 +200,6 @@ __remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq 


void __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr, 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);

kernel/sched/wait.c

+8 −49
Original line number Diff line number Diff line
@@ -47,13 +47,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
@@ -64,20 +57,12 @@ 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);



	if (&curr->entry == &wq_head->head)
@@ -87,21 +72,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;
@@ -111,19 +86,10 @@ static void __wake_up_common_lock(struct wait_queue_head *wq_head, unsigned int 
			int nr_exclusive, int wake_flags, void *key)

{

	unsigned long flags;

	wait_queue_entry_t bookmark;



	bookmark.flags = 0;

	bookmark.private = NULL;

	bookmark.func = NULL;

	INIT_LIST_HEAD(&bookmark.entry);



	do {

	spin_lock_irqsave(&wq_head->lock, flags);

		nr_exclusive = __wake_up_common(wq_head, mode, nr_exclusive,

						wake_flags, key, &bookmark);

	__wake_up_common(wq_head, mode, nr_exclusive, wake_flags, key);

	spin_unlock_irqrestore(&wq_head->lock, flags);

	} while (bookmark.flags & WQ_FLAG_BOOKMARK);

}



/**
@@ -148,23 +114,16 @@ EXPORT_SYMBOL(__wake_up); 
 */

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
@@ -210,7 +169,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);