parity_math.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013-2021 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#pragma once

#ifndef __MOTR_SNS_PARITY_MATH_H__
#define __MOTR_SNS_PARITY_MATH_H__

#include "lib/vec.h"
#include "lib/bitmap.h"
#include "lib/tlist.h"
#include "matvec.h"
#include "ls_solve.h"

enum m0_parity_cal_algo {
        M0_PARITY_CAL_ALGO_XOR,
        M0_PARITY_CAL_ALGO_REED_SOLOMON,
        M0_PARITY_CAL_ALGO_NR
};

enum m0_sns_ir_block_status {
        M0_SI_BLOCK_ALIVE,
        M0_SI_BLOCK_FAILED,
};

enum m0_sns_ir_block_type {
        M0_SI_BLOCK_LOCAL,
        M0_SI_BLOCK_REMOTE,
};

enum m0_parity_linsys_algo {
        M0_LA_GAUSSIAN,
        M0_LA_INVERSE,
};
struct m0_sns_ir_block {
        /* Index of a block within parity group. */
        uint32_t                     sib_idx;
        /* Data from a block is submitted to incremental-recovery-module using
         * struct m0_bufvec. sib_addr holds address for the same.
         */
        struct m0_bufvec            *sib_addr;
        /* Whenever a block fails, sib_bitmap holds block indices of
         * blocks required for its recovery.
         */
        struct m0_bitmap             sib_bitmap;
        /* Indicates whether a block is available, failed or restored. */
        enum m0_sns_ir_block_status  sib_status;
};

struct m0_reed_solomon {
        /* Pointer to sets of arrays of input coefficients used
         * to encode or decode data.*/
        uint8_t          *rs_encode_matrix;
        /* Pointer to concatenated output tables for encode.
         * Must be of size MIN_TABLE_LEN * data_count * parity_count
         */
        uint8_t          *rs_encode_tbls;
        /* Pointer to concatenated output tables for decode.
         * Must be of size MIN_TABLE_LEN * data_count * parity_count
         */
        uint8_t          *rs_decode_tbls;
        /* Number of failed blocks. */
        uint32_t          rs_failed_nr;
        /* Array holding indices of all failed blocks. */
        uint8_t          *rs_failed_idx;
        /* Array holding indices of all alive blocks. */
        uint8_t          *rs_alive_idx;
        /* Array of buffer pointers to be used as source for encoding or
         * recovery. */
        uint8_t         **rs_bufs_in;
        /* Array of buffer pointers to be used as destination for encoding or
         * recovery. */
        uint8_t         **rs_bufs_out;
};

struct m0_parity_math {
        enum m0_parity_cal_algo      pmi_parity_algo;

        uint32_t                     pmi_data_count;
        uint32_t                     pmi_parity_count;
        struct m0_reed_solomon       pmi_rs;
};

/* Holds information essential for incremental recovery. */
struct m0_sns_ir {
        uint32_t                si_data_nr;
        uint32_t                si_parity_nr;
        uint32_t                si_alive_nr;
        /* Number of blocks from a parity group that are available locally
         * on a node. */
        uint32_t                si_local_nr;
        /* Array holding all blocks */
        struct m0_sns_ir_block *si_blocks;
        struct m0_reed_solomon  si_rs;
};

M0_INTERNAL int m0_parity_math_init(struct m0_parity_math *math,
                                    uint32_t data_count, uint32_t parity_count);

M0_INTERNAL void m0_parity_math_fini(struct m0_parity_math *math);

M0_INTERNAL void m0_parity_math_calculate(struct m0_parity_math *math,
                                          struct m0_buf *data,
                                          struct m0_buf *parity);

M0_INTERNAL int m0_parity_math_diff(struct m0_parity_math *math,
                                    struct m0_buf *old_ver,
                                    struct m0_buf *new_ver,
                                    struct m0_buf *parity, uint32_t index);

M0_INTERNAL void m0_parity_math_refine(struct m0_parity_math *math,
                                       struct m0_buf *data,
                                       struct m0_buf *parity,
                                       uint32_t data_ind_changed);

M0_INTERNAL int m0_parity_math_recover(struct m0_parity_math *math,
                                       struct m0_buf *data,
                                       struct m0_buf *parity,
                                       struct m0_buf *fails,
                                       enum m0_parity_linsys_algo algo);

M0_INTERNAL void m0_parity_math_fail_index_recover(struct m0_parity_math *math,
                                                   struct m0_buf *data,
                                                   struct m0_buf *parity,
                                                   const uint32_t
                                                   failure_index);

M0_INTERNAL void m0_parity_math_buffer_xor(struct m0_buf *dest,
                                           const struct m0_buf *src);

M0_INTERNAL int m0_sns_ir_failure_register(struct m0_bufvec *recov_addr,
                                           uint32_t failed_index,
                                           struct m0_sns_ir *ir);

M0_INTERNAL int m0_sns_ir_init(const struct m0_parity_math *math,
                               uint32_t local_nr, struct m0_sns_ir *ir);
M0_INTERNAL int m0_sns_ir_mat_compute(struct m0_sns_ir *ir);

M0_INTERNAL int m0_sns_ir_recover(struct m0_sns_ir *ir,
                                  struct m0_bufvec *bufvec,
                                  const struct m0_bitmap *bitmap,
                                  uint32_t failed_index,
                                  enum m0_sns_ir_block_type block_type);
//M0_INTERNAL void m0_sns_ir_local_xform(struct m0_sns_ir *ir);
M0_INTERNAL void m0_sns_ir_fini(struct m0_sns_ir *ir);
/* __MOTR_SNS_PARITY_MATH_H__  */
#endif

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */