From: Rafał Miłecki Date: Tue, 13 Dec 2016 08:39:33 +0000 (+0100) Subject: kernel: backport ubifs support for dirty_writeback_interval X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=d6ef917bdb8890c3392dae2a9ef3dce47118c798;p=openwrt%2Fstaging%2Fldir.git kernel: backport ubifs support for dirty_writeback_interval These patches were queued for 4.10. For possible use cases see added: [PATCH] ubifs: Use dirty_writeback_interval value for wbuf timer Signed-off-by: Rafał Miłecki --- diff --git a/target/linux/generic/patches-4.4/053-0001-ubifs-Drop-softlimit-and-delta-fields-from-struct-ub.patch b/target/linux/generic/patches-4.4/053-0001-ubifs-Drop-softlimit-and-delta-fields-from-struct-ub.patch new file mode 100644 index 0000000000..662584ca61 --- /dev/null +++ b/target/linux/generic/patches-4.4/053-0001-ubifs-Drop-softlimit-and-delta-fields-from-struct-ub.patch @@ -0,0 +1,82 @@ +From 854826c9d526fd81077742c3b000e3f7fcaef3ce Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Tue, 20 Sep 2016 10:36:14 +0200 +Subject: [PATCH] ubifs: Drop softlimit and delta fields from struct ubifs_wbuf +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Values of these fields are set during init and never modified. They are +used (read) in a single function only. There isn't really any reason to +keep them in a struct. It only makes struct just a bit bigger without +any visible gain. + +Signed-off-by: Rafał Miłecki +Reviewed-by: Boris Brezillon +Signed-off-by: Richard Weinberger +--- + fs/ubifs/io.c | 18 ++++++++++-------- + fs/ubifs/ubifs.h | 5 ----- + 2 files changed, 10 insertions(+), 13 deletions(-) + +--- a/fs/ubifs/io.c ++++ b/fs/ubifs/io.c +@@ -452,16 +452,22 @@ static enum hrtimer_restart wbuf_timer_c + */ + static void new_wbuf_timer_nolock(struct ubifs_wbuf *wbuf) + { ++ ktime_t softlimit = ktime_set(WBUF_TIMEOUT_SOFTLIMIT, 0); ++ unsigned long long delta; ++ ++ delta = WBUF_TIMEOUT_HARDLIMIT - WBUF_TIMEOUT_SOFTLIMIT; ++ delta *= 1000000000ULL; ++ + ubifs_assert(!hrtimer_active(&wbuf->timer)); ++ ubifs_assert(delta <= ULONG_MAX); + + if (wbuf->no_timer) + return; + dbg_io("set timer for jhead %s, %llu-%llu millisecs", + dbg_jhead(wbuf->jhead), +- div_u64(ktime_to_ns(wbuf->softlimit), USEC_PER_SEC), +- div_u64(ktime_to_ns(wbuf->softlimit) + wbuf->delta, +- USEC_PER_SEC)); +- hrtimer_start_range_ns(&wbuf->timer, wbuf->softlimit, wbuf->delta, ++ div_u64(ktime_to_ns(softlimit), USEC_PER_SEC), ++ div_u64(ktime_to_ns(softlimit) + delta, USEC_PER_SEC)); ++ hrtimer_start_range_ns(&wbuf->timer, softlimit, delta, + HRTIMER_MODE_REL); + } + +@@ -1059,10 +1065,6 @@ int ubifs_wbuf_init(struct ubifs_info *c + + hrtimer_init(&wbuf->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); + wbuf->timer.function = wbuf_timer_callback_nolock; +- wbuf->softlimit = ktime_set(WBUF_TIMEOUT_SOFTLIMIT, 0); +- wbuf->delta = WBUF_TIMEOUT_HARDLIMIT - WBUF_TIMEOUT_SOFTLIMIT; +- wbuf->delta *= 1000000000ULL; +- ubifs_assert(wbuf->delta <= ULONG_MAX); + return 0; + } + +--- a/fs/ubifs/ubifs.h ++++ b/fs/ubifs/ubifs.h +@@ -668,9 +668,6 @@ typedef int (*ubifs_lpt_scan_callback)(s + * @io_mutex: serializes write-buffer I/O + * @lock: serializes @buf, @lnum, @offs, @avail, @used, @next_ino and @inodes + * fields +- * @softlimit: soft write-buffer timeout interval +- * @delta: hard and soft timeouts delta (the timer expire interval is @softlimit +- * and @softlimit + @delta) + * @timer: write-buffer timer + * @no_timer: non-zero if this write-buffer does not have a timer + * @need_sync: non-zero if the timer expired and the wbuf needs sync'ing +@@ -699,8 +696,6 @@ struct ubifs_wbuf { + int (*sync_callback)(struct ubifs_info *c, int lnum, int free, int pad); + struct mutex io_mutex; + spinlock_t lock; +- ktime_t softlimit; +- unsigned long long delta; + struct hrtimer timer; + unsigned int no_timer:1; + unsigned int need_sync:1; diff --git a/target/linux/generic/patches-4.4/053-0002-ubifs-Use-dirty_writeback_interval-value-for-wbuf-ti.patch b/target/linux/generic/patches-4.4/053-0002-ubifs-Use-dirty_writeback_interval-value-for-wbuf-ti.patch new file mode 100644 index 0000000000..9313cd557e --- /dev/null +++ b/target/linux/generic/patches-4.4/053-0002-ubifs-Use-dirty_writeback_interval-value-for-wbuf-ti.patch @@ -0,0 +1,66 @@ +From 1b7fc2c0069f3864a3dda15430b7aded31c0bfcc Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= +Date: Tue, 20 Sep 2016 10:36:15 +0200 +Subject: [PATCH] ubifs: Use dirty_writeback_interval value for wbuf timer +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Right now wbuf timer has hardcoded timeouts and there is no place for +manual adjustments. Some projects / cases many need that though. Few +file systems allow doing that by respecting dirty_writeback_interval +that can be set using sysctl (dirty_writeback_centisecs). + +Lowering dirty_writeback_interval could be some way of dealing with user +space apps lacking proper fsyncs. This is definitely *not* a perfect +solution but we don't have ideal (user space) world. There were already +advanced discussions on this matter, mostly when ext4 was introduced and +it wasn't behaving as ext3. Anyway, the final decision was to add some +hacks to the ext4, as trying to fix whole user space or adding new API +was pointless. + +We can't (and shouldn't?) just follow ext4. We can't e.g. sync on close +as this would cause too many commits and flash wearing. On the other +hand we still should allow some trade-off between -o sync and default +wbuf timeout. Respecting dirty_writeback_interval should allow some sane +cutomizations if used warily. + +Signed-off-by: Rafał Miłecki +Reviewed-by: Boris Brezillon +Signed-off-by: Richard Weinberger +--- + fs/ubifs/io.c | 8 ++++---- + fs/ubifs/ubifs.h | 4 ---- + 2 files changed, 4 insertions(+), 8 deletions(-) + +--- a/fs/ubifs/io.c ++++ b/fs/ubifs/io.c +@@ -452,11 +452,11 @@ static enum hrtimer_restart wbuf_timer_c + */ + static void new_wbuf_timer_nolock(struct ubifs_wbuf *wbuf) + { +- ktime_t softlimit = ktime_set(WBUF_TIMEOUT_SOFTLIMIT, 0); +- unsigned long long delta; ++ ktime_t softlimit = ms_to_ktime(dirty_writeback_interval * 10); ++ unsigned long long delta = dirty_writeback_interval; + +- delta = WBUF_TIMEOUT_HARDLIMIT - WBUF_TIMEOUT_SOFTLIMIT; +- delta *= 1000000000ULL; ++ /* centi to milli, milli to nano, then 10% */ ++ delta *= 10ULL * NSEC_PER_MSEC / 10ULL; + + ubifs_assert(!hrtimer_active(&wbuf->timer)); + ubifs_assert(delta <= ULONG_MAX); +--- a/fs/ubifs/ubifs.h ++++ b/fs/ubifs/ubifs.h +@@ -106,10 +106,6 @@ + */ + #define BGT_NAME_PATTERN "ubifs_bgt%d_%d" + +-/* Write-buffer synchronization timeout interval in seconds */ +-#define WBUF_TIMEOUT_SOFTLIMIT 3 +-#define WBUF_TIMEOUT_HARDLIMIT 5 +- + /* Maximum possible inode number (only 32-bit inodes are supported now) */ + #define MAX_INUM 0xFFFFFFFF +