Merge branch 'for-4.15/block' of git://git.kernel.dk/linux-block

Pull core block layer updates from Jens Axboe:
 "This is the main pull request for block storage for 4.15-rc1.

  Nothing out of the ordinary in here, and no API changes or anything
  like that. Just various new features for drivers, core changes, etc.
  In particular, this pull request contains:

   - A patch series from Bart, closing the whole on blk/scsi-mq queue
     quescing.

   - A series from Christoph, building towards hidden gendisks (for
     multipath) and ability to move bio chains around.

   - NVMe
        - Support for native multipath for NVMe (Christoph).
        - Userspace notifications for AENs (Keith).
        - Command side-effects support (Keith).
        - SGL support (Chaitanya Kulkarni)
        - FC fixes and improvements (James Smart)
        - Lots of fixes and tweaks (Various)

   - bcache
        - New maintainer (Michael Lyle)
        - Writeback control improvements (Michael)
        - Various fixes (Coly, Elena, Eric, Liang, et al)

   - lightnvm updates, mostly centered around the pblk interface
     (Javier, Hans, and Rakesh).

   - Removal of unused bio/bvec kmap atomic interfaces (me, Christoph)

   - Writeback series that fix the much discussed hundreds of millions
     of sync-all units. This goes all the way, as discussed previously
     (me).

   - Fix for missing wakeup on writeback timer adjustments (Yafang
     Shao).

   - Fix laptop mode on blk-mq (me).

   - {mq,name} tupple lookup for IO schedulers, allowing us to have
     alias names. This means you can use 'deadline' on both !mq and on
     mq (where it's called mq-deadline). (me).

   - blktrace race fix, oopsing on sg load (me).

   - blk-mq optimizations (me).

   - Obscure waitqueue race fix for kyber (Omar).

   - NBD fixes (Josef).

   - Disable writeback throttling by default on bfq, like we do on cfq
     (Luca Miccio).

   - Series from Ming that enable us to treat flush requests on blk-mq
     like any other request. This is a really nice cleanup.

   - Series from Ming that improves merging on blk-mq with schedulers,
     getting us closer to flipping the switch on scsi-mq again.

   - BFQ updates (Paolo).

   - blk-mq atomic flags memory ordering fixes (Peter Z).

   - Loop cgroup support (Shaohua).

   - Lots of minor fixes from lots of different folks, both for core and
     driver code"

* 'for-4.15/block' of git://git.kernel.dk/linux-block: (294 commits)
  nvme: fix visibility of "uuid" ns attribute
  blk-mq: fixup some comment typos and lengths
  ide: ide-atapi: fix compile error with defining macro DEBUG
  blk-mq: improve tag waiting setup for non-shared tags
  brd: remove unused brd_mutex
  blk-mq: only run the hardware queue if IO is pending
  block: avoid null pointer dereference on null disk
  fs: guard_bio_eod() needs to consider partitions
  xtensa/simdisk: fix compile error
  nvme: expose subsys attribute to sysfs
  nvme: create 'slaves' and 'holders' entries for hidden controllers
  block: create 'slaves' and 'holders' entries for hidden gendisks
  nvme: also expose the namespace identification sysfs files for mpath nodes
  nvme: implement multipath access to nvme subsystems
  nvme: track shared namespaces
  nvme: introduce a nvme_ns_ids structure
  nvme: track subsystems
  block, nvme: Introduce blk_mq_req_flags_t
  block, scsi: Make SCSI quiesce and resume work reliably
  block: Add the QUEUE_FLAG_PREEMPT_ONLY request queue flag
  ...

1 files changed, 71 insertions, 46 deletions

diff --git a/drivers/md/bcache/writeback.c b/drivers/md/bcache/writeback.c
index 70454f2ad2fa..56a37884ca8b 100644
--- a/drivers/md/bcache/writeback.c
+++ b/drivers/md/bcache/writeback.c
@@ -26,48 +26,63 @@ static void __update_writeback_rate(struct cached_dev *dc)
                                 bcache_flash_devs_sectors_dirty(c);
         uint64_t cache_dirty_target =
                 div_u64(cache_sectors * dc->writeback_percent, 100);
-
         int64_t target = div64_u64(cache_dirty_target * bdev_sectors(dc->bdev),
                                    c->cached_dev_sectors);
 
-        /* PD controller */
-
+        /*
+         * PI controller:
+         * Figures out the amount that should be written per second.
+         *
+         * First, the error (number of sectors that are dirty beyond our
+         * target) is calculated.  The error is accumulated (numerically
+         * integrated).
+         *
+         * Then, the proportional value and integral value are scaled
+         * based on configured values.  These are stored as inverses to
+         * avoid fixed point math and to make configuration easy-- e.g.
+         * the default value of 40 for writeback_rate_p_term_inverse
+         * attempts to write at a rate that would retire all the dirty
+         * blocks in 40 seconds.
+         *
+         * The writeback_rate_i_inverse value of 10000 means that 1/10000th
+         * of the error is accumulated in the integral term per second.
+         * This acts as a slow, long-term average that is not subject to
+         * variations in usage like the p term.
+         */
         int64_t dirty = bcache_dev_sectors_dirty(&dc->disk);
-        int64_t derivative = dirty - dc->disk.sectors_dirty_last;
-        int64_t proportional = dirty - target;
-        int64_t change;
-
-        dc->disk.sectors_dirty_last = dirty;
-
-        /* Scale to sectors per second */
-
-        proportional *= dc->writeback_rate_update_seconds;
-        proportional = div_s64(proportional, dc->writeback_rate_p_term_inverse);
-
-        derivative = div_s64(derivative, dc->writeback_rate_update_seconds);
-
-        derivative = ewma_add(dc->disk.sectors_dirty_derivative, derivative,
-                              (dc->writeback_rate_d_term /
-                               dc->writeback_rate_update_seconds) ?: 1, 0);
-
-        derivative *= dc->writeback_rate_d_term;
-        derivative = div_s64(derivative, dc->writeback_rate_p_term_inverse);
-
-        change = proportional + derivative;
+        int64_t error = dirty - target;
+        int64_t proportional_scaled =
+                div_s64(error, dc->writeback_rate_p_term_inverse);
+        int64_t integral_scaled;
+        uint32_t new_rate;
+
+        if ((error < 0 && dc->writeback_rate_integral > 0) ||
+            (error > 0 && time_before64(local_clock(),
+                         dc->writeback_rate.next + NSEC_PER_MSEC))) {
+                /*
+                 * Only decrease the integral term if it's more than
+                 * zero.  Only increase the integral term if the device
+                 * is keeping up.  (Don't wind up the integral
+                 * ineffectively in either case).
+                 *
+                 * It's necessary to scale this by
+                 * writeback_rate_update_seconds to keep the integral
+                 * term dimensioned properly.
+                 */
+                dc->writeback_rate_integral += error *
+                        dc->writeback_rate_update_seconds;
+        }
 
-        /* Don't increase writeback rate if the device isn't keeping up */
-        if (change > 0 &&
-            time_after64(local_clock(),
-                         dc->writeback_rate.next + NSEC_PER_MSEC))
-                change = 0;
+        integral_scaled = div_s64(dc->writeback_rate_integral,
+                        dc->writeback_rate_i_term_inverse);
 
-        dc->writeback_rate.rate =
-                clamp_t(int64_t, (int64_t) dc->writeback_rate.rate + change,
-                        1, NSEC_PER_MSEC);
+        new_rate = clamp_t(int32_t, (proportional_scaled + integral_scaled),
+                        dc->writeback_rate_minimum, NSEC_PER_SEC);
 
-        dc->writeback_rate_proportional = proportional;
-        dc->writeback_rate_derivative = derivative;
-        dc->writeback_rate_change = change;
+        dc->writeback_rate_proportional = proportional_scaled;
+        dc->writeback_rate_integral_scaled = integral_scaled;
+        dc->writeback_rate_change = new_rate - dc->writeback_rate.rate;
+        dc->writeback_rate.rate = new_rate;
         dc->writeback_rate_target = target;
 }
 
@@ -180,13 +195,21 @@ static void write_dirty(struct closure *cl)
         struct dirty_io *io = container_of(cl, struct dirty_io, cl);
         struct keybuf_key *w = io->bio.bi_private;
 
-        dirty_init(w);
-        bio_set_op_attrs(&io->bio, REQ_OP_WRITE, 0);
-        io->bio.bi_iter.bi_sector = KEY_START(&w->key);
-        bio_set_dev(&io->bio, io->dc->bdev);
-        io->bio.bi_end_io       = dirty_endio;
+        /*
+         * IO errors are signalled using the dirty bit on the key.
+         * If we failed to read, we should not attempt to write to the
+         * backing device.  Instead, immediately go to write_dirty_finish
+         * to clean up.
+         */
+        if (KEY_DIRTY(&w->key)) {
+                dirty_init(w);
+                bio_set_op_attrs(&io->bio, REQ_OP_WRITE, 0);
+                io->bio.bi_iter.bi_sector = KEY_START(&w->key);
+                bio_set_dev(&io->bio, io->dc->bdev);
+                io->bio.bi_end_io       = dirty_endio;
 
-        closure_bio_submit(&io->bio, cl);
+                closure_bio_submit(&io->bio, cl);
+        }
 
         continue_at(cl, write_dirty_finish, io->dc->writeback_write_wq);
 }
@@ -418,6 +441,8 @@ static int bch_writeback_thread(void *arg)
         struct cached_dev *dc = arg;
         bool searched_full_index;
 
+        bch_ratelimit_reset(&dc->writeback_rate);
+
         while (!kthread_should_stop()) {
                 down_write(&dc->writeback_lock);
                 if (!atomic_read(&dc->has_dirty) ||
@@ -445,7 +470,6 @@ static int bch_writeback_thread(void *arg)
 
                 up_write(&dc->writeback_lock);
 
-                bch_ratelimit_reset(&dc->writeback_rate);
                 read_dirty(dc);
 
                 if (searched_full_index) {
@@ -455,6 +479,8 @@ static int bch_writeback_thread(void *arg)
                                !kthread_should_stop() &&
                                !test_bit(BCACHE_DEV_DETACHING, &dc->disk.flags))
                                 delay = schedule_timeout_interruptible(delay);
+
+                        bch_ratelimit_reset(&dc->writeback_rate);
                 }
         }
 
@@ -492,8 +518,6 @@ void bch_sectors_dirty_init(struct bcache_device *d)
 
         bch_btree_map_keys(&op.op, d->c, &KEY(op.inode, 0, 0),
                            sectors_dirty_init_fn, 0);
-
-        d->sectors_dirty_last = bcache_dev_sectors_dirty(d);
 }
 
 void bch_cached_dev_writeback_init(struct cached_dev *dc)
@@ -507,10 +531,11 @@ void bch_cached_dev_writeback_init(struct cached_dev *dc)
         dc->writeback_percent           = 10;
         dc->writeback_delay             = 30;
         dc->writeback_rate.rate         = 1024;
+        dc->writeback_rate_minimum      = 8;
 
         dc->writeback_rate_update_seconds = 5;
-        dc->writeback_rate_d_term       = 30;
-        dc->writeback_rate_p_term_inverse = 6000;
+        dc->writeback_rate_p_term_inverse = 40;
+        dc->writeback_rate_i_term_inverse = 10000;
 
         INIT_DELAYED_WORK(&dc->writeback_rate_update, update_writeback_rate);
 }