cksum.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 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_CKSUM_H__
#define __MOTR_CKSUM_H__

#include "lib/vec.h"
#include "fid/fid.h"
#include "xcode/xcode_attr.h"
#ifndef __KERNEL__
#include <openssl/md5.h>
#endif


#define m0_cksum_print(buf, seg, dbuf, msg) \
do { \
        struct m0_vec *vec = &(buf)->ov_vec; \
        char *dst = (char *)(buf)->ov_buf[seg]; \
        char *data = (char *)(dbuf)->ov_buf[seg]; \
        M0_LOG(M0_DEBUG, msg " count[%d] = %"PRIu64 \
                        " cksum = %c%c data = %c%c", \
                        seg, vec->v_count[seg], dst[0], dst[1], data[0],data[1]); \
}while(0)


/*
 * Macro calculates the size of padding required in a struct
 * for byte alignment
 * size - size of all structure members
 * alignment - power of two, byte alignment
 */
#define M0_CALC_PAD(size, alignment) ( size%alignment ? (((size/alignment + 1 ) * alignment) - size) : 0)


/* Constants for protection info type, max types supported is 8 */
enum
{
        M0_PI_TYPE_MD5,
        M0_PI_TYPE_MD5_INC_CONTEXT,
        M0_PI_TYPE_CRC,
        M0_PI_TYPE_MAX
};

enum m0_pi_calc_flag {

        /* NO PI FLAG */
        M0_PI_NO_FLAG = 0,
        /* PI calculation for data unit 0 */
        M0_PI_CALC_UNIT_ZERO = 1 << 0,
        /* Skip PI final value calculation */
        M0_PI_SKIP_CALC_FINAL = 1 << 1

};

M0_BASSERT(M0_PI_TYPE_MAX <= 8);

struct m0_pi_hdr {
        /* type of protection algorithm being used */
        uint8_t pih_type : 8;
        /*size of PI Structure in multiple of  32 bytes*/
        uint8_t pih_size : 8;
};

struct m0_md5_pi {

        /* header for protection info */
        struct m0_pi_hdr pimd5_hdr;
#ifndef __KERNEL__
        /* protection value computed for the current data*/
        unsigned char    pimd5_value[MD5_DIGEST_LENGTH];
        /* structure should be 32 byte aligned */
        char             pimd5_pad[M0_CALC_PAD((sizeof(struct m0_pi_hdr)+
                                   MD5_DIGEST_LENGTH), 32)];
#endif
};

struct m0_md5_inc_context_pi {

        /* header for protection info */
        struct m0_pi_hdr pimd5c_hdr;
#ifndef __KERNEL__
        /*context of previous data unit, required for checksum computation */
        unsigned char    pimd5c_prev_context[sizeof(MD5_CTX)];
        /* protection value computed for the current data unit.
         * If seed is not provided then this checksum is
         * calculated without seed.
         */
        unsigned char    pimd5c_value[MD5_DIGEST_LENGTH];
        /* structure should be 32 byte aligned */
        char             pi_md5c_pad[M0_CALC_PAD((sizeof(struct m0_pi_hdr)+
                                     sizeof(MD5_CTX)+MD5_DIGEST_LENGTH), 32)];
#endif
};

struct m0_generic_pi {
        /* header for protection info */
        struct m0_pi_hdr pi_hdr;
        /*pointer to access specific pi structure fields*/
        void            *pi_t_pi;
};

/* seed values for calculating checksum */
struct m0_pi_seed {
        struct m0_fid pis_obj_id;
        /* offset within motr object */
        m0_bindex_t   pis_data_unit_offset;
};

M0_INTERNAL int m0_calculate_md5_inc_context(
                struct m0_md5_inc_context_pi *pi,
                struct m0_pi_seed *seed,
                struct m0_bufvec *bvec,
                enum m0_pi_calc_flag flag,
                unsigned char *curr_context,
                unsigned char *pi_value_without_seed);

M0_INTERNAL uint64_t m0_calculate_cksum_size(struct m0_generic_pi *pi);

M0_INTERNAL uint64_t max_cksum_size(void);

int m0_client_calculate_pi(struct m0_generic_pi *pi,
                struct m0_pi_seed *seed,
                struct m0_bufvec *bvec,
                enum m0_pi_calc_flag flag,
                unsigned char *curr_context,
                unsigned char *pi_value_without_seed);


bool m0_calc_verify_cksum_one_unit(struct m0_generic_pi *pi,
                                   struct m0_pi_seed *seed,
                                   struct m0_bufvec *bvec);

#endif /* __MOTR_CKSUM_H__ */