Distributed Spare (dRAID) Feature

[mirror_zfs.git] / include / sys / vdev_raidz_impl.h

diff --git a/include/sys/vdev_raidz_impl.h b/include/sys/vdev_raidz_impl.h
index 8492daedb6f81c5aa7f861f50a5218f71d59ef13..38d4f9e0bd48ef9ef726a8c2d00bbf5bf17000b1 100644 (file)
--- a/include/sys/vdev_raidz_impl.h
+++ b/include/sys/vdev_raidz_impl.h
@@ -29,6 +29,7 @@
 #include <sys/debug.h>
 #include <sys/kstat.h>
 #include <sys/abd.h>
+#include <sys/vdev_impl.h>
 
 #ifdef  __cplusplus
 extern "C" {
@@ -106,30 +107,45 @@ typedef struct raidz_col {
        uint64_t rc_offset;             /* device offset */
        uint64_t rc_size;               /* I/O size */
        abd_t *rc_abd;                  /* I/O data */
-       void *rc_gdata;                 /* used to store the "good" version */
+       void *rc_orig_data;             /* pre-reconstruction */
+       abd_t *rc_gdata;                /* used to store the "good" version */
        int rc_error;                   /* I/O error for this device */
        uint8_t rc_tried;               /* Did we attempt this I/O column? */
        uint8_t rc_skipped;             /* Did we skip this I/O column? */
+       uint8_t rc_need_orig_restore;   /* need to restore from orig_data? */
+       uint8_t rc_repair;              /* Write good data to this column */
 } raidz_col_t;
 
+typedef struct raidz_row {
+       uint64_t rr_cols;               /* Regular column count */
+       uint64_t rr_scols;              /* Count including skipped columns */
+       uint64_t rr_bigcols;            /* Remainder data column count */
+       uint64_t rr_missingdata;        /* Count of missing data devices */
+       uint64_t rr_missingparity;      /* Count of missing parity devices */
+       uint64_t rr_firstdatacol;       /* First data column/parity count */
+       abd_t *rr_abd_copy;             /* rm_asize-buffer of copied data */
+       abd_t *rr_abd_empty;            /* dRAID empty sector buffer */
+       int rr_nempty;                  /* empty sectors included in parity */
+       int rr_code;                    /* reconstruction code (unused) */
+#ifdef ZFS_DEBUG
+       uint64_t rr_offset;             /* Logical offset for *_io_verify() */
+       uint64_t rr_size;               /* Physical size for *_io_verify() */
+#endif
+       raidz_col_t rr_col[0];          /* Flexible array of I/O columns */
+} raidz_row_t;
+
 typedef struct raidz_map {
-       uint64_t rm_cols;               /* Regular column count */
-       uint64_t rm_scols;              /* Count including skipped columns */
-       uint64_t rm_bigcols;            /* Number of oversized columns */
-       uint64_t rm_asize;              /* Actual total I/O size */
-       uint64_t rm_missingdata;        /* Count of missing data devices */
-       uint64_t rm_missingparity;      /* Count of missing parity devices */
-       uint64_t rm_firstdatacol;       /* First data column/parity count */
-       uint64_t rm_nskip;              /* Skipped sectors for padding */
-       uint64_t rm_skipstart;          /* Column index of padding start */
-       abd_t *rm_abd_copy;             /* rm_asize-buffer of copied data */
        uintptr_t rm_reports;           /* # of referencing checksum reports */
-       uint8_t rm_freed;               /* map no longer has referencing ZIO */
-       uint8_t rm_ecksuminjected;      /* checksum error was injected */
+       boolean_t rm_freed;             /* map no longer has referencing ZIO */
+       boolean_t rm_ecksuminjected;    /* checksum error was injected */
+       int rm_nrows;                   /* Regular row count */
+       int rm_nskip;                   /* RAIDZ sectors skipped for padding */
+       int rm_skipstart;               /* Column index of padding start */
        const raidz_impl_ops_t *rm_ops; /* RAIDZ math operations */
-       raidz_col_t rm_col[1];          /* Flexible array of I/O columns */
+       raidz_row_t *rm_row[0];         /* flexible array of rows */
 } raidz_map_t;
 
+
 #define        RAIDZ_ORIGINAL_IMPL     (INT_MAX)
 
 extern const raidz_impl_ops_t vdev_raidz_scalar_impl;
@@ -163,14 +179,15 @@ extern const raidz_impl_ops_t vdev_raidz_powerpc_altivec_impl;
  *
  * raidz_parity                Returns parity of the RAIDZ block
  * raidz_ncols         Returns number of columns the block spans
+ *                     Note, all rows have the same number of columns.
  * raidz_nbigcols      Returns number of big columns
  * raidz_col_p         Returns pointer to a column
  * raidz_col_size      Returns size of a column
  * raidz_big_size      Returns size of big columns
  * raidz_short_size    Returns size of short columns
  */
-#define        raidz_parity(rm)        ((rm)->rm_firstdatacol)
-#define        raidz_ncols(rm)         ((rm)->rm_cols)
+#define        raidz_parity(rm)        ((rm)->rm_row[0]->rr_firstdatacol)
+#define        raidz_ncols(rm)         ((rm)->rm_row[0]->rr_cols)
 #define        raidz_nbigcols(rm)      ((rm)->rm_bigcols)
 #define        raidz_col_p(rm, c)      ((rm)->rm_col + (c))
 #define        raidz_col_size(rm, c)   ((rm)->rm_col[c].rc_size)
@@ -185,10 +202,10 @@ extern const raidz_impl_ops_t vdev_raidz_powerpc_altivec_impl;
  */
 #define        _RAIDZ_GEN_WRAP(code, impl)                                     \
 static void                                                            \
-impl ## _gen_ ## code(void *rmp)                                       \
+impl ## _gen_ ## code(void *rrp)                                       \
 {                                                                      \
-       raidz_map_t *rm = (raidz_map_t *)rmp;                           \
-       raidz_generate_## code ## _impl(rm);                            \
+       raidz_row_t *rr = (raidz_row_t *)rrp;                           \
+       raidz_generate_## code ## _impl(rr);                            \
 }
 
 /*
@@ -199,10 +216,10 @@ impl ## _gen_ ## code(void *rmp)                                  \
  */
 #define        _RAIDZ_REC_WRAP(code, impl)                                     \
 static int                                                             \
-impl ## _rec_ ## code(void *rmp, const int *tgtidx)                    \
+impl ## _rec_ ## code(void *rrp, const int *tgtidx)                    \
 {                                                                      \
-       raidz_map_t *rm = (raidz_map_t *)rmp;                           \
-       return (raidz_reconstruct_## code ## _impl(rm, tgtidx));        \
+       raidz_row_t *rr = (raidz_row_t *)rrp;                           \
+       return (raidz_reconstruct_## code ## _impl(rr, tgtidx));        \
 }
 
 /*