02730c333c
Enable picky cstyle checks and resolve the new warnings. The vast
majority of the changes needed were to handle minor issues with
whitespace formatting. This patch contains no functional changes.
Non-whitespace changes are as follows:
* 8 times ; to { } in for/while loop
* fix missing ; in cmd/zed/agents/zfs_diagnosis.c
* comment (confim -> confirm)
* change endline , to ; in cmd/zpool/zpool_main.c
* a number of /* BEGIN CSTYLED */ /* END CSTYLED */ blocks
* /* CSTYLED */ markers
* change == 0 to !
* ulong to unsigned long in module/zfs/dsl_scan.c
* rearrangement of module_param lines in module/zfs/metaslab.c
* add { } block around statement after for_each_online_node
Reviewed-by: Giuseppe Di Natale <dinatale2@llnl.gov>
Reviewed-by: Håkan Johansson <f96hajo@chalmers.se>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #5465
1478 lines
34 KiB
C
1478 lines
34 KiB
C
/*
|
|
* CDDL HEADER START
|
|
*
|
|
* The contents of this file are subject to the terms of the
|
|
* Common Development and Distribution License (the "License").
|
|
* You may not use this file except in compliance with the License.
|
|
*
|
|
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
* or http://www.opensolaris.org/os/licensing.
|
|
* See the License for the specific language governing permissions
|
|
* and limitations under the License.
|
|
*
|
|
* When distributing Covered Code, include this CDDL HEADER in each
|
|
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
* If applicable, add the following below this CDDL HEADER, with the
|
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
|
* information: Portions Copyright [yyyy] [name of copyright owner]
|
|
*
|
|
* CDDL HEADER END
|
|
*/
|
|
/*
|
|
* Copyright (C) 2016 Gvozden Nešković. All rights reserved.
|
|
*/
|
|
|
|
#ifndef _VDEV_RAIDZ_MATH_IMPL_H
|
|
#define _VDEV_RAIDZ_MATH_IMPL_H
|
|
|
|
#include <sys/types.h>
|
|
|
|
#define raidz_inline inline __attribute__((always_inline))
|
|
#ifndef noinline
|
|
#define noinline __attribute__((noinline))
|
|
#endif
|
|
|
|
/*
|
|
* Functions calculate multiplication constants for data reconstruction.
|
|
* Coefficients depend on RAIDZ geometry, indexes of failed child vdevs, and
|
|
* used parity columns for reconstruction.
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
* @coeff output array of coefficients. Array must be provided by
|
|
* user and must hold minimum MUL_CNT values.
|
|
*/
|
|
static noinline void
|
|
raidz_rec_q_coeff(const raidz_map_t *rm, const int *tgtidx, unsigned *coeff)
|
|
{
|
|
const unsigned ncols = raidz_ncols(rm);
|
|
const unsigned x = tgtidx[TARGET_X];
|
|
|
|
coeff[MUL_Q_X] = gf_exp2(255 - (ncols - x - 1));
|
|
}
|
|
|
|
static noinline void
|
|
raidz_rec_r_coeff(const raidz_map_t *rm, const int *tgtidx, unsigned *coeff)
|
|
{
|
|
const unsigned ncols = raidz_ncols(rm);
|
|
const unsigned x = tgtidx[TARGET_X];
|
|
|
|
coeff[MUL_R_X] = gf_exp4(255 - (ncols - x - 1));
|
|
}
|
|
|
|
static noinline void
|
|
raidz_rec_pq_coeff(const raidz_map_t *rm, const int *tgtidx, unsigned *coeff)
|
|
{
|
|
const unsigned ncols = raidz_ncols(rm);
|
|
const unsigned x = tgtidx[TARGET_X];
|
|
const unsigned y = tgtidx[TARGET_Y];
|
|
gf_t a, b, e;
|
|
|
|
a = gf_exp2(x + 255 - y);
|
|
b = gf_exp2(255 - (ncols - x - 1));
|
|
e = a ^ 0x01;
|
|
|
|
coeff[MUL_PQ_X] = gf_div(a, e);
|
|
coeff[MUL_PQ_Y] = gf_div(b, e);
|
|
}
|
|
|
|
static noinline void
|
|
raidz_rec_pr_coeff(const raidz_map_t *rm, const int *tgtidx, unsigned *coeff)
|
|
{
|
|
const unsigned ncols = raidz_ncols(rm);
|
|
const unsigned x = tgtidx[TARGET_X];
|
|
const unsigned y = tgtidx[TARGET_Y];
|
|
|
|
gf_t a, b, e;
|
|
|
|
a = gf_exp4(x + 255 - y);
|
|
b = gf_exp4(255 - (ncols - x - 1));
|
|
e = a ^ 0x01;
|
|
|
|
coeff[MUL_PR_X] = gf_div(a, e);
|
|
coeff[MUL_PR_Y] = gf_div(b, e);
|
|
}
|
|
|
|
static noinline void
|
|
raidz_rec_qr_coeff(const raidz_map_t *rm, const int *tgtidx, unsigned *coeff)
|
|
{
|
|
const unsigned ncols = raidz_ncols(rm);
|
|
const unsigned x = tgtidx[TARGET_X];
|
|
const unsigned y = tgtidx[TARGET_Y];
|
|
|
|
gf_t nx, ny, nxxy, nxyy, d;
|
|
|
|
nx = gf_exp2(ncols - x - 1);
|
|
ny = gf_exp2(ncols - y - 1);
|
|
nxxy = gf_mul(gf_mul(nx, nx), ny);
|
|
nxyy = gf_mul(gf_mul(nx, ny), ny);
|
|
d = nxxy ^ nxyy;
|
|
|
|
coeff[MUL_QR_XQ] = ny;
|
|
coeff[MUL_QR_X] = gf_div(ny, d);
|
|
coeff[MUL_QR_YQ] = nx;
|
|
coeff[MUL_QR_Y] = gf_div(nx, d);
|
|
}
|
|
|
|
static noinline void
|
|
raidz_rec_pqr_coeff(const raidz_map_t *rm, const int *tgtidx, unsigned *coeff)
|
|
{
|
|
const unsigned ncols = raidz_ncols(rm);
|
|
const unsigned x = tgtidx[TARGET_X];
|
|
const unsigned y = tgtidx[TARGET_Y];
|
|
const unsigned z = tgtidx[TARGET_Z];
|
|
|
|
gf_t nx, ny, nz, nxx, nyy, nzz, nyyz, nyzz, xd, yd;
|
|
|
|
nx = gf_exp2(ncols - x - 1);
|
|
ny = gf_exp2(ncols - y - 1);
|
|
nz = gf_exp2(ncols - z - 1);
|
|
|
|
nxx = gf_exp4(ncols - x - 1);
|
|
nyy = gf_exp4(ncols - y - 1);
|
|
nzz = gf_exp4(ncols - z - 1);
|
|
|
|
nyyz = gf_mul(gf_mul(ny, nz), ny);
|
|
nyzz = gf_mul(nzz, ny);
|
|
|
|
xd = gf_mul(nxx, ny) ^ gf_mul(nx, nyy) ^ nyyz ^
|
|
gf_mul(nxx, nz) ^ gf_mul(nzz, nx) ^ nyzz;
|
|
|
|
yd = gf_inv(ny ^ nz);
|
|
|
|
coeff[MUL_PQR_XP] = gf_div(nyyz ^ nyzz, xd);
|
|
coeff[MUL_PQR_XQ] = gf_div(nyy ^ nzz, xd);
|
|
coeff[MUL_PQR_XR] = gf_div(ny ^ nz, xd);
|
|
coeff[MUL_PQR_YU] = nx;
|
|
coeff[MUL_PQR_YP] = gf_mul(nz, yd);
|
|
coeff[MUL_PQR_YQ] = yd;
|
|
}
|
|
|
|
/*
|
|
* Method for zeroing a buffer (can be implemented using SIMD).
|
|
* This method is used by multiple for gen/rec functions.
|
|
*
|
|
* @dc Destination buffer
|
|
* @dsize Destination buffer size
|
|
* @private Unused
|
|
*/
|
|
static int
|
|
raidz_zero_abd_cb(void *dc, size_t dsize, void *private)
|
|
{
|
|
v_t *dst = (v_t *)dc;
|
|
size_t i;
|
|
|
|
ZERO_DEFINE();
|
|
|
|
(void) private; /* unused */
|
|
|
|
ZERO(ZERO_D);
|
|
|
|
for (i = 0; i < dsize / sizeof (v_t); i += (2 * ZERO_STRIDE)) {
|
|
STORE(dst + i, ZERO_D);
|
|
STORE(dst + i + ZERO_STRIDE, ZERO_D);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
#define raidz_zero(dabd, size) \
|
|
{ \
|
|
abd_iterate_func(dabd, 0, size, raidz_zero_abd_cb, NULL); \
|
|
}
|
|
|
|
/*
|
|
* Method for copying two buffers (can be implemented using SIMD).
|
|
* This method is used by multiple for gen/rec functions.
|
|
*
|
|
* @dc Destination buffer
|
|
* @sc Source buffer
|
|
* @dsize Destination buffer size
|
|
* @ssize Source buffer size
|
|
* @private Unused
|
|
*/
|
|
static int
|
|
raidz_copy_abd_cb(void *dc, void *sc, size_t size, void *private)
|
|
{
|
|
v_t *dst = (v_t *)dc;
|
|
const v_t *src = (v_t *)sc;
|
|
size_t i;
|
|
|
|
COPY_DEFINE();
|
|
|
|
(void) private; /* unused */
|
|
|
|
for (i = 0; i < size / sizeof (v_t); i += (2 * COPY_STRIDE)) {
|
|
LOAD(src + i, COPY_D);
|
|
STORE(dst + i, COPY_D);
|
|
|
|
LOAD(src + i + COPY_STRIDE, COPY_D);
|
|
STORE(dst + i + COPY_STRIDE, COPY_D);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
|
|
#define raidz_copy(dabd, sabd, size) \
|
|
{ \
|
|
abd_iterate_func2(dabd, sabd, 0, 0, size, raidz_copy_abd_cb, NULL);\
|
|
}
|
|
|
|
/*
|
|
* Method for adding (XORing) two buffers.
|
|
* Source and destination are XORed together and result is stored in
|
|
* destination buffer. This method is used by multiple for gen/rec functions.
|
|
*
|
|
* @dc Destination buffer
|
|
* @sc Source buffer
|
|
* @dsize Destination buffer size
|
|
* @ssize Source buffer size
|
|
* @private Unused
|
|
*/
|
|
static int
|
|
raidz_add_abd_cb(void *dc, void *sc, size_t size, void *private)
|
|
{
|
|
v_t *dst = (v_t *)dc;
|
|
const v_t *src = (v_t *)sc;
|
|
size_t i;
|
|
|
|
ADD_DEFINE();
|
|
|
|
(void) private; /* unused */
|
|
|
|
for (i = 0; i < size / sizeof (v_t); i += (2 * ADD_STRIDE)) {
|
|
LOAD(dst + i, ADD_D);
|
|
XOR_ACC(src + i, ADD_D);
|
|
STORE(dst + i, ADD_D);
|
|
|
|
LOAD(dst + i + ADD_STRIDE, ADD_D);
|
|
XOR_ACC(src + i + ADD_STRIDE, ADD_D);
|
|
STORE(dst + i + ADD_STRIDE, ADD_D);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
#define raidz_add(dabd, sabd, size) \
|
|
{ \
|
|
abd_iterate_func2(dabd, sabd, 0, 0, size, raidz_add_abd_cb, NULL);\
|
|
}
|
|
|
|
/*
|
|
* Method for multiplying a buffer with a constant in GF(2^8).
|
|
* Symbols from buffer are multiplied by a constant and result is stored
|
|
* back in the same buffer.
|
|
*
|
|
* @dc In/Out data buffer.
|
|
* @size Size of the buffer
|
|
* @private pointer to the multiplication constant (unsigned)
|
|
*/
|
|
static int
|
|
raidz_mul_abd_cb(void *dc, size_t size, void *private)
|
|
{
|
|
const unsigned mul = *((unsigned *)private);
|
|
v_t *d = (v_t *)dc;
|
|
size_t i;
|
|
|
|
MUL_DEFINE();
|
|
|
|
for (i = 0; i < size / sizeof (v_t); i += (2 * MUL_STRIDE)) {
|
|
LOAD(d + i, MUL_D);
|
|
MUL(mul, MUL_D);
|
|
STORE(d + i, MUL_D);
|
|
|
|
LOAD(d + i + MUL_STRIDE, MUL_D);
|
|
MUL(mul, MUL_D);
|
|
STORE(d + i + MUL_STRIDE, MUL_D);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
|
|
/*
|
|
* Syndrome generation/update macros
|
|
*
|
|
* Require LOAD(), XOR(), STORE(), MUL2(), and MUL4() macros
|
|
*/
|
|
#define P_D_SYNDROME(D, T, t) \
|
|
{ \
|
|
LOAD((t), T); \
|
|
XOR(D, T); \
|
|
STORE((t), T); \
|
|
}
|
|
|
|
#define Q_D_SYNDROME(D, T, t) \
|
|
{ \
|
|
LOAD((t), T); \
|
|
MUL2(T); \
|
|
XOR(D, T); \
|
|
STORE((t), T); \
|
|
}
|
|
|
|
#define Q_SYNDROME(T, t) \
|
|
{ \
|
|
LOAD((t), T); \
|
|
MUL2(T); \
|
|
STORE((t), T); \
|
|
}
|
|
|
|
#define R_D_SYNDROME(D, T, t) \
|
|
{ \
|
|
LOAD((t), T); \
|
|
MUL4(T); \
|
|
XOR(D, T); \
|
|
STORE((t), T); \
|
|
}
|
|
|
|
#define R_SYNDROME(T, t) \
|
|
{ \
|
|
LOAD((t), T); \
|
|
MUL4(T); \
|
|
STORE((t), T); \
|
|
}
|
|
|
|
|
|
/*
|
|
* PARITY CALCULATION
|
|
*
|
|
* Macros *_SYNDROME are used for parity/syndrome calculation.
|
|
* *_D_SYNDROME() macros are used to calculate syndrome between 0 and
|
|
* length of data column, and *_SYNDROME() macros are only for updating
|
|
* the parity/syndrome if data column is shorter.
|
|
*
|
|
* P parity is calculated using raidz_add_abd().
|
|
*/
|
|
|
|
/*
|
|
* Generate P parity (RAIDZ1)
|
|
*
|
|
* @rm RAIDZ map
|
|
*/
|
|
static raidz_inline void
|
|
raidz_generate_p_impl(raidz_map_t * const rm)
|
|
{
|
|
size_t c;
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t psize = rm->rm_col[CODE_P].rc_size;
|
|
abd_t *pabd = rm->rm_col[CODE_P].rc_abd;
|
|
size_t size;
|
|
abd_t *dabd;
|
|
|
|
raidz_math_begin();
|
|
|
|
/* start with first data column */
|
|
raidz_copy(pabd, rm->rm_col[1].rc_abd, psize);
|
|
|
|
for (c = 2; c < ncols; c++) {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
size = rm->rm_col[c].rc_size;
|
|
|
|
/* add data column */
|
|
raidz_add(pabd, dabd, size);
|
|
}
|
|
|
|
raidz_math_end();
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate PQ parity (RAIDZ2)
|
|
* The function is called per data column.
|
|
*
|
|
* @c array of pointers to parity (code) columns
|
|
* @dc pointer to data column
|
|
* @csize size of parity columns
|
|
* @dsize size of data column
|
|
*/
|
|
static void
|
|
raidz_gen_pq_add(void **c, const void *dc, const size_t csize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *p = (v_t *)c[0];
|
|
v_t *q = (v_t *)c[1];
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
const v_t * const qend = q + (csize / sizeof (v_t));
|
|
|
|
GEN_PQ_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += GEN_PQ_STRIDE, p += GEN_PQ_STRIDE,
|
|
q += GEN_PQ_STRIDE) {
|
|
LOAD(d, GEN_PQ_D);
|
|
P_D_SYNDROME(GEN_PQ_D, GEN_PQ_C, p);
|
|
Q_D_SYNDROME(GEN_PQ_D, GEN_PQ_C, q);
|
|
}
|
|
for (; q < qend; q += GEN_PQ_STRIDE) {
|
|
Q_SYNDROME(GEN_PQ_C, q);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate PQ parity (RAIDZ2)
|
|
*
|
|
* @rm RAIDZ map
|
|
*/
|
|
static raidz_inline void
|
|
raidz_generate_pq_impl(raidz_map_t * const rm)
|
|
{
|
|
size_t c;
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t csize = rm->rm_col[CODE_P].rc_size;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
abd_t *cabds[] = {
|
|
rm->rm_col[CODE_P].rc_abd,
|
|
rm->rm_col[CODE_Q].rc_abd
|
|
};
|
|
|
|
raidz_math_begin();
|
|
|
|
raidz_copy(cabds[CODE_P], rm->rm_col[2].rc_abd, csize);
|
|
raidz_copy(cabds[CODE_Q], rm->rm_col[2].rc_abd, csize);
|
|
|
|
for (c = 3; c < ncols; c++) {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
|
|
abd_raidz_gen_iterate(cabds, dabd, csize, dsize, 2,
|
|
raidz_gen_pq_add);
|
|
}
|
|
|
|
raidz_math_end();
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate PQR parity (RAIDZ3)
|
|
* The function is called per data column.
|
|
*
|
|
* @c array of pointers to parity (code) columns
|
|
* @dc pointer to data column
|
|
* @csize size of parity columns
|
|
* @dsize size of data column
|
|
*/
|
|
static void
|
|
raidz_gen_pqr_add(void **c, const void *dc, const size_t csize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *p = (v_t *)c[0];
|
|
v_t *q = (v_t *)c[1];
|
|
v_t *r = (v_t *)c[CODE_R];
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
const v_t * const qend = q + (csize / sizeof (v_t));
|
|
|
|
GEN_PQR_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += GEN_PQR_STRIDE, p += GEN_PQR_STRIDE,
|
|
q += GEN_PQR_STRIDE, r += GEN_PQR_STRIDE) {
|
|
LOAD(d, GEN_PQR_D);
|
|
P_D_SYNDROME(GEN_PQR_D, GEN_PQR_C, p);
|
|
Q_D_SYNDROME(GEN_PQR_D, GEN_PQR_C, q);
|
|
R_D_SYNDROME(GEN_PQR_D, GEN_PQR_C, r);
|
|
}
|
|
for (; q < qend; q += GEN_PQR_STRIDE, r += GEN_PQR_STRIDE) {
|
|
Q_SYNDROME(GEN_PQR_C, q);
|
|
R_SYNDROME(GEN_PQR_C, r);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate PQR parity (RAIDZ2)
|
|
*
|
|
* @rm RAIDZ map
|
|
*/
|
|
static raidz_inline void
|
|
raidz_generate_pqr_impl(raidz_map_t * const rm)
|
|
{
|
|
size_t c;
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t csize = rm->rm_col[CODE_P].rc_size;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
abd_t *cabds[] = {
|
|
rm->rm_col[CODE_P].rc_abd,
|
|
rm->rm_col[CODE_Q].rc_abd,
|
|
rm->rm_col[CODE_R].rc_abd
|
|
};
|
|
|
|
raidz_math_begin();
|
|
|
|
raidz_copy(cabds[CODE_P], rm->rm_col[3].rc_abd, csize);
|
|
raidz_copy(cabds[CODE_Q], rm->rm_col[3].rc_abd, csize);
|
|
raidz_copy(cabds[CODE_R], rm->rm_col[3].rc_abd, csize);
|
|
|
|
for (c = 4; c < ncols; c++) {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
|
|
abd_raidz_gen_iterate(cabds, dabd, csize, dsize, 3,
|
|
raidz_gen_pqr_add);
|
|
}
|
|
|
|
raidz_math_end();
|
|
}
|
|
|
|
|
|
/*
|
|
* DATA RECONSTRUCTION
|
|
*
|
|
* Data reconstruction process consists of two phases:
|
|
* - Syndrome calculation
|
|
* - Data reconstruction
|
|
*
|
|
* Syndrome is calculated by generating parity using available data columns
|
|
* and zeros in places of erasure. Existing parity is added to corresponding
|
|
* syndrome value to obtain the [P|Q|R]syn values from equation:
|
|
* P = Psyn + Dx + Dy + Dz
|
|
* Q = Qsyn + 2^x * Dx + 2^y * Dy + 2^z * Dz
|
|
* R = Rsyn + 4^x * Dx + 4^y * Dy + 4^z * Dz
|
|
*
|
|
* For data reconstruction phase, the corresponding equations are solved
|
|
* for missing data (Dx, Dy, Dz). This generally involves multiplying known
|
|
* symbols by an coefficient and adding them together. The multiplication
|
|
* constant coefficients are calculated ahead of the operation in
|
|
* raidz_rec_[q|r|pq|pq|qr|pqr]_coeff() functions.
|
|
*
|
|
* IMPLEMENTATION NOTE: RAID-Z block can have complex geometry, with "big"
|
|
* and "short" columns.
|
|
* For this reason, reconstruction is performed in minimum of
|
|
* two steps. First, from offset 0 to short_size, then from short_size to
|
|
* short_size. Calculation functions REC_[*]_BLOCK() are implemented to work
|
|
* over both ranges. The split also enables removal of conditional expressions
|
|
* from loop bodies, improving throughput of SIMD implementations.
|
|
* For the best performance, all functions marked with raidz_inline attribute
|
|
* must be inlined by compiler.
|
|
*
|
|
* parity data
|
|
* columns columns
|
|
* <----------> <------------------>
|
|
* x y <----+ missing columns (x, y)
|
|
* | |
|
|
* +---+---+---+---+-v-+---+-v-+---+ ^ 0
|
|
* | | | | | | | | | |
|
|
* | | | | | | | | | |
|
|
* | P | Q | R | D | D | D | D | D | |
|
|
* | | | | 0 | 1 | 2 | 3 | 4 | |
|
|
* | | | | | | | | | v
|
|
* | | | | | +---+---+---+ ^ short_size
|
|
* | | | | | | |
|
|
* +---+---+---+---+---+ v big_size
|
|
* <------------------> <---------->
|
|
* big columns short columns
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Reconstruct single data column using P parity
|
|
*
|
|
* @syn_method raidz_add_abd()
|
|
* @rec_method not applicable
|
|
*
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
*/
|
|
static raidz_inline int
|
|
raidz_reconstruct_p_impl(raidz_map_t *rm, const int *tgtidx)
|
|
{
|
|
size_t c;
|
|
const size_t firstdc = raidz_parity(rm);
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t x = tgtidx[TARGET_X];
|
|
const size_t xsize = rm->rm_col[x].rc_size;
|
|
abd_t *xabd = rm->rm_col[x].rc_abd;
|
|
size_t size;
|
|
abd_t *dabd;
|
|
|
|
raidz_math_begin();
|
|
|
|
/* copy P into target */
|
|
raidz_copy(xabd, rm->rm_col[CODE_P].rc_abd, xsize);
|
|
|
|
/* generate p_syndrome */
|
|
for (c = firstdc; c < ncols; c++) {
|
|
if (c == x)
|
|
continue;
|
|
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
size = MIN(rm->rm_col[c].rc_size, xsize);
|
|
|
|
raidz_add(xabd, dabd, size);
|
|
}
|
|
|
|
raidz_math_end();
|
|
|
|
return (1 << CODE_P);
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate Q syndrome (Qsyn)
|
|
*
|
|
* @xc array of pointers to syndrome columns
|
|
* @dc data column (NULL if missing)
|
|
* @xsize size of syndrome columns
|
|
* @dsize size of data column (0 if missing)
|
|
*/
|
|
static void
|
|
raidz_syn_q_abd(void **xc, const void *dc, const size_t xsize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *x = (v_t *)xc[TARGET_X];
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
const v_t * const xend = x + (xsize / sizeof (v_t));
|
|
|
|
SYN_Q_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += SYN_STRIDE, x += SYN_STRIDE) {
|
|
LOAD(d, SYN_Q_D);
|
|
Q_D_SYNDROME(SYN_Q_D, SYN_Q_X, x);
|
|
}
|
|
for (; x < xend; x += SYN_STRIDE) {
|
|
Q_SYNDROME(SYN_Q_X, x);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct single data column using Q parity
|
|
*
|
|
* @syn_method raidz_add_abd()
|
|
* @rec_method raidz_mul_abd_cb()
|
|
*
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
*/
|
|
static raidz_inline int
|
|
raidz_reconstruct_q_impl(raidz_map_t *rm, const int *tgtidx)
|
|
{
|
|
size_t c;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
const size_t firstdc = raidz_parity(rm);
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t x = tgtidx[TARGET_X];
|
|
abd_t *xabd = rm->rm_col[x].rc_abd;
|
|
const size_t xsize = rm->rm_col[x].rc_size;
|
|
abd_t *tabds[] = { xabd };
|
|
|
|
unsigned coeff[MUL_CNT];
|
|
raidz_rec_q_coeff(rm, tgtidx, coeff);
|
|
|
|
raidz_math_begin();
|
|
|
|
/* Start with first data column if present */
|
|
if (firstdc != x) {
|
|
raidz_copy(xabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
} else {
|
|
raidz_zero(xabd, xsize);
|
|
}
|
|
|
|
/* generate q_syndrome */
|
|
for (c = firstdc+1; c < ncols; c++) {
|
|
if (c == x) {
|
|
dabd = NULL;
|
|
dsize = 0;
|
|
} else {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
}
|
|
|
|
abd_raidz_gen_iterate(tabds, dabd, xsize, dsize, 1,
|
|
raidz_syn_q_abd);
|
|
}
|
|
|
|
/* add Q to the syndrome */
|
|
raidz_add(xabd, rm->rm_col[CODE_Q].rc_abd, xsize);
|
|
|
|
/* transform the syndrome */
|
|
abd_iterate_func(xabd, 0, xsize, raidz_mul_abd_cb, (void*) coeff);
|
|
|
|
raidz_math_end();
|
|
|
|
return (1 << CODE_Q);
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate R syndrome (Rsyn)
|
|
*
|
|
* @xc array of pointers to syndrome columns
|
|
* @dc data column (NULL if missing)
|
|
* @tsize size of syndrome columns
|
|
* @dsize size of data column (0 if missing)
|
|
*/
|
|
static void
|
|
raidz_syn_r_abd(void **xc, const void *dc, const size_t tsize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *x = (v_t *)xc[TARGET_X];
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
const v_t * const xend = x + (tsize / sizeof (v_t));
|
|
|
|
SYN_R_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += SYN_STRIDE, x += SYN_STRIDE) {
|
|
LOAD(d, SYN_R_D);
|
|
R_D_SYNDROME(SYN_R_D, SYN_R_X, x);
|
|
}
|
|
for (; x < xend; x += SYN_STRIDE) {
|
|
R_SYNDROME(SYN_R_X, x);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct single data column using R parity
|
|
*
|
|
* @syn_method raidz_add_abd()
|
|
* @rec_method raidz_mul_abd_cb()
|
|
*
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
*/
|
|
static raidz_inline int
|
|
raidz_reconstruct_r_impl(raidz_map_t *rm, const int *tgtidx)
|
|
{
|
|
size_t c;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
const size_t firstdc = raidz_parity(rm);
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t x = tgtidx[TARGET_X];
|
|
const size_t xsize = rm->rm_col[x].rc_size;
|
|
abd_t *xabd = rm->rm_col[x].rc_abd;
|
|
abd_t *tabds[] = { xabd };
|
|
|
|
unsigned coeff[MUL_CNT];
|
|
raidz_rec_r_coeff(rm, tgtidx, coeff);
|
|
|
|
raidz_math_begin();
|
|
|
|
/* Start with first data column if present */
|
|
if (firstdc != x) {
|
|
raidz_copy(xabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
} else {
|
|
raidz_zero(xabd, xsize);
|
|
}
|
|
|
|
|
|
/* generate q_syndrome */
|
|
for (c = firstdc+1; c < ncols; c++) {
|
|
if (c == x) {
|
|
dabd = NULL;
|
|
dsize = 0;
|
|
} else {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
}
|
|
|
|
abd_raidz_gen_iterate(tabds, dabd, xsize, dsize, 1,
|
|
raidz_syn_r_abd);
|
|
}
|
|
|
|
/* add R to the syndrome */
|
|
raidz_add(xabd, rm->rm_col[CODE_R].rc_abd, xsize);
|
|
|
|
/* transform the syndrome */
|
|
abd_iterate_func(xabd, 0, xsize, raidz_mul_abd_cb, (void *)coeff);
|
|
|
|
raidz_math_end();
|
|
|
|
return (1 << CODE_R);
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate P and Q syndromes
|
|
*
|
|
* @xc array of pointers to syndrome columns
|
|
* @dc data column (NULL if missing)
|
|
* @tsize size of syndrome columns
|
|
* @dsize size of data column (0 if missing)
|
|
*/
|
|
static void
|
|
raidz_syn_pq_abd(void **tc, const void *dc, const size_t tsize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *x = (v_t *)tc[TARGET_X];
|
|
v_t *y = (v_t *)tc[TARGET_Y];
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
const v_t * const yend = y + (tsize / sizeof (v_t));
|
|
|
|
SYN_PQ_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += SYN_STRIDE, x += SYN_STRIDE, y += SYN_STRIDE) {
|
|
LOAD(d, SYN_PQ_D);
|
|
P_D_SYNDROME(SYN_PQ_D, SYN_PQ_X, x);
|
|
Q_D_SYNDROME(SYN_PQ_D, SYN_PQ_X, y);
|
|
}
|
|
for (; y < yend; y += SYN_STRIDE) {
|
|
Q_SYNDROME(SYN_PQ_X, y);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Reconstruct data using PQ parity and PQ syndromes
|
|
*
|
|
* @tc syndrome/result columns
|
|
* @tsize size of syndrome/result columns
|
|
* @c parity columns
|
|
* @mul array of multiplication constants
|
|
*/
|
|
static void
|
|
raidz_rec_pq_abd(void **tc, const size_t tsize, void **c,
|
|
const unsigned *mul)
|
|
{
|
|
v_t *x = (v_t *)tc[TARGET_X];
|
|
v_t *y = (v_t *)tc[TARGET_Y];
|
|
const v_t * const xend = x + (tsize / sizeof (v_t));
|
|
const v_t *p = (v_t *)c[CODE_P];
|
|
const v_t *q = (v_t *)c[CODE_Q];
|
|
|
|
REC_PQ_DEFINE();
|
|
|
|
for (; x < xend; x += REC_PQ_STRIDE, y += REC_PQ_STRIDE,
|
|
p += REC_PQ_STRIDE, q += REC_PQ_STRIDE) {
|
|
LOAD(x, REC_PQ_X);
|
|
LOAD(y, REC_PQ_Y);
|
|
|
|
XOR_ACC(p, REC_PQ_X);
|
|
XOR_ACC(q, REC_PQ_Y);
|
|
|
|
/* Save Pxy */
|
|
COPY(REC_PQ_X, REC_PQ_T);
|
|
|
|
/* Calc X */
|
|
MUL(mul[MUL_PQ_X], REC_PQ_X);
|
|
MUL(mul[MUL_PQ_Y], REC_PQ_Y);
|
|
XOR(REC_PQ_Y, REC_PQ_X);
|
|
STORE(x, REC_PQ_X);
|
|
|
|
/* Calc Y */
|
|
XOR(REC_PQ_T, REC_PQ_X);
|
|
STORE(y, REC_PQ_X);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct two data columns using PQ parity
|
|
*
|
|
* @syn_method raidz_syn_pq_abd()
|
|
* @rec_method raidz_rec_pq_abd()
|
|
*
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
*/
|
|
static raidz_inline int
|
|
raidz_reconstruct_pq_impl(raidz_map_t *rm, const int *tgtidx)
|
|
{
|
|
size_t c;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
const size_t firstdc = raidz_parity(rm);
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t x = tgtidx[TARGET_X];
|
|
const size_t y = tgtidx[TARGET_Y];
|
|
const size_t xsize = rm->rm_col[x].rc_size;
|
|
const size_t ysize = rm->rm_col[y].rc_size;
|
|
abd_t *xabd = rm->rm_col[x].rc_abd;
|
|
abd_t *yabd = rm->rm_col[y].rc_abd;
|
|
abd_t *tabds[2] = { xabd, yabd };
|
|
abd_t *cabds[] = {
|
|
rm->rm_col[CODE_P].rc_abd,
|
|
rm->rm_col[CODE_Q].rc_abd
|
|
};
|
|
|
|
unsigned coeff[MUL_CNT];
|
|
raidz_rec_pq_coeff(rm, tgtidx, coeff);
|
|
|
|
/*
|
|
* Check if some of targets is shorter then others
|
|
* In this case, shorter target needs to be replaced with
|
|
* new buffer so that syndrome can be calculated.
|
|
*/
|
|
if (ysize < xsize) {
|
|
yabd = abd_alloc(xsize, B_FALSE);
|
|
tabds[1] = yabd;
|
|
}
|
|
|
|
raidz_math_begin();
|
|
|
|
/* Start with first data column if present */
|
|
if (firstdc != x) {
|
|
raidz_copy(xabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
raidz_copy(yabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
} else {
|
|
raidz_zero(xabd, xsize);
|
|
raidz_zero(yabd, xsize);
|
|
}
|
|
|
|
/* generate q_syndrome */
|
|
for (c = firstdc+1; c < ncols; c++) {
|
|
if (c == x || c == y) {
|
|
dabd = NULL;
|
|
dsize = 0;
|
|
} else {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
}
|
|
|
|
abd_raidz_gen_iterate(tabds, dabd, xsize, dsize, 2,
|
|
raidz_syn_pq_abd);
|
|
}
|
|
|
|
abd_raidz_rec_iterate(cabds, tabds, xsize, 2, raidz_rec_pq_abd, coeff);
|
|
|
|
/* Copy shorter targets back to the original abd buffer */
|
|
if (ysize < xsize)
|
|
raidz_copy(rm->rm_col[y].rc_abd, yabd, ysize);
|
|
|
|
raidz_math_end();
|
|
|
|
if (ysize < xsize)
|
|
abd_free(yabd);
|
|
|
|
return ((1 << CODE_P) | (1 << CODE_Q));
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate P and R syndromes
|
|
*
|
|
* @xc array of pointers to syndrome columns
|
|
* @dc data column (NULL if missing)
|
|
* @tsize size of syndrome columns
|
|
* @dsize size of data column (0 if missing)
|
|
*/
|
|
static void
|
|
raidz_syn_pr_abd(void **c, const void *dc, const size_t tsize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *x = (v_t *)c[TARGET_X];
|
|
v_t *y = (v_t *)c[TARGET_Y];
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
const v_t * const yend = y + (tsize / sizeof (v_t));
|
|
|
|
SYN_PR_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += SYN_STRIDE, x += SYN_STRIDE, y += SYN_STRIDE) {
|
|
LOAD(d, SYN_PR_D);
|
|
P_D_SYNDROME(SYN_PR_D, SYN_PR_X, x);
|
|
R_D_SYNDROME(SYN_PR_D, SYN_PR_X, y);
|
|
}
|
|
for (; y < yend; y += SYN_STRIDE) {
|
|
R_SYNDROME(SYN_PR_X, y);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Reconstruct data using PR parity and PR syndromes
|
|
*
|
|
* @tc syndrome/result columns
|
|
* @tsize size of syndrome/result columns
|
|
* @c parity columns
|
|
* @mul array of multiplication constants
|
|
*/
|
|
static void
|
|
raidz_rec_pr_abd(void **t, const size_t tsize, void **c,
|
|
const unsigned *mul)
|
|
{
|
|
v_t *x = (v_t *)t[TARGET_X];
|
|
v_t *y = (v_t *)t[TARGET_Y];
|
|
const v_t * const xend = x + (tsize / sizeof (v_t));
|
|
const v_t *p = (v_t *)c[CODE_P];
|
|
const v_t *q = (v_t *)c[CODE_Q];
|
|
|
|
REC_PR_DEFINE();
|
|
|
|
for (; x < xend; x += REC_PR_STRIDE, y += REC_PR_STRIDE,
|
|
p += REC_PR_STRIDE, q += REC_PR_STRIDE) {
|
|
LOAD(x, REC_PR_X);
|
|
LOAD(y, REC_PR_Y);
|
|
XOR_ACC(p, REC_PR_X);
|
|
XOR_ACC(q, REC_PR_Y);
|
|
|
|
/* Save Pxy */
|
|
COPY(REC_PR_X, REC_PR_T);
|
|
|
|
/* Calc X */
|
|
MUL(mul[MUL_PR_X], REC_PR_X);
|
|
MUL(mul[MUL_PR_Y], REC_PR_Y);
|
|
XOR(REC_PR_Y, REC_PR_X);
|
|
STORE(x, REC_PR_X);
|
|
|
|
/* Calc Y */
|
|
XOR(REC_PR_T, REC_PR_X);
|
|
STORE(y, REC_PR_X);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct two data columns using PR parity
|
|
*
|
|
* @syn_method raidz_syn_pr_abd()
|
|
* @rec_method raidz_rec_pr_abd()
|
|
*
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
*/
|
|
static raidz_inline int
|
|
raidz_reconstruct_pr_impl(raidz_map_t *rm, const int *tgtidx)
|
|
{
|
|
size_t c;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
const size_t firstdc = raidz_parity(rm);
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t x = tgtidx[0];
|
|
const size_t y = tgtidx[1];
|
|
const size_t xsize = rm->rm_col[x].rc_size;
|
|
const size_t ysize = rm->rm_col[y].rc_size;
|
|
abd_t *xabd = rm->rm_col[x].rc_abd;
|
|
abd_t *yabd = rm->rm_col[y].rc_abd;
|
|
abd_t *tabds[2] = { xabd, yabd };
|
|
abd_t *cabds[] = {
|
|
rm->rm_col[CODE_P].rc_abd,
|
|
rm->rm_col[CODE_R].rc_abd
|
|
};
|
|
unsigned coeff[MUL_CNT];
|
|
raidz_rec_pr_coeff(rm, tgtidx, coeff);
|
|
|
|
/*
|
|
* Check if some of targets are shorter then others.
|
|
* They need to be replaced with a new buffer so that syndrome can
|
|
* be calculated on full length.
|
|
*/
|
|
if (ysize < xsize) {
|
|
yabd = abd_alloc(xsize, B_FALSE);
|
|
tabds[1] = yabd;
|
|
}
|
|
|
|
raidz_math_begin();
|
|
|
|
/* Start with first data column if present */
|
|
if (firstdc != x) {
|
|
raidz_copy(xabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
raidz_copy(yabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
} else {
|
|
raidz_zero(xabd, xsize);
|
|
raidz_zero(yabd, xsize);
|
|
}
|
|
|
|
/* generate q_syndrome */
|
|
for (c = firstdc+1; c < ncols; c++) {
|
|
if (c == x || c == y) {
|
|
dabd = NULL;
|
|
dsize = 0;
|
|
} else {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
}
|
|
|
|
abd_raidz_gen_iterate(tabds, dabd, xsize, dsize, 2,
|
|
raidz_syn_pr_abd);
|
|
}
|
|
|
|
abd_raidz_rec_iterate(cabds, tabds, xsize, 2, raidz_rec_pr_abd, coeff);
|
|
|
|
/*
|
|
* Copy shorter targets back to the original abd buffer
|
|
*/
|
|
if (ysize < xsize)
|
|
raidz_copy(rm->rm_col[y].rc_abd, yabd, ysize);
|
|
|
|
raidz_math_end();
|
|
|
|
if (ysize < xsize)
|
|
abd_free(yabd);
|
|
|
|
return ((1 << CODE_P) | (1 << CODE_Q));
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate Q and R syndromes
|
|
*
|
|
* @xc array of pointers to syndrome columns
|
|
* @dc data column (NULL if missing)
|
|
* @tsize size of syndrome columns
|
|
* @dsize size of data column (0 if missing)
|
|
*/
|
|
static void
|
|
raidz_syn_qr_abd(void **c, const void *dc, const size_t tsize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *x = (v_t *)c[TARGET_X];
|
|
v_t *y = (v_t *)c[TARGET_Y];
|
|
const v_t * const xend = x + (tsize / sizeof (v_t));
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
|
|
SYN_QR_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += SYN_STRIDE, x += SYN_STRIDE, y += SYN_STRIDE) {
|
|
LOAD(d, SYN_PQ_D);
|
|
Q_D_SYNDROME(SYN_QR_D, SYN_QR_X, x);
|
|
R_D_SYNDROME(SYN_QR_D, SYN_QR_X, y);
|
|
}
|
|
for (; x < xend; x += SYN_STRIDE, y += SYN_STRIDE) {
|
|
Q_SYNDROME(SYN_QR_X, x);
|
|
R_SYNDROME(SYN_QR_X, y);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct data using QR parity and QR syndromes
|
|
*
|
|
* @tc syndrome/result columns
|
|
* @tsize size of syndrome/result columns
|
|
* @c parity columns
|
|
* @mul array of multiplication constants
|
|
*/
|
|
static void
|
|
raidz_rec_qr_abd(void **t, const size_t tsize, void **c,
|
|
const unsigned *mul)
|
|
{
|
|
v_t *x = (v_t *)t[TARGET_X];
|
|
v_t *y = (v_t *)t[TARGET_Y];
|
|
const v_t * const xend = x + (tsize / sizeof (v_t));
|
|
const v_t *p = (v_t *)c[CODE_P];
|
|
const v_t *q = (v_t *)c[CODE_Q];
|
|
|
|
REC_QR_DEFINE();
|
|
|
|
for (; x < xend; x += REC_QR_STRIDE, y += REC_QR_STRIDE,
|
|
p += REC_QR_STRIDE, q += REC_QR_STRIDE) {
|
|
LOAD(x, REC_QR_X);
|
|
LOAD(y, REC_QR_Y);
|
|
|
|
XOR_ACC(p, REC_QR_X);
|
|
XOR_ACC(q, REC_QR_Y);
|
|
|
|
/* Save Pxy */
|
|
COPY(REC_QR_X, REC_QR_T);
|
|
|
|
/* Calc X */
|
|
MUL(mul[MUL_QR_XQ], REC_QR_X); /* X = Q * xqm */
|
|
XOR(REC_QR_Y, REC_QR_X); /* X = R ^ X */
|
|
MUL(mul[MUL_QR_X], REC_QR_X); /* X = X * xm */
|
|
STORE(x, REC_QR_X);
|
|
|
|
/* Calc Y */
|
|
MUL(mul[MUL_QR_YQ], REC_QR_T); /* X = Q * xqm */
|
|
XOR(REC_QR_Y, REC_QR_T); /* X = R ^ X */
|
|
MUL(mul[MUL_QR_Y], REC_QR_T); /* X = X * xm */
|
|
STORE(y, REC_QR_T);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct two data columns using QR parity
|
|
*
|
|
* @syn_method raidz_syn_qr_abd()
|
|
* @rec_method raidz_rec_qr_abd()
|
|
*
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
*/
|
|
static raidz_inline int
|
|
raidz_reconstruct_qr_impl(raidz_map_t *rm, const int *tgtidx)
|
|
{
|
|
size_t c;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
const size_t firstdc = raidz_parity(rm);
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t x = tgtidx[TARGET_X];
|
|
const size_t y = tgtidx[TARGET_Y];
|
|
const size_t xsize = rm->rm_col[x].rc_size;
|
|
const size_t ysize = rm->rm_col[y].rc_size;
|
|
abd_t *xabd = rm->rm_col[x].rc_abd;
|
|
abd_t *yabd = rm->rm_col[y].rc_abd;
|
|
abd_t *tabds[2] = { xabd, yabd };
|
|
abd_t *cabds[] = {
|
|
rm->rm_col[CODE_Q].rc_abd,
|
|
rm->rm_col[CODE_R].rc_abd
|
|
};
|
|
unsigned coeff[MUL_CNT];
|
|
raidz_rec_qr_coeff(rm, tgtidx, coeff);
|
|
|
|
/*
|
|
* Check if some of targets is shorter then others
|
|
* In this case, shorter target needs to be replaced with
|
|
* new buffer so that syndrome can be calculated.
|
|
*/
|
|
if (ysize < xsize) {
|
|
yabd = abd_alloc(xsize, B_FALSE);
|
|
tabds[1] = yabd;
|
|
}
|
|
|
|
raidz_math_begin();
|
|
|
|
/* Start with first data column if present */
|
|
if (firstdc != x) {
|
|
raidz_copy(xabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
raidz_copy(yabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
} else {
|
|
raidz_zero(xabd, xsize);
|
|
raidz_zero(yabd, xsize);
|
|
}
|
|
|
|
/* generate q_syndrome */
|
|
for (c = firstdc+1; c < ncols; c++) {
|
|
if (c == x || c == y) {
|
|
dabd = NULL;
|
|
dsize = 0;
|
|
} else {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
}
|
|
|
|
abd_raidz_gen_iterate(tabds, dabd, xsize, dsize, 2,
|
|
raidz_syn_qr_abd);
|
|
}
|
|
|
|
abd_raidz_rec_iterate(cabds, tabds, xsize, 2, raidz_rec_qr_abd, coeff);
|
|
|
|
/*
|
|
* Copy shorter targets back to the original abd buffer
|
|
*/
|
|
if (ysize < xsize)
|
|
raidz_copy(rm->rm_col[y].rc_abd, yabd, ysize);
|
|
|
|
raidz_math_end();
|
|
|
|
if (ysize < xsize)
|
|
abd_free(yabd);
|
|
|
|
|
|
return ((1 << CODE_Q) | (1 << CODE_R));
|
|
}
|
|
|
|
|
|
/*
|
|
* Generate P, Q, and R syndromes
|
|
*
|
|
* @xc array of pointers to syndrome columns
|
|
* @dc data column (NULL if missing)
|
|
* @tsize size of syndrome columns
|
|
* @dsize size of data column (0 if missing)
|
|
*/
|
|
static void
|
|
raidz_syn_pqr_abd(void **c, const void *dc, const size_t tsize,
|
|
const size_t dsize)
|
|
{
|
|
v_t *x = (v_t *)c[TARGET_X];
|
|
v_t *y = (v_t *)c[TARGET_Y];
|
|
v_t *z = (v_t *)c[TARGET_Z];
|
|
const v_t * const yend = y + (tsize / sizeof (v_t));
|
|
const v_t *d = (v_t *)dc;
|
|
const v_t * const dend = d + (dsize / sizeof (v_t));
|
|
|
|
SYN_PQR_DEFINE();
|
|
|
|
MUL2_SETUP();
|
|
|
|
for (; d < dend; d += SYN_STRIDE, x += SYN_STRIDE, y += SYN_STRIDE,
|
|
z += SYN_STRIDE) {
|
|
LOAD(d, SYN_PQR_D);
|
|
P_D_SYNDROME(SYN_PQR_D, SYN_PQR_X, x)
|
|
Q_D_SYNDROME(SYN_PQR_D, SYN_PQR_X, y);
|
|
R_D_SYNDROME(SYN_PQR_D, SYN_PQR_X, z);
|
|
}
|
|
for (; y < yend; y += SYN_STRIDE, z += SYN_STRIDE) {
|
|
Q_SYNDROME(SYN_PQR_X, y);
|
|
R_SYNDROME(SYN_PQR_X, z);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct data using PRQ parity and PQR syndromes
|
|
*
|
|
* @tc syndrome/result columns
|
|
* @tsize size of syndrome/result columns
|
|
* @c parity columns
|
|
* @mul array of multiplication constants
|
|
*/
|
|
static void
|
|
raidz_rec_pqr_abd(void **t, const size_t tsize, void **c,
|
|
const unsigned * const mul)
|
|
{
|
|
v_t *x = (v_t *)t[TARGET_X];
|
|
v_t *y = (v_t *)t[TARGET_Y];
|
|
v_t *z = (v_t *)t[TARGET_Z];
|
|
const v_t * const xend = x + (tsize / sizeof (v_t));
|
|
const v_t *p = (v_t *)c[CODE_P];
|
|
const v_t *q = (v_t *)c[CODE_Q];
|
|
const v_t *r = (v_t *)c[CODE_R];
|
|
|
|
REC_PQR_DEFINE();
|
|
|
|
for (; x < xend; x += REC_PQR_STRIDE, y += REC_PQR_STRIDE,
|
|
z += REC_PQR_STRIDE, p += REC_PQR_STRIDE, q += REC_PQR_STRIDE,
|
|
r += REC_PQR_STRIDE) {
|
|
LOAD(x, REC_PQR_X);
|
|
LOAD(y, REC_PQR_Y);
|
|
LOAD(z, REC_PQR_Z);
|
|
|
|
XOR_ACC(p, REC_PQR_X);
|
|
XOR_ACC(q, REC_PQR_Y);
|
|
XOR_ACC(r, REC_PQR_Z);
|
|
|
|
/* Save Pxyz and Qxyz */
|
|
COPY(REC_PQR_X, REC_PQR_XS);
|
|
COPY(REC_PQR_Y, REC_PQR_YS);
|
|
|
|
/* Calc X */
|
|
MUL(mul[MUL_PQR_XP], REC_PQR_X); /* Xp = Pxyz * xp */
|
|
MUL(mul[MUL_PQR_XQ], REC_PQR_Y); /* Xq = Qxyz * xq */
|
|
XOR(REC_PQR_Y, REC_PQR_X);
|
|
MUL(mul[MUL_PQR_XR], REC_PQR_Z); /* Xr = Rxyz * xr */
|
|
XOR(REC_PQR_Z, REC_PQR_X); /* X = Xp + Xq + Xr */
|
|
STORE(x, REC_PQR_X);
|
|
|
|
/* Calc Y */
|
|
XOR(REC_PQR_X, REC_PQR_XS); /* Pyz = Pxyz + X */
|
|
MUL(mul[MUL_PQR_YU], REC_PQR_X); /* Xq = X * upd_q */
|
|
XOR(REC_PQR_X, REC_PQR_YS); /* Qyz = Qxyz + Xq */
|
|
COPY(REC_PQR_XS, REC_PQR_X); /* restore Pyz */
|
|
MUL(mul[MUL_PQR_YP], REC_PQR_X); /* Yp = Pyz * yp */
|
|
MUL(mul[MUL_PQR_YQ], REC_PQR_YS); /* Yq = Qyz * yq */
|
|
XOR(REC_PQR_X, REC_PQR_YS); /* Y = Yp + Yq */
|
|
STORE(y, REC_PQR_YS);
|
|
|
|
/* Calc Z */
|
|
XOR(REC_PQR_XS, REC_PQR_YS); /* Z = Pz = Pyz + Y */
|
|
STORE(z, REC_PQR_YS);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Reconstruct three data columns using PQR parity
|
|
*
|
|
* @syn_method raidz_syn_pqr_abd()
|
|
* @rec_method raidz_rec_pqr_abd()
|
|
*
|
|
* @rm RAIDZ map
|
|
* @tgtidx array of missing data indexes
|
|
*/
|
|
static raidz_inline int
|
|
raidz_reconstruct_pqr_impl(raidz_map_t *rm, const int *tgtidx)
|
|
{
|
|
size_t c;
|
|
size_t dsize;
|
|
abd_t *dabd;
|
|
const size_t firstdc = raidz_parity(rm);
|
|
const size_t ncols = raidz_ncols(rm);
|
|
const size_t x = tgtidx[TARGET_X];
|
|
const size_t y = tgtidx[TARGET_Y];
|
|
const size_t z = tgtidx[TARGET_Z];
|
|
const size_t xsize = rm->rm_col[x].rc_size;
|
|
const size_t ysize = rm->rm_col[y].rc_size;
|
|
const size_t zsize = rm->rm_col[z].rc_size;
|
|
abd_t *xabd = rm->rm_col[x].rc_abd;
|
|
abd_t *yabd = rm->rm_col[y].rc_abd;
|
|
abd_t *zabd = rm->rm_col[z].rc_abd;
|
|
abd_t *tabds[] = { xabd, yabd, zabd };
|
|
abd_t *cabds[] = {
|
|
rm->rm_col[CODE_P].rc_abd,
|
|
rm->rm_col[CODE_Q].rc_abd,
|
|
rm->rm_col[CODE_R].rc_abd
|
|
};
|
|
unsigned coeff[MUL_CNT];
|
|
raidz_rec_pqr_coeff(rm, tgtidx, coeff);
|
|
|
|
/*
|
|
* Check if some of targets is shorter then others
|
|
* In this case, shorter target needs to be replaced with
|
|
* new buffer so that syndrome can be calculated.
|
|
*/
|
|
if (ysize < xsize) {
|
|
yabd = abd_alloc(xsize, B_FALSE);
|
|
tabds[1] = yabd;
|
|
}
|
|
if (zsize < xsize) {
|
|
zabd = abd_alloc(xsize, B_FALSE);
|
|
tabds[2] = zabd;
|
|
}
|
|
|
|
raidz_math_begin();
|
|
|
|
/* Start with first data column if present */
|
|
if (firstdc != x) {
|
|
raidz_copy(xabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
raidz_copy(yabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
raidz_copy(zabd, rm->rm_col[firstdc].rc_abd, xsize);
|
|
} else {
|
|
raidz_zero(xabd, xsize);
|
|
raidz_zero(yabd, xsize);
|
|
raidz_zero(zabd, xsize);
|
|
}
|
|
|
|
/* generate q_syndrome */
|
|
for (c = firstdc+1; c < ncols; c++) {
|
|
if (c == x || c == y || c == z) {
|
|
dabd = NULL;
|
|
dsize = 0;
|
|
} else {
|
|
dabd = rm->rm_col[c].rc_abd;
|
|
dsize = rm->rm_col[c].rc_size;
|
|
}
|
|
|
|
abd_raidz_gen_iterate(tabds, dabd, xsize, dsize, 3,
|
|
raidz_syn_pqr_abd);
|
|
}
|
|
|
|
abd_raidz_rec_iterate(cabds, tabds, xsize, 3, raidz_rec_pqr_abd, coeff);
|
|
|
|
/*
|
|
* Copy shorter targets back to the original abd buffer
|
|
*/
|
|
if (ysize < xsize)
|
|
raidz_copy(rm->rm_col[y].rc_abd, yabd, ysize);
|
|
if (zsize < xsize)
|
|
raidz_copy(rm->rm_col[z].rc_abd, zabd, zsize);
|
|
|
|
raidz_math_end();
|
|
|
|
if (ysize < xsize)
|
|
abd_free(yabd);
|
|
if (zsize < xsize)
|
|
abd_free(zabd);
|
|
|
|
return ((1 << CODE_P) | (1 << CODE_Q) | (1 << CODE_R));
|
|
}
|
|
|
|
#endif /* _VDEV_RAIDZ_MATH_IMPL_H */
|