Unverified Commit 5c78757c authored by openeuler-ci-bot's avatar openeuler-ci-bot Committed by Gitee
Browse files

!4689 Remove WQ_FLAG_BOOKMARK flag 

Merge Pull Request from: @ci-robot 
 
PR sync from: Zizhi Wo <wozizhi@huawei.com>
https://mailweb.openeuler.org/hyperkitty/list/kernel@openeuler.org/message/QTBOF2AGZOJF37L3G4M73NJT6Z2FRQSY/ 
Fix softlockup by removing the wait_queue flag: WQ_FLAG_BOOKMARK.

Matthew Wilcox (Oracle) (2):
  filemap: remove use of wait bookmarks
  sched: remove wait bookmarks


-- 
2.39.2
 
https://gitee.com/openeuler/kernel/issues/I93R23 
 
Link:https://gitee.com/openeuler/kernel/pulls/4689

 

Reviewed-by: default avatarKefeng Wang <wangkefeng.wang@huawei.com>
Reviewed-by: default avatarZucheng Zheng <zhengzucheng@huawei.com>
Signed-off-by: default avatarZheng Zengkai <zhengzengkai@huawei.com>
parents 97ba28f6 0a0d5791

include/linux/wait.h

+3 −6
Original line number Diff line number Diff line
@@ -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);

kernel/sched/wait.c

+10 −50
Original line number Diff line number Diff line
@@ -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,20 +71,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)
@@ -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;



	bookmark.flags = 0;

	bookmark.private = NULL;

	bookmark.func = NULL;

	INIT_LIST_HEAD(&bookmark.entry);

	int remaining;



	do {

	spin_lock_irqsave(&wq_head->lock, flags);

		remaining = __wake_up_common(wq_head, mode, remaining,

						wake_flags, key, &bookmark);

	remaining = __wake_up_common(wq_head, mode, nr_exclusive, wake_flags,

			key);

	spin_unlock_irqrestore(&wq_head->lock, flags);

	} while (bookmark.flags & WQ_FLAG_BOOKMARK);



	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);

mm/filemap.c

+1 −20
Original line number Diff line number Diff line
@@ -1142,32 +1142,13 @@ static void folio_wake_bit(struct folio *folio, int bit_nr) 
	wait_queue_head_t *q = folio_waitqueue(folio);

	struct wait_page_key key;

	unsigned long flags;

	wait_queue_entry_t bookmark;



	key.folio = folio;

	key.bit_nr = bit_nr;

	key.page_match = 0;



	bookmark.flags = 0;

	bookmark.private = NULL;

	bookmark.func = NULL;

	INIT_LIST_HEAD(&bookmark.entry);



	spin_lock_irqsave(&q->lock, flags);

	__wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);



	while (bookmark.flags & WQ_FLAG_BOOKMARK) {

		/*

		 * Take a breather from holding the lock,

		 * allow pages that finish wake up asynchronously

		 * to acquire the lock and remove themselves

		 * from wait queue

		 */

		spin_unlock_irqrestore(&q->lock, flags);

		cpu_relax();

		spin_lock_irqsave(&q->lock, flags);

		__wake_up_locked_key_bookmark(q, TASK_NORMAL, &key, &bookmark);

	}

	__wake_up_locked_key(q, TASK_NORMAL, &key);



	/*

	 * It's possible to miss clearing waiters here, when we woke our page