Print this page
6214 zpools going south

@@ -742,10 +742,11 @@
         /* protected by arc_buf_hdr mutex */
         l2arc_dev_t             *b_dev;         /* L2ARC device */
         uint64_t                b_daddr;        /* disk address, offset byte */
         /* real alloc'd buffer size depending on b_compress applied */
         int32_t                 b_asize;
+        uint8_t                 b_compress;
 
         list_node_t             b_l2node;
 } l2arc_buf_hdr_t;
 
 struct arc_buf_hdr {

@@ -801,19 +802,10 @@
 #define HDR_ISTYPE_DATA(hdr)    (!HDR_ISTYPE_METADATA(hdr))
 
 #define HDR_HAS_L1HDR(hdr)      ((hdr)->b_flags & ARC_FLAG_HAS_L1HDR)
 #define HDR_HAS_L2HDR(hdr)      ((hdr)->b_flags & ARC_FLAG_HAS_L2HDR)
 
-/* For storing compression mode in b_flags */
-#define HDR_COMPRESS_OFFSET     24
-#define HDR_COMPRESS_NBITS      7
-
-#define HDR_GET_COMPRESS(hdr)   ((enum zio_compress)BF32_GET(hdr->b_flags, \
-            HDR_COMPRESS_OFFSET, HDR_COMPRESS_NBITS))
-#define HDR_SET_COMPRESS(hdr, cmp) BF32_SET(hdr->b_flags, \
-            HDR_COMPRESS_OFFSET, HDR_COMPRESS_NBITS, (cmp))
-
 /*
  * Other sizes
  */
 
 #define HDR_FULL_SIZE ((int64_t)sizeof (arc_buf_hdr_t))

@@ -2040,25 +2032,25 @@
          * l2arc_write_buffer() has started (which does the compression
          * step). In either case, b_tmp_cdata does not point to a
          * separately compressed buffer, so there's nothing to free (it
          * points to the same buffer as the arc_buf_t's b_data field).
          */
-        if (HDR_GET_COMPRESS(hdr) == ZIO_COMPRESS_OFF) {
+        if (hdr->b_l2hdr.b_compress == ZIO_COMPRESS_OFF) {
                 hdr->b_l1hdr.b_tmp_cdata = NULL;
                 return;
         }
 
         /*
          * There's nothing to free since the buffer was all zero's and
          * compressed to a zero length buffer.
          */
-        if (HDR_GET_COMPRESS(hdr) == ZIO_COMPRESS_EMPTY) {
+        if (hdr->b_l2hdr.b_compress == ZIO_COMPRESS_EMPTY) {
                 ASSERT3P(hdr->b_l1hdr.b_tmp_cdata, ==, NULL);
                 return;
         }
 
-        ASSERT(L2ARC_IS_VALID_COMPRESS(HDR_GET_COMPRESS(hdr)));
+        ASSERT(L2ARC_IS_VALID_COMPRESS(hdr->b_l2hdr.b_compress));
 
         arc_buf_free_on_write(hdr->b_l1hdr.b_tmp_cdata,
             hdr->b_size, zio_data_buf_free);
 
         ARCSTAT_BUMP(arcstat_l2_cdata_free_on_write);

@@ -4167,11 +4159,11 @@
 
                 if (HDR_HAS_L2HDR(hdr) &&
                     (vd = hdr->b_l2hdr.b_dev->l2ad_vdev) != NULL) {
                         devw = hdr->b_l2hdr.b_dev->l2ad_writing;
                         addr = hdr->b_l2hdr.b_daddr;
-                        b_compress = HDR_GET_COMPRESS(hdr);
+                        b_compress = hdr->b_l2hdr.b_compress;
                         b_asize = hdr->b_l2hdr.b_asize;
                         /*
                          * Lock out device removal.
                          */
                         if (vdev_is_dead(vd) ||

@@ -5628,10 +5620,12 @@
          * If the buffer was compressed, decompress it first.
          */
         if (cb->l2rcb_compress != ZIO_COMPRESS_OFF)
                 l2arc_decompress_zio(zio, hdr, cb->l2rcb_compress);
         ASSERT(zio->io_data != NULL);
+        ASSERT3U(zio->io_size, ==, hdr->b_size);
+        ASSERT3U(BP_GET_LSIZE(&cb->l2rcb_bp), ==, hdr->b_size);
 
         /*
          * Check this survived the L2ARC journey.
          */
         equal = arc_cksum_equal(buf);

@@ -5664,11 +5658,11 @@
                         zio_t *pio = zio_unique_parent(zio);
 
                         ASSERT(!pio || pio->io_child_type == ZIO_CHILD_LOGICAL);
 
                         zio_nowait(zio_read(pio, cb->l2rcb_spa, &cb->l2rcb_bp,
-                            buf->b_data, zio->io_size, arc_read_done, buf,
+                            buf->b_data, hdr->b_size, arc_read_done, buf,
                             zio->io_priority, cb->l2rcb_flags, &cb->l2rcb_zb));
                 }
         }
 
         kmem_free(cb, sizeof (l2arc_read_callback_t));

@@ -5962,11 +5956,11 @@
                          * there. This is because can't access b_l1hdr.b_buf
                          * without holding the hash_lock, which we in turn
                          * can't access without holding the ARC list locks
                          * (which we want to avoid during compression/writing).
                          */
-                        HDR_SET_COMPRESS(hdr, ZIO_COMPRESS_OFF);
+                        hdr->b_l2hdr.b_compress = ZIO_COMPRESS_OFF;
                         hdr->b_l2hdr.b_asize = hdr->b_size;
                         hdr->b_l1hdr.b_tmp_cdata = hdr->b_l1hdr.b_buf->b_data;
 
                         /*
                          * Explicitly set the b_daddr field to a known

@@ -6152,11 +6146,11 @@
         size_t csize, len, rounded;
         ASSERT(HDR_HAS_L2HDR(hdr));
         l2arc_buf_hdr_t *l2hdr = &hdr->b_l2hdr;
 
         ASSERT(HDR_HAS_L1HDR(hdr));
-        ASSERT(HDR_GET_COMPRESS(hdr) == ZIO_COMPRESS_OFF);
+        ASSERT(l2hdr->b_compress == ZIO_COMPRESS_OFF);
         ASSERT(hdr->b_l1hdr.b_tmp_cdata != NULL);
 
         len = l2hdr->b_asize;
         cdata = zio_data_buf_alloc(len);
         ASSERT3P(cdata, !=, NULL);

@@ -6170,21 +6164,21 @@
         }
 
         if (csize == 0) {
                 /* zero block, indicate that there's nothing to write */
                 zio_data_buf_free(cdata, len);
-                HDR_SET_COMPRESS(hdr, ZIO_COMPRESS_EMPTY);
+                l2hdr->b_compress = ZIO_COMPRESS_EMPTY;
                 l2hdr->b_asize = 0;
                 hdr->b_l1hdr.b_tmp_cdata = NULL;
                 ARCSTAT_BUMP(arcstat_l2_compress_zeros);
                 return (B_TRUE);
         } else if (csize > 0 && csize < len) {
                 /*
                  * Compression succeeded, we'll keep the cdata around for
                  * writing and release it afterwards.
                  */
-                HDR_SET_COMPRESS(hdr, ZIO_COMPRESS_LZ4);
+                l2hdr->b_compress = ZIO_COMPRESS_LZ4;
                 l2hdr->b_asize = csize;
                 hdr->b_l1hdr.b_tmp_cdata = cdata;
                 ARCSTAT_BUMP(arcstat_l2_compress_successes);
                 return (B_TRUE);
         } else {

@@ -6267,11 +6261,12 @@
  * done, we can dispose of it.
  */
 static void
 l2arc_release_cdata_buf(arc_buf_hdr_t *hdr)
 {
-        enum zio_compress comp = HDR_GET_COMPRESS(hdr);
+        ASSERT(HDR_HAS_L2HDR(hdr));
+        enum zio_compress comp = hdr->b_l2hdr.b_compress;
 
         ASSERT(HDR_HAS_L1HDR(hdr));
         ASSERT(comp == ZIO_COMPRESS_OFF || L2ARC_IS_VALID_COMPRESS(comp));
 
         if (comp == ZIO_COMPRESS_OFF) {