tx.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_BE_TX_H__
#define __MOTR_BE_TX_H__

#include "lib/misc.h"           /* M0_BITS */
#include "lib/buf.h"            /* m0_buf */

#include "sm/sm.h"              /* m0_sm */

#include "be/tx_regmap.h"       /* m0_be_reg_area */

struct m0_be_domain;
struct m0_be_tx_group;
struct m0_be_fmt_tx;
struct m0_fol_rec;

enum m0_be_tx_state {
        M0_BTS_FAILED = 1,
        M0_BTS_PREPARE,
        M0_BTS_OPENING,
        M0_BTS_GROUPING,
        M0_BTS_ACTIVE,
        M0_BTS_CLOSED,
        /*
         * All transaction updates made it to the log.
         */
        M0_BTS_LOGGED,
        M0_BTS_PLACED,
        M0_BTS_DONE,
        M0_BTS_NR
};

/*
 * NOTE: Call-backs of this type must be asynchronous, because they can be
 * called from state transition functions.
 */
typedef void (*m0_be_tx_cb_t)(const struct m0_be_tx *tx);

struct m0_be_tx {
        struct m0_sm           t_sm;

        uint64_t               t_id;
        struct m0_be_engine   *t_engine;
        struct m0_be_domain   *t_dom;

        struct m0_tlink        t_engine_linkage;
        struct m0_tlink        t_group_linkage;
        uint64_t               t_magic;

        struct m0_be_tx_credit t_prepared;
        struct m0_be_reg_area  t_reg_area;

        m0_be_tx_cb_t          t_persistent;

        m0_be_tx_cb_t          t_discarded;

        void                 (*t_filler)(struct m0_be_tx *tx, void *payload);

        void                  *t_datum;
        uint64_t               t_lsn;
        m0_bindex_t            t_lsn_discarded;
        struct m0_buf          t_payload;
        m0_bcount_t            t_payload_prepared;
        struct m0_sm_ast       t_ast_grouping;
        struct m0_sm_ast       t_ast_active;
        struct m0_sm_ast       t_ast_failed;
        struct m0_sm_ast       t_ast_logged;
        struct m0_sm_ast       t_ast_placed;
        struct m0_sm_ast       t_ast_done;
        struct m0_be_tx_group *t_group;
        uint32_t               t_ref;
        bool                   t_log_reserved;
        /* XXX TODO merge with t_log_reserved. */
        m0_bcount_t            t_log_reserved_size;
        bool                   t_fast;
        bool                   t_exclusive;
        bool                   t_gc_enabled;
        void                 (*t_gc_free)(struct m0_be_tx *tx, void *param);
        void                  *t_gc_param;
        struct m0_tlink        t_first_capture_linkage;
        bool                   t_recovering;
        bool                   t_grouped;
        struct m0_atomic64     t_fdmi_ref;
        struct m0_tlink        t_fdmi_linkage;
        struct m0_sm_ast       t_fdmi_put_ast;
};

struct m0_be_tx_remid {
        uint64_t tri_txid;
        uint64_t tri_locality;
} M0_XCA_RECORD M0_XCA_DOMAIN(be|rpc);

#if M0_DEBUG_BE_CREDITS == 1

#define M0_BE_CREDIT_INC(n, cr_user, credit) ({                          \
        typeof(cr_user) cu = (cr_user);                                  \
        typeof(credit)  cr = (credit);                                   \
        cr->tc_balance[cu] += (n);                                       \
        M0_LOG(M0_DEBUG, "INC cr=%p user=%d balance=%d", cr, (int)cu,    \
                         cr->tc_balance[cu]);                            \
})

#define M0_BE_CREDIT_DEC(cr_user, tx) ({                                 \
        struct m0_be_tx_credit *cr = &(tx)->t_prepared;                  \
        typeof(cr_user)         cu = (cr_user);                          \
        M0_LOG(M0_DEBUG, "DEC cr=%p user=%d balance=%d", cr, (int)cu,    \
                         cr->tc_balance[cu]);                            \
        M0_CNT_DEC(cr->tc_balance[cu]);                                  \
})

#else

#define M0_BE_CREDIT_INC(n, cr_user, credit)
#define M0_BE_CREDIT_DEC(cr_user, tx)

#endif

M0_INTERNAL bool m0_be_tx__invariant(const struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx_init(struct m0_be_tx     *tx,
                               uint64_t             tid,
                               struct m0_be_domain *dom,
                               struct m0_sm_group  *sm_group,
                               m0_be_tx_cb_t        persistent,
                               m0_be_tx_cb_t        discarded,
                               void               (*filler)(struct m0_be_tx *tx,
                                                            void *payload),
                               void                *datum);

M0_INTERNAL void m0_be_tx_fini(struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx_prep(struct m0_be_tx              *tx,
                               const struct m0_be_tx_credit *credit);

M0_INTERNAL void m0_be_tx_payload_prep(struct m0_be_tx *tx, m0_bcount_t size);

M0_INTERNAL void m0_be_tx_open(struct m0_be_tx *tx);
M0_INTERNAL void m0_be_tx_exclusive_open(struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx_capture(struct m0_be_tx        *tx,
                                  const struct m0_be_reg *reg);
M0_INTERNAL void m0_be_tx_uncapture(struct m0_be_tx        *tx,
                                    const struct m0_be_reg *reg);

/* XXX change to (tx, seg, ptr) */
#define M0_BE_TX_CAPTURE_PTR(seg, tx, ptr) \
        m0_be_tx_capture((tx), &M0_BE_REG((seg), sizeof *(ptr), (ptr)))
#define M0_BE_TX_CAPTURE_ARR(seg, tx, arr, nr) \
        m0_be_tx_capture((tx), &M0_BE_REG((seg), (nr) * sizeof((arr)[0]), (arr)))
#define M0_BE_TX_CAPTURE_BUF(seg, tx, buf) \
        m0_be_tx_capture((tx), &M0_BE_REG((seg), (buf)->b_nob, (buf)->b_addr))

M0_INTERNAL void m0_be_tx_close(struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx_get(struct m0_be_tx *tx);
M0_INTERNAL void m0_be_tx_put(struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx_force(struct m0_be_tx *tx);

M0_INTERNAL int m0_be_tx_timedwait(struct m0_be_tx *tx,
                                   uint64_t         states,
                                   m0_time_t        deadline);

M0_INTERNAL enum m0_be_tx_state m0_be_tx_state(const struct m0_be_tx *tx);
M0_INTERNAL const char *m0_be_tx_state_name(enum m0_be_tx_state state);

M0_INTERNAL int m0_be_tx_open_sync(struct m0_be_tx *tx);
M0_INTERNAL int m0_be_tx_exclusive_open_sync(struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx_close_sync(struct m0_be_tx *tx);

M0_INTERNAL bool m0_be_tx__is_fast(struct m0_be_tx *tx);

M0_INTERNAL int m0_be_tx_fol_add(struct m0_be_tx *tx, struct m0_fol_rec *rec);

M0_INTERNAL void m0_be_tx_force (struct m0_be_tx *tx);

M0_INTERNAL bool m0_be_tx__is_exclusive(const struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx__recovering_set(struct m0_be_tx *tx);
M0_INTERNAL bool m0_be_tx__is_recovering(struct m0_be_tx *tx);

M0_INTERNAL void m0_be_tx_deconstruct(struct m0_be_tx     *tx,
                                      struct m0_be_fmt_tx *ftx);
/*
 * @pre m0_be_tx_state(tx) == M0_BTS_PREPARE
 */
M0_INTERNAL void m0_be_tx_reconstruct(struct m0_be_tx           *tx,
                                      const struct m0_be_fmt_tx *ftx);

/*
 * Assign tx to a group.
 *
 * Does nothing if m0_be_tx__is_recovering(tx).
 */
M0_INTERNAL void m0_be_tx__group_assign(struct m0_be_tx       *tx,
                                        struct m0_be_tx_group *gr);

M0_INTERNAL bool m0_be_tx_should_break(struct m0_be_tx *tx,
                                       const struct m0_be_tx_credit *c);

M0_INTERNAL void m0_be_tx_gc_enable(struct m0_be_tx *tx,
                                    void           (*gc_free)(struct m0_be_tx *,
                                                              void *param),
                                    void            *param);

M0_INTERNAL bool m0_be_should_break(struct m0_be_engine          *eng,
                                    const struct m0_be_tx_credit *accum,
                                    const struct m0_be_tx_credit *delta);

M0_INTERNAL bool m0_be_should_break_half(struct m0_be_engine          *eng,
                                         const struct m0_be_tx_credit *accum,
                                         const struct m0_be_tx_credit *delta);


M0_INTERNAL void m0_be_tx_lsn_set(struct m0_be_tx *tx,
                                  m0_bindex_t      lsn,
                                  m0_bindex_t      lsn_discarded);
M0_INTERNAL void m0_be_tx_lsn_get(struct m0_be_tx *tx,
                                  m0_bindex_t     *lsn,
                                  m0_bindex_t     *lsn_discarded);

#endif /* __MOTR_BE_TX_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */
/*
 * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
 */