writeback: Generalize and expose wb_completion

wb_completion is used to track writeback completions. We want to use it from memcg side for foreign inode flushes. This patch updates it to remember the target waitq instead of assuming bdi->wb_waitq and expose it outside of fs-writeback.c.

Tejun Heo committed 7 years ago

Commit 5b9cce41 parent 38b4e093 files · +36 −33Browse files

Unified · Split

3 files

fs/fs-writeback.c +14 −33
include/linux/backing-dev-defs.h +20 −0
include/linux/backing-dev.h +2 −0

fs/fs-writeback.c+14−33

  */
 #define MIN_WRITEBACK_PAGES	(4096UL >> (PAGE_SHIFT - 10))
-struct wb_completion {
-	atomic_t		cnt;
-};
 /*
  * Passed into wb_writeback(), essentially a subset of writeback_control
  */
 	struct wb_completion *done;	/* set if the caller waits */
 };
-/*
- * If one wants to wait for one or more wb_writeback_works, each work's
- * ->done should be set to a wb_completion defined using the following
- * macro.  Once all work items are issued with wb_queue_work(), the caller
- * can wait for the completion of all using wb_wait_for_completion().  Work
- * items which are waited upon aren't freed automatically on completion.
- */
-#define DEFINE_WB_COMPLETION_ONSTACK(cmpl)				\
-	struct wb_completion cmpl = {					\
-		.cnt		= ATOMIC_INIT(1),			\
-	}
 /*
  * If an inode is constantly having its pages dirtied, but then the
  * updates stop dirtytime_expire_interval seconds in the past, it's
 	if (work->auto_free)
 		kfree(work);
 	if (done && atomic_dec_and_test(&done->cnt))
-		wake_up_all(&wb->bdi->wb_waitq);
+		wake_up_all(done->waitq);
 }
 static void wb_queue_work(struct bdi_writeback *wb,
 /**
  * wb_wait_for_completion - wait for completion of bdi_writeback_works
- * @bdi: bdi work items were issued to
  * @done: target wb_completion
  *
  * Wait for one or more work items issued to @bdi with their ->done field
- * set to @done, which should have been defined with
+ * set to @done, which should have been initialized with
- * DEFINE_WB_COMPLETION_ONSTACK().  This function returns after all such
+ * DEFINE_WB_COMPLETION().  This function returns after all such work items
- * work items are completed.  Work items which are waited upon aren't freed
+ * are completed.  Work items which are waited upon aren't freed
  * automatically on completion.
  */
-static void wb_wait_for_completion(struct backing_dev_info *bdi,
+void wb_wait_for_completion(struct wb_completion *done)
-				   struct wb_completion *done)
 {
 	atomic_dec(&done->cnt);		/* put down the initial count */
-	wait_event(bdi->wb_waitq, !atomic_read(&done->cnt));
+	wait_event(*done->waitq, !atomic_read(&done->cnt));
 }
 #ifdef CONFIG_CGROUP_WRITEBACK
 restart:
 	rcu_read_lock();
 	list_for_each_entry_continue_rcu(wb, &bdi->wb_list, bdi_node) {
-		DEFINE_WB_COMPLETION_ONSTACK(fallback_work_done);
+		DEFINE_WB_COMPLETION(fallback_work_done, bdi);
 		struct wb_writeback_work fallback_work;
 		struct wb_writeback_work *work;
 		long nr_pages;
 		last_wb = wb;
 		rcu_read_unlock();
-		wb_wait_for_completion(bdi, &fallback_work_done);
+		wb_wait_for_completion(&fallback_work_done);
 		goto restart;
 	}
 	rcu_read_unlock();
 static void __writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr,
 				     enum wb_reason reason, bool skip_if_busy)
 {
-	DEFINE_WB_COMPLETION_ONSTACK(done);
+	struct backing_dev_info *bdi = sb->s_bdi;
+	DEFINE_WB_COMPLETION(done, bdi);
 	struct wb_writeback_work work = {
 		.sb			= sb,
 		.sync_mode		= WB_SYNC_NONE,
 		.nr_pages		= nr,
 		.reason			= reason,
 	};
-	struct backing_dev_info *bdi = sb->s_bdi;
 	if (!bdi_has_dirty_io(bdi) || bdi == &noop_backing_dev_info)
 		return;
 	WARN_ON(!rwsem_is_locked(&sb->s_umount));
 	bdi_split_work_to_wbs(sb->s_bdi, &work, skip_if_busy);
-	wb_wait_for_completion(bdi, &done);
+	wb_wait_for_completion(&done);
 }
 /**
  */
 void sync_inodes_sb(struct super_block *sb)
 {
-	DEFINE_WB_COMPLETION_ONSTACK(done);
+	struct backing_dev_info *bdi = sb->s_bdi;
+	DEFINE_WB_COMPLETION(done, bdi);
 	struct wb_writeback_work work = {
 		.sb		= sb,
 		.sync_mode	= WB_SYNC_ALL,
 		.reason		= WB_REASON_SYNC,
 		.for_sync	= 1,
 	};
-	struct backing_dev_info *bdi = sb->s_bdi;
 	/*
 	 * Can't skip on !bdi_has_dirty() because we should wait for !dirty
 	/* protect against inode wb switch, see inode_switch_wbs_work_fn() */
 	bdi_down_write_wb_switch_rwsem(bdi);
 	bdi_split_work_to_wbs(bdi, &work, false);
-	wb_wait_for_completion(bdi, &done);
+	wb_wait_for_completion(&done);
 	bdi_up_write_wb_switch_rwsem(bdi);
 	wait_sb_inodes(sb);

include/linux/backing-dev-defs.h+20−0

@@ -67,6 +67,26 @@ enum wb_reason { · 66 unmodified lines
67	WB_REASON_MAX,	67	WB_REASON_MAX,
68	};	68	};
69		69
		70	struct wb_completion {
		71	atomic_t cnt;
		72	wait_queue_head_t *waitq;
		73	};
		74
		75	#define __WB_COMPLETION_INIT(_waitq) \
		76	(struct wb_completion){ .cnt = ATOMIC_INIT(1), .waitq = (_waitq) }
		77
		78	/*
		79	* If one wants to wait for one or more wb_writeback_works, each work's
		80	* ->done should be set to a wb_completion defined using the following
		81	* macro. Once all work items are issued with wb_queue_work(), the caller
		82	* can wait for the completion of all using wb_wait_for_completion(). Work
		83	* items which are waited upon aren't freed automatically on completion.
		84	*/
		85	#define WB_COMPLETION_INIT(bdi) __WB_COMPLETION_INIT(&(bdi)->wb_waitq)
		86
		87	#define DEFINE_WB_COMPLETION(cmpl, bdi) \
		88	struct wb_completion cmpl = WB_COMPLETION_INIT(bdi)
		89
70	/*	90	/*
71	* For cgroup writeback, multiple wb's may map to the same blkcg. Those	91	* For cgroup writeback, multiple wb's may map to the same blkcg. Those
72	* wb's can operate mostly independently but should share the congested	92	* wb's can operate mostly independently but should share the congested

include/linux/backing-dev.h+2−0

@@ -44,6 +44,8 @@ void wb_start_background_writeback(struct bdi_writeback *wb); · 43 unmodified lines
44	void wb_workfn(struct work_struct *work);	44	void wb_workfn(struct work_struct *work);
45	void wb_wakeup_delayed(struct bdi_writeback *wb);	45	void wb_wakeup_delayed(struct bdi_writeback *wb);
46		46
		47	void wb_wait_for_completion(struct wb_completion *done);
		48
47	extern spinlock_t bdi_lock;	49	extern spinlock_t bdi_lock;
48	extern struct list_head bdi_list;	50	extern struct list_head bdi_list;
49		51

writeback: Generalize and expose wb_completion

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code