Add explicit MAXNAMELEN check

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

diff --git a/module/zfs/zio.c b/module/zfs/zio.c
index 66f228b..77b1764 100644 (file)
--- a/module/zfs/zio.c
+++ b/module/zfs/zio.c
@@ -210,6 +210,8 @@ zio_init(void)
        zfs_mg_alloc_failures = MAX((3 * max_ncpus / 2), 8);
 
        zio_inject_init();
+
+       lz4_init();
 }
 
 void
@@ -238,6 +240,8 @@ zio_fini(void)
        kmem_cache_destroy(zio_cache);
 
        zio_inject_fini();
+
+       lz4_fini();
 }
 
 /*
@@ -1248,7 +1252,7 @@ __zio_execute(zio_t *zio)
        while (zio->io_stage < ZIO_STAGE_DONE) {
                enum zio_stage pipeline = zio->io_pipeline;
                enum zio_stage stage = zio->io_stage;
-               dsl_pool_t *dsl;
+               dsl_pool_t *dp;
                boolean_t cut;
                int rv;
 
@@ -1262,7 +1266,7 @@ __zio_execute(zio_t *zio)
 
                ASSERT(stage <= ZIO_STAGE_DONE);
 
-               dsl = spa_get_dsl(zio->io_spa);
+               dp = spa_get_dsl(zio->io_spa);
                cut = (stage == ZIO_STAGE_VDEV_IO_START) ?
                    zio_requeue_io_start_cut_in_line : B_FALSE;
 
@@ -1272,20 +1276,30 @@ __zio_execute(zio_t *zio)
                 * or may wait for an I/O that needs an interrupt thread
                 * to complete, issue async to avoid deadlock.
                 *
-                * If we are in the txg_sync_thread or being called
-                * during pool init issue async to minimize stack depth.
-                * Both of these call paths may be recursively called.
-                *
                 * For VDEV_IO_START, we cut in line so that the io will
                 * be sent to disk promptly.
                 */
-               if (((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL &&
-                   zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) ||
-                   (dsl != NULL && dsl_pool_sync_context(dsl))) {
+               if ((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL &&
+                   zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) {
                        zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
                        return;
                }
 
+#ifdef _KERNEL
+               /*
+                * If we executing in the context of the tx_sync_thread,
+                * or we are performing pool initialization outside of a
+                * zio_taskq[ZIO_TASKQ_ISSUE] context.  Then issue the zio
+                * async to minimize stack usage for these deep call paths.
+                */
+               if ((dp && curthread == dp->dp_tx.tx_sync_thread) ||
+                   (dp && spa_is_initializing(dp->dp_spa) &&
+                   !zio_taskq_member(zio, ZIO_TASKQ_ISSUE))) {
+                       zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
+                       return;
+               }
+#endif
+
                zio->io_stage = stage;
                rv = zio_pipeline[highbit(stage) - 1](zio);