Skip to contentSkip to conversation

writeback: add tracepoints for cgroup foreign writebacks

PATCH In review Tejun Heo 3 participants 8 messages Aug 29, 2019 – Sep 2, 2019

Subsystems (6)
lore
Share & tools
lore

Tejun Heo

author
#0 lore raw

PATCH 1/1 writeback: add tracepoints for cgroup foreign writebacks

cgroup foreign inode handling has quite a bit of heuristics and internal states which sometimes makes it difficult to understand what's going on. Add tracepoints to improve visibility.

---
 fs/fs-writeback.c                |    5 +
 include/trace/events/writeback.h |  123 +++++++++++++++++++++++++++++++++++++++
 mm/memcontrol.c                  |    5 +
 3 files changed, 133 insertions(+)
fs/fs-writeback.c +5 -0
index 658dc16c9e6d..8aaa7eec7b74 100644
@@ -389,6 +389,8 @@ static void inode_switch_wbs_work_fn(struct work_struct *work)
 	if (unlikely(inode->i_state & I_FREEING))
 		goto skip_switch;
 
+	trace_inode_switch_wbs(inode, old_wb, new_wb);
+
 	/*
 	 * Count and transfer stats.  Note that PAGECACHE_TAG_DIRTY points
 	 * to possibly dirty pages while PAGECACHE_TAG_WRITEBACK points to
@@ -673,6 +675,9 @@ void wbc_detach_inode(struct writeback_control *wbc)
 		if (wbc->wb_id != max_id)
 			history |= (1U << slots) - 1;
 
+		if (history)
+			trace_inode_foreign_history(inode, wbc, history);
+
 		/*
 		 * Switch if the current wb isn't the consistent winner.
 		 * If there are multiple closely competing dirtiers, the
include/trace/events/writeback.h +123 -0

129 lines not on this page · raw message

mm/memcontrol.c +5 -0
index eb626a290d93..b74c9d143d5e 100644
@@ -4159,6 +4159,8 @@ static int mem_cgroup_oom_control_write(struct cgroup_subsys_state *css,
 
 #ifdef CONFIG_CGROUP_WRITEBACK
 
+#include <trace/events/writeback.h>
+
 static int memcg_wb_domain_init(struct mem_cgroup *memcg, gfp_t gfp)
 {
 	return wb_domain_init(&memcg->cgwb_domain, gfp);
@@ -4296,6 +4298,8 @@ void mem_cgroup_track_foreign_dirty_slowpath(struct page *page,
 	int oldest = -1;
 	int i;
 
+	trace_track_foreign_dirty(page, wb);
+
 	/*
 	 * Pick the slot to use.  If there is already a slot for @wb, keep
 	 * using it.  If not replace the oldest one which isn't being
@@ -4356,6 +4360,7 @@ void mem_cgroup_flush_foreign(struct bdi_writeback *wb)
 		if (time_after64(frn->at, now - intv) &&
 		    atomic_read(&frn->done.cnt) == 1) {
 			frn->at = 0;
+			trace_flush_foreign(wb, frn->bdi_id, frn->memcg_id);
 			cgroup_writeback_by_id(frn->bdi_id, frn->memcg_id, 0,
 					       WB_REASON_FOREIGN_FLUSH,
 					       &frn->done);
maintainer
#1 lore raw
Quoted 3 lines · Tejun Heo

cgroup foreign inode handling has quite a bit of heuristics and internal states which sometimes makes it difficult to understand what's going on. Add tracepoints to improve visibility.

LGTM, applied.

Signature · 1 line
Jens Axboe
maintainer
#2 lore raw
In reply to Tejun Heo
Quoted 5 lines · Tejun Heo

cgroup foreign inode handling has quite a bit of heuristics and internal states which sometimes makes it difficult to understand what's going on. Add tracepoints to improve visibility.

...

Quoted 13 lines
include/trace/events/writeback.h +13 -0
+TRACE_EVENT(track_foreign_dirty,
+
+	TP_PROTO(struct page *page, struct bdi_writeback *wb),
+
+	TP_ARGS(page, wb),
+
+	TP_STRUCT__entry(
+		__array(char,		name, 32)
+		__field(u64,		bdi_id)
+		__field(unsigned long,	ino)
+		__field(unsigned int,	memcg_id)
+		__field(unsigned int,	cgroup_ino)
+		__field(unsigned int,	page_cgroup_ino)

include/trace/events/writeback.h static inline unsigned int __trace_wbc_assign_cgroup(struct writeback_control *w · line 260

Quoted 10 lines
include/trace/events/writeback.h +10 -0
+	),
+
+	TP_fast_assign(
+		strncpy(__entry->name,	dev_name(wb->bdi->dev), 32);
+		__entry->bdi_id		= wb->bdi->id;
+		__entry->ino		= page->mapping->host->i_ino;
+		__entry->memcg_id	= wb->memcg_css->id;
+		__entry->cgroup_ino	= __trace_wb_assign_cgroup(wb);
+		__entry->page_cgroup_ino = page->mem_cgroup->css.cgroup->kn->id.ino;
+	),

Are the page dereferences above safe? I suppose lock_page_memcg() protects the page->mem_cgroup->css.cgroup->kn->id dereference? But page->mapping does not seem to be protected by page lock?

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author
#3 lore raw

Hello, Jan.

Quoted 4 lines · Jan Kara
Quoted 4 lines
include/trace/events/writeback.h +4 -0
+	TP_fast_assign(
+		strncpy(__entry->name,	dev_name(wb->bdi->dev), 32);
+		__entry->bdi_id		= wb->bdi->id;
+		__entry->ino		= page->mapping->host->i_ino;
Quoted 8 lines

include/trace/events/writeback.h static inline unsigned int __trace_wbc_assign_cgroup(struct writeback_control *w · line 260

Quoted 4 lines
include/trace/events/writeback.h +4 -0
+		__entry->memcg_id	= wb->memcg_css->id;
+		__entry->cgroup_ino	= __trace_wb_assign_cgroup(wb);
+		__entry->page_cgroup_ino = page->mem_cgroup->css.cgroup->kn->id.ino;
+	),

Are the page dereferences above safe? I suppose lock_page_memcg() protects the page->mem_cgroup->css.cgroup->kn->id dereference? But page->mapping does not seem to be protected by page lock?

Hah, I assumed it would work because there are preceding if (page_mapping()) tests in the dirty paths -
e.g. __set_page_dirty_nobuffers(). Oh, regardless of that assumption, I should have used page_mapping().

Thanks.

Signature · 1 line
tejun
maintainer
#4 lore raw
Quoted 16 lines · Tejun Heo

Hello, Jan.

Quoted 4 lines · Jan Kara
Quoted 4 lines
include/trace/events/writeback.h +4 -0
+	TP_fast_assign(
+		strncpy(__entry->name,	dev_name(wb->bdi->dev), 32);
+		__entry->bdi_id		= wb->bdi->id;
+		__entry->ino		= page->mapping->host->i_ino;
Quoted 8 lines

include/trace/events/writeback.h static inline unsigned int __trace_wbc_assign_cgroup(struct writeback_control *w · line 260

Quoted 4 lines
include/trace/events/writeback.h +4 -0
+		__entry->memcg_id	= wb->memcg_css->id;
+		__entry->cgroup_ino	= __trace_wb_assign_cgroup(wb);
+		__entry->page_cgroup_ino = page->mem_cgroup->css.cgroup->kn->id.ino;
+	),

Are the page dereferences above safe? I suppose lock_page_memcg() protects the page->mem_cgroup->css.cgroup->kn->id dereference? But page->mapping does not seem to be protected by page lock?

Quoted 4 lines

Hah, I assumed it would work because there are preceding if (page_mapping()) tests in the dirty paths -
e.g. __set_page_dirty_nobuffers(). Oh, regardless of that assumption, I should have used page_mapping().

Well, but if you look at __set_page_dirty_nobuffers() it is careful. It does:

struct address_space *mapping = page_mapping(page);

if (!mapping) {
bail
}
... use mapping

Exactly because page->mapping can become NULL under your hands if you don't hold page lock. So I think you either need something similar in your tracepoint or handle this in the caller.

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author
#5 lore raw

Hello, Jan.

Quoted 5 lines · Jan Kara

Well, but if you look at __set_page_dirty_nobuffers() it is careful. It does:

struct address_space *mapping = page_mapping(page);

Quoted 8 lines

if (!mapping) {
bail
}
... use mapping

Exactly because page->mapping can become NULL under your hands if you don't hold page lock. So I think you either need something similar in your tracepoint or handle this in the caller.

So, account_page_dirtied() is called from two places.

__set_page_dirty() and __set_page_dirty_nobuffers(). The following is from the latter.

	lock_page_memcg(page);
	if (!TestSetPageDirty(page)) {
		struct address_space *mapping = page_mapping(page);
		...

		if (!mapping) {
			unlock_page_memcg(page);
			return 1;
		}

		xa_lock_irqsave(&mapping->i_pages, flags);
		BUG_ON(page_mapping(page) != mapping);
		WARN_ON_ONCE(!PagePrivate(page) && !PageUptodate(page));
		account_page_dirtied(page, mapping);
		...

If I'm reading it right, it's saying that at this point if mapping exists after setting page dirty, it must not change while locking i_pages.

__set_page_dirty_nobuffers() is more brief but seems to be making the same assumption.

	xa_lock_irqsave(&mapping->i_pages, flags);
	if (page->mapping) {	/* Race with truncate? */
		WARN_ON_ONCE(warn && !PageUptodate(page));
		account_page_dirtied(page, mapping);
		__xa_set_mark(&mapping->i_pages, page_index(page),
				PAGECACHE_TAG_DIRTY);
	}
	xa_unlock_irqrestore(&mapping->i_pages, flags);

Both are clearly assuming that once i_pages is locked, mapping can't change. So, inside account_page_dirtied(), mapping clearly can't change. The TP in question - track_foreign_dirty - is invoked from mem_cgroup_track_foreign_dirty() which is only called from account_page_dirty(), so I'm failing to see how mapping would change there.

Thanks.

Signature · 1 line
tejun
maintainer
#6 lore raw

Hello Tejun,

Quoted 36 lines · Tejun Heo
Quoted 5 lines · Jan Kara

Well, but if you look at __set_page_dirty_nobuffers() it is careful. It does:

struct address_space *mapping = page_mapping(page);

Quoted 8 lines

if (!mapping) {
bail
}
... use mapping

Exactly because page->mapping can become NULL under your hands if you don't hold page lock. So I think you either need something similar in your tracepoint or handle this in the caller.

So, account_page_dirtied() is called from two places.

__set_page_dirty() and __set_page_dirty_nobuffers(). The following is from the latter.

	lock_page_memcg(page);
	if (!TestSetPageDirty(page)) {
		struct address_space *mapping = page_mapping(page);
		...

		if (!mapping) {
			unlock_page_memcg(page);
			return 1;
		}

		xa_lock_irqsave(&mapping->i_pages, flags);
		BUG_ON(page_mapping(page) != mapping);
		WARN_ON_ONCE(!PagePrivate(page) && !PageUptodate(page));
		account_page_dirtied(page, mapping);
		...
Quoted 3 lines

If I'm reading it right, it's saying that at this point if mapping exists after setting page dirty, it must not change while locking i_pages.

Correct __set_page_dirty_nobuffers() is supposed to be called serialized with truncation either through page lock or other means. At least the comment says so and the code looks like that.

Quoted 3 lines

__set_page_dirty_nobuffers() is more brief but seems to be making the same assumption.

I suppose you mean __set_page_dirty() here.

Quoted 9 lines
	xa_lock_irqsave(&mapping->i_pages, flags);
	if (page->mapping) {	/* Race with truncate? */
		WARN_ON_ONCE(warn && !PageUptodate(page));
		account_page_dirtied(page, mapping);
		__xa_set_mark(&mapping->i_pages, page_index(page),
				PAGECACHE_TAG_DIRTY);
	}
	xa_unlock_irqrestore(&mapping->i_pages, flags);
Quoted 6 lines

Both are clearly assuming that once i_pages is locked, mapping can't change. So, inside account_page_dirtied(), mapping clearly can't change. The TP in question - track_foreign_dirty - is invoked from mem_cgroup_track_foreign_dirty() which is only called from account_page_dirty(), so I'm failing to see how mapping would change there.

I'm not sure where we depend here on page->mapping not getting cleared. The point is even if page->mapping is getting cleared while we work on the page, we have 'mapping' stored locally so we just account everything against the original mapping.

I've researched this a bit more and commit 2d6d7f982846 "mm: protect set_page_dirty() from ongoing truncation" introduced the idea that __set_page_dirty_nobuffers() should be only called synchronized with truncation. Now I know for a fact that this is not always the case (e.g. various RDMA drivers calling set_page_dirty() without a lock or any other protection against truncate) but let's consider this a bug in the caller of set_page_dirty(). So in the end I agree that you're fine with relying on page_mapping() not changing under you.

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author
#7 lore raw
In reply to Jan Kara
Quoted 3 lines · Jan Kara

Are the page dereferences above safe? I suppose lock_page_memcg() protects the page->mem_cgroup->css.cgroup->kn->id dereference? But page->mapping does not seem to be protected by page lock?

Forgot to respond to the mem_cgroup part. The page to memcg association never changes on cgroup2 as long as the page has ref, so I think that one should be safe.

Thanks.

Signature · 1 line
tejun