3246 ZFS I/O deadman thread

[zfs.git] / module / zfs / vdev_queue.c

diff --git a/module/zfs/vdev_queue.c b/module/zfs/vdev_queue.c
index 8f86635..3f2793b 100644 (file)
--- a/module/zfs/vdev_queue.c
+++ b/module/zfs/vdev_queue.c
@@ -23,6 +23,10 @@
  * Use is subject to license terms.
  */
 
+/*
+ * Copyright (c) 2012 by Delphix. All rights reserved.
+ */
+
 #include <sys/zfs_context.h>
 #include <sys/vdev_impl.h>
 #include <sys/zio.h>
@@ -106,6 +110,7 @@ void
 vdev_queue_init(vdev_t *vd)
 {
        vdev_queue_t *vq = &vd->vdev_queue;
+       int i;
 
        mutex_init(&vq->vq_lock, NULL, MUTEX_DEFAULT, NULL);
 
@@ -120,18 +125,36 @@ vdev_queue_init(vdev_t *vd)
 
        avl_create(&vq->vq_pending_tree, vdev_queue_offset_compare,
            sizeof (zio_t), offsetof(struct zio, io_offset_node));
+
+       /*
+        * A list of buffers which can be used for aggregate I/O, this
+        * avoids the need to allocate them on demand when memory is low.
+        */
+       list_create(&vq->vq_io_list, sizeof (vdev_io_t),
+           offsetof(vdev_io_t, vi_node));
+
+       for (i = 0; i < zfs_vdev_max_pending; i++)
+               list_insert_tail(&vq->vq_io_list, zio_vdev_alloc());
 }
 
 void
 vdev_queue_fini(vdev_t *vd)
 {
        vdev_queue_t *vq = &vd->vdev_queue;
+       vdev_io_t *vi;
 
        avl_destroy(&vq->vq_deadline_tree);
        avl_destroy(&vq->vq_read_tree);
        avl_destroy(&vq->vq_write_tree);
        avl_destroy(&vq->vq_pending_tree);
 
+       while ((vi = list_head(&vq->vq_io_list)) != NULL) {
+               list_remove(&vq->vq_io_list, vi);
+               zio_vdev_free(vi);
+       }
+
+       list_destroy(&vq->vq_io_list);
+
        mutex_destroy(&vq->vq_lock);
 }
 
@@ -152,6 +175,8 @@ vdev_queue_io_remove(vdev_queue_t *vq, zio_t *zio)
 static void
 vdev_queue_agg_io_done(zio_t *aio)
 {
+       vdev_queue_t *vq = &aio->io_vd->vdev_queue;
+       vdev_io_t *vi = aio->io_data;
        zio_t *pio;
 
        while ((pio = zio_walk_parents(aio)) != NULL)
@@ -159,7 +184,9 @@ vdev_queue_agg_io_done(zio_t *aio)
                        bcopy((char *)aio->io_data + (pio->io_offset -
                            aio->io_offset), pio->io_data, pio->io_size);
 
-       zio_buf_free(aio->io_data, aio->io_size);
+       mutex_enter(&vq->vq_lock);
+       list_insert_tail(&vq->vq_io_list, vi);
+       mutex_exit(&vq->vq_lock);
 }
 
 /*
@@ -176,8 +203,9 @@ vdev_queue_io_to_issue(vdev_queue_t *vq, uint64_t pending_limit)
 {
        zio_t *fio, *lio, *aio, *dio, *nio, *mio;
        avl_tree_t *t;
+       vdev_io_t *vi;
        int flags;
-       uint64_t maxspan = zfs_vdev_aggregation_limit;
+       uint64_t maxspan = MIN(zfs_vdev_aggregation_limit, SPA_MAXBLOCKSIZE);
        uint64_t maxgap;
        int stretch;
 
@@ -194,6 +222,12 @@ again:
        flags = fio->io_flags & ZIO_FLAG_AGG_INHERIT;
        maxgap = (t == &vq->vq_read_tree) ? zfs_vdev_read_gap_limit : 0;
 
+       vi = list_head(&vq->vq_io_list);
+       if (vi == NULL) {
+               vi = zio_vdev_alloc();
+               list_insert_head(&vq->vq_io_list, vi);
+       }
+
        if (!(flags & ZIO_FLAG_DONT_AGGREGATE)) {
                /*
                 * We can aggregate I/Os that are sufficiently adjacent and of
@@ -282,12 +316,14 @@ again:
 
        if (fio != lio) {
                uint64_t size = IO_SPAN(fio, lio);
-               ASSERT(size <= zfs_vdev_aggregation_limit);
+               ASSERT(size <= maxspan);
+               ASSERT(vi != NULL);
 
                aio = zio_vdev_delegated_io(fio->io_vd, fio->io_offset,
-                   zio_buf_alloc(size), size, fio->io_type, ZIO_PRIORITY_AGG,
+                   vi, size, fio->io_type, ZIO_PRIORITY_AGG,
                    flags | ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE,
                    vdev_queue_agg_io_done, NULL);
+               aio->io_timestamp = fio->io_timestamp;
 
                nio = fio;
                do {
@@ -313,6 +349,7 @@ again:
                } while (dio != lio);
 
                avl_add(&vq->vq_pending_tree, aio);
+               list_remove(&vq->vq_io_list, vi);
 
                return (aio);
        }
@@ -359,7 +396,8 @@ vdev_queue_io(zio_t *zio)
 
        mutex_enter(&vq->vq_lock);
 
-       zio->io_deadline = (ddi_get_lbolt64() >> zfs_vdev_time_shift) +
+       zio->io_timestamp = ddi_get_lbolt64();
+       zio->io_deadline = (zio->io_timestamp >> zfs_vdev_time_shift) +
            zio->io_priority;
 
        vdev_queue_io_add(vq, zio);
@@ -385,10 +423,17 @@ vdev_queue_io_done(zio_t *zio)
        vdev_queue_t *vq = &zio->io_vd->vdev_queue;
        int i;
 
+       if (zio_injection_enabled)
+               delay(SEC_TO_TICK(zio_handle_io_delay(zio)));
+
        mutex_enter(&vq->vq_lock);
 
        avl_remove(&vq->vq_pending_tree, zio);
 
+       zio->io_delta = ddi_get_lbolt64() - zio->io_timestamp;
+       vq->vq_io_complete_ts = ddi_get_lbolt64();
+       vq->vq_io_delta_ts = vq->vq_io_complete_ts - zio->io_timestamp;
+
        for (i = 0; i < zfs_vdev_ramp_rate; i++) {
                zio_t *nio = vdev_queue_io_to_issue(vq, zfs_vdev_max_pending);
                if (nio == NULL)
@@ -405,3 +450,26 @@ vdev_queue_io_done(zio_t *zio)
 
        mutex_exit(&vq->vq_lock);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+module_param(zfs_vdev_max_pending, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_max_pending, "Max pending per-vdev I/Os");
+
+module_param(zfs_vdev_min_pending, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_min_pending, "Min pending per-vdev I/Os");
+
+module_param(zfs_vdev_aggregation_limit, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_aggregation_limit, "Max vdev I/O aggregation size");
+
+module_param(zfs_vdev_time_shift, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_time_shift, "Deadline time shift for vdev I/O");
+
+module_param(zfs_vdev_ramp_rate, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_ramp_rate, "Exponential I/O issue ramp-up rate");
+
+module_param(zfs_vdev_read_gap_limit, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_read_gap_limit, "Aggregate read I/O over gap");
+
+module_param(zfs_vdev_write_gap_limit, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_write_gap_limit, "Aggregate write I/O over gap");
+#endif