log.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_LOG_H__
#define __MOTR_BE_LOG_H__

#include "lib/mutex.h"          /* m0_mutex */
#include "lib/tlist.h"          /* m0_tl */
#include "lib/types.h"          /* m0_bcount_t */

#include "be/fmt.h"
#include "be/log_store.h"       /* m0_be_log_store */
#include "be/log_sched.h"       /* m0_be_log_sched */
#include "be/op.h"              /* m0_be_op */
#include "be/io.h"              /* m0_be_io */
#include "be/recovery.h"        /* m0_be_recovery */

#include "stob/io.h"            /* m0_stob_io_opcode */

struct m0_ext;
struct m0_stob_id;
struct m0_be_io;
struct m0_be_log_io;
struct m0_be_log_record_iter;
struct m0_be_tx_group;

struct m0_be_log;
struct m0_be_log_record;
typedef void (*m0_be_log_got_space_cb_t)(struct m0_be_log *log);
typedef void (*m0_be_log_record_cb_t)(struct m0_be_log_record *record);
typedef void (*m0_be_log_full_cb_t)(struct m0_be_log *log);

enum {
        M0_BE_LOG_RECORD_IO_NR_MAX = 2,
};

enum {
        M0_BE_LOG_LEVEL_INIT,
        M0_BE_LOG_LEVEL_LOG_SCHED,
        M0_BE_LOG_LEVEL_LOG_STORE,
        M0_BE_LOG_LEVEL_HEADER_PREINIT,
        M0_BE_LOG_LEVEL_HEADER,
        M0_BE_LOG_LEVEL_RECOVERY,
        M0_BE_LOG_LEVEL_ASSIGNS,
        M0_BE_LOG_LEVEL_READY,
};

struct m0_be_log_cfg {
        struct m0_be_log_store_cfg  lc_store_cfg;
        struct m0_be_log_sched_cfg  lc_sched_cfg;
        struct m0_be_recovery_cfg   lc_recovery_cfg;
        m0_be_log_got_space_cb_t    lc_got_space_cb;
        m0_be_log_full_cb_t         lc_full_cb;
        m0_bcount_t                 lc_full_threshold;
        struct m0_mutex            *lc_lock;
        bool                        lc_skip_recovery;
};

struct m0_be_log {
        struct m0_be_log_cfg     lg_cfg;
        bool                     lg_create_mode;
        bool                     lg_destroy_mode;
        struct m0_module         lg_module;
        struct m0_be_log_store   lg_store;
        struct m0_be_log_sched   lg_sched;
        struct m0_be_recovery    lg_recovery;
        struct m0_be_fmt_log_header lg_header;
        struct m0_tl             lg_records;
        struct m0_mutex          lg_record_state_lock;
        m0_bindex_t              lg_current;
        m0_bindex_t              lg_discarded;
        m0_bcount_t              lg_free;
        m0_bcount_t              lg_reserved;
        m0_bindex_t              lg_prev_record;
        m0_bcount_t              lg_prev_record_size;
        bool                     lg_unplaced_exists;
        m0_bindex_t              lg_unplaced_pos;
        m0_bcount_t              lg_unplaced_size;
        m0_be_log_got_space_cb_t lg_got_space_cb;
        struct m0_mutex         *lg_external_lock;
        /* op for log header read */
        struct m0_be_op          lg_header_read_op;
        /* op for log header write */
        struct m0_be_op          lg_header_write_op;
};

/* m0_be_log */
#define BL_F "(lg_current=%" PRIu64 " lg_discarded=%" PRIu64 \
             " lg_free=%" PRIu64 ")"
#define BL_P(log) (log)->lg_current, (log)->lg_discarded, (log)->lg_free

struct m0_be_log_record {
        struct m0_be_log    *lgr_log;
        int                  lgr_state;
        bool                 lgr_need_discard;
        m0_bindex_t          lgr_last_discarded;
        m0_bindex_t          lgr_position;
        m0_bcount_t          lgr_size;
        m0_bindex_t          lgr_prev_pos;
        m0_bcount_t          lgr_prev_size;
        m0_bindex_t          lgr_log_header_discarded;

        uint64_t             lgr_magic;
        struct m0_tlink      lgr_linkage;
        struct m0_tlink      lgr_sched_linkage;

        /* Fields for I/O launch */
        int                  lgr_io_nr;
        struct m0_be_log_io *lgr_io[M0_BE_LOG_RECORD_IO_NR_MAX];
        struct m0_be_op     *lgr_op[M0_BE_LOG_RECORD_IO_NR_MAX];
        struct m0_be_op      lgr_record_op;

        struct m0_be_op     *lgr_user_op;

        struct m0_be_fmt_log_record_header lgr_header;
        struct m0_be_fmt_log_record_footer lgr_footer;

        /*
         * Log header is updated just before the record is written
         * to the log if the flag is set.
         */
        bool                 lgr_write_header;
};

/* m0_be_log_record */
#define BLR_F "(lgr_last_discarded=%" PRIu64 " lgr_position=%" PRIu64 " " \
               "lgr_size=%" PRIu64 " " \
               "lgr_prev_pos=%" PRIu64 " lgr_prev_size=%" PRIu64 ")"
#define BLR_P(record) (record)->lgr_last_discarded, (record)->lgr_position, \
                      (record)->lgr_size, \
                      (record)->lgr_prev_pos, (record)->lgr_prev_size

M0_INTERNAL void m0_be_log_module_setup(struct m0_be_log     *log,
                                        struct m0_be_log_cfg *lg_cfg,
                                        bool                  create_mode);

M0_INTERNAL bool m0_be_log__invariant(struct m0_be_log *log);

M0_INTERNAL int  m0_be_log_open(struct m0_be_log     *log,
                                struct m0_be_log_cfg *log_cfg);
M0_INTERNAL void m0_be_log_close(struct m0_be_log *log);

M0_INTERNAL int  m0_be_log_create(struct m0_be_log     *log,
                                  struct m0_be_log_cfg *log_cfg);
M0_INTERNAL void m0_be_log_destroy(struct m0_be_log *log);

M0_INTERNAL m0_bcount_t m0_be_log_reserved_size(struct m0_be_log *log,
                                                m0_bcount_t      *lio_size,
                                                int               lio_nr);

M0_INTERNAL void m0_be_log_record_init(struct m0_be_log_record *record,
                                       struct m0_be_log *log);
M0_INTERNAL void m0_be_log_record_fini(struct m0_be_log_record *record);
M0_INTERNAL void m0_be_log_record_reset(struct m0_be_log_record *record);

M0_INTERNAL void
m0_be_log_record_assign(struct m0_be_log_record      *record,
                        struct m0_be_log_record_iter *iter,
                        bool                          need_discard);

M0_INTERNAL void m0_be_log_record_ext(struct m0_be_log_record *record,
                                      struct m0_ext           *ext);

M0_INTERNAL void m0_be_log_record_skip_discard(struct m0_be_log_record *record);
M0_INTERNAL void m0_be_log_record_discard(struct m0_be_log *log,
                                          m0_bcount_t       size);

M0_INTERNAL int m0_be_log_record_io_create(struct m0_be_log_record *record,
                                           m0_bcount_t              size_max);
M0_INTERNAL int m0_be_log_record_allocate(struct m0_be_log_record *record);
M0_INTERNAL void m0_be_log_record_deallocate(struct m0_be_log_record *record);
M0_INTERNAL void m0_be_log_record_io_size_set(struct m0_be_log_record *record,
                                              int                      index,
                                              m0_bcount_t              size);
M0_INTERNAL void
m0_be_log_record_io_prepare(struct m0_be_log_record *record,
                            enum m0_stob_io_opcode   opcode,
                            m0_bcount_t              size_reserved);
M0_INTERNAL struct m0_bufvec *
m0_be_log_record_io_bufvec(struct m0_be_log_record *record,
                           int                      index);
M0_INTERNAL void m0_be_log_record_io_launch(struct m0_be_log_record *record,
                                            struct m0_be_op         *op);


M0_INTERNAL m0_bindex_t
m0_be_log_record_position(const struct m0_be_log_record *record);

M0_INTERNAL m0_bindex_t
m0_be_log_record_discarded(const struct m0_be_log_record *record);

M0_INTERNAL int m0_be_log_reserve(struct m0_be_log *log, m0_bcount_t size);
M0_INTERNAL void m0_be_log_unreserve(struct m0_be_log *log, m0_bcount_t size);

M0_INTERNAL uint32_t m0_be_log_bshift(struct m0_be_log *log);

M0_INTERNAL void m0_be_log_header__set(struct m0_be_fmt_log_header *hdr,
                                       m0_bindex_t                  discarded,
                                       m0_bindex_t                  lsn,
                                       m0_bcount_t                  size);
M0_INTERNAL bool m0_be_log_header__is_eq(struct m0_be_fmt_log_header *hdr1,
                                         struct m0_be_fmt_log_header *hdr2);
M0_INTERNAL bool m0_be_log_header__repair(struct m0_be_fmt_log_header **hdrs,
                                          int                           nr,
                                          struct m0_be_fmt_log_header  *out);
M0_INTERNAL int m0_be_log_header_read(struct m0_be_log            *log,
                                      struct m0_be_fmt_log_header *log_hdr);

struct m0_be_log_record_iter {
        struct m0_be_fmt_log_record_header lri_header;
        m0_bindex_t                        lri_log_header_discarded;
        struct m0_tlink                    lri_linkage;
        uint64_t                           lri_magic;
};

M0_INTERNAL int m0_be_log_record_iter_init(struct m0_be_log_record_iter *iter);
M0_INTERNAL void m0_be_log_record_iter_fini(struct m0_be_log_record_iter *iter);
M0_INTERNAL void m0_be_log_record_iter_copy(struct m0_be_log_record_iter *dest,
                                            struct m0_be_log_record_iter *src);
M0_INTERNAL int m0_be_log_record_initial(struct m0_be_log             *log,
                                         struct m0_be_log_record_iter *curr);
M0_INTERNAL int m0_be_log_record_next(struct m0_be_log                   *log,
                                      const struct m0_be_log_record_iter *curr,
                                      struct m0_be_log_record_iter       *next);
M0_INTERNAL int m0_be_log_record_prev(struct m0_be_log *log,
                                      const struct m0_be_log_record_iter *curr,
                                      struct m0_be_log_record_iter       *prev);
M0_INTERNAL bool m0_be_fmt_log_record_header__invariant(
                                struct m0_be_fmt_log_record_header *header,
                                struct m0_be_log                   *log);

M0_INTERNAL bool
m0_be_log_recovery_record_available(struct m0_be_log *log);
M0_INTERNAL void
m0_be_log_recovery_record_get(struct m0_be_log             *log,
                              struct m0_be_log_record_iter *iter);
M0_INTERNAL m0_bindex_t
m0_be_log_recovery_discarded(struct m0_be_log *log);

M0_INTERNAL bool m0_be_log_contains_stob(struct m0_be_log        *log,
                                         const struct m0_stob_id *stob_id);
#endif /* __MOTR_BE_LOG_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
 */