fol.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2013-2020 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_FOL_FOL_H__
#define __MOTR_FOL_FOL_H__

/* export */
struct m0_fol;
struct m0_fol_rec;

/* import */
#include "lib/types.h"      /* uint64_t */
#include "lib/arith.h"      /* M0_IS_8ALIGNED */
#include "lib/mutex.h"
#include "lib/tlist.h"
#include "fid/fid.h"
#include "be/tx_credit.h"
#include "dtm/dtm_update.h" /* m0_update_id, m0_epoch_id */
#include "fid/fid_xc.h"
#include "dtm/dtm_update_xc.h"
#include "fdmi/src_rec.h"   /* m0_fdmi_src_rec */

struct m0_be_tx;
struct m0_epoch_id;

enum {
        /*
         * The maximum possible length of fol record.
         *
         * We need to obtain sufficient BE credit before adding new record
         * to the fol. Fol records are of variable length and the actual
         * length is hard, if possible, to calculate at the moment of
         * m0_fol_credit() call. We use the empirical value of maximum
         * possible record length instead.
         *
         * XXX REVISEME: If the value is not sufficient, increase it.
         * Alternative (proper?) solution is to calculate the size of fol
         * record as a function of rpc opcode.
         */
        /* FOL_REC_MAXSIZE = 1024 * 1024 */

        /* EN: Previous size is too big to fit into one RPC message */
        FOL_REC_MAXSIZE = 1024 * 256
};

struct m0_fol {
        struct m0_mutex    f_lock;
};

M0_INTERNAL void m0_fol_init(struct m0_fol *fol);
M0_INTERNAL void m0_fol_fini(struct m0_fol *fol);

struct m0_fol_rec_header {
        uint32_t            rh_frags_nr;
        uint32_t            rh_data_len;
        struct m0_update_id rh_self;
        uint64_t            rh_lsn;
        uint64_t            rh_lsn_discarded;
        uint64_t            rh_magic;
} M0_XCA_RECORD;

M0_BASSERT(M0_IS_8ALIGNED(sizeof(struct m0_fol_rec_header)));

struct m0_fol_rec {
        struct m0_fol            *fr_fol;
        uint64_t                  fr_tid;
        struct m0_fol_rec_header  fr_header;
        struct m0_epoch_id       *fr_epoch;
        struct m0_fol_update_ref *fr_sibling;
        struct m0_tl              fr_frags;
        struct m0_fdmi_src_rec    fr_fdmi_rec;
};

M0_INTERNAL void m0_fol_rec_init(struct m0_fol_rec *rec, struct m0_fol *fol);

M0_INTERNAL void m0_fol_rec_fini(struct m0_fol_rec *rec);

M0_INTERNAL int m0_fol_rec_encode(struct m0_fol_rec *rec, struct m0_buf *at);

M0_INTERNAL int m0_fol_rec_decode(struct m0_fol_rec *rec, struct m0_buf *at);

int m0_fol_rec_to_str(struct m0_fol_rec *rec, char *str, int str_len);

M0_INTERNAL bool m0_fol_rec_invariant(const struct m0_fol_rec *drec);

M0_INTERNAL int m0_fols_init(void);
M0_INTERNAL void m0_fols_fini(void);

struct m0_fol_frag {
        const struct m0_fol_frag_ops    *rp_ops;
        void                            *rp_data;
        struct m0_tlink                  rp_link;
        uint64_t                         rp_magic;
        enum m0_xcode_what               rp_flag;
};

struct m0_fol_frag_type {
        uint32_t                           rpt_index;
        const char                        *rpt_name;
        const struct m0_xcode_type        *rpt_xt;
        const struct m0_fol_frag_type_ops *rpt_ops;
};

struct m0_fol_frag_type_ops {
        void (*rpto_rec_frag_init)(struct m0_fol_frag *frag);
};

struct m0_fol_frag_ops {
        const struct m0_fol_frag_type *rpo_type;
        int (*rpo_undo)(struct m0_fol_frag *frag, struct m0_be_tx *tx);
        int (*rpo_redo)(struct m0_fol_frag *frag, struct m0_be_tx *tx);
        void (*rpo_undo_credit)(const struct m0_fol_frag *frag,
                                struct m0_be_tx_credit *accum);
        void (*rpo_redo_credit)(const struct m0_fol_frag *frag,
                                struct m0_be_tx_credit *accum);
};

struct m0_fol_frag_header {
        uint32_t rph_index;
        uint64_t rph_magic;
} M0_XCA_RECORD;

M0_INTERNAL void
m0_fol_frag_init(struct m0_fol_frag *frag, void *data,
                     const struct m0_fol_frag_type *type);

M0_INTERNAL void m0_fol_frag_fini(struct m0_fol_frag *frag);

M0_INTERNAL int
m0_fol_frag_type_register(struct m0_fol_frag_type *type);

M0_INTERNAL void
m0_fol_frag_type_deregister(struct m0_fol_frag_type *type);

M0_TL_DESCR_DECLARE(m0_rec_frag, M0_EXTERN);
M0_TL_DECLARE(m0_rec_frag, M0_INTERNAL, struct m0_fol_frag);

M0_INTERNAL void m0_fol_frag_add(struct m0_fol_rec *rec,
                                     struct m0_fol_frag *frag);

#define M0_FOL_FRAG_TYPE_DECLARE(frag, scope, undo, redo,       \
                                     undo_cred, redo_cred)      \
scope struct m0_fol_frag_type frag ## _type;                    \
static const struct m0_fol_frag_ops frag ## _ops = {            \
        .rpo_type = &frag ## _type,                             \
        .rpo_undo = undo,                                       \
        .rpo_redo = redo,                                       \
        .rpo_undo_credit = undo_cred,                           \
        .rpo_redo_credit = redo_cred,                           \
};                                                              \
static void frag ## _ops_init(struct m0_fol_frag *frag) \
{                                                               \
        frag->rp_ops = &frag ## _ops;                           \
}                                                               \
static const struct m0_fol_frag_type_ops frag ## _type_ops = {  \
        .rpto_rec_frag_init = frag ##_ops_init                  \
};

#define M0_FOL_FRAG_TYPE_XC_OPS(name, frag_xc, frag_type_ops)   \
(struct m0_fol_frag_type) {                                     \
        .rpt_name = name,                                       \
        .rpt_xt   = (frag_xc),                                  \
        .rpt_ops  = (frag_type_ops)                             \
};

#define M0_FOL_FRAG_TYPE_INIT(frag, name)                       \
frag ## _type = M0_FOL_FRAG_TYPE_XC_OPS(name, frag ## _xc,      \
                                            &frag ## _type_ops)

#endif /* __MOTR_FOL_FOL_H__ */

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