Adressing some recent review feedback.

Signed-off-by: Don Brady <[email protected]>

Author: don-brady

include/sys/arc.h

@@ -63,15 +63,15 @@ extern "C" {
 	(hdr)->b_psize = ((x) >> SPA_MINBLOCKSHIFT); \
 } while (0)
 
-/* The asize in the header is only used by L2 cache */
-#define	HDR_SET_ASIZE(hdr, x) do { \
+/* The l2size in the header is only used by L2 cache */
+#define	HDR_SET_L2SIZE(hdr, x) do { \
 	ASSERT(IS_P2ALIGNED((x), 1U << SPA_MINBLOCKSHIFT)); \
-	(hdr)->b_asize = ((x) >> SPA_MINBLOCKSHIFT); \
+	(hdr)->b_l2size = ((x) >> SPA_MINBLOCKSHIFT); \
 } while (0)
 
 #define	HDR_GET_LSIZE(hdr)	((hdr)->b_lsize << SPA_MINBLOCKSHIFT)
 #define	HDR_GET_PSIZE(hdr)	((hdr)->b_psize << SPA_MINBLOCKSHIFT)
-#define	HDR_GET_ASIZE(hdr)	((hdr)->b_asize << SPA_MINBLOCKSHIFT)
+#define	HDR_GET_L2SIZE(hdr)	((hdr)->b_l2size << SPA_MINBLOCKSHIFT)
 
 typedef struct arc_buf_hdr arc_buf_hdr_t;
 typedef struct arc_buf arc_buf_t;

include/sys/arc_impl.h

@@ -476,7 +476,7 @@ struct arc_buf_hdr {
 	arc_buf_contents_t	b_type;
 	uint8_t			b_complevel;
 	uint8_t			b_reserved1;	/* used for 4 byte alignment */
-	uint16_t		b_asize;	/* alignment or L2-only asize */
+	uint16_t		b_l2size;	/* alignment or L2-only size */
 	arc_buf_hdr_t		*b_hash_next;
 	arc_flags_t		b_flags;
 

module/zfs/arc.c

@@ -1728,7 +1728,7 @@ arc_buf_try_copy_decompressed_data(arc_buf_t *buf)
  */
 static arc_buf_hdr_t *
 arc_buf_alloc_l2only(size_t size, arc_buf_contents_t type, l2arc_dev_t *dev,
-    dva_t dva, uint64_t daddr, int32_t psize, uint64_t birth,
+    dva_t dva, uint64_t daddr, int32_t psize, uint64_t asize, uint64_t birth,
     enum zio_compress compress, uint8_t complevel, boolean_t protected,
     boolean_t prefetch, arc_state_type_t arcs_state)
 {
@@ -1744,7 +1744,7 @@ arc_buf_alloc_l2only(size_t size, arc_buf_contents_t type, l2arc_dev_t *dev,
 	arc_hdr_set_flags(hdr, arc_bufc_to_flags(type) | ARC_FLAG_HAS_L2HDR);
 	HDR_SET_LSIZE(hdr, size);
 	HDR_SET_PSIZE(hdr, psize);
-	HDR_SET_ASIZE(hdr, vdev_psize_to_asize(dev->l2ad_vdev, psize));
+	HDR_SET_L2SIZE(hdr, asize);
 	arc_hdr_set_compress(hdr, compress);
 	hdr->b_complevel = complevel;
 	if (protected)
@@ -3534,13 +3534,13 @@ l2arc_hdr_arcstats_update(arc_buf_hdr_t *hdr, boolean_t incr,
 {
 	uint64_t lsize = HDR_GET_LSIZE(hdr);
 	uint64_t psize = HDR_GET_PSIZE(hdr);
-	uint64_t asize = HDR_GET_ASIZE(hdr);
+	uint64_t asize = HDR_GET_L2SIZE(hdr);
 	arc_buf_contents_t type = hdr->b_type;
 	int64_t lsize_s;
 	int64_t psize_s;
 	int64_t asize_s;
 
-	/* For L2 we expect the header's b_asize to be valid */
+	/* For L2 we expect the header's b_l2size to be valid */
 	ASSERT3U(asize, >=, psize);
 
 	if (incr) {
@@ -3612,7 +3612,7 @@ arc_hdr_l2hdr_destroy(arc_buf_hdr_t *hdr)
 
 	l2arc_hdr_arcstats_decrement(hdr);
 	if (dev->l2ad_vdev != NULL) {
-		uint64_t asize = HDR_GET_ASIZE(hdr);
+		uint64_t asize = HDR_GET_L2SIZE(hdr);
 		vdev_space_update(dev->l2ad_vdev, -asize, 0, 0);
 	}
 
@@ -4501,15 +4501,8 @@ arc_flush_async(spa_t *spa)
 	uint64_t spa_guid = spa_load_guid(spa);
 	arc_async_flush_t *af = arc_async_flush_add(spa_guid, 1);
 
-	/*
-	 * Note that arc_flush_task() needs arc_async_flush_lock to remove af
-	 * list node.  So by holding the lock we avoid a race for af removal
-	 * with our use here.
-	 */
-	mutex_enter(&arc_async_flush_lock);
 	taskq_dispatch_ent(arc_flush_taskq, arc_flush_task,
 	    af, TQ_SLEEP, &af->af_tqent);
-	mutex_exit(&arc_async_flush_lock);
 }
 
 /*
@@ -7876,8 +7869,8 @@ arc_init(void)
 	list_create(&arc_async_flush_list, sizeof (arc_async_flush_t),
 	    offsetof(arc_async_flush_t, af_node));
 	mutex_init(&arc_async_flush_lock, NULL, MUTEX_DEFAULT, NULL);
-	arc_flush_taskq = taskq_create("arc_flush", 75, defclsyspri,
-	    1, INT_MAX, TASKQ_DYNAMIC | TASKQ_THREADS_CPU_PCT);
+	arc_flush_taskq = taskq_create("arc_flush", MIN(boot_ncpus, 4),
+	    defclsyspri, 1, INT_MAX, TASKQ_DYNAMIC);
 
 	arc_ksp = kstat_create("zfs", 0, "arcstats", "misc", KSTAT_TYPE_NAMED,
 	    sizeof (arc_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
@@ -9442,7 +9435,7 @@ l2arc_write_buffers(spa_t *spa, l2arc_dev_t *dev, uint64_t target_sz)
 			hdr->b_l2hdr.b_arcs_state =
 			    hdr->b_l1hdr.b_state->arcs_state;
 			/* l2arc_hdr_arcstats_update() expects a valid asize */
-			HDR_SET_ASIZE(hdr, asize);
+			HDR_SET_L2SIZE(hdr, asize);
 			arc_hdr_set_flags(hdr, ARC_FLAG_HAS_L2HDR |
 			    ARC_FLAG_L2_WRITING);
 
@@ -9609,10 +9602,8 @@ l2arc_feed_thread(void *unused)
 		 * held to prevent device removal.  l2arc_dev_get_next()
 		 * will grab and release l2arc_dev_mtx.
 		 */
-		if ((dev = l2arc_dev_get_next()) == NULL ||
-		    dev->l2ad_spa == NULL) {
+		if ((dev = l2arc_dev_get_next()) == NULL)
 			continue;
-		}
 
 		spa = dev->l2ad_spa;
 		ASSERT3P(spa, !=, NULL);
@@ -10573,7 +10564,8 @@ l2arc_hdr_restore(const l2arc_log_ent_phys_t *le, l2arc_dev_t *dev)
 	arc_buf_hdr_t		*hdr, *exists;
 	kmutex_t		*hash_lock;
 	arc_buf_contents_t	type = L2BLK_GET_TYPE((le)->le_prop);
-	uint64_t		asize;
+	uint64_t		asize = vdev_psize_to_asize(dev->l2ad_vdev,
+	    L2BLK_GET_PSIZE((le)->le_prop));
 
 	/*
 	 * Do all the allocation before grabbing any locks, this lets us
@@ -10582,14 +10574,11 @@ l2arc_hdr_restore(const l2arc_log_ent_phys_t *le, l2arc_dev_t *dev)
 	 */
 	hdr = arc_buf_alloc_l2only(L2BLK_GET_LSIZE((le)->le_prop), type,
 	    dev, le->le_dva, le->le_daddr,
-	    L2BLK_GET_PSIZE((le)->le_prop), le->le_birth,
+	    L2BLK_GET_PSIZE((le)->le_prop), asize, le->le_birth,
 	    L2BLK_GET_COMPRESS((le)->le_prop), le->le_complevel,
 	    L2BLK_GET_PROTECTED((le)->le_prop),
 	    L2BLK_GET_PREFETCH((le)->le_prop),
 	    L2BLK_GET_STATE((le)->le_prop));
-	asize = vdev_psize_to_asize(dev->l2ad_vdev,
-	    L2BLK_GET_PSIZE((le)->le_prop));
-	ASSERT3U(asize, ==, HDR_GET_ASIZE(hdr));
 
 	/*
 	 * vdev_space_update() has to be called before arc_hdr_destroy() to
@@ -10620,7 +10609,7 @@ l2arc_hdr_restore(const l2arc_log_ent_phys_t *le, l2arc_dev_t *dev)
 			exists->b_l2hdr.b_arcs_state =
 			    L2BLK_GET_STATE((le)->le_prop);
 			/* l2arc_hdr_arcstats_update() expects a valid asize */
-			HDR_SET_ASIZE(exists, asize);
+			HDR_SET_L2SIZE(exists, asize);
 			mutex_enter(&dev->l2ad_mtx);
 			list_insert_tail(&dev->l2ad_buflist, exists);
 			(void) zfs_refcount_add_many(&dev->l2ad_alloc,