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

!5033 v3 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/TVO7R5GLUWSG3HG6J5MEDL5YSZUK2ERX/ 
Fix softlockup by removing the wait_queue flag: WQ_FLAG_BOOKMARK.

Changes in V3:
 - corrected the wrong bugzilla number in commit message.

Changes in V2:
 - fixed incorrect mainline patch adaptation of WQ_FLAG_{CUSTOM, DONE}.

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


-- 
2.39.2
 
https://gitee.com/openeuler/kernel/issues/I93R1D 
 
Link:https://gitee.com/openeuler/kernel/pulls/5033

 

Reviewed-by: default avatarZucheng Zheng <zhengzucheng@huawei.com>
Reviewed-by: default avatarKefeng Wang <wangkefeng.wang@huawei.com>
Signed-off-by: default avatarJialin Zhang <zhangjialin11@huawei.com>
parents 069e191b fd26b0a9

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

mm/filemap.c

+1 −20
Original line number Diff line number Diff line
@@ -1095,32 +1095,13 @@ static void wake_up_page_bit(struct page *page, int bit_nr) 
	wait_queue_head_t *q = page_waitqueue(page);

	struct wait_page_key key;

	unsigned long flags;

	wait_queue_entry_t bookmark;



	key.page = page;

	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 is possible for other pages to have collided on the waitqueue