Lines Matching defs:rm
528 vdev_raidz_generate_parity_p(raidz_map_t *rm)
533 pcount = rm->rm_col[VDEV_RAIDZ_P].rc_size / sizeof (src[0]);
535 for (c = rm->rm_firstdatacol; c < rm->rm_cols; c++) {
536 src = rm->rm_col[c].rc_data;
537 p = rm->rm_col[VDEV_RAIDZ_P].rc_data;
538 ccount = rm->rm_col[c].rc_size / sizeof (src[0]);
540 if (c == rm->rm_firstdatacol) {
555 vdev_raidz_generate_parity_pq(raidz_map_t *rm)
560 pcnt = rm->rm_col[VDEV_RAIDZ_P].rc_size / sizeof (src[0]);
561 ASSERT(rm->rm_col[VDEV_RAIDZ_P].rc_size ==
562 rm->rm_col[VDEV_RAIDZ_Q].rc_size);
564 for (c = rm->rm_firstdatacol; c < rm->rm_cols; c++) {
565 src = rm->rm_col[c].rc_data;
566 p = rm->rm_col[VDEV_RAIDZ_P].rc_data;
567 q = rm->rm_col[VDEV_RAIDZ_Q].rc_data;
569 ccnt = rm->rm_col[c].rc_size / sizeof (src[0]);
571 if (c == rm->rm_firstdatacol) {
607 vdev_raidz_generate_parity_pqr(raidz_map_t *rm)
612 pcnt = rm->rm_col[VDEV_RAIDZ_P].rc_size / sizeof (src[0]);
613 ASSERT(rm->rm_col[VDEV_RAIDZ_P].rc_size ==
614 rm->rm_col[VDEV_RAIDZ_Q].rc_size);
615 ASSERT(rm->rm_col[VDEV_RAIDZ_P].rc_size ==
616 rm->rm_col[VDEV_RAIDZ_R].rc_size);
618 for (c = rm->rm_firstdatacol; c < rm->rm_cols; c++) {
619 src = rm->rm_col[c].rc_data;
620 p = rm->rm_col[VDEV_RAIDZ_P].rc_data;
621 q = rm->rm_col[VDEV_RAIDZ_Q].rc_data;
622 r = rm->rm_col[VDEV_RAIDZ_R].rc_data;
624 ccnt = rm->rm_col[c].rc_size / sizeof (src[0]);
626 if (c == rm->rm_firstdatacol) {
672 vdev_raidz_generate_parity(raidz_map_t *rm)
674 switch (rm->rm_firstdatacol) {
676 vdev_raidz_generate_parity_p(rm);
679 vdev_raidz_generate_parity_pq(rm);
682 vdev_raidz_generate_parity_pqr(rm);
844 vdev_raidz_matrix_init(raidz_map_t *rm, int n, int nmap, int *map,
850 ASSERT(n == rm->rm_cols - rm->rm_firstdatacol);
874 vdev_raidz_matrix_invert(raidz_map_t *rm, int n, int nmissing, int *missing,
886 ASSERT3S(used[i], <, rm->rm_firstdatacol);
889 ASSERT3S(used[i], >=, rm->rm_firstdatacol);
906 ASSERT3U(used[j], >=, rm->rm_firstdatacol);
907 jj = used[j] - rm->rm_firstdatacol;
968 vdev_raidz_matrix_reconstruct(raidz_map_t *rm, int n, int nmissing,
1000 ASSERT3U(c, <, rm->rm_cols);
1002 src = rm->rm_col[c].rc_data;
1003 ccount = rm->rm_col[c].rc_size;
1005 cc = missing[j] + rm->rm_firstdatacol;
1006 ASSERT3U(cc, >=, rm->rm_firstdatacol);
1007 ASSERT3U(cc, <, rm->rm_cols);
1010 dst[j] = rm->rm_col[cc].rc_data;
1011 dcount[j] = rm->rm_col[cc].rc_size;
1014 ASSERT(ccount >= rm->rm_col[missing[0]].rc_size || i > 0);
1044 vdev_raidz_reconstruct_general(raidz_map_t *rm, int *tgts, int ntgts)
1061 n = rm->rm_cols - rm->rm_firstdatacol;
1068 if (tgts[t] >= rm->rm_firstdatacol) {
1070 tgts[t] - rm->rm_firstdatacol;
1080 ASSERT(c < rm->rm_firstdatacol);
1115 for (tt = 0, c = rm->rm_firstdatacol; c < rm->rm_cols; c++) {
1117 c == missing_rows[tt] + rm->rm_firstdatacol) {
1130 vdev_raidz_matrix_init(rm, n, nmissing_rows, parity_map, rows);
1135 vdev_raidz_matrix_invert(rm, n, nmissing_rows, missing_rows, rows,
1141 vdev_raidz_matrix_reconstruct(rm, n, nmissing_rows, missing_rows,
1150 vdev_raidz_reconstruct(raidz_map_t *rm, int *t, int nt)
1165 nbadparity = rm->rm_firstdatacol;
1166 nbaddata = rm->rm_cols - nbadparity;
1168 for (i = 0, c = 0; c < rm->rm_cols; c++) {
1172 } else if (rm->rm_col[c].rc_error != 0) {
1174 } else if (c >= rm->rm_firstdatacol) {
1185 code = vdev_raidz_reconstruct_general(rm, tgts, ntgts);
1195 raidz_map_t *rm;
1217 rm = zfs_alloc(offsetof(raidz_map_t, rm_col[scols]));
1219 rm->rm_cols = acols;
1220 rm->rm_scols = scols;
1221 rm->rm_bigcols = bc;
1222 rm->rm_skipstart = bc;
1223 rm->rm_missingdata = 0;
1224 rm->rm_missingparity = 0;
1225 rm->rm_firstdatacol = nparity;
1226 rm->rm_reports = 0;
1227 rm->rm_freed = 0;
1228 rm->rm_ecksuminjected = 0;
1239 rm->rm_col[c].rc_devidx = col;
1240 rm->rm_col[c].rc_offset = coff;
1241 rm->rm_col[c].rc_data = NULL;
1242 rm->rm_col[c].rc_error = 0;
1243 rm->rm_col[c].rc_tried = 0;
1244 rm->rm_col[c].rc_skipped = 0;
1247 rm->rm_col[c].rc_size = 0;
1249 rm->rm_col[c].rc_size = (q + 1) << unit_shift;
1251 rm->rm_col[c].rc_size = q << unit_shift;
1253 asize += rm->rm_col[c].rc_size;
1257 rm->rm_asize = roundup(asize, (nparity + 1) << unit_shift);
1258 rm->rm_nskip = roundup(tot, nparity + 1) - tot;
1259 ASSERT3U(rm->rm_asize - asize, ==, rm->rm_nskip << unit_shift);
1260 ASSERT3U(rm->rm_nskip, <=, nparity);
1262 for (c = 0; c < rm->rm_firstdatacol; c++)
1263 rm->rm_col[c].rc_data = zfs_alloc(rm->rm_col[c].rc_size);
1265 rm->rm_col[c].rc_data = data;
1268 rm->rm_col[c].rc_data = (char *)rm->rm_col[c - 1].rc_data +
1269 rm->rm_col[c - 1].rc_size;
1291 ASSERT(rm->rm_cols >= 2);
1292 ASSERT(rm->rm_col[0].rc_size == rm->rm_col[1].rc_size);
1294 if (rm->rm_firstdatacol == 1 && (offset & (1ULL << 20))) {
1295 devidx = rm->rm_col[0].rc_devidx;
1296 o = rm->rm_col[0].rc_offset;
1297 rm->rm_col[0].rc_devidx = rm->rm_col[1].rc_devidx;
1298 rm->rm_col[0].rc_offset = rm->rm_col[1].rc_offset;
1299 rm->rm_col[1].rc_devidx = devidx;
1300 rm->rm_col[1].rc_offset = o;
1302 if (rm->rm_skipstart == 0)
1303 rm->rm_skipstart = 1;
1306 return (rm);
1310 vdev_raidz_map_free(raidz_map_t *rm)
1314 for (c = rm->rm_firstdatacol - 1; c >= 0; c--)
1315 zfs_free(rm->rm_col[c].rc_data, rm->rm_col[c].rc_size);
1317 zfs_free(rm, offsetof(raidz_map_t, rm_col[rm->rm_scols]));
1351 raidz_parity_verify(raidz_map_t *rm)
1357 for (c = 0; c < rm->rm_firstdatacol; c++) {
1358 rc = &rm->rm_col[c];
1365 vdev_raidz_generate_parity(rm);
1367 for (c = rm->rm_firstdatacol - 1; c >= 0; c--) {
1368 rc = &rm->rm_col[c];
1390 vdev_raidz_combrec(const spa_t *spa, raidz_map_t *rm, const blkptr_t *bp,
1400 ASSERT(total_errors < rm->rm_firstdatacol);
1407 for (n = 1; n <= rm->rm_firstdatacol - total_errors; n++) {
1419 c < rm->rm_firstdatacol) {
1420 c = rm->rm_firstdatacol;
1423 while (rm->rm_col[c].rc_error != 0) {
1425 ASSERT3S(c, <, rm->rm_cols);
1434 tgts[n] = rm->rm_cols;
1443 orig[n - 1] = zfs_alloc(rm->rm_col[0].rc_size);
1460 ASSERT3S(c, <, rm->rm_cols);
1461 rc = &rm->rm_col[c];
1469 code = vdev_raidz_reconstruct(rm, tgts, n);
1473 rc = &rm->rm_col[c];
1487 rc = &rm->rm_col[c];
1497 next < rm->rm_cols &&
1498 rm->rm_col[next].rc_error != 0; next++)
1514 rm->rm_col[c].rc_error != 0; c++)
1526 zfs_free(orig[i], rm->rm_col[0].rc_size);
1538 raidz_map_t *rm;
1553 rm = vdev_raidz_map_alloc(data, offset, bytes, tvd->v_ashift,
1560 for (c = rm->rm_cols - 1; c >= 0; c--) {
1561 rc = &rm->rm_col[c];
1564 if (c >= rm->rm_firstdatacol)
1565 rm->rm_missingdata++;
1567 rm->rm_missingparity++;
1575 if (c >= rm->rm_firstdatacol)
1576 rm->rm_missingdata++;
1578 rm->rm_missingparity++;
1584 if (c >= rm->rm_firstdatacol || rm->rm_missingdata > 0) {
1599 ASSERT(rm->rm_missingparity <= rm->rm_firstdatacol);
1600 ASSERT(rm->rm_missingdata <= rm->rm_cols - rm->rm_firstdatacol);
1602 for (c = 0; c < rm->rm_cols; c++) {
1603 rc = &rm->rm_col[c];
1608 if (c < rm->rm_firstdatacol)
1617 } else if (c < rm->rm_firstdatacol && !rc->rc_tried) {
1639 if (total_errors <= rm->rm_firstdatacol - parity_untried) {
1654 rm->rm_firstdatacol) {
1655 n = raidz_parity_verify(rm);
1658 rm->rm_firstdatacol);
1671 ASSERT(parity_errors < rm->rm_firstdatacol);
1677 for (c = rm->rm_firstdatacol; c < rm->rm_cols; c++) {
1678 rc = &rm->rm_col[c];
1685 ASSERT(rm->rm_firstdatacol >= n);
1687 code = vdev_raidz_reconstruct(rm, tgts, n);
1704 if (parity_errors < rm->rm_firstdatacol - n) {
1705 n = raidz_parity_verify(rm);
1708 rm->rm_firstdatacol);
1725 rm->rm_missingdata = 0;
1726 rm->rm_missingparity = 0;
1729 for (c = 0; c < rm->rm_cols; c++) {
1730 rc = &rm->rm_col[c];
1761 if (total_errors > rm->rm_firstdatacol) {
1763 } else if (total_errors < rm->rm_firstdatacol &&
1764 (code = vdev_raidz_combrec(vd->v_spa, rm, bp, data, offset, bytes,
1771 if (code != (1 << rm->rm_firstdatacol) - 1)
1772 (void) raidz_parity_verify(rm);
1790 vdev_raidz_map_free(rm);