[PATCH 11/30] dept: Apply Dept to wait/event of PG_{locked, writeback}
Gwan-gyeong Mun
gwan-gyeong.mun at intel.com
Mon Nov 21 09:54:43 UTC 2022
From: Byungchul Park <byungchul.park at lge.com>
Makes Dept able to track dependencies by PG_{locked,writeback}. For
instance, (un)lock_page() generates that type of dependency.
Signed-off-by: Byungchul Park <byungchul.park at lge.com>
Signed-off-by: Gwan-gyeong Mun <gwan-gyeong.mun at intel.com>
---
include/linux/dept_page.h | 94 +++++++++++++++++++++++++++++++++
include/linux/page-flags.h | 45 +++++++++++++++-
include/linux/pagemap.h | 7 ++-
init/main.c | 2 +
kernel/dependency/dept_object.h | 2 +-
lib/Kconfig.debug | 1 +
mm/filemap.c | 86 ++++++++++++++++++++++++++++++
mm/page_ext.c | 5 ++
8 files changed, 238 insertions(+), 4 deletions(-)
create mode 100644 include/linux/dept_page.h
diff --git a/include/linux/dept_page.h b/include/linux/dept_page.h
new file mode 100644
index 000000000000..152c4c92e3be
--- /dev/null
+++ b/include/linux/dept_page.h
@@ -0,0 +1,94 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __LINUX_DEPT_PAGE_H
+#define __LINUX_DEPT_PAGE_H
+
+#ifdef CONFIG_DEPT
+#include <linux/dept.h>
+
+extern struct page_ext_operations dept_pglocked_ops;
+extern struct page_ext_operations dept_pgwriteback_ops;
+extern struct dept_map_common pglocked_mc;
+extern struct dept_map_common pgwriteback_mc;
+
+extern void dept_page_init(void);
+extern struct dept_map_each *get_pglocked_me(struct page *page, void **cookie);
+extern struct dept_map_each *get_pgwriteback_me(struct page *page, void **cookie);
+extern void put_pglocked_me(void *cookie);
+extern void put_pgwriteback_me(void *cookie);
+
+#define dept_pglocked_wait(f) \
+do { \
+ void *cookie; \
+ struct dept_map_each *me = get_pglocked_me(&(f)->page, &cookie);\
+ \
+ if (likely(me)) \
+ dept_wait_split_map(me, &pglocked_mc, _RET_IP_, __func__, 0);\
+ \
+ put_pglocked_me(cookie); \
+} while (0)
+
+#define dept_pglocked_set_bit(f) \
+do { \
+ void *cookie; \
+ struct dept_map_each *me = get_pglocked_me(&(f)->page, &cookie);\
+ \
+ if (likely(me)) \
+ dept_ask_event_split_map(me, &pglocked_mc); \
+ \
+ put_pglocked_me(cookie); \
+} while (0)
+
+#define dept_pglocked_event(f) \
+do { \
+ void *cookie; \
+ struct dept_map_each *me = get_pglocked_me(&(f)->page, &cookie);\
+ \
+ if (likely(me)) \
+ dept_event_split_map(me, &pglocked_mc, _RET_IP_, __func__);\
+ \
+ put_pglocked_me(cookie); \
+} while (0)
+
+#define dept_pgwriteback_wait(f) \
+do { \
+ void *cookie; \
+ struct dept_map_each *me = get_pgwriteback_me(&(f)->page, &cookie);\
+ \
+ if (likely(me)) \
+ dept_wait_split_map(me, &pgwriteback_mc, _RET_IP_, __func__, 0);\
+ \
+ put_pgwriteback_me(cookie); \
+} while (0)
+
+#define dept_pgwriteback_set_bit(f) \
+do { \
+ void *cookie; \
+ struct dept_map_each *me = get_pgwriteback_me(&(f)->page, &cookie);\
+ \
+ if (likely(me)) \
+ dept_ask_event_split_map(me, &pgwriteback_mc); \
+ \
+ put_pgwriteback_me(cookie); \
+} while (0)
+
+#define dept_pgwriteback_event(f) \
+do { \
+ void *cookie; \
+ struct dept_map_each *me = get_pgwriteback_me(&(f)->page, &cookie);\
+ \
+ if (likely(me)) \
+ dept_event_split_map(me, &pgwriteback_mc, _RET_IP_, __func__);\
+ \
+ put_pgwriteback_me(cookie); \
+} while (0)
+#else
+#define dept_page_init() do { } while (0)
+#define dept_pglocked_wait(f) do { } while (0)
+#define dept_pglocked_set_bit(f) do { } while (0)
+#define dept_pglocked_event(f) do { } while (0)
+#define dept_pgwriteback_wait(f) do { } while (0)
+#define dept_pgwriteback_set_bit(f) do { } while (0)
+#define dept_pgwriteback_event(f) do { } while (0)
+#endif
+
+#endif /* __LINUX_DEPT_PAGE_H */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 0b0ae5084e60..d221cbbef586 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -470,7 +470,6 @@ static inline int TestClearPage##uname(struct page *page) { return 0; }
#define TESTSCFLAG_FALSE(uname, lname) \
TESTSETFLAG_FALSE(uname, lname) TESTCLEARFLAG_FALSE(uname, lname)
-__PAGEFLAG(Locked, locked, PF_NO_TAIL)
PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)
PAGEFLAG(Error, error, PF_NO_TAIL) TESTCLEARFLAG(Error, error, PF_NO_TAIL)
PAGEFLAG(Referenced, referenced, PF_HEAD)
@@ -518,7 +517,6 @@ PAGEFLAG(OwnerPriv1, owner_priv_1, PF_ANY)
* risky: they bypass page accounting.
*/
TESTPAGEFLAG(Writeback, writeback, PF_NO_TAIL)
- TESTSCFLAG(Writeback, writeback, PF_NO_TAIL)
PAGEFLAG(MappedToDisk, mappedtodisk, PF_NO_TAIL)
/* PG_readahead is only used for reads; PG_reclaim is only for writes */
@@ -601,6 +599,49 @@ PAGEFLAG(SkipKASanPoison, skip_kasan_poison, PF_HEAD)
PAGEFLAG_FALSE(SkipKASanPoison, skip_kasan_poison)
#endif
+#ifdef CONFIG_DEPT
+TESTPAGEFLAG(Locked, locked, PF_NO_TAIL)
+__CLEARPAGEFLAG(Locked, locked, PF_NO_TAIL)
+TESTCLEARFLAG(Writeback, writeback, PF_NO_TAIL)
+
+#include <linux/dept_page.h>
+
+static __always_inline
+void __folio_set_locked(struct folio *folio)
+{
+ dept_pglocked_set_bit(folio);
+ __set_bit(PG_locked, folio_flags(folio, FOLIO_PF_NO_TAIL));
+}
+
+static __always_inline void __SetPageLocked(struct page *page)
+{
+ dept_pglocked_set_bit(page_folio(page));
+ __set_bit(PG_locked, &PF_NO_TAIL(page, 1)->flags);
+}
+
+static __always_inline
+bool folio_test_set_writeback(struct folio *folio)
+{
+ bool ret = test_and_set_bit(PG_writeback, folio_flags(folio, FOLIO_PF_NO_TAIL));
+
+ if (!ret)
+ dept_pgwriteback_set_bit(folio);
+ return ret;
+}
+
+static __always_inline int TestSetPageWriteback(struct page *page)
+{
+ int ret = test_and_set_bit(PG_writeback, &PF_NO_TAIL(page, 1)->flags);
+
+ if (!ret)
+ dept_pgwriteback_set_bit(page_folio(page));
+ return ret;
+}
+#else
+__PAGEFLAG(Locked, locked, PF_NO_TAIL)
+TESTSCFLAG(Writeback, writeback, PF_NO_TAIL)
+#endif
+
/*
* PageReported() is used to track reported free pages within the Buddy
* allocator. We can use the non-atomic version of the test and set
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index bbccb4044222..85773310ceeb 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -15,6 +15,7 @@
#include <linux/bitops.h>
#include <linux/hardirq.h> /* for in_interrupt() */
#include <linux/hugetlb_inline.h>
+#include <linux/dept_page.h>
struct folio_batch;
@@ -899,7 +900,11 @@ void folio_unlock(struct folio *folio);
*/
static inline bool folio_trylock(struct folio *folio)
{
- return likely(!test_and_set_bit_lock(PG_locked, folio_flags(folio, 0)));
+ int ret = test_and_set_bit_lock(PG_locked, folio_flags(folio, 0));
+
+ if (likely(!ret))
+ dept_pglocked_set_bit(folio);
+ return likely(!ret);
}
/*
diff --git a/init/main.c b/init/main.c
index 358a8bc85390..b69b1bc023b6 100644
--- a/init/main.c
+++ b/init/main.c
@@ -103,6 +103,7 @@
#include <linux/stackdepot.h>
#include <linux/randomize_kstack.h>
#include <net/net_namespace.h>
+#include <linux/pagemap.h>
#include <asm/io.h>
#include <asm/bugs.h>
@@ -1078,6 +1079,7 @@ asmlinkage __visible void __init __no_sanitize_address start_kernel(void)
lockdep_init();
dept_init();
+ dept_page_init();
/*
* Need to run this when irqs are enabled, because it wants
diff --git a/kernel/dependency/dept_object.h b/kernel/dependency/dept_object.h
index 0b7eb16fe9fb..75b4212fa124 100644
--- a/kernel/dependency/dept_object.h
+++ b/kernel/dependency/dept_object.h
@@ -6,7 +6,7 @@
* nr: # of the object that should be kept in the pool.
*/
-OBJECT(dep, 1024 * 8)
+OBJECT(dep, 1024 * 16)
OBJECT(class, 1024 * 8)
OBJECT(stack, 1024 * 32)
OBJECT(ecxt, 1024 * 16)
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 683d8a54797b..75de2a04da1b 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1236,6 +1236,7 @@ config DEPT
select DEBUG_RWSEMS
select DEBUG_WW_MUTEX_SLOWPATH
select DEBUG_LOCK_ALLOC
+ select PAGE_EXTENSION
select TRACE_IRQFLAGS
select STACKTRACE
select FRAME_POINTER if !MIPS && !PPC && !ARM && !S390 && !MICROBLAZE && !ARC && !X86
diff --git a/mm/filemap.c b/mm/filemap.c
index 08341616ae7a..7b72d934dcec 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -1132,6 +1132,11 @@ static void folio_wake_bit(struct folio *folio, int bit_nr)
unsigned long flags;
wait_queue_entry_t bookmark;
+ if (bit_nr == PG_locked)
+ dept_pglocked_event(folio);
+ else if (bit_nr == PG_writeback)
+ dept_pgwriteback_event(folio);
+
key.folio = folio;
key.bit_nr = bit_nr;
key.page_match = 0;
@@ -1204,6 +1209,10 @@ static inline bool folio_trylock_flag(struct folio *folio, int bit_nr,
if (wait->flags & WQ_FLAG_EXCLUSIVE) {
if (test_and_set_bit(bit_nr, &folio->flags))
return false;
+ else if (bit_nr == PG_locked)
+ dept_pglocked_set_bit(folio);
+ else if (bit_nr == PG_writeback)
+ dept_pgwriteback_set_bit(folio);
} else if (test_bit(bit_nr, &folio->flags))
return false;
@@ -1225,6 +1234,11 @@ static inline int folio_wait_bit_common(struct folio *folio, int bit_nr,
unsigned long pflags;
bool in_thrashing;
+ if (bit_nr == PG_locked)
+ dept_pglocked_wait(folio);
+ else if (bit_nr == PG_writeback)
+ dept_pgwriteback_wait(folio);
+
if (bit_nr == PG_locked &&
!folio_test_uptodate(folio) && folio_test_workingset(folio)) {
delayacct_thrashing_start(&in_thrashing);
@@ -1314,6 +1328,11 @@ static inline int folio_wait_bit_common(struct folio *folio, int bit_nr,
if (unlikely(test_and_set_bit(bit_nr, folio_flags(folio, 0))))
goto repeat;
+ if (bit_nr == PG_locked)
+ dept_pglocked_set_bit(folio);
+ else if (bit_nr == PG_writeback)
+ dept_pgwriteback_set_bit(folio);
+
wait->flags |= WQ_FLAG_DONE;
break;
}
@@ -3949,3 +3968,70 @@ bool filemap_release_folio(struct folio *folio, gfp_t gfp)
return try_to_free_buffers(folio);
}
EXPORT_SYMBOL(filemap_release_folio);
+
+#ifdef CONFIG_DEPT
+static bool need_dept_pglocked(void)
+{
+ return true;
+}
+
+struct page_ext_operations dept_pglocked_ops = {
+ .size = sizeof(struct dept_map_each),
+ .need = need_dept_pglocked,
+};
+
+struct dept_map_each *get_pglocked_me(struct page *p, void **cookie)
+{
+ struct page_ext *e = page_ext_get(p);
+
+ *cookie = (void *)e;
+
+ return e ? (void *)e + dept_pglocked_ops.offset : NULL;
+}
+EXPORT_SYMBOL(get_pglocked_me);
+
+void put_pglocked_me(void *cookie)
+{
+ if (cookie)
+ page_ext_put((struct page_ext *)cookie);
+}
+EXPORT_SYMBOL(put_pglocked_me);
+
+static bool need_dept_pgwriteback(void)
+{
+ return true;
+}
+
+struct page_ext_operations dept_pgwriteback_ops = {
+ .size = sizeof(struct dept_map_each),
+ .need = need_dept_pgwriteback,
+};
+
+struct dept_map_each *get_pgwriteback_me(struct page *p, void **cookie)
+{
+ struct page_ext *e = page_ext_get(p);
+
+ *cookie = (void *)e;
+
+ return e ? (void *)e + dept_pgwriteback_ops.offset : NULL;
+}
+EXPORT_SYMBOL(get_pgwriteback_me);
+
+void put_pgwriteback_me(void *cookie)
+{
+ if (cookie)
+ page_ext_put((struct page_ext *)cookie);
+}
+EXPORT_SYMBOL(put_pgwriteback_me);
+
+struct dept_map_common pglocked_mc;
+EXPORT_SYMBOL(pglocked_mc);
+struct dept_map_common pgwriteback_mc;
+EXPORT_SYMBOL(pgwriteback_mc);
+
+void dept_page_init(void)
+{
+ dept_split_map_common_init(&pglocked_mc, NULL, "pglocked");
+ dept_split_map_common_init(&pgwriteback_mc, NULL, "pgwriteback");
+}
+#endif
diff --git a/mm/page_ext.c b/mm/page_ext.c
index affe80243b6d..e5767b8ed01b 100644
--- a/mm/page_ext.c
+++ b/mm/page_ext.c
@@ -10,6 +10,7 @@
#include <linux/page_idle.h>
#include <linux/page_table_check.h>
#include <linux/rcupdate.h>
+#include <linux/dept_page.h>
/*
* struct page extension
@@ -84,6 +85,10 @@ static struct page_ext_operations *page_ext_ops[] __initdata = {
#ifdef CONFIG_PAGE_TABLE_CHECK
&page_table_check_ops,
#endif
+#ifdef CONFIG_DEPT
+ &dept_pglocked_ops,
+ &dept_pgwriteback_ops,
+#endif
};
unsigned long page_ext_size = sizeof(struct page_ext);
--
2.37.1
More information about the Intel-gfx-trybot
mailing list