Motr  M0
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
Meta-data back-end

Data Structures

struct  m0_be_allocator_call_stat
 
struct  m0_be_allocator_call_stats
 
struct  m0_be_alloc_zone_stats
 
struct  m0_be_allocator_stats
 Allocator statistics. More...
 
struct  m0_be_allocator
 Allocator. More...
 
struct  be_alloc_chunk
 Allocator chunk. More...
 
struct  m0_be_alloc_zone
 Allocator memory zone. More...
 
struct  m0_be_allocator_header
 Allocator header. More...
 
struct  btree_node_pos
 
struct  m0_be_btree_backlink
 
struct  m0_be_btree
 
struct  m0_be_btree_kv_ops
 
struct  m0_be_btree_anchor
 
struct  m0_be_btree_cursor_stack_entry
 
struct  m0_be_btree_cursor
 
struct  be_btree_key_val
 
struct  m0_be_bnode
 
struct  m0_be_0type_seg_cfg
 
struct  m0_be_domain_cfg
 
struct  m0_be_domain
 
struct  m0_be_engine_cfg
 
struct  m0_be_engine
 
struct  m0_be_fl_size
 
struct  m0_be_fl
 
struct  m0_fmt_xcode_ctx
 
struct  m0_be_fmt_group_info
 
struct  m0_be_fmt_group_header
 
struct  m0_be_fmt_content_header_tx
 
struct  m0_be_fmt_content_header_txs
 
struct  m0_be_fmt_content_header_reg
 
struct  m0_be_fmt_content_header_reg_area
 
struct  m0_be_fmt_content_header
 
struct  m0_be_fmt_content_payloads
 
struct  m0_be_fmt_content_reg_area
 
struct  m0_be_fmt_content
 
struct  m0_be_fmt_log_store_header_cfg
 
struct  m0_be_fmt_log_store_header
 
struct  m0_be_fmt_log_header
 
struct  m0_be_fmt_group
 
struct  m0_be_fmt_cblock
 
struct  m0_be_fmt_group_cfg
 
struct  m0_be_fmt_log_record_footer
 
struct  m0_be_fmt_log_record_header_cfg
 
struct  m0_be_fmt_log_record_header_io_size
 
struct  m0_be_fmt_log_record_header
 
struct  m0_be_fmt_decode_cfg
 
struct  m0_be_fmt_reg
 
struct  m0_be_fmt_tx
 
struct  m0_be_io_part
 
struct  m0_be_io_credit
 
struct  m0_be_io
 
struct  m0_be_io_sched_cfg
 
struct  m0_be_io_sched
 
struct  m0_be_list_descr
 
struct  m0_be_list_link
 
struct  m0_be_list_head
 
struct  m0_be_list
 
struct  m0_be_log_cfg
 
struct  m0_be_log
 
struct  m0_be_log_record
 
struct  m0_be_log_record_iter
 
struct  m0_be_log_discard_item
 
struct  m0_be_log_discard_cfg
 
struct  m0_be_log_discard
 
struct  m0_be_log_sched_cfg
 
struct  m0_be_log_sched
 
struct  m0_be_log_io
 
struct  m0_be_log_store_cfg
 
struct  m0_be_log_store
 
struct  m0_be_op
 
struct  m0_be_pd_io
 
struct  m0_be_pd_cfg
 
struct  m0_be_pd
 
struct  be_pool_queue_item
 
struct  m0_be_pool_cfg
 
struct  m0_be_pool
 
struct  m0_be_pool_item
 
struct  m0_be_pool_descr
 
struct  be_queue_item
 
struct  be_queue_wait_op
 
struct  m0_be_queue_cfg
 
struct  m0_be_queue
 
struct  m0_be_recovery_cfg
 
struct  m0_be_recovery
 
struct  m0_be_seg
 
struct  m0_be_seg_geom
 
struct  m0_be_reg
 
struct  m0_be_0type
 
struct  be_seg_dict_keyval
 
struct  m0_be_seg_hdr
 
struct  queue
 
struct  scanner
 
struct  stats
 
struct  rectype
 
struct  recops
 
struct  bstats
 
struct  btype
 
struct  gen
 
struct  action
 
struct  bnode_act
 
struct  cob_action
 
struct  action_ops
 
struct  cache_slot
 
struct  cache
 
struct  ad_dom_info
 
struct  builder
 
struct  emap_action
 
struct  worker_off_info
 
struct  scanner_off_info
 
struct  part_info
 
struct  nv_offset_info
 
struct  offset_info
 
struct  ctg_action
 
struct  m0_betool_common_ctx
 
struct  m0_be_tx
 
struct  m0_be_tx_remid
 
struct  be_tx_bulk_item
 
struct  be_tx_bulk_worker
 
struct  m0_be_tx_bulk_cfg
 
struct  m0_be_tx_bulk
 
struct  m0_be_tx_credit
 
struct  be_recovering_tx
 
struct  m0_be_tx_group_cfg
 
struct  m0_be_tx_group
 
struct  m0_be_tx_group_fom
 
struct  m0_be_group_format_cfg
 
struct  m0_be_group_format
 
struct  m0_be_reg_d
 
struct  m0_be_reg_d_tree
 
struct  m0_be_regmap_ops
 
struct  m0_be_regmap
 
struct  m0_be_reg_area
 
struct  m0_be_reg_area_merger
 
struct  tx_service
 
struct  m0_be_ut_fmt_group_test
 
struct  be_ut_io_sched_io_state
 
struct  be_ut_io_sched_test
 
struct  be_ut_log_discard_gp_test
 
struct  be_ut_log_discard_gp_test_item
 
struct  be_ut_op_mt_dep
 
struct  be_ut_op_mt_thread_cfg
 
struct  be_ut_pd_usecase_test
 
struct  be_ut_queue_cfg
 
struct  be_ut_queue_result
 
struct  be_ut_queue_data
 
struct  be_ut_queue_ctx
 
struct  be_ut_queue_thread_param
 
struct  be_ut_complex
 
struct  be_ut_tx_x
 
struct  be_ut_tx_fast
 
struct  be_ut_tx_thread_state
 
struct  be_ut_gc_test
 
struct  be_ut_tx_payload_test
 
struct  be_ut_tx_bulk_be_ctx
 
struct  be_ut_tx_bulk_be_cfg
 
struct  be_ut_tx_bulk_usecase
 
struct  be_ut_tx_bulk_state
 
struct  be_ut_tx_bulk_parallel_ctx
 
struct  be_ut_tx_bulk_parallel_thread_param
 
struct  be_ut_tx_bulk_parallel_work_item
 

Macros

#define M0_BE_ALLOC_ARR(arr, nr, seg, tx, op)
 
#define M0_BE_ALLOC_PTR(ptr, seg, tx, op)   M0_BE_ALLOC_ARR((ptr), 1, (seg), (tx), (op))
 
#define M0_BE_ALLOC_ARR_SYNC(arr, nr, seg, tx)
 
#define M0_BE_ALLOC_PTR_SYNC(ptr, seg, tx)   M0_BE_OP_SYNC(__op, M0_BE_ALLOC_PTR((ptr), (seg), (tx), &__op))
 
#define M0_BE_FREE_PTR(ptr, seg, tx, op)   m0_be_free(m0_be_seg_allocator(seg), (tx), (op), (ptr))
 
#define M0_BE_FREE_PTR_SYNC(ptr, seg, tx)   M0_BE_OP_SYNC(__op, M0_BE_FREE_PTR((ptr), (seg), (tx), &__op))
 
#define M0_BE_ALLOC_BUF(buf, seg, tx, op)
 
#define M0_BE_ALLOC_BUF_SYNC(buf, seg, tx)   M0_BE_OP_SYNC(__op, M0_BE_ALLOC_BUF((buf), (seg), (tx), &__op))
 
#define M0_BE_ALLOC_CREDIT_PTR(ptr, seg, accum)
 
#define M0_BE_FREE_CREDIT_PTR(ptr, seg, accum)
 
#define M0_BE_ALLOC_CREDIT_ARR(arr, nr, seg, accum)
 
#define M0_BE_FREE_CREDIT_ARR(arr, nr, seg, accum)
 
#define M0_BE_ALLOC_CREDIT_BUF(buf, seg, accum)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BTREE
 
#define BE_DOMAIN_LEVEL(level)
 
#define M0_BE_FMT_DEFINE_INIT_SIMPLE(name)
 
#define M0_BE_FMT_DEFINE_XCODE(name)
 
#define BFLH_F
 
#define BFLH_P(log_hdr)
 
#define BFLRH_F
 
#define BFLRH_P(h)
 
#define M0_BE_FMT_DECODE_CFG_DEFAULT
 
#define M0_BE_FMT_DECODE_CFG_DEFAULT_WITH_TRACE
 
#define M0_BE_FMT_DECLARE(name)
 
#define M0_BE_FMT_REG(size, addr, buf)
 
#define M0_BE_FMT_TX(payload, id)
 
#define M0_BE_IO_CREDIT(reg_nr, reg_size, part_nr)
 
#define BE_IOCRED_F
 
#define BE_IOCRED_P(iocred)   (iocred)->bic_reg_nr, (iocred)->bic_reg_size, (iocred)->bic_part_nr
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define M0_BE_LIST_DESCR(name, amb_type, link_field, magic_field, link_magic, head_magic)
 
#define M0_BE_LIST_DESCR_DEFINE(name, hname, scope, amb_type, link_field, magic_field, link_magic, head_magic)
 
#define M0_BE_LIST_DECLARE(name, scope, amb_type)
 
#define M0_BE_LIST_DEFINE(name, scope, amb_type)
 
#define m0_be_list_for(name, head, obj)
 
#define m0_be_list_endfor   ;(void)__bl; } while (0)
 
#define m0_be_list_forall(name, var, head, ...)
 
#define BL_F
 
#define BL_P(log)   (log)->lg_current, (log)->lg_discarded, (log)->lg_free
 
#define BLR_F
 
#define BLR_P(record)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define M0_BE_OP_SYNC(op_obj, action)
 
#define M0_BE_OP_SYNC_RC(op_obj, action)
 
#define M0_BE_OP_SYNC_WITH(op, action)
 
#define M0_BE_OP_SYNC_WITH_RC(op, action)
 
#define M0_BE_OP_SYNC_RET(op_obj, action, member)
 
#define M0_BE_OP_SYNC_RET_WITH(op, action, member)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define M0_BE_POOL_DESCR(hname, amb_type, pool_field, pool_magic_field, pool_magic)
 
#define M0_BE_POOL_DESCR_DEFINE(name, hname, scope, amb_type, pool_field, pool_magic_field, pool_magic)
 
#define M0_BE_POOL_DEFINE(name, scope, amb_type)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define BE_QUEUE_ITEM2BUF(bq, bqi)   M0_BUF_INIT((bq)->bq_cfg.bqc_item_length, &(bqi)->bqi_data)
 
#define BEQ_F
 
#define BEQ_P(bq)
 
#define M0_BE_QUEUE_PUT(bq, op, ptr)   m0_be_queue_put(bq, op, &M0_BUF_INIT_PTR(ptr))
 
#define M0_BE_QUEUE_GET(bq, op, ptr, successful)   m0_be_queue_get(bq, op, &M0_BUF_INIT_PTR(ptr), successful)
 
#define M0_BE_QUEUE_PEEK(bq, ptr)   m0_be_queue_peek(bq, &M0_BUF_INIT_PTR(ptr))
 
#define M0_BE_SEG_PG_PRESENT   0x8000000000000000ULL
 
#define M0_BE_SEG_PG_PIN_CNT_MASK   (~M0_BE_SEG_PG_PRESENT)
 
#define M0_BE_SEG_GEOM0
 
#define M0_BE_REG(seg, size, addr)
 
#define M0_BE_REG_PTR(seg, ptr)   M0_BE_REG((seg), sizeof *(ptr), (ptr))
 
#define M0_BE_REG_SEG(seg)   M0_BE_REG((seg), (seg)->bs_size, (seg)->bs_addr)
 
#define _FILE_OFFSET_BITS   64 /* for fseeko */
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define _FT(name)   M0_FORMAT_TYPE_ ## name
 
#define _TAG(name)   M0_ ## name ## _FORMAT_VERSION , _FT(name)
 
#define _T(name, str, field, ops)
 
#define _B(t, proc)   [t] = { .b_type = (t), .b_proc = (proc) }
 
#define FLOG(level, rc, s)
 
#define RLOG(level, prefix, s, r, tag)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define BE_TX_LOCKED_AT_STATE(tx, states)
 
#define M0_BE_CREDIT_INC(n, cr_user, credit)
 
#define M0_BE_CREDIT_DEC(cr_user, tx)
 
#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))
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define BTBI_F
 
#define BTBI_P(btbi)
 
#define M0_DEBUG_BE_CREDITS   (1)
 
#define M0_BE_TX_CREDIT(nr, size)   (struct m0_be_tx_credit){ .tc_reg_nr = (nr), .tc_reg_size = (size) }
 
#define M0_BE_TX_CREDIT_TYPE(type)   M0_BE_TX_CREDIT(1, sizeof(type))
 
#define M0_BE_TX_CREDIT_PTR(ptr)   M0_BE_TX_CREDIT(1, sizeof *(ptr))
 
#define M0_BE_TX_CREDIT_BUF(buf)   M0_BE_TX_CREDIT(1, (buf)->b_nob)
 
#define BETXCR_F   "(%lu,%lu)"
 
#define BETXCR_P(c)
 
#define M0_BE_TX_GROUP_TX_FORALL(gr, tx)   m0_tl_for(grp, &(gr)->tg_txs, (tx))
 
#define M0_BE_TX_GROUP_TX_ENDFOR   m0_tl_endfor
 
#define gft_fmt_group_choose(gft)
 
#define REGD_EXT(rd)
 
#define ARRAY_ALLOC_NZ(arr, nr)   ((arr) = m0_alloc_nz((nr) * sizeof ((arr)[0])))
 
#define M0_BE_REG_D(reg, buf)
 
#define M0_BE_REG_D_CREDIT(rd)   M0_BE_TX_CREDIT(1, (rd)->rd_reg.br_size)
 
#define M0_BE_REG_AREA_FORALL(ra, rd)
 
#define CFG(tx_nr_max, reg_nr_max, payload_sz_max, ra_sz_max)
 
#define REG(size, addr, buf)
 
#define TX(p_addr, p_nob, id)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE
 
#define BE_UT_QUEUE_TEST(q_size_max, producers, consumers, items_nr)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT
 
#define TX_PAYLOAD_TEST(credit, fill, capture, offset)
 
#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT
 

Typedefs

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)
 
typedef void(* m0_be_op_cb_t) (struct m0_be_op *op, void *param)
 
typedef void(* m0_be_tx_cb_t) (const struct m0_be_tx *tx)
 
typedef void(* m0_be_group_format_reg_area_rebuild_t) (struct m0_be_reg_area *ra, struct m0_be_reg_area *ra_new, void *param)
 

Enumerations

enum  m0_avi_be_labels {
  M0_AVI_BE_TX_STATE = M0_AVI_BE_RANGE_START + 1, M0_AVI_BE_TX_COUNTER, M0_AVI_BE_TX_COUNTER_END = M0_AVI_BE_TX_COUNTER + 0x100, M0_AVI_BE_OP_COUNTER,
  M0_AVI_BE_OP_COUNTER_END = M0_AVI_BE_OP_COUNTER + 0x100, M0_AVI_BE_TX_TO_GROUP, M0_AVI_BE_TX_ATTR_PAYLOAD_NOB, M0_AVI_BE_TX_ATTR_PAYLOAD_PREP,
  M0_AVI_BE_TX_ATTR_LOG_RESERVED_SZ, M0_AVI_BE_TX_ATTR_LOG_USED, M0_AVI_BE_TX_ATTR_RA_AREA_USED, M0_AVI_BE_TX_ATTR_RA_PREP_TC_REG_NR,
  M0_AVI_BE_TX_ATTR_RA_PREP_TC_REG_SIZE, M0_AVI_BE_TX_ATTR_RA_CAPT_TC_REG_NR, M0_AVI_BE_TX_ATTR_RA_CAPT_TC_REG_SIZE
}
 
enum  { M0_BE_ALLOC_SHIFT_MIN = 3 }
 
enum  { M0_BE_ALLOCATOR_STATS_BOUNDARY = 1024, M0_BE_ALLOCATOR_STATS_PRINT_INTERVAL = 100 }
 
enum  m0_be_alloc_zone_type { M0_BAP_REPAIR, M0_BAP_NORMAL, M0_BAP_NR }
 
enum  m0_be_allocator_op {
  M0_BAO_CREATE, M0_BAO_DESTROY, M0_BAO_ALLOC, M0_BAO_ALLOC_ALIGNED,
  M0_BAO_FREE, M0_BAO_FREE_ALIGNED
}
 
enum  { BTREE_ALLOC_SHIFT = 0 }
 
enum  btree_save_optype { BTREE_SAVE_INSERT, BTREE_SAVE_UPDATE, BTREE_SAVE_OVERWRITE }
 
enum  position_t { P_LEFT = -1, P_RIGHT = 1 }
 
enum  m0_be_btree_format_version { M0_BE_BTREE_FORMAT_VERSION_1 = 1, M0_BE_BTREE_FORMAT_VERSION = M0_BE_BTREE_FORMAT_VERSION_1 }
 
enum  m0_be_btree_type {
  M0_BBT_INVALID = 1, M0_BBT_BALLOC_GROUP_EXTENTS, M0_BBT_BALLOC_GROUP_DESC, M0_BBT_EMAP_EM_MAPPING,
  M0_BBT_CAS_CTG, M0_BBT_COB_NAMESPACE, M0_BBT_COB_OBJECT_INDEX, M0_BBT_COB_FILEATTR_BASIC,
  M0_BBT_COB_FILEATTR_EA, M0_BBT_COB_FILEATTR_OMG, M0_BBT_COB_BYTECOUNT, M0_BBT_CONFDB,
  M0_BBT_UT_KV_OPS, M0_BBT_NR
}
 
enum  m0_be_btree_op {
  M0_BBO_CREATE, M0_BBO_DESTROY, M0_BBO_INSERT, M0_BBO_DELETE,
  M0_BBO_UPDATE, M0_BBO_LOOKUP, M0_BBO_MAXKEY, M0_BBO_MINKEY,
  M0_BBO_CURSOR_GET, M0_BBO_CURSOR_NEXT, M0_BBO_CURSOR_PREV
}
 
enum  { BTREE_FAN_OUT = 128, BTREE_HEIGHT_MAX = 5 }
 
enum  { KV_NR = 2 * BTREE_FAN_OUT - 1 }
 
enum  m0_be_bnode_format_version { M0_BE_BNODE_FORMAT_VERSION_1 = 1, M0_BE_BNODE_FORMAT_VERSION = M0_BE_BNODE_FORMAT_VERSION_1 }
 
enum  {
  M0_BE_DOMAIN_LEVEL_INIT, M0_BE_DOMAIN_LEVEL_0TYPES_REGISTER, M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_DESTROY, M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_CREATE,
  M0_BE_DOMAIN_LEVEL_NORMAL_STOB_DOMAIN_INIT, M0_BE_DOMAIN_LEVEL_LOG_CONFIGURE, M0_BE_DOMAIN_LEVEL_MKFS_LOG_CREATE, M0_BE_DOMAIN_LEVEL_NORMAL_LOG_OPEN,
  M0_BE_DOMAIN_LEVEL_PD_INIT, M0_BE_DOMAIN_LEVEL_NORMAL_SEG0_OPEN, M0_BE_DOMAIN_LEVEL_NORMAL_0TYPES_VISIT, M0_BE_DOMAIN_LEVEL_LOG_DISCARD_INIT,
  M0_BE_DOMAIN_LEVEL_ENGINE_INIT, M0_BE_DOMAIN_LEVEL_ENGINE_START, M0_BE_DOMAIN_LEVEL_MKFS_SEG0_CREATE, M0_BE_DOMAIN_LEVEL_MKFS_SEG0_STRUCTS_CREATE,
  M0_BE_DOMAIN_LEVEL_MKFS_SEG0_0TYPE, M0_BE_DOMAIN_LEVEL_MKFS_SEGMENTS_CREATE, M0_BE_DOMAIN_LEVEL_READY
}
 
enum  { M0_BE_FL_STEP = 8, M0_BE_FL_NR = 128, M0_BE_FL_PICK_SCAN_LIMIT = 0x10 }
 
enum  m0_be_fl_op { M0_BFL_CREATE, M0_BFL_DESTROY, M0_BFL_ADD, M0_BFL_DEL }
 
enum  { BE_LIST_POISON_BYTE = 0xCC }
 
enum  m0_be_list_format_version { M0_BE_LIST_FORMAT_VERSION_1 = 1, M0_BE_LIST_FORMAT_VERSION = M0_BE_LIST_FORMAT_VERSION_1 }
 
enum  m0_be_list_op {
  M0_BLO_CREATE, M0_BLO_DESTROY, M0_BLO_ADD, M0_BLO_DEL,
  M0_BLO_TLINK_CREATE, M0_BLO_TLINK_DESTROY, M0_BLO_NR
}
 
enum  {
  LGR_NEW = 1, LGR_USED, LGR_SCHEDULED, LGR_DONE,
  LGR_DISCARDED, LGR_FINI
}
 
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
}
 
enum  be_log_discard_item_state {
  LDI_INIT, LDI_STARTING, LDI_FINISHED, LDI_SYNCED,
  LDI_DISCARDED
}
 
enum  { M0_BE_LOG_STORE_WRITE_SIZE_MAX = 4 * 1024 * 1024 }
 
enum  {
  M0_BE_LOG_STORE_LEVEL_ASSIGNS, M0_BE_LOG_STORE_LEVEL_STOB_DOMAIN, M0_BE_LOG_STORE_LEVEL_STOB_FIND, M0_BE_LOG_STORE_LEVEL_STOB_LOCATE,
  M0_BE_LOG_STORE_LEVEL_STOB_CREATE, M0_BE_LOG_STORE_LEVEL_ZERO, M0_BE_LOG_STORE_LEVEL_LS_HEADER_INIT, M0_BE_LOG_STORE_LEVEL_LS_HEADER_BUF_ALLOC,
  M0_BE_LOG_STORE_LEVEL_HEADER_CREATE, M0_BE_LOG_STORE_LEVEL_HEADER_ENCODE, M0_BE_LOG_STORE_LEVEL_HEADER_IO, M0_BE_LOG_STORE_LEVEL_HEADER_DECODE,
  M0_BE_LOG_STORE_LEVEL_RBUF_ARR_ALLOC, M0_BE_LOG_STORE_LEVEL_RBUF_INIT, M0_BE_LOG_STORE_LEVEL_RBUF_ASSIGN, M0_BE_LOG_STORE_LEVEL_READY
}
 
enum  m0_be_log_store_io_type { M0_BE_LOG_STORE_IO_READ, M0_BE_LOG_STORE_IO_WRITE }
 
enum  m0_be_op_state {
  M0_BOS_INVALID, M0_BOS_INIT, M0_BOS_ACTIVE, M0_BOS_DONE,
  M0_BOS_GC
}
 
enum  m0_be_op_type { M0_BOP_TREE, M0_BOP_LIST }
 
enum  m0_be_pd_io_state { M0_BPD_IO_IDLE, M0_BPD_IO_IN_PROGRESS, M0_BPD_IO_DONE, M0_BPD_IO_STATE_NR }
 
enum  m0_be_seg_states { M0_BSS_INIT, M0_BSS_OPENED, M0_BSS_CLOSED }
 
enum  {
  M0_BE_SEG_HEADER_OFFSET = 0ULL, M0_BE_SEG_READ_SIZE_MAX = 1ULL << 26, M0_BE_SEG_CORE_DUMP_LIMIT = 64ULL << 20, M0_BE_SEG_FAKE_ID = ~0,
  M0_BE_SEG_PAGE_SIZE = 1ULL << 12
}
 
enum  { M0_BE_SEG_HDR_GEOM_ITMES_MAX = 16, M0_BE_SEG_HDR_VERSION_LEN_MAX = 64 }
 
enum  m0_be_seg_hdr_format_version { M0_BE_SEG_HDR_FORMAT_VERSION_1 = 1, M0_BE_SEG_HDR_FORMAT_VERSION = M0_BE_SEG_HDR_FORMAT_VERSION_1 }
 
enum  action_opcode {
  AO_INIT = 1, AO_DONE = 2, AO_CTG = 3, AO_COB = 4,
  AO_EMAP_FIRST = 5, AO_NR = 30
}
 
enum  { MAX_WORKERS_NR = 64 }
 
enum  { CACHE_SIZE = 1000000 }
 
enum  { NV_OFFSET_SAVE_DELTA_IN_BYTES = 0x40000000 }
 
enum  { NV_OFFSET_SAVE_ACT_DELTA = 1000 }
 
enum  {
  MAX_GEN = 256, MAX_SCAN_QUEUED = 10000000, MAX_QUEUED = 1000000, MAX_REC_SIZE = 64*1024,
  MAX_GEN_DIFF_SEC = 30, MAX_KEY_LEN = 256, MAX_VALUE_LEN = 256, DEFAULT_BE_SEG_LOAD_ADDR = 0x400000100000,
  DEFAULT_BE_MAX_TX_REG_SZ = (44 * 1024 * 1024ULL)
}
 
enum  { DELTA = 60 }
 
enum  { BETOOL_ST_SEG_SIZE = 0x4000000, BETOOL_ST_TX_STEP = 0x400000, BETOOL_ST_CAPTURE_STEP = 0x20000, BETOOL_ST_CAPTURE_BLOCK = 0x1F000 }
 
enum  betool_st_event {
  BETOOL_ST_TIME_BEGIN, BETOOL_ST_TIME_TX_OPEN, BETOOL_ST_TIME_SEG_FILL, BETOOL_ST_TIME_TX_CAPTURE,
  BETOOL_ST_TIME_TX_CLOSE_WAIT, BETOOL_ST_TIME_END, BETOOL_ST_TIME_NR
}
 
enum  m0_be_tx_state {
  M0_BTS_FAILED = 1, M0_BTS_PREPARE, M0_BTS_OPENING, M0_BTS_GROUPING,
  M0_BTS_ACTIVE, M0_BTS_CLOSED, M0_BTS_LOGGED, M0_BTS_PLACED,
  M0_BTS_DONE, M0_BTS_NR
}
 
enum  { BE_TX_BULK_WORKER_MAX = 0x40 }
 
enum  m0_be_credit_users {
  M0_BE_CU_BTREE_INSERT, M0_BE_CU_BTREE_DELETE, M0_BE_CU_BTREE_UPDATE, M0_BE_CU_EMAP_SPLIT,
  M0_BE_CU_EMAP_PASTE, M0_BE_CU_NR
}
 
enum  m0_be_tx_group_state {
  M0_BGS_READY, M0_BGS_OPEN, M0_BGS_FROZEN, M0_BGS_CLOSED,
  M0_BGS_NR
}
 
enum  tx_group_fom_state {
  TGS_INIT = M0_FOM_PHASE_INIT, TGS_FINISH = M0_FOM_PHASE_FINISH, TGS_OPEN = M0_FOM_PHASE_NR, TGS_PREPARE,
  TGS_LOGGING, TGS_RECONSTRUCT, TGS_TX_OPEN, TGS_TX_CLOSE,
  TGS_REAPPLY, TGS_PLACING, TGS_PLACED, TGS_STABILIZING,
  TGS_STABLE, TGS_TX_GC_WAIT, TGS_RESET, TGS_STOPPING,
  TGS_FAILED, TGS_NR
}
 
enum  { GFT_GROUP_IO = 0, GFT_GROUP_CB_IO = 1 }
 
enum  {
  M0_BE_GROUP_FORMAT_LEVEL_ASSIGNS, M0_BE_GROUP_FORMAT_LEVEL_OP_INIT, M0_BE_GROUP_FORMAT_LEVEL_FMT_GROUP_INIT, M0_BE_GROUP_FORMAT_LEVEL_FMT_CBLOCK_INIT,
  M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_INIT, M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_IO_CREATE_GROUP, M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_IO_CREATE_CBLOCK, M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_ITER_INIT,
  M0_BE_GROUP_FORMAT_LEVEL_INITED, M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_ALLOCATE, M0_BE_GROUP_FORMAT_LEVEL_ALLOCATED
}
 
enum  m0_be_reg_area_type { M0_BE_REG_AREA_DATA_COPY, M0_BE_REG_AREA_DATA_NOCOPY }
 
enum  { BE_UT_FMT_GROUP_SIZE_MAX_RND_NR = 0x40, BE_UT_FMT_GROUP_SIZE_MAX_RND_ITER = 0x40 }
 
enum  {
  BE_UT_IO_SCHED_THREAD_NR = 0x10, BE_UT_IO_SCHED_IO_NR = 0x10, BE_UT_IO_SCHED_ADD_NR = 0x400, BE_UT_IO_SCHED_IO_OFFSET_MAX = 0x10000,
  BE_UT_IO_SCHED_EXT_SIZE_MAX = 0xdf3
}
 
enum  be_ut_io_sched_io_op { BE_UT_IO_SCHED_IO_START, BE_UT_IO_SCHED_IO_FINISH }
 
enum  { BE_UT_LOG_DISCARD_USECASE_ITEMS_MAX = 0x10, BE_UT_LOG_DISCARD_USECASE_ITEMS_THRESHOLD = 0x8 }
 
enum  {
  BE_UT_LOG_DISCARD_GP_ITEM_MAX = 0x10, BE_UT_LOG_DISCARD_GP_CONSUMERS = 0x20, BE_UT_LOG_DISCARD_GP_PRODUCERS = 0x18, BE_UT_LOG_DISCARD_GP_OPERATION_NR = 0x80000,
  BE_UT_LOG_DISCARD_GP_OPERATION_STEP = 0x10
}
 
enum  be_ut_log_discard_gp_role { BE_UT_LOG_DISCARD_GP_PRODUCER, BE_UT_LOG_DISCARD_GP_CONSUMER }
 
enum  be_ut_op_mt_cmd {
  BE_UT_OP_MT_INIT, BE_UT_OP_MT_WAIT1, BE_UT_OP_MT_ACTIVE, BE_UT_OP_MT_WAIT2,
  BE_UT_OP_MT_DONE, BE_UT_OP_MT_WAIT3, BE_UT_OP_MT_FINI, BE_UT_OP_MT_CMD_NR
}
 
enum  be_ut_op_mt_dep_type { BE_UT_OP_MT_WAIT_BEFORE, BE_UT_OP_MT_WAIT_AFTER }
 
enum  { BE_UT_OP_SET_USECASE_NR = 0x1000 }
 
enum  { BE_UT_OP_SET_TREE_LEVEL_SIZE = 5, BE_UT_OP_SET_TREE_LEVEL_NR = 8, BE_UT_OP_SET_TREE_RNG_SEED = 5, BE_UT_OP_SET_TREE_SHUFFLE_ITER = 0x100 }
 
enum  be_ut_op_set_tree_cmd {
  BE_UT_OP_SET_TREE_INIT, BE_UT_OP_SET_TREE_SET_ADD, BE_UT_OP_SET_TREE_STATES, BE_UT_OP_SET_TREE_FINI,
  BE_UT_OP_SET_TREE_SET_ACTIVE, BE_UT_OP_SET_TREE_SET_DONE, BE_UT_OP_SET_TREE_ASSERT_DONE, BE_UT_OP_SET_TREE_ASSERT_NOT_DONE
}
 
enum  {
  BE_UT_PD_USECASE_POS_START = 0x12345, BE_UT_PD_USECASE_PD_IO_NR = 0x10, BE_UT_PD_USECASE_REG_NR = 0x10, BE_UT_PD_USECASE_THREAD_NR = 0x10,
  BE_UT_PD_USECASE_ITER_NR = 0x10
}
 
enum  be_ut_queue_test {
  BE_UT_QUEUE_1_1_1, BE_UT_QUEUE_2_1_1, BE_UT_QUEUE_100_1_1, BE_UT_QUEUE_100_1_10,
  BE_UT_QUEUE_100_10_1, BE_UT_QUEUE_100_10_10, BE_UT_QUEUE_10_100_1, BE_UT_QUEUE_10_100_5,
  BE_UT_QUEUE_10_1_100, BE_UT_QUEUE_10_5_100, BE_UT_QUEUE_10_100_100, BE_UT_QUEUE_NR
}
 
enum  { SHIFT = 0 }
 
enum  { BE_UT_TX_P_SEG_SIZE = 0x10000, BE_UT_TX_P_TX_NR = 0x100, BE_UT_TX_P_REG_NR = 0x10, BE_UT_TX_P_REG_SIZE_MAX = 0x100 }
 
enum  {
  BE_UT_TX_F_SEG_SIZE = 0x20000, BE_UT_TX_F_TX_NR = 0x100, BE_UT_TX_F_TX_CONCUR = 0x80, BE_UT_TX_F_INIT = 1,
  BE_UT_TX_F_CAPTURE = 2
}
 
enum  { BE_UT_TX_C_THREAD_NR = 0x10, BE_UT_TX_C_TX_PER_THREAD = 0x40 }
 
enum  { BE_UT_TX_CAPTURING_SEG_SIZE = 0x10000, BE_UT_TX_CAPTURING_TX_NR = 0x10, BE_UT_TX_CAPTURING_NR = 0x100, BE_UT_TX_CAPTURING_RANGE = 0x20 }
 
enum  { BE_UT_TX_GC_SEG_SIZE = 0x10000, BE_UT_TX_GC_TX_NR = 0x100, BE_UT_TX_GC_RAND_DENOMINATOR = 0x5 }
 
enum  { BE_UT_TX_PAYLOAD_SEG_SIZE = 0x10000, BE_UT_TX_PAYLOAD_TEST_NR = 0x100, BE_UT_TX_PAYLOAD_SIZE_MAX = 0x10000 }
 
enum  { BE_UT_TX_BULK_Q_SIZE_MAX = 0x100, BE_UT_TX_BULK_SEG_SIZE = 1UL << 26, BE_UT_TX_BULK_TX_SIZE_MAX_BP = 2000, BE_UT_TX_BULK_WORKERS = 0x40 }
 
enum  { BE_UT_TX_BULK_USECASE_ALLOC = 1UL << 16 }
 
enum  {
  BE_UT_TX_BULK_TX_NR_EMPTY = 0x1000, BE_UT_TX_BULK_TX_NR_ERROR = 0x10000, BE_UT_TX_BULK_TX_NR_LARGE_TX = 0x40, BE_UT_TX_BULK_TX_NR_LARGE_PAYLOAD = 0x100,
  BE_UT_TX_BULK_TX_NR_LARGE_ALL = 0x40, BE_UT_TX_BULK_TX_NR_SMALL_TX = 0x1000, BE_UT_TX_BULK_TX_NR_MEDIUM_TX = 0x1000, BE_UT_TX_BULK_TX_NR_LARGE_CRED = 0x1000,
  BE_UT_TX_BULK_TX_NR_MEDIUM_CRED = 0x1000, BE_UT_TX_BULK_BUF_NR = 0x30, BE_UT_TX_BULK_BUF_SIZE = 0x100000
}
 
enum  {
  BE_UT_TX_BULK_FILL_NOTHING = 0, BE_UT_TX_BULK_FILL_TX = 1 << 1, BE_UT_TX_BULK_FILL_PAYLOAD = 1 << 2, BE_UT_TX_BULK_ERROR_REG = 1 << 3,
  BE_UT_TX_BULK_ERROR_PAYLOAD = 1 << 4
}
 
enum  {
  BE_UT_TX_BULK_PARALLEL_THREADS_NR = 0x10, BE_UT_TX_BULK_PARALLEL_QUEUE_SIZE_MAX = 4, BE_UT_TX_BULK_PARALLEL_PARTITIONS_NR_MAX = 15, BE_UT_TX_BULK_PARALLEL_WORKERS_NR_MAX = 15,
  BE_UT_TX_BULK_PARALLEL_ALLOC = 0x10000, BE_UT_TX_BULK_PARALLEL_Q_SIZE_MAX = 0x10, BE_UT_TX_BULK_PARALLEL_ITEMS_PER_PARTITION = 31, BE_UT_TX_BULK_PARALLEL_ITEMS_PER_TX_MAX = 3
}
 

Functions

struct m0_be_allocator_call_stat M0_XCA_DOMAIN (be)
 
M0_INTERNAL int m0_be_allocator_init (struct m0_be_allocator *a, struct m0_be_seg *seg)
 
M0_INTERNAL void m0_be_allocator_fini (struct m0_be_allocator *a)
 
M0_INTERNAL bool m0_be_allocator__invariant (struct m0_be_allocator *a)
 
M0_INTERNAL int m0_be_allocator_create (struct m0_be_allocator *a, struct m0_be_tx *tx, uint32_t *zone_percent, uint32_t zones_nr)
 
M0_INTERNAL void m0_be_allocator_destroy (struct m0_be_allocator *a, struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_allocator_credit (struct m0_be_allocator *a, enum m0_be_allocator_op optype, m0_bcount_t size, unsigned shift, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_alloc_aligned (struct m0_be_allocator *a, struct m0_be_tx *tx, struct m0_be_op *op, void **ptr, m0_bcount_t size, unsigned shift, uint64_t zonemask)
 
M0_INTERNAL void m0_be_alloc (struct m0_be_allocator *a, struct m0_be_tx *tx, struct m0_be_op *op, void **ptr, m0_bcount_t size)
 
M0_INTERNAL void m0_be_free_aligned (struct m0_be_allocator *a, struct m0_be_tx *tx, struct m0_be_op *op, void *ptr)
 
M0_INTERNAL void m0_be_free (struct m0_be_allocator *a, struct m0_be_tx *tx, struct m0_be_op *op, void *ptr)
 
M0_INTERNAL void m0_be_alloc_stats (struct m0_be_allocator *a, struct m0_be_allocator_stats *out)
 
M0_INTERNAL void m0_be_alloc_stats_credit (struct m0_be_allocator *a, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_alloc_stats_capture (struct m0_be_allocator *a, struct m0_be_tx *tx)
 
 M0_BASSERT (sizeof(struct be_alloc_chunk) %(1UL<< M0_BE_ALLOC_SHIFT_MIN)==0)
 
M0_INTERNAL int m0_backend_init (void)
 
M0_INTERNAL void m0_backend_fini (void)
 
static struct m0_be_op__btree * op_tree (struct m0_be_op *op)
 
static struct m0_rwlock * btree_rwlock (struct m0_be_btree *tree)
 
static struct be_btree_key_val * be_btree_search (struct m0_be_btree *btree, void *key)
 
static void btree_root_set (struct m0_be_btree *btree, struct m0_be_bnode *new_root)
 
static void btree_op_fill (struct m0_be_op *op, struct m0_be_btree *btree, struct m0_be_tx *tx, enum m0_be_btree_op optype, struct m0_be_btree_anchor *anchor)
 
static struct m0_be_allocator * tree_allocator (const struct m0_be_btree *btree)
 
static void mem_free (const struct m0_be_btree *btree, struct m0_be_tx *tx, void *ptr)
 
static void mem_update (const struct m0_be_btree *btree, struct m0_be_tx *tx, void *ptr, m0_bcount_t size)
 
static void * mem_alloc (const struct m0_be_btree *btree, struct m0_be_tx *tx, m0_bcount_t size, uint64_t zonemask)
 
static void btree_mem_alloc_credit (const struct m0_be_btree *btree, m0_bcount_t size, struct m0_be_tx_credit *accum)
 
static void btree_mem_free_credit (const struct m0_be_btree *btree, m0_bcount_t size, struct m0_be_tx_credit *accum)
 
static m0_bcount_t be_btree_ksize (const struct m0_be_btree *btree, const void *key)
 
static m0_bcount_t be_btree_vsize (const struct m0_be_btree *btree, const void *data)
 
static int be_btree_compare (const struct m0_be_btree *btree, const void *key0, const void *key1)
 
static int key_lt (const struct m0_be_btree *btree, const void *key0, const void *key1)
 
static int key_gt (const struct m0_be_btree *btree, const void *key0, const void *key1)
 
static int key_eq (const struct m0_be_btree *btree, const void *key0, const void *key1)
 
static struct m0_be_bnode * be_btree_node_alloc (const struct m0_be_btree *btree, struct m0_be_tx *tx)
 
static void btree_node_free (struct m0_be_bnode *node, const struct m0_be_btree *btree, struct m0_be_tx *tx)
 
static void btree_pair_release (struct m0_be_btree *btree, struct m0_be_tx *tx, struct be_btree_key_val *kv)
 
static struct btree_node_pos be_btree_get_btree_node (struct m0_be_btree_cursor *it, const void *key, bool slant)
 
static void be_btree_delete_key_from_node (struct m0_be_btree *tree, struct m0_be_tx *tx, struct btree_node_pos *node_pos)
 
static void be_btree_move_parent_key (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_bnode *node, enum position_t pos, unsigned int index)
 
static void be_btree_get_max_key_pos (struct m0_be_bnode *node, struct btree_node_pos *pos)
 
static void be_btree_get_min_key_pos (struct m0_be_bnode *node, struct btree_node_pos *pos)
 
static int iter_prepare (struct m0_be_bnode *node, bool print)
 
static bool btree_backlink_invariant (const struct m0_be_btree_backlink *h, const struct m0_be_seg *seg, const uint64_t *parent)
 
static bool btree_node_invariant (const struct m0_be_btree *btree, const struct m0_be_bnode *node, bool root)
 
static bool btree_node_subtree_invariant (const struct m0_be_btree *btree, const struct m0_be_bnode *node)
 
static bool btree_invariant (const struct m0_be_btree *btree)
 
static void btree_node_update (struct m0_be_bnode *node, const struct m0_be_btree *btree, struct m0_be_tx *tx)
 
static void btree_node_keyval_update (struct m0_be_bnode *node, const struct m0_be_btree *btree, struct m0_be_tx *tx, unsigned int index)
 
static void btree_create (struct m0_be_btree *btree, struct m0_be_tx *tx, const struct m0_fid *btree_fid)
 
static void be_btree_set_node_params (struct m0_be_bnode *p_node, unsigned int num_active_key, unsigned int level, bool isleaf)
 
static void be_btree_split_child (struct m0_be_btree *btree, struct m0_be_tx *tx, struct m0_be_bnode *parent, unsigned int index)
 
static void be_btree_insert_into_nonfull (struct m0_be_btree *btree, struct m0_be_tx *tx, struct m0_be_bnode *node, struct be_btree_key_val *kv)
 
static void be_btree_insert_newkey (struct m0_be_btree *btree, struct m0_be_tx *tx, struct be_btree_key_val *kv)
 
static void be_btree_shift_key_vals (struct m0_be_bnode *dest, struct m0_be_bnode *src, unsigned int start_index, unsigned int key_src_offset, unsigned int key_dest_offset, unsigned int child_src_offset, unsigned int child_dest_offset, unsigned int stop_index)
 
static struct m0_be_bnode * be_btree_merge_siblings (struct m0_be_tx *tx, struct m0_be_btree *tree, struct m0_be_bnode *parent, unsigned int idx)
 
static void be_btree_move_parent_key_to_right_child (struct m0_be_bnode *parent, struct m0_be_bnode *lch, struct m0_be_bnode *rch, unsigned int idx)
 
static void be_btree_move_parent_key_to_left_child (struct m0_be_bnode *parent, struct m0_be_bnode *lch, struct m0_be_bnode *rch, unsigned int idx)
 
static void btree_node_child_delete (struct m0_be_btree *btree, struct m0_be_tx *tx, struct m0_be_bnode *node, unsigned index, struct btree_node_pos *child, bool left)
 
static int be_btree_delete_key (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_bnode *bnode, void *key)
 
static void node_push (struct m0_be_btree_cursor *it, struct m0_be_bnode *node, int idx)
 
static struct m0_be_bnode * node_pop (struct m0_be_btree_cursor *it, int *idx)
 
static void be_btree_destroy (struct m0_be_btree *btree, struct m0_be_tx *tx)
 
static void btree_truncate (struct m0_be_btree *btree, struct m0_be_tx *tx, m0_bcount_t limit)
 
static void * be_btree_get_max_key (struct m0_be_btree *tree)
 
static void * be_btree_get_min_key (struct m0_be_btree *tree)
 
static void btree_save (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, const struct m0_buf *val, struct m0_be_btree_anchor *anchor, enum btree_save_optype optype, uint64_t zonemask)
 
M0_INTERNAL void m0_be_btree_init (struct m0_be_btree *tree, struct m0_be_seg *seg, const struct m0_be_btree_kv_ops *ops)
 
M0_INTERNAL void m0_be_btree_fini (struct m0_be_btree *tree)
 
M0_INTERNAL void m0_be_btree_create (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_fid *btree_fid)
 
M0_INTERNAL void m0_be_btree_destroy (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_btree_truncate (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, m0_bcount_t limit)
 
static void btree_node_alloc_credit (const struct m0_be_btree *tree, struct m0_be_tx_credit *accum)
 
static void btree_node_update_credit (struct m0_be_tx_credit *accum, m0_bcount_t nr)
 
static void btree_node_free_credit (const struct m0_be_btree *tree, struct m0_be_tx_credit *accum)
 
static void btree_credit (const struct m0_be_btree *tree, struct m0_be_tx_credit *accum)
 
static void btree_rebalance_credit (const struct m0_be_btree *tree, struct m0_be_tx_credit *accum)
 
static void kv_insert_credit (const struct m0_be_btree *tree, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
static void kv_delete_credit (const struct m0_be_btree *tree, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
static void btree_node_split_child_credit (const struct m0_be_btree *tree, struct m0_be_tx_credit *accum)
 
static void insert_credit (const struct m0_be_btree *tree, m0_bcount_t nr, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum, bool use_current_height)
 
static void delete_credit (const struct m0_be_btree *tree, m0_bcount_t nr, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_btree_insert_credit (const struct m0_be_btree *tree, m0_bcount_t nr, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_btree_insert_credit2 (const struct m0_be_btree *tree, m0_bcount_t nr, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_btree_delete_credit (const struct m0_be_btree *tree, m0_bcount_t nr, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_btree_update_credit (const struct m0_be_btree *tree, m0_bcount_t nr, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_btree_update_credit2 (const struct m0_be_btree *tree, m0_bcount_t nr, m0_bcount_t ksize, m0_bcount_t vsize, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_btree_create_credit (const struct m0_be_btree *tree, m0_bcount_t nr, struct m0_be_tx_credit *accum)
 
static int btree_count_items (struct m0_be_btree *tree, m0_bcount_t *ksize, m0_bcount_t *vsize)
 
M0_INTERNAL void m0_be_btree_destroy_credit (struct m0_be_btree *tree, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_btree_clear_credit (struct m0_be_btree *tree, struct m0_be_tx_credit *fixed_part, struct m0_be_tx_credit *single_record, m0_bcount_t *records_nr)
 
static void be_btree_insert (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, const struct m0_buf *val, struct m0_be_btree_anchor *anchor, uint64_t zonemask)
 
M0_INTERNAL void m0_be_btree_save (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, const struct m0_buf *val, bool overwrite)
 
M0_INTERNAL void m0_be_btree_insert (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, const struct m0_buf *val)
 
M0_INTERNAL void m0_be_btree_update (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, const struct m0_buf *val)
 
M0_INTERNAL void m0_be_btree_delete (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key)
 
static void be_btree_lookup (struct m0_be_btree *tree, struct m0_be_op *op, const struct m0_buf *key_in, struct m0_buf *key_out, struct m0_buf *value)
 
M0_INTERNAL void m0_be_btree_lookup (struct m0_be_btree *tree, struct m0_be_op *op, const struct m0_buf *key, struct m0_buf *value)
 
M0_INTERNAL void m0_be_btree_lookup_slant (struct m0_be_btree *tree, struct m0_be_op *op, struct m0_buf *key, struct m0_buf *value)
 
M0_INTERNAL void m0_be_btree_maxkey (struct m0_be_btree *tree, struct m0_be_op *op, struct m0_buf *out)
 
M0_INTERNAL void m0_be_btree_minkey (struct m0_be_btree *tree, struct m0_be_op *op, struct m0_buf *out)
 
M0_INTERNAL void m0_be_btree_update_inplace (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, struct m0_be_btree_anchor *anchor)
 
M0_INTERNAL void m0_be_btree_insert_inplace (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, struct m0_be_btree_anchor *anchor, uint64_t zonemask)
 
M0_INTERNAL void m0_be_btree_save_inplace (struct m0_be_btree *tree, struct m0_be_tx *tx, struct m0_be_op *op, const struct m0_buf *key, struct m0_be_btree_anchor *anchor, bool overwrite, uint64_t zonemask)
 
M0_INTERNAL void m0_be_btree_lookup_inplace (struct m0_be_btree *tree, struct m0_be_op *op, const struct m0_buf *key, struct m0_be_btree_anchor *anchor)
 
M0_INTERNAL void m0_be_btree_release (struct m0_be_tx *tx, struct m0_be_btree_anchor *anchor)
 
static void print_single_node (struct m0_be_bnode *node)
 
M0_INTERNAL void m0_be_btree_cursor_init (struct m0_be_btree_cursor *cur, struct m0_be_btree *btree)
 
M0_INTERNAL void m0_be_btree_cursor_fini (struct m0_be_btree_cursor *cursor)
 
M0_INTERNAL void m0_be_btree_cursor_get (struct m0_be_btree_cursor *cur, const struct m0_buf *key, bool slant)
 
M0_INTERNAL int m0_be_btree_cursor_get_sync (struct m0_be_btree_cursor *cur, const struct m0_buf *key, bool slant)
 
static int btree_cursor_seek (struct m0_be_btree_cursor *cur, void *key)
 
M0_INTERNAL int m0_be_btree_cursor_first_sync (struct m0_be_btree_cursor *cur)
 
M0_INTERNAL int m0_be_btree_cursor_last_sync (struct m0_be_btree_cursor *cur)
 
M0_INTERNAL void m0_be_btree_cursor_next (struct m0_be_btree_cursor *cur)
 
M0_INTERNAL void m0_be_btree_cursor_prev (struct m0_be_btree_cursor *cur)
 
M0_INTERNAL int m0_be_btree_cursor_next_sync (struct m0_be_btree_cursor *cur)
 
M0_INTERNAL int m0_be_btree_cursor_prev_sync (struct m0_be_btree_cursor *cur)
 
M0_INTERNAL void m0_be_btree_cursor_put (struct m0_be_btree_cursor *cursor)
 
M0_INTERNAL void m0_be_btree_cursor_kv_get (struct m0_be_btree_cursor *cur, struct m0_buf *key, struct m0_buf *val)
 
M0_INTERNAL bool m0_be_btree_is_empty (struct m0_be_btree *tree)
 
M0_INTERNAL void btree_dbg_print (struct m0_be_btree *tree)
 
 M0_BASSERT (sizeof(bool)==1)
 
static void be_domain_lock (struct m0_be_domain *dom)
 
static void be_domain_unlock (struct m0_be_domain *dom)
 
static int m0_be_segobj_opt_iterate (struct m0_be_seg *dict, const struct m0_be_0type *objtype, struct m0_buf *opt, char **suffix, bool begin)
 
M0_INTERNAL int m0_be_segobj_opt_next (struct m0_be_seg *dict, const struct m0_be_0type *objtype, struct m0_buf *opt, char **suffix)
 
M0_INTERNAL int m0_be_segobj_opt_begin (struct m0_be_seg *dict, const struct m0_be_0type *objtype, struct m0_buf *opt, char **suffix)
 
static const char * id_cut (const char *prefix, const char *key)
 
static int _0types_visit (struct m0_be_domain *dom, bool init)
 
static int be_domain_stob_open (struct m0_be_domain *dom, uint64_t stob_key, const char *stob_create_cfg, struct m0_stob **out, bool create)
 
static int be_domain_seg_structs_create (struct m0_be_domain *dom, struct m0_be_tx *tx, struct m0_be_seg *seg)
 
static int be_domain_seg_close (struct m0_be_domain *dom, struct m0_be_seg *seg, bool destroy)
 
static int be_domain_seg_open (struct m0_be_domain *dom, struct m0_be_seg *seg, uint64_t stob_key)
 
static int be_domain_seg_destroy (struct m0_be_domain *dom, uint64_t seg_id)
 
static int be_domain_seg_create (struct m0_be_domain *dom, struct m0_be_tx *tx, struct m0_be_seg *seg, const struct m0_be_0type_seg_cfg *seg_cfg)
 
static int be_0type_seg_init (struct m0_be_domain *dom, const char *suffix, const struct m0_buf *data)
 
static void be_0type_seg_fini (struct m0_be_domain *dom, const char *suffix, const struct m0_buf *data)
 
M0_INTERNAL void be_domain_log_cleanup (const char *stob_domain_location, struct m0_be_log_cfg *log_cfg, bool create)
 
static int be_domain_mkfs_seg0 (struct m0_be_domain *dom, const struct m0_be_0type_seg_cfg *seg0_cfg)
 
static void be_domain_ldsc_sync (struct m0_be_log_discard *ld, struct m0_be_op *op, struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL void m0_be_domain_cleanup_by_location (const char *stob_domain_location)
 
M0_INTERNAL struct m0_be_tx * m0_be_domain_tx_find (struct m0_be_domain *dom, uint64_t id)
 
M0_INTERNAL struct m0_be_engine * m0_be_domain_engine (struct m0_be_domain *dom)
 
M0_INTERNAL struct m0_be_seg * m0_be_domain_seg0_get (struct m0_be_domain *dom)
 
M0_INTERNAL struct m0_be_log * m0_be_domain_log (struct m0_be_domain *dom)
 
M0_INTERNAL struct m0_be_seg * m0_be_domain_seg (const struct m0_be_domain *dom, const void *addr)
 
M0_INTERNAL struct m0_be_seg * m0_be_domain_seg_first (const struct m0_be_domain *dom)
 
M0_INTERNAL struct m0_be_seg * m0_be_domain_seg_by_id (const struct m0_be_domain *dom, uint64_t id)
 
static void be_domain_seg_suffix_make (const struct m0_be_domain *dom, uint64_t seg_id, char *str, size_t str_size)
 
M0_INTERNAL void m0_be_domain_seg_create_credit (struct m0_be_domain *dom, const struct m0_be_0type_seg_cfg *seg_cfg, struct m0_be_tx_credit *cred)
 
M0_INTERNAL void m0_be_domain_seg_destroy_credit (struct m0_be_domain *dom, struct m0_be_seg *seg, struct m0_be_tx_credit *cred)
 
M0_INTERNAL int m0_be_domain_seg_create (struct m0_be_domain *dom, struct m0_be_tx *tx, const struct m0_be_0type_seg_cfg *seg_cfg, struct m0_be_seg **out)
 
M0_INTERNAL int m0_be_domain_seg_destroy (struct m0_be_domain *dom, struct m0_be_tx *tx, struct m0_be_seg *seg)
 
M0_INTERNAL bool m0_be_domain_is_locked (const struct m0_be_domain *dom)
 
M0_INTERNAL void m0_be_domain__0type_register (struct m0_be_domain *dom, struct m0_be_0type *type)
 
M0_INTERNAL void m0_be_domain__0type_unregister (struct m0_be_domain *dom, struct m0_be_0type *type)
 
static int be_domain_level_enter (struct m0_module *module)
 
static void be_domain_level_leave (struct m0_module *module)
 
M0_INTERNAL void m0_be_domain_module_setup (struct m0_be_domain *dom, const struct m0_be_domain_cfg *cfg)
 
M0_INTERNAL void m0_be_domain_tx_size_max (struct m0_be_domain *dom, struct m0_be_tx_credit *cred, m0_bcount_t *payload_size)
 
M0_INTERNAL void m0_be_domain__group_limits (struct m0_be_domain *dom, uint32_t *group_nr, uint32_t *tx_per_group)
 
M0_INTERNAL bool m0_be_domain_is_stob_log (struct m0_be_domain *dom, const struct m0_stob_id *stob_id)
 
M0_INTERNAL bool m0_be_domain_is_stob_seg (struct m0_be_domain *dom, const struct m0_stob_id *stob_id)
 
M0_INTERNAL struct m0_be_seg * m0_be_domain_seg_by_addr (struct m0_be_domain *dom, void *addr)
 
M0_INTERNAL bool m0_be_domain_seg_is_valid (struct m0_be_domain *dom, struct m0_be_seg *seg)
 
 M0_TL_DESCR_DEFINE (etx, "m0_be_engine::eng_txs[]", M0_INTERNAL, struct m0_be_tx, t_engine_linkage, t_magic, M0_BE_TX_MAGIC, M0_BE_TX_ENGINE_MAGIC)
 
 M0_TL_DEFINE (etx, M0_INTERNAL, struct m0_be_tx)
 
 M0_TL_DESCR_DEFINE (egr, "m0_be_engine::eng_groups[]", static, struct m0_be_tx_group, tg_engine_linkage, tg_magic, M0_BE_TX_MAGIC, M0_BE_TX_ENGINE_MAGIC)
 
 M0_TL_DEFINE (egr, static, struct m0_be_tx_group)
 
static bool be_engine_is_locked (const struct m0_be_engine *en)
 
static void be_engine_tx_group_open (struct m0_be_engine *en, struct m0_be_tx_group *gr)
 
static void be_engine_group_freeze (struct m0_be_engine *en, struct m0_be_tx_group *gr)
 
static void be_engine_group_tryclose (struct m0_be_engine *en, struct m0_be_tx_group *gr)
 
static void be_engine_tx_group_state_move (struct m0_be_engine *en, struct m0_be_tx_group *gr, enum m0_be_tx_group_state state)
 
static int be_engine_cfg_validate (struct m0_be_engine_cfg *en_cfg)
 
M0_INTERNAL int m0_be_engine_init (struct m0_be_engine *en, struct m0_be_domain *dom, struct m0_be_engine_cfg *en_cfg)
 
M0_INTERNAL void m0_be_engine_fini (struct m0_be_engine *en)
 
static void be_engine_lock (struct m0_be_engine *en)
 
static void be_engine_unlock (struct m0_be_engine *en)
 
static bool be_engine_invariant (struct m0_be_engine *en)
 
static uint64_t be_engine_tx_id_allocate (struct m0_be_engine *en)
 
static struct m0_be_tx * be_engine_tx_peek (struct m0_be_engine *en, enum m0_be_tx_state state)
 
static void be_engine_tx_state_post (struct m0_be_engine *en, struct m0_be_tx *tx, enum m0_be_tx_state state)
 
static bool is_engine_at_stopped_or_done (const struct m0_be_engine *en, bool stopped)
 
static struct m0_be_tx * be_engine_tx_opening_peek (struct m0_be_engine *en)
 
static void be_engine_got_tx_open (struct m0_be_engine *en, struct m0_be_tx *tx)
 
static void be_engine_group_timer_cb (struct m0_sm_timer *timer)
 
static void be_engine_group_timer_arm (struct m0_sm_group *sm_grp, struct m0_sm_ast *ast)
 
static void be_engine_group_timer_disarm (struct m0_sm_group *sm_grp, struct m0_sm_ast *ast)
 
static void be_engine_group_timeout_arm (struct m0_be_engine *en, struct m0_be_tx_group *gr)
 
static struct m0_be_tx_group * be_engine_group_find (struct m0_be_engine *en)
 
static int be_engine_tx_trygroup (struct m0_be_engine *en, struct m0_be_tx *tx)
 
static bool be_engine_recovery_is_finished (struct m0_be_engine *en)
 
static void be_engine_recovery_finish (struct m0_be_engine *en)
 
static void be_engine_try_recovery (struct m0_be_engine *en)
 
static struct m0_be_tx * be_engine_recovery_tx_find (struct m0_be_engine *en, enum m0_be_tx_state state)
 
static void be_engine_got_tx_grouping (struct m0_be_engine *en)
 
static void be_engine_got_tx_closed (struct m0_be_engine *en, struct m0_be_tx *tx)
 
static void be_engine_got_tx_done (struct m0_be_engine *en, struct m0_be_tx *tx)
 
M0_INTERNAL bool m0_be_engine__invariant (struct m0_be_engine *en)
 
M0_INTERNAL void m0_be_engine__tx_init (struct m0_be_engine *en, struct m0_be_tx *tx, enum m0_be_tx_state state)
 
M0_INTERNAL void m0_be_engine__tx_fini (struct m0_be_engine *en, struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_engine__tx_state_set (struct m0_be_engine *en, struct m0_be_tx *tx, enum m0_be_tx_state state)
 
M0_INTERNAL void m0_be_engine__tx_force (struct m0_be_engine *en, struct m0_be_tx *tx)
 
static void be_engine_tx_group_ready (struct m0_be_engine *en, struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_engine__tx_group_ready (struct m0_be_engine *en, struct m0_be_tx_group *gr)
 
static void be_engine_group_stop_nr (struct m0_be_engine *en, size_t nr)
 
static int be_engine_group_start (struct m0_be_engine *en, size_t index)
 
M0_INTERNAL int m0_be_engine_start (struct m0_be_engine *en)
 
M0_INTERNAL void m0_be_engine_stop (struct m0_be_engine *en)
 
M0_INTERNAL void m0_be_engine_got_log_space_cb (struct m0_be_log *log)
 
M0_INTERNAL void m0_be_engine_full_log_cb (struct m0_be_log *log)
 
M0_INTERNAL struct m0_be_tx * m0_be_engine__tx_find (struct m0_be_engine *en, uint64_t id)
 
M0_INTERNAL int m0_be_engine__exclusive_open_invariant (struct m0_be_engine *en, struct m0_be_tx *excl)
 
M0_INTERNAL void m0_be_engine_tx_size_max (struct m0_be_engine *en, struct m0_be_tx_credit *cred, m0_bcount_t *payload_size)
 
M0_INTERNAL void m0_be_engine__group_limits (struct m0_be_engine *en, uint32_t *group_nr, uint32_t *tx_per_group)
 
M0_INTERNAL void m0_be_engine__tx_group_discard (struct m0_be_engine *en, struct m0_be_tx_group *gr)
 
 M0_BE_LIST_DESCR_DEFINE (fl, "m0_be_fl", static, struct be_alloc_chunk, bac_linkage_free, bac_magic_free, M0_BE_ALLOC_FREE_LINK_MAGIC, M0_BE_ALLOC_FREE_MAGIC)
 
 M0_BE_LIST_DEFINE (fl, static, struct be_alloc_chunk)
 
static struct m0_be_list * be_fl_list (struct m0_be_fl *fl, unsigned long index)
 
static bool be_fl_list_is_empty (struct m0_be_fl *fl, unsigned long index)
 
M0_INTERNAL void m0_be_fl_create (struct m0_be_fl *fl, struct m0_be_tx *tx, struct m0_be_seg *seg)
 
M0_INTERNAL void m0_be_fl_destroy (struct m0_be_fl *fl, struct m0_be_tx *tx)
 
static unsigned long be_fl_index_round_up (struct m0_be_fl *fl, m0_bcount_t size)
 
static unsigned long be_fl_index_round_down_chunk (struct m0_be_fl *fl, const struct be_alloc_chunk *chunk)
 
M0_INTERNAL bool m0_be_fl__invariant (struct m0_be_fl *fl)
 
M0_INTERNAL void m0_be_fl_add (struct m0_be_fl *fl, struct m0_be_tx *tx, struct be_alloc_chunk *chunk)
 
M0_INTERNAL void m0_be_fl_del (struct m0_be_fl *fl, struct m0_be_tx *tx, struct be_alloc_chunk *chunk)
 
M0_INTERNAL struct be_alloc_chunk * m0_be_fl_pick (struct m0_be_fl *fl, m0_bcount_t size)
 
M0_INTERNAL void m0_be_fl_credit (struct m0_be_fl *fl, enum m0_be_fl_op fl_op, struct m0_be_tx_credit *accum)
 
 M0_BASSERT (M0_BE_FL_STEP *M0_BE_FL_NR< M0_BCOUNT_MAX)
 
static void * disabled_xcode_alloc (struct m0_xcode_cursor *it, size_t nob)
 
static void disabled_xcode_free (struct m0_xcode_cursor *it)
 
static m0_bcount_t be_fmt_xcoded_size (struct m0_xcode_type *type, void *object)
 
static int be_fmt_encode (struct m0_xcode_type *type, void *object, struct m0_bufvec_cursor *cur)
 
static void * be_fmt_alloc (struct m0_xcode_cursor *it, size_t nob)
 
static int be_fmt_decode (struct m0_xcode_type *type, void **object, struct m0_bufvec_cursor *cur, const struct m0_be_fmt_decode_cfg *cfg)
 
static void be_fmt_decoded_free (struct m0_xcode_type *type, void *object)
 
static bool m0_be_fmt_group__invariant (struct m0_be_fmt_group *fg)
 
static void be_fmt_content_bufs_init (struct m0_be_fmt_group *fg)
 
M0_INTERNAL void m0_be_fmt_type_trace_end (const struct m0_xcode_cursor *it)
 
M0_INTERNAL int m0_be_fmt_type_trace (const struct m0_xcode_cursor *it)
 
M0_INTERNAL int m0_be_fmt_group_init (struct m0_be_fmt_group *fg, const struct m0_be_fmt_group_cfg *cfg)
 
M0_INTERNAL void m0_be_fmt_group_fini (struct m0_be_fmt_group *fg)
 
M0_INTERNAL void m0_be_fmt_group_reset (struct m0_be_fmt_group *fg)
 
M0_INTERNAL m0_bcount_t m0_be_fmt_group_size (struct m0_be_fmt_group *fg)
 
M0_INTERNAL m0_bcount_t m0_be_fmt_group_size_max (const struct m0_be_fmt_group_cfg *cfg)
 
M0_INTERNAL int m0_be_fmt_group_encode (struct m0_be_fmt_group *fg, struct m0_bufvec_cursor *cur)
 
M0_INTERNAL int m0_be_fmt_group_decode (struct m0_be_fmt_group **fg, struct m0_bufvec_cursor *cur, const struct m0_be_fmt_decode_cfg *cfg)
 
M0_INTERNAL void m0_be_fmt_group_decoded_free (struct m0_be_fmt_group *fg)
 
M0_INTERNAL void m0_be_fmt_group_reg_add (struct m0_be_fmt_group *fg, const struct m0_be_fmt_reg *freg)
 
M0_INTERNAL uint32_t m0_be_fmt_group_reg_nr (const struct m0_be_fmt_group *fg)
 
M0_INTERNAL void m0_be_fmt_group_reg_by_id (const struct m0_be_fmt_group *fg, uint32_t index, struct m0_be_fmt_reg *freg)
 
M0_INTERNAL void m0_be_fmt_group_tx_add (struct m0_be_fmt_group *fg, const struct m0_be_fmt_tx *ftx)
 
M0_INTERNAL uint32_t m0_be_fmt_group_tx_nr (const struct m0_be_fmt_group *fg)
 
M0_INTERNAL void m0_be_fmt_group_tx_by_id (const struct m0_be_fmt_group *fg, uint32_t index, struct m0_be_fmt_tx *ftx)
 
M0_INTERNAL struct m0_be_fmt_group_info * m0_be_fmt_group_info_get (struct m0_be_fmt_group *fg)
 
M0_INTERNAL bool m0_be_fmt_group_sanity_check (struct m0_be_fmt_group *fg)
 
M0_INTERNAL int m0_be_fmt_log_record_header_init (struct m0_be_fmt_log_record_header *obj, const struct m0_be_fmt_log_record_header_cfg *cfg)
 
M0_INTERNAL void m0_be_fmt_log_record_header_fini (struct m0_be_fmt_log_record_header *obj)
 
M0_INTERNAL void m0_be_fmt_log_record_header_reset (struct m0_be_fmt_log_record_header *obj)
 
M0_INTERNAL m0_bcount_t m0_be_fmt_log_record_header_size_max (const struct m0_be_fmt_log_record_header_cfg *cfg)
 
M0_INTERNAL void m0_be_fmt_log_record_header_io_size_add (struct m0_be_fmt_log_record_header *obj, m0_bcount_t size)
 
 M0_BE_FMT_DEFINE_XCODE (log_record_header)
 
 M0_BE_FMT_DEFINE_INIT_SIMPLE (log_record_footer)
 
 M0_BE_FMT_DEFINE_XCODE (log_record_footer)
 
 M0_BE_FMT_DEFINE_INIT_SIMPLE (log_store_header)
 
 M0_BE_FMT_DEFINE_XCODE (log_store_header)
 
 M0_BE_FMT_DEFINE_INIT_SIMPLE (cblock)
 
 M0_BE_FMT_DEFINE_XCODE (cblock)
 
 M0_BE_FMT_DEFINE_INIT_SIMPLE (log_header)
 
 M0_BE_FMT_DEFINE_XCODE (log_header)
 
 M0_BASSERT (sizeof(((struct m0_be_fmt_group *) NULL) ->fg_cfg)==sizeof(struct m0_be_fmt_group_cfg *))
 
 M0_BE_FMT_DECLARE (group)
 
 M0_BE_FMT_DECLARE (log_store_header)
 
 M0_BE_FMT_DECLARE (log_record_footer)
 
 M0_BE_FMT_DECLARE (log_header)
 
 M0_BE_FMT_DECLARE (cblock)
 
 M0_BE_FMT_DECLARE (log_record_header)
 
static bool be_io_cb (struct m0_clink *link)
 
static m0_bindex_t be_io_stob_offset_pack (m0_bindex_t offset, uint32_t bshift)
 
static m0_bcount_t be_io_size_pack (m0_bcount_t size, uint32_t bshift)
 
static m0_bcount_t be_io_size_unpack (m0_bcount_t size, uint32_t bshift)
 
static void be_io_free (struct m0_be_io *bio)
 
static void be_io_part_init (struct m0_be_io_part *bip, struct m0_be_io *bio)
 
static void be_io_part_fini (struct m0_be_io_part *bip)
 
static bool be_io_part_invariant (struct m0_be_io_part *bip)
 
static int be_io_part_launch (struct m0_be_io_part *bip)
 
static void be_io_part_reset (struct m0_be_io_part *bip)
 
static bool be_io_part_add (struct m0_be_io_part *bip, void *ptr_user, m0_bindex_t offset_stob, m0_bcount_t size)
 
M0_INTERNAL int m0_be_io_init (struct m0_be_io *bio)
 
M0_INTERNAL int m0_be_io_allocate (struct m0_be_io *bio, struct m0_be_io_credit *iocred)
 
M0_INTERNAL void m0_be_io_deallocate (struct m0_be_io *bio)
 
M0_INTERNAL void m0_be_io_fini (struct m0_be_io *bio)
 
M0_INTERNAL bool m0_be_io__invariant (struct m0_be_io *bio)
 
static void be_io_vec_cut (struct m0_be_io *bio, struct m0_be_io_part *bip)
 
M0_INTERNAL void m0_be_io_add (struct m0_be_io *bio, struct m0_stob *stob, void *ptr_user, m0_bindex_t offset_stob, m0_bcount_t size)
 
M0_INTERNAL void m0_be_io_add_nostob (struct m0_be_io *bio, void *ptr_user, m0_bindex_t offset_stob, m0_bcount_t size)
 
static void be_io_vec_fork (struct m0_be_io *bio, unsigned index)
 
static unsigned be_io_vec_index_by_ptr (struct m0_be_io *bio, m0_bindex_t *iv_ptr)
 
M0_INTERNAL void m0_be_io_stob_assign (struct m0_be_io *bio, struct m0_stob *stob, m0_bindex_t offset, m0_bcount_t size)
 
M0_INTERNAL void m0_be_io_stob_move (struct m0_be_io *bio, struct m0_stob *stob, m0_bindex_t offset, m0_bindex_t win_start, m0_bcount_t win_size)
 
M0_INTERNAL void m0_be_io_vec_pack (struct m0_be_io *bio)
 
M0_INTERNAL m0_bcount_t m0_be_io_size (struct m0_be_io *bio)
 
M0_INTERNAL void m0_be_io_configure (struct m0_be_io *bio, enum m0_stob_io_opcode opcode)
 
static void be_io_finished (struct m0_be_io *bio)
 
static void be_io_empty_ast (struct m0_sm_group *grp, struct m0_sm_ast *ast)
 
M0_INTERNAL void m0_be_io_launch (struct m0_be_io *bio, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_io_sync_enable (struct m0_be_io *bio)
 
M0_INTERNAL bool m0_be_io_sync_is_enabled (struct m0_be_io *bio)
 
M0_INTERNAL enum m0_stob_io_opcode m0_be_io_opcode (struct m0_be_io *io)
 
M0_INTERNAL bool m0_be_io_is_empty (struct m0_be_io *bio)
 
M0_INTERNAL void m0_be_io_reset (struct m0_be_io *bio)
 
M0_INTERNAL void m0_be_io_sort (struct m0_be_io *bio)
 
M0_INTERNAL void m0_be_io_user_data_set (struct m0_be_io *bio, void *data)
 
M0_INTERNAL void * m0_be_io_user_data (struct m0_be_io *bio)
 
M0_INTERNAL int m0_be_io_single (struct m0_stob *stob, enum m0_stob_io_opcode opcode, void *ptr_user, m0_bindex_t offset_stob, m0_bcount_t size)
 
static bool be_io_part_intersect (const struct m0_be_io_part *bip1, const struct m0_be_io_part *bip2)
 
M0_INTERNAL bool m0_be_io_intersect (const struct m0_be_io *bio1, const struct m0_be_io *bio2)
 
M0_INTERNAL bool m0_be_io_ptr_user_is_eq (const struct m0_be_io *bio1, const struct m0_be_io *bio2)
 
M0_INTERNAL bool m0_be_io_offset_stob_is_eq (const struct m0_be_io *bio1, const struct m0_be_io *bio2)
 
M0_INTERNAL void m0_be_io_credit_add (struct m0_be_io_credit *iocred0, const struct m0_be_io_credit *iocred1)
 
M0_INTERNAL bool m0_be_io_credit_le (const struct m0_be_io_credit *iocred0, const struct m0_be_io_credit *iocred1)
 
 M0_TL_DESCR_DEFINE (sched_io, "be log scheduler IOs", static, struct m0_be_io, bio_sched_link, bio_sched_magic, M0_BE_IO_SCHED_MAGIC, M0_BE_IO_SCHED_HEAD_MAGIC)
 
 M0_TL_DEFINE (sched_io, static, struct m0_be_io)
 
M0_INTERNAL int m0_be_io_sched_init (struct m0_be_io_sched *sched, struct m0_be_io_sched_cfg *cfg)
 
M0_INTERNAL void m0_be_io_sched_fini (struct m0_be_io_sched *sched)
 
M0_INTERNAL void m0_be_io_sched_lock (struct m0_be_io_sched *sched)
 
M0_INTERNAL void m0_be_io_sched_unlock (struct m0_be_io_sched *sched)
 
M0_INTERNAL bool m0_be_io_sched_is_locked (struct m0_be_io_sched *sched)
 
static bool be_io_sched_invariant (struct m0_be_io_sched *sched)
 
static void be_io_sched_launch_next (struct m0_be_io_sched *sched)
 
static void be_io_sched_launch_next_locked (struct m0_be_io_sched *sched)
 
static void be_io_sched_cb (struct m0_be_op *op, void *param)
 
static void be_io_sched_insert (struct m0_be_io_sched *sched, struct m0_be_io *io)
 
M0_INTERNAL void m0_be_io_sched_add (struct m0_be_io_sched *sched, struct m0_be_io *io, struct m0_ext *ext, struct m0_be_op *op)
 
static bool be_list_invariant (const struct m0_be_list *blist, const struct m0_be_list_descr *descr)
 
static bool be_tlink_invariant (const struct m0_be_list_link *link, const struct m0_be_list_descr *descr)
 
M0_INTERNAL void m0_be_list_credit (enum m0_be_list_op optype, m0_bcount_t nr, struct m0_be_tx_credit *accum)
 
static void be_list_capture (struct m0_be_list *blist, struct m0_be_tx *tx)
 
static void be_tlink_capture (struct m0_be_list_link *link, struct m0_be_tx *tx)
 
static struct m0_be_list_link * be_list_obj2link (const void *obj, const struct m0_be_list_descr *descr)
 
static void * be_list_link2obj (struct m0_be_list_link *link, const struct m0_be_list_descr *descr)
 
M0_INTERNAL void m0_be_list_create (struct m0_be_list *blist, const struct m0_be_list_descr *descr, struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_list_destroy (struct m0_be_list *blist, const struct m0_be_list_descr *descr, struct m0_be_tx *tx)
 
M0_INTERNAL bool m0_be_list_is_empty (struct m0_be_list *blist, const struct m0_be_list_descr *descr)
 
M0_INTERNAL void m0_be_tlink_create (void *obj, const struct m0_be_list_descr *descr, struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_tlink_destroy (void *obj, const struct m0_be_list_descr *descr, struct m0_be_tx *tx)
 
static bool be_tlink_is_tail (struct m0_be_list *blist, struct m0_be_list_link *link)
 
static bool be_tlink_is_head (struct m0_be_list *blist, struct m0_be_list_link *link)
 
static bool be_tlink_is_in_list (struct m0_be_list_link *link)
 
M0_INTERNAL void * m0_be_list_tail (struct m0_be_list *blist, const struct m0_be_list_descr *descr)
 
M0_INTERNAL void * m0_be_list_head (struct m0_be_list *blist, const struct m0_be_list_descr *descr)
 
M0_INTERNAL void * m0_be_list_prev (struct m0_be_list *blist, const struct m0_be_list_descr *descr, const void *obj)
 
M0_INTERNAL void * m0_be_list_next (struct m0_be_list *blist, const struct m0_be_list_descr *descr, const void *obj)
 
M0_INTERNAL void m0_be_list_add (struct m0_be_list *blist, const struct m0_be_list_descr *descr, struct m0_be_tx *tx, void *obj)
 
M0_INTERNAL void m0_be_list_add_after (struct m0_be_list *blist, const struct m0_be_list_descr *descr, struct m0_be_tx *tx, void *obj, void *obj_new)
 
M0_INTERNAL void m0_be_list_add_before (struct m0_be_list *blist, const struct m0_be_list_descr *descr, struct m0_be_tx *tx, void *obj, void *obj_new)
 
M0_INTERNAL void m0_be_list_add_tail (struct m0_be_list *blist, const struct m0_be_list_descr *descr, struct m0_be_tx *tx, void *obj)
 
M0_INTERNAL void m0_be_list_del (struct m0_be_list *blist, const struct m0_be_list_descr *descr, struct m0_be_tx *tx, void *obj)
 
static void be_log_header_update (struct m0_be_log *log)
 
static int be_log_header_write (struct m0_be_log *log, struct m0_be_fmt_log_header *log_hdr)
 
 M0_TL_DESCR_DEFINE (record, "be log records", static, struct m0_be_log_record, lgr_linkage, lgr_magic, M0_BE_LOG_RECORD_MAGIC, M0_BE_LOG_RECORD_HEAD_MAGIC)
 
 M0_TL_DEFINE (record, static, struct m0_be_log_record)
 
static struct m0_be_log * be_log_module2log (struct m0_module *module)
 
static int be_log_level_enter (struct m0_module *module)
 
static void be_log_level_leave (struct m0_module *module)
 
M0_INTERNAL void m0_be_log_module_setup (struct m0_be_log *log, struct m0_be_log_cfg *lg_cfg, bool create_mode)
 
static void be_log_module_fini (struct m0_be_log *log, bool destroy_mode)
 
static int be_log_module_init (struct m0_be_log *log, struct m0_be_log_cfg *log_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)
 
static void be_log_header_io (struct m0_be_log *log, enum m0_be_log_store_io_type io_type, struct m0_be_op *op)
 
static void be_log_header_io_sync (struct m0_be_log *log, enum m0_be_log_store_io_type io_type)
 
static m0_bcount_t be_log_record_header_size (void)
 
static m0_bcount_t be_log_record_footer_size (void)
 
M0_INTERNAL m0_bcount_t m0_be_log_reserved_size (struct m0_be_log *log, m0_bcount_t *lio_size, int lio_nr)
 
static void be_log_record_io_done_cb (struct m0_be_op *op, void *param)
 
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)
 
static void be_log_io_credit (struct m0_be_log *log, struct m0_be_io_credit *accum)
 
M0_INTERNAL int m0_be_log_record_io_create (struct m0_be_log_record *record, m0_bcount_t size_max)
 
static int be_log_record_header_init (struct m0_be_fmt_log_record_header *hdr)
 
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 void m0_be_log_record_io_launch (struct m0_be_log_record *record, struct m0_be_op *op)
 
M0_INTERNAL struct m0_bufvec * m0_be_log_record_io_bufvec (struct m0_be_log_record *record, int index)
 
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)
 
static int be_log_read_plain (struct m0_be_log *log, m0_bindex_t pos, m0_bcount_t size, void *out)
 
M0_INTERNAL bool m0_be_fmt_log_record_header__invariant (struct m0_be_fmt_log_record_header *header, struct m0_be_log *log)
 
static void be_log_record_header_copy (struct m0_be_fmt_log_record_header *dest, struct m0_be_fmt_log_record_header *src)
 
static int be_log_record_iter_read (struct m0_be_log *log, struct m0_be_log_record_iter *iter, m0_bindex_t pos)
 
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_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)
 
 M0_TL_DESCR_DEFINE (ld_start, "m0_be_log_discard::lds_start_q", static, struct m0_be_log_discard_item, ldi_start_link, ldi_magic, M0_BE_LOG_DISCARD_MAGIC, M0_BE_LOG_DISCARD_HEAD_MAGIC)
 
 M0_TL_DEFINE (ld_start, static, struct m0_be_log_discard_item)
 
 M0_BE_POOL_DESCR_DEFINE (ld, "m0_be_log_discard::lds_item_pool", static, struct m0_be_log_discard_item, ldi_pool_item, ldi_pool_magic, M0_BE_LOG_DISCARD_POOL_MAGIC)
 
 M0_BE_POOL_DEFINE (ld, static, struct m0_be_log_discard_item)
 
static void be_log_discard_sync_done_cb (struct m0_be_op *op, void *param)
 
static void be_log_discard_timer_start (struct m0_be_log_discard *ld)
 
static void be_log_discard_timer_cancel (struct m0_be_log_discard *ld)
 
M0_INTERNAL int m0_be_log_discard_init (struct m0_be_log_discard *ld, struct m0_be_log_discard_cfg *ld_cfg)
 
static void be_log_discard_wait (struct m0_be_log_discard *ld)
 
M0_INTERNAL void m0_be_log_discard_fini (struct m0_be_log_discard *ld)
 
static void be_log_discard_lock (struct m0_be_log_discard *ld)
 
static void be_log_discard_unlock (struct m0_be_log_discard *ld)
 
static bool be_log_discard_is_locked (struct m0_be_log_discard *ld)
 
static void be_log_discard_flush_finished (struct m0_be_log_discard *ld)
 
static void be_log_discard_check_sync (struct m0_be_log_discard *ld, bool force)
 
static void be_log_discard_item_discard (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
static void be_log_discard_item_trydiscard (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
static void be_log_discard_ast (struct m0_sm_group *grp, struct m0_sm_ast *ast)
 
static void be_log_discard_timer_cb (struct m0_sm_timer *timer)
 
static int be_log_discard_timer_start_loc (void *param)
 
static int be_log_discard_timer_cancel_loc (void *param)
 
M0_INTERNAL void m0_be_log_discard_sync (struct m0_be_log_discard *ld)
 
M0_INTERNAL void m0_be_log_discard_flush (struct m0_be_log_discard *ld, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_log_discard_item_starting (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL void m0_be_log_discard_item_finished (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
static void be_log_discard_item_reset (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL void m0_be_log_discard_item_get (struct m0_be_log_discard *ld, struct m0_be_op *op, struct m0_be_log_discard_item **ldi)
 
M0_INTERNAL void m0_be_log_discard_item_put (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL void m0_be_log_discard_item_user_data_set (struct m0_be_log_discard_item *ldi, void *data)
 
M0_INTERNAL void * m0_be_log_discard_item_user_data (struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL void m0_be_log_discard_item_ext_set (struct m0_be_log_discard_item *ldi, struct m0_ext *ext)
 
M0_INTERNAL struct m0_ext * m0_be_log_discard_item_ext (struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL int m0_be_log_sched_init (struct m0_be_log_sched *sched, struct m0_be_log_sched_cfg *cfg)
 
M0_INTERNAL void m0_be_log_sched_fini (struct m0_be_log_sched *sched)
 
M0_INTERNAL void m0_be_log_sched_lock (struct m0_be_log_sched *sched)
 
M0_INTERNAL void m0_be_log_sched_unlock (struct m0_be_log_sched *sched)
 
M0_INTERNAL bool m0_be_log_sched_is_locked (struct m0_be_log_sched *sched)
 
M0_INTERNAL void m0_be_log_sched_add (struct m0_be_log_sched *sched, struct m0_be_log_io *lio, struct m0_be_op *op)
 
M0_INTERNAL int m0_be_log_io_init (struct m0_be_log_io *lio)
 
M0_INTERNAL void m0_be_log_io_fini (struct m0_be_log_io *lio)
 
M0_INTERNAL void m0_be_log_io_reset (struct m0_be_log_io *lio)
 
M0_INTERNAL int m0_be_log_io_allocate (struct m0_be_log_io *lio, struct m0_be_io_credit *iocred, uint32_t log_bshift)
 
M0_INTERNAL void m0_be_log_io_deallocate (struct m0_be_log_io *lio)
 
M0_INTERNAL struct m0_bufvec * m0_be_log_io_bufvec (struct m0_be_log_io *lio)
 
M0_INTERNAL struct m0_be_io * m0_be_log_io_be_io (struct m0_be_log_io *lio)
 
M0_INTERNAL void m0_be_log_io_user_data_set (struct m0_be_log_io *lio, void *data)
 
M0_INTERNAL void * m0_be_log_io_user_data (struct m0_be_log_io *lio)
 
M0_INTERNAL bool m0_be_log_io_is_empty (struct m0_be_log_io *lio)
 
static int be_log_store_buf_alloc_aligned (struct m0_be_log_store *ls, struct m0_buf *buf, m0_bcount_t size)
 
static void be_log_store_buf_free_aligned (struct m0_be_log_store *ls, struct m0_buf *buf)
 
M0_INTERNAL bool m0_be_log_store__invariant (struct m0_be_log_store *ls)
 
static int be_log_store_zero (struct m0_be_log_store *ls, m0_bcount_t ls_size)
 
static struct m0_be_log_store * be_log_store_module2store (struct m0_module *module)
 
static bool be_log_store_header_validate (struct m0_be_fmt_log_store_header *header, uint64_t alignment)
 
static int be_log_store_rbuf_alloc (struct m0_be_log_store *ls, struct m0_buf *buf)
 
static void be_log_store_rbuf_free (struct m0_be_log_store *ls, struct m0_buf *buf)
 
static int be_log_store_rbuf_init_fini_index (struct m0_be_log_store *ls, int i, bool init)
 
static void be_log_store_rbuf_fini_nr (struct m0_be_log_store *ls, int nr)
 
static void be_log_store_rbuf_fini (struct m0_be_log_store *ls)
 
static int be_log_store_rbuf_init (struct m0_be_log_store *ls)
 
static void be_log_store_rbuf_arr_free (struct m0_be_log_store *ls)
 
static int be_log_store_level_enter (struct m0_module *module)
 
static void be_log_store_level_leave (struct m0_module *module)
 
M0_INTERNAL void m0_be_log_store_module_setup (struct m0_be_log_store *ls, struct m0_be_log_store_cfg *ls_cfg, bool create_mode)
 
static void be_log_store_module_fini (struct m0_be_log_store *ls, bool destroy_mode)
 
static int be_log_store_module_init (struct m0_be_log_store *ls, struct m0_be_log_store_cfg *ls_cfg, bool create_mode)
 
M0_INTERNAL int m0_be_log_store_open (struct m0_be_log_store *ls, struct m0_be_log_store_cfg *ls_cfg)
 
M0_INTERNAL int m0_be_log_store_create (struct m0_be_log_store *ls, struct m0_be_log_store_cfg *ls_cfg)
 
M0_INTERNAL void m0_be_log_store_destroy (struct m0_be_log_store *ls)
 
M0_INTERNAL void m0_be_log_store_close (struct m0_be_log_store *ls)
 
M0_INTERNAL uint32_t m0_be_log_store_bshift (struct m0_be_log_store *ls)
 
M0_INTERNAL m0_bcount_t m0_be_log_store_buf_size (struct m0_be_log_store *ls)
 
M0_INTERNAL void m0_be_log_store_io_credit (struct m0_be_log_store *ls, struct m0_be_io_credit *accum)
 
M0_INTERNAL int m0_be_log_store_io_window (struct m0_be_log_store *ls, m0_bindex_t offset, m0_bcount_t *length)
 
M0_INTERNAL void m0_be_log_store_io_discard (struct m0_be_log_store *ls, m0_bindex_t offset, struct m0_be_op *op)
 
static m0_bindex_t be_log_store_phys_addr (struct m0_be_log_store *ls, m0_bindex_t position)
 
M0_INTERNAL void m0_be_log_store_io_translate (struct m0_be_log_store *ls, m0_bindex_t position, struct m0_be_io *bio)
 
M0_INTERNAL struct m0_buf * m0_be_log_store_rbuf_write_buf (struct m0_be_log_store *ls)
 
M0_INTERNAL struct m0_buf * m0_be_log_store_rbuf_read_buf_first (struct m0_be_log_store *ls, unsigned *iter)
 
M0_INTERNAL struct m0_buf * m0_be_log_store_rbuf_read_buf_next (struct m0_be_log_store *ls, unsigned *iter)
 
static struct m0_be_log_io * be_log_store_rbuf_io_and_op (struct m0_be_log_store *ls, enum m0_be_log_store_io_type io_type, struct m0_be_op **op, unsigned index)
 
M0_INTERNAL struct m0_be_log_io * m0_be_log_store_rbuf_io_first (struct m0_be_log_store *ls, enum m0_be_log_store_io_type io_type, struct m0_be_op **op, unsigned *iter)
 
M0_INTERNAL struct m0_be_log_io * m0_be_log_store_rbuf_io_next (struct m0_be_log_store *ls, enum m0_be_log_store_io_type io_type, struct m0_be_op **op, unsigned *iter)
 
M0_INTERNAL void m0_be_log_store_rbuf_io_reset (struct m0_be_log_store *ls, enum m0_be_log_store_io_type io_type)
 
M0_INTERNAL bool m0_be_log_store_overwrites (struct m0_be_log_store *ls, m0_bindex_t index, m0_bcount_t size, m0_bindex_t position)
 
M0_INTERNAL bool m0_be_log_store_contains_stob (struct m0_be_log_store *ls, const struct m0_stob_id *stob_id)
 
 M0_TL_DESCR_DEFINE (bos, "m0_be_op::bo_children", static, struct m0_be_op, bo_set_link, bo_set_link_magic, M0_BE_OP_SET_LINK_MAGIC, M0_BE_OP_SET_MAGIC)
 
 M0_TL_DEFINE (bos, static, struct m0_be_op)
 
static void be_op_sm_init (struct m0_be_op *op)
 
static void be_op_sm_fini (struct m0_be_op *op)
 
M0_INTERNAL void m0_be_op_init (struct m0_be_op *op)
 
M0_INTERNAL void m0_be_op_fini (struct m0_be_op *op)
 
M0_INTERNAL void m0_be_op_lock (struct m0_be_op *op)
 
M0_INTERNAL void m0_be_op_unlock (struct m0_be_op *op)
 
M0_INTERNAL bool m0_be_op_is_locked (const struct m0_be_op *op)
 
static void be_op_set_add (struct m0_be_op *parent, struct m0_be_op *child)
 
static bool be_op_set_del (struct m0_be_op *parent, struct m0_be_op *child)
 
M0_INTERNAL void m0_be_op_reset (struct m0_be_op *op)
 
static void be_op_state_change (struct m0_be_op *op, enum m0_be_op_state state)
 
M0_INTERNAL void m0_be_op_active (struct m0_be_op *op)
 
M0_INTERNAL void m0_be_op_done (struct m0_be_op *op)
 
M0_INTERNAL bool m0_be_op_is_done (struct m0_be_op *op)
 
M0_INTERNAL void m0_be_op_callback_set (struct m0_be_op *op, m0_be_op_cb_t cb, void *param, enum m0_be_op_state state)
 
M0_INTERNAL int m0_be_op_tick_ret (struct m0_be_op *op, struct m0_fom *fom, int next_state)
 
M0_INTERNAL void m0_be_op_wait (struct m0_be_op *op)
 
M0_INTERNAL void m0_be_op_set_add (struct m0_be_op *parent, struct m0_be_op *child)
 
M0_INTERNAL void m0_be_op_rc_set (struct m0_be_op *op, int rc)
 
M0_INTERNAL int m0_be_op_rc (struct m0_be_op *op)
 
 M0_BE_POOL_DESCR_DEFINE (pdio, "pd_io pool", static, struct m0_be_pd_io, bpi_pool_item, bpi_pool_magic, M0_BE_PD_IO_MAGIC)
 
 M0_BE_POOL_DEFINE (pdio, static, struct m0_be_pd_io)
 
static void be_pd_io_move (struct m0_be_pd *pd, struct m0_be_pd_io *pdio, enum m0_be_pd_io_state state)
 
static void be_pd_io_op_done (struct m0_be_op *op, void *param)
 
M0_INTERNAL int m0_be_pd_init (struct m0_be_pd *pd, struct m0_be_pd_cfg *pd_cfg)
 
M0_INTERNAL void m0_be_pd_fini (struct m0_be_pd *pd)
 
M0_INTERNAL void m0_be_pd_io_add (struct m0_be_pd *pd, struct m0_be_pd_io *pdio, struct m0_ext *ext, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_pd_io_get (struct m0_be_pd *pd, struct m0_be_pd_io **pdio, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_pd_io_put (struct m0_be_pd *pd, struct m0_be_pd_io *pdio)
 
M0_INTERNAL struct m0_be_io * m0_be_pd_io_be_io (struct m0_be_pd_io *pdio)
 
static void be_pd_sync_run (struct m0_sm_group *grp, struct m0_sm_ast *ast)
 
M0_INTERNAL void m0_be_pd_sync (struct m0_be_pd *pd, m0_bindex_t pos, struct m0_stob **stobs, int nr, struct m0_be_op *op)
 
 M0_TL_DESCR_DEFINE (be_pool, "list of be_pool_items", static, struct m0_be_pool_item, bpli_link, bpli_magic, M0_BE_POOL_MAGIC, M0_BE_POOL_HEAD_MAGIC)
 
 M0_TL_DEFINE (be_pool, static, struct m0_be_pool_item)
 
 M0_TL_DESCR_DEFINE (be_pool_q, "list of be_pool_queue_items", static, struct be_pool_queue_item, bplq_link, bplq_magic, M0_BE_POOL_QUEUE_MAGIC, M0_BE_POOL_QUEUE_HEAD_MAGIC)
 
 M0_TL_DEFINE (be_pool_q, static, struct be_pool_queue_item)
 
M0_INTERNAL int m0_be_pool_init (struct m0_be_pool *pool, struct m0_be_pool_cfg *cfg)
 
M0_INTERNAL void m0_be_pool_fini (struct m0_be_pool *pool)
 
static void be_pool_lock (struct m0_be_pool *pool)
 
static void be_pool_unlock (struct m0_be_pool *pool)
 
static bool be_pool_is_locked (struct m0_be_pool *pool)
 
static void * be_pool_amb (const struct m0_be_pool_descr *d, struct m0_be_pool_item *item)
 
static struct m0_be_pool_item * be_pool_item (const struct m0_be_pool_descr *d, void *obj)
 
static uint64_t be_pool_magic (const struct m0_be_pool_descr *d, void *obj)
 
static void be_pool_magic_set (const struct m0_be_pool_descr *d, void *obj, uint64_t magic)
 
static bool be_pool_obj__invariant (const struct m0_be_pool_descr *d, void *obj)
 
static void be_pool_get (const struct m0_be_pool_descr *d, struct m0_be_pool *pool, void **obj)
 
static void be_pool_got_free_item (const struct m0_be_pool_descr *d, struct m0_be_pool *pool)
 
M0_INTERNAL void m0_be_pool_add (const struct m0_be_pool_descr *d, struct m0_be_pool *pool, void *obj)
 
M0_INTERNAL void * m0_be_pool_del (const struct m0_be_pool_descr *d, struct m0_be_pool *pool)
 
M0_INTERNAL void m0_be_pool_get (const struct m0_be_pool_descr *d, struct m0_be_pool *pool, void **obj, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_pool_put (const struct m0_be_pool_descr *d, struct m0_be_pool *pool, void *obj)
 
 M0_TL_DESCR_DEFINE (bqq, "m0_be_queue::bq_q*[]", static, struct be_queue_item, bqi_link, bqi_magic, M0_BE_QUEUE_Q_MAGIC, M0_BE_QUEUE_Q_HEAD_MAGIC)
 
 M0_TL_DEFINE (bqq, static, struct be_queue_item)
 
 M0_TL_DESCR_DEFINE (bqop, "m0_be_queue::bq_op_*[]", static, struct be_queue_wait_op, bbo_link, bbo_magic, M0_BE_QUEUE_OP_MAGIC, M0_BE_QUEUE_OP_HEAD_MAGIC)
 
 M0_TL_DEFINE (bqop, static, struct be_queue_wait_op)
 
static uint64_t bq_queue_items_max (struct m0_be_queue *bq)
 
static struct be_queue_item * be_queue_qitem (struct m0_be_queue *bq, uint64_t index)
 
static bool be_queue_invariant (struct m0_be_queue *bq)
 
M0_INTERNAL int m0_be_queue_init (struct m0_be_queue *bq, struct m0_be_queue_cfg *cfg)
 
M0_INTERNAL void m0_be_queue_fini (struct m0_be_queue *bq)
 
M0_INTERNAL void m0_be_queue_lock (struct m0_be_queue *bq)
 
M0_INTERNAL void m0_be_queue_unlock (struct m0_be_queue *bq)
 
static uint64_t be_queue_items_nr (struct m0_be_queue *bq)
 
static bool be_queue_is_empty (struct m0_be_queue *bq)
 
static bool be_queue_is_full (struct m0_be_queue *bq)
 
static struct be_queue_item * be_queue_q_put (struct m0_be_queue *bq, const struct m0_buf *data)
 
static void be_queue_q_peek (struct m0_be_queue *bq, struct m0_buf *data)
 
static void be_queue_q_get (struct m0_be_queue *bq, struct m0_buf *data, bool *successful)
 
static void be_queue_op_put (struct m0_be_queue *bq, struct m0_be_op *op, struct be_queue_item *bqi)
 
static void be_queue_op_put_done (struct m0_be_queue *bq)
 
static bool be_queue_op_put_is_waiting (struct m0_be_queue *bq)
 
static void be_queue_op_get (struct m0_be_queue *bq, struct m0_be_op *op, struct m0_buf *data, bool *successful)
 
static void be_queue_op_get_done (struct m0_be_queue *bq, bool success)
 
static bool be_queue_op_get_is_waiting (struct m0_be_queue *bq)
 
M0_INTERNAL void m0_be_queue_put (struct m0_be_queue *bq, struct m0_be_op *op, const struct m0_buf *data)
 
M0_INTERNAL void m0_be_queue_end (struct m0_be_queue *bq)
 
M0_INTERNAL void m0_be_queue_get (struct m0_be_queue *bq, struct m0_be_op *op, struct m0_buf *data, bool *successful)
 
M0_INTERNAL bool m0_be_queue_peek (struct m0_be_queue *bq, struct m0_buf *data)
 
M0_INTERNAL void m0_be_recovery_init (struct m0_be_recovery *rvr, struct m0_be_recovery_cfg *cfg)
 
M0_INTERNAL void m0_be_recovery_fini (struct m0_be_recovery *rvr)
 
M0_INTERNAL int m0_be_recovery_run (struct m0_be_recovery *rvr)
 
M0_INTERNAL bool m0_be_recovery_log_record_available (struct m0_be_recovery *rvr)
 
M0_INTERNAL void m0_be_recovery_log_record_get (struct m0_be_recovery *rvr, struct m0_be_log_record_iter *iter)
 
static const struct m0_be_seg_geom * be_seg_geom_find_by_id (const struct m0_be_seg_hdr *hdr, uint64_t id)
 
static int be_seg_geom_len (const struct m0_be_seg_geom *geom)
 
static int be_seg_hdr_size (void)
 
static int be_seg_hdr_create (struct m0_stob *stob, struct m0_be_seg_hdr *hdr)
 
M0_INTERNAL bool m0_be_seg_geom_eq (const struct m0_be_seg_geom *left, const struct m0_be_seg_geom *right)
 
static bool be_seg_geom_has_no_overlapps (const struct m0_be_seg_geom *geom, int len)
 
M0_INTERNAL int m0_be_seg_create_multiple (struct m0_stob *stob, const struct m0_be_seg_geom *geom)
 
M0_INTERNAL int m0_be_seg_create (struct m0_be_seg *seg, m0_bcount_t size, void *addr)
 
M0_INTERNAL int m0_be_seg_destroy (struct m0_be_seg *seg)
 
M0_INTERNAL void m0_be_seg_init (struct m0_be_seg *seg, struct m0_stob *stob, struct m0_be_domain *dom, uint64_t seg_id)
 
M0_INTERNAL void m0_be_seg_fini (struct m0_be_seg *seg)
 
M0_INTERNAL bool m0_be_seg__invariant (const struct m0_be_seg *seg)
 
bool m0_be_reg__invariant (const struct m0_be_reg *reg)
 
static void be_seg_madvise (struct m0_be_seg *seg, m0_bcount_t dump_limit, int flag)
 
M0_INTERNAL int m0_be_seg_open (struct m0_be_seg *seg)
 
M0_INTERNAL void m0_be_seg_close (struct m0_be_seg *seg)
 
M0_INTERNAL bool m0_be_seg_contains (const struct m0_be_seg *seg, const void *addr)
 
M0_INTERNAL bool m0_be_reg_eq (const struct m0_be_reg *r1, const struct m0_be_reg *r2)
 
M0_INTERNAL m0_bindex_t m0_be_seg_offset (const struct m0_be_seg *seg, const void *addr)
 
M0_INTERNAL m0_bindex_t m0_be_reg_offset (const struct m0_be_reg *reg)
 
M0_INTERNAL m0_bcount_t m0_be_seg_reserved (const struct m0_be_seg *seg)
 
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator (struct m0_be_seg *seg)
 
static int be_seg_io (struct m0_be_reg *reg, void *ptr, enum m0_stob_io_opcode opcode)
 
M0_INTERNAL int m0_be_seg__read (struct m0_be_reg *reg, void *dst)
 
M0_INTERNAL int m0_be_seg__write (struct m0_be_reg *reg, void *src)
 
M0_INTERNAL int m0_be_reg__read (struct m0_be_reg *reg)
 
M0_INTERNAL int m0_be_reg__write (struct m0_be_reg *reg)
 
M0_INTERNAL unsigned long m0_be_reg_gen_idx (const struct m0_be_reg *reg)
 
M0_INTERNAL bool m0_be_seg_contains_stob (struct m0_be_seg *seg, const struct m0_stob_id *stob_id)
 
void m0_be_0type_register (struct m0_be_domain *dom, struct m0_be_0type *zt)
 
void m0_be_0type_unregister (struct m0_be_domain *dom, struct m0_be_0type *zt)
 
void m0_be_0type_del_credit (struct m0_be_domain *dom, const struct m0_be_0type *zt, const char *suffix, struct m0_be_tx_credit *credit)
 
void m0_be_0type_add_credit (struct m0_be_domain *dom, const struct m0_be_0type *zt, const char *suffix, const struct m0_buf *data, struct m0_be_tx_credit *credit)
 
int m0_be_0type_add (struct m0_be_0type *zt, struct m0_be_domain *dom, struct m0_be_tx *tx, const char *suffix, const struct m0_buf *data)
 
int m0_be_0type_del (struct m0_be_0type *zt, struct m0_be_domain *dom, struct m0_be_tx *tx, const char *suffix)
 
 M0_BE_LIST_DESCR_DEFINE (be_seg_dict, "be_seg_dict", static, struct be_seg_dict_keyval, dkv_link, dkv_magic, M0_BE_SEG_DICT_MAGIC, M0_BE_SEG_DICT_HEAD_MAGIC)
 
 M0_BE_LIST_DEFINE (be_seg_dict, static, struct be_seg_dict_keyval)
 
static struct m0_be_list * be_seg_dict_get (const struct m0_be_seg *seg)
 
static void be_seg_dict_kv_get (const struct be_seg_dict_keyval *kv)
 
static void be_seg_dict_kv_put (const struct be_seg_dict_keyval *kv)
 
static struct be_seg_dict_keyval * be_seg_dict_find (struct m0_be_seg *seg, const char *user_key, bool(*compare)(const char *dict_key, const char *user_key))
 
static bool be_seg_dict_kv_eq (const char *dict_key, const char *user_key)
 
M0_INTERNAL void m0_be_seg_dict_insert_credit (struct m0_be_seg *seg, const char *name, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_seg_dict_delete_credit (struct m0_be_seg *seg, const char *name, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_seg_dict_create_credit (struct m0_be_seg *seg, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_seg_dict_destroy_credit (struct m0_be_seg *seg, struct m0_be_tx_credit *accum)
 
M0_INTERNAL void m0_be_seg_dict_init (struct m0_be_seg *seg)
 
M0_INTERNAL void m0_be_seg_dict_fini (struct m0_be_seg *seg)
 
M0_INTERNAL int m0_be_seg_dict_lookup (struct m0_be_seg *seg, const char *name, void **out)
 
static bool be_seg_dict_kv_begin (const char *dict_key, const char *user_key)
 
static bool be_seg_dict_kv_next (const char *dict_key, const char *user_key)
 
static int be_seg_dict_iterate (struct m0_be_seg *seg, const char *prefix, const char *start_key, const char **this_key, void **this_rec, bool(*compare)(const char *dict_key, const char *user_key))
 
M0_INTERNAL int m0_be_seg_dict_begin (struct m0_be_seg *seg, const char *start_key, const char **this_key, void **this_rec)
 
M0_INTERNAL int m0_be_seg_dict_next (struct m0_be_seg *seg, const char *prefix, const char *start_key, const char **this_key, void **this_rec)
 
M0_INTERNAL int m0_be_seg_dict_insert (struct m0_be_seg *seg, struct m0_be_tx *tx, const char *name, void *value)
 
M0_INTERNAL int m0_be_seg_dict_delete (struct m0_be_seg *seg, struct m0_be_tx *tx, const char *name)
 
M0_INTERNAL void m0_be_seg_dict_create (struct m0_be_seg *seg, struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_seg_dict_destroy (struct m0_be_seg *seg, struct m0_be_tx *tx)
 
 M0_TL_DESCR_DECLARE (ad_domains, M0_EXTERN)
 
 M0_TL_DECLARE (ad_domains, M0_EXTERN, struct ad_domain_map)
 
static int init (void)
 
static void fini (void)
 
static int scan (struct scanner *s)
 
static void stats_print (void)
 
static int parse (struct scanner *s)
 
static int get (struct scanner *s, void *buf, size_t nob)
 
static int getat (struct scanner *s, off_t off, void *buf, size_t nob)
 
static int deref (struct scanner *s, const void *addr, void *buf, size_t nob)
 
static int recdo (struct scanner *s, const struct m0_format_tag *tag, struct rectype *rt)
 
static const char * recname (const struct rectype *rt)
 
static const char * bname (const struct btype *bt)
 
static int btree (struct scanner *s, struct rectype *r, char *buf)
 
static int bnode (struct scanner *s, struct rectype *r, char *buf)
 
static int seghdr (struct scanner *s, struct rectype *r, char *buf)
 
static void * scanner_action (size_t len, enum action_opcode opc, const struct action_ops *ops)
 
static void genadd (uint64_t gen)
 
static void generation_id_print (uint64_t gen)
 
static void generation_id_get (FILE *fp, uint64_t *gen_id)
 
static int generation_id_verify (struct scanner *s, uint64_t gen)
 
static void seg_get (FILE *fp, struct m0_be_seg *out)
 
static int scanner_cache_init (struct scanner *s)
 
static int scanner_init (struct scanner *s)
 
static void scanner_fini (struct scanner *s)
 
static int builder_init (struct builder *b)
 
static void builder_fini (struct builder *b)
 
static void ad_dom_fini (struct builder *b)
 
static void builder_thread (struct builder *b)
 
static void be_cfg_default_init (struct m0_be_domain_cfg *dom_cfg, struct m0_be_tx_bulk_cfg *tb_cfg)
 
static int format_header_verify (const struct m0_format_header *h, uint16_t rtype)
 
static bool btree_node_pre_is_valid (const struct m0_be_bnode *node, struct scanner *s)
 
static bool btree_node_post_is_valid (const struct m0_be_bnode *node, const struct m0_be_btree_kv_ops *ops)
 
static bool btree_kv_is_valid (struct m0_be_bnode *node, int index, struct m0_buf *key)
 
static void btree_bad_kv_count_update (uint64_t type, int count)
 
static void * builder_action (struct builder *b, size_t len, enum action_opcode opc, const struct action_ops *ops)
 
static bool fid_without_type_eq (const struct m0_fid *fid0, const struct m0_fid *fid1)
 
static struct cache_slot * cache_lookup (struct cache *c, struct m0_fid *fid)
 
static struct cache_slot * cache_insert (struct cache *c, const struct m0_fid *fid)
 
static void qinit (struct queue *q, uint64_t maxnr)
 
static void qfini (struct queue *q)
 
static void qput (struct queue *q, struct action *act)
 
static struct action * qget (struct queue *q)
 
static struct action * qtry (struct queue *q)
 
static struct action * qpeek (struct queue *q)
 
static bool isqempty (struct queue *q)
 
static int ctg_proc (struct scanner *s, struct btype *b, struct m0_be_bnode *node, off_t node_offset)
 
static int ctg_pver_fid_get (struct m0_fid *fid)
 
static void test (void)
 
static int cob_proc (struct scanner *s, struct btype *b, struct m0_be_bnode *node, off_t node_offset)
 
static int emap_proc (struct scanner *s, struct btype *b, struct m0_be_bnode *node, off_t node_offset)
 
static int emap_prep (struct action *act, struct m0_be_tx_credit *cred)
 
static void emap_act (struct action *act, struct m0_be_tx *tx)
 
static void emap_fini (struct action *act)
 
static int emap_kv_get (struct scanner *s, const struct be_btree_key_val *kv, struct m0_buf *key_buf, struct m0_buf *val_buf)
 
static void sig_handler (int num)
 
static int be_cfg_from_yaml_update (const char *yaml_file, struct m0_be_domain_cfg *cfg)
 
static int nv_scan_offset_init (uint64_t workers_nr, uint64_t partitions_nr)
 
static void nv_scan_offset_fini (void)
 
static off_t nv_scan_offset_get (off_t snapshot_size)
 
static void nv_scan_offset_update (void)
 
static void scanner_thread (struct scanner *s)
 
 M0_BASSERT (ARRAY_SIZE(rt)==M0_FORMAT_TYPE_NR+1)
 
int main (int argc, char **argv)
 
static bool seg_hdr_get (FILE *fp, struct m0_be_seg_hdr *out)
 
static int btree_check (struct scanner *s, struct rectype *r, char *buf)
 
static int bnode_check (struct scanner *s, struct rectype *r, char *buf)
 
static struct m0_stob_ad_domain * emap_dom_find (const struct action *act, const struct m0_fid *emap_fid, int *lockid)
 
static void emap_to_gob_convert (const struct m0_uint128 *emap_prefix, struct m0_fid *out)
 
static int emap_entry_lookup (struct m0_stob_ad_domain *adom, struct m0_uint128 prefix, m0_bindex_t offset, struct m0_be_emap_cursor *it)
 
static int seghdr_ver (struct scanner *s, struct rectype *r, char *buf)
 
static int seghdr_check (struct scanner *s, struct rectype *r, char *buf)
 
static void builder_do (struct m0_be_tx_bulk *tb, struct m0_be_tx *tx, struct m0_be_op *op, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void builder_done (struct m0_be_tx_bulk *tb, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void builder_work_put (struct m0_be_tx_bulk *tb, struct builder *b)
 
static int ad_dom_init (struct builder *b)
 
static void be_cfg_update (struct m0_be_domain_cfg *cfg, const char *str_key, const char *str_value)
 
static bool btree_kv_post_is_valid (struct scanner *s, struct m0_buf *key, struct m0_buf *val)
 
static int ctg_k_get (struct scanner *s, const void *addr, struct m0_buf *kbuf)
 
static int ctg_v_get (struct scanner *s, const void *addr, struct m0_buf *vbuf)
 
static int ctg_btree_fid_get (struct m0_buf *kbuf, struct m0_fid *fid)
 
static struct cache_slot * ctg_getslot_insertcred (struct ctg_action *ca, struct builder *b, struct m0_fid *cas_ctg_fid, struct m0_be_tx_credit *accum)
 
static int ctg_prep (struct action *act, struct m0_be_tx_credit *accum)
 
static struct m0_cas_ctg * ctg_create_meta (struct ctg_action *ca, struct m0_be_tx *tx)
 
static void ctg_act (struct action *act, struct m0_be_tx *tx)
 
static void ctg_fini (struct action *act)
 
static bool qinvariant (const struct queue *q)
 
static int cob_kv_get (struct scanner *s, const struct be_btree_key_val *kv, struct m0_buf *key, struct m0_buf *val)
 
static int cob_prep (struct action *act, struct m0_be_tx_credit *accum)
 
static void cob_act (struct action *act, struct m0_be_tx *tx)
 
static void cob_fini (struct action *act)
 
static int noop_prep (struct action *act, struct m0_be_tx_credit *cred)
 
static void noop_act (struct action *act, struct m0_be_tx *tx)
 
static void noop_fini (struct action *act)
 
static void test_queue (void)
 
void m0_betool_m0_init (void)
 
void m0_betool_m0_fini (void)
 
 M0_TL_DESCR_DECLARE (zt, M0_EXTERN)
 
 M0_TL_DEFINE (zt, M0_EXTERN, struct m0_be_0type)
 
void track_cob_btrees (struct m0_cob_domain *cdom, bool print_btree)
 
void track_ad_btrees (struct stob_ad_0type_rec *rec, bool print_btree)
 
static void scan_btree (struct m0_be_domain *dom, bool print_btree)
 
static void be_recovery_run (char *path)
 
static int be_log_resize (char *path, uint64_t size)
 
static void scan (char *path, char *what)
 
int main (int argc, char *argv[])
 
int m0_betool_st_mkfs (void)
 
static void betool_st_data_check (struct m0_be_ut_backend *ut_be, struct m0_be_seg *seg, uint64_t *fill)
 
 M0_BASSERT (ARRAY_SIZE(betool_st_event_descr)==BETOOL_ST_TIME_NR)
 
static void betool_st_event_time (m0_time_t *time, enum betool_st_event event)
 
static void betool_st_event_time_print (m0_time_t *time, const char *info, uint64_t fill)
 
static void betool_st_data_write (struct m0_be_ut_backend *ut_be, struct m0_be_seg *seg, uint64_t fill, uint64_t fill_end)
 
int m0_betool_st_run (void)
 
static bool be_tx_state_invariant (const struct m0_sm *mach)
 
static bool be_tx_is_locked (const struct m0_be_tx *tx)
 
static void be_tx_state_move_ast (struct m0_be_tx *tx, enum m0_be_tx_state state)
 
static void be_tx_ast_cb (struct m0_sm_group *sm_group, struct m0_sm_ast *ast)
 
static struct m0_sm_ast * be_tx_ast (struct m0_be_tx *tx, enum m0_be_tx_state state)
 
static void be_tx_state_move (struct m0_be_tx *tx, enum m0_be_tx_state state, int rc)
 
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)
 
static void be_tx_make_reg_d (struct m0_be_tx *tx, struct m0_be_reg_d *rd, const struct m0_be_reg *reg)
 
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)
 
static void addb2_add_tx_attrs (const struct m0_be_tx *tx)
 
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 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)
 
static int be_tx_memory_allocate (struct m0_be_tx *tx)
 
static void be_tx_gc (struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_tx__state_post (struct m0_be_tx *tx, enum m0_be_tx_state state)
 
M0_INTERNAL bool m0_be_tx__invariant (const struct m0_be_tx *tx)
 
M0_INTERNAL struct m0_be_reg_area * m0_be_tx__reg_area (struct m0_be_tx *tx)
 
M0_INTERNAL int m0_be_tx_open_sync (struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_tx_exclusive_open (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)
 
M0_INTERNAL void m0_be_tx_reconstruct (struct m0_be_tx *tx, const struct m0_be_fmt_tx *ftx)
 
M0_INTERNAL void m0_be_tx__group_assign (struct m0_be_tx *tx, struct m0_be_tx_group *gr)
 
static bool be_should_break (struct m0_be_engine *eng, uint64_t fraction, const struct m0_be_tx_credit *accum, const struct m0_be_tx_credit *delta)
 
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_gc_enable (struct m0_be_tx *tx, void(*gc_free)(struct m0_be_tx *, void *param), void *param)
 
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)
 
M0_INTERNAL int m0_be_tx_mod_init (void)
 
M0_INTERNAL void m0_be_tx_mod_fini (void)
 
struct m0_be_tx_remid M0_XCA_DOMAIN (be|rpc)
 
M0_INTERNAL bool m0_be_tx_should_break (struct m0_be_tx *tx, const struct m0_be_tx_credit *c)
 
static void be_tx_bulk_finish_cb (struct m0_sm_group *grp, struct m0_sm_ast *ast)
 
static void be_tx_bulk_queue_get_cb (struct m0_sm_group *grp, struct m0_sm_ast *ast)
 
static void be_tx_bulk_init_cb (struct m0_sm_group *grp, struct m0_sm_ast *ast)
 
static bool be_tx_bulk_open_cb (struct m0_clink *clink)
 
static void be_tx_bulk_close_cb (struct m0_sm_group *grp, struct m0_sm_ast *ast)
 
static void be_tx_bulk_gc_cb (struct m0_be_tx *tx, void *param)
 
static void be_tx_bulk_queue_get_done_cb (struct m0_be_op *op, void *param)
 
M0_INTERNAL int m0_be_tx_bulk_init (struct m0_be_tx_bulk *tb, struct m0_be_tx_bulk_cfg *tb_cfg)
 
M0_INTERNAL void m0_be_tx_bulk_fini (struct m0_be_tx_bulk *tb)
 
static void be_tx_bulk_lock (struct m0_be_tx_bulk *tb)
 
static void be_tx_bulk_unlock (struct m0_be_tx_bulk *tb)
 
static void be_tx_bulk_queues_drain (struct m0_be_tx_bulk *tb)
 
static void be_tx_bulk_open (struct be_tx_bulk_worker *worker, struct m0_be_tx_credit *cred, m0_bcount_t cred_payload)
 
M0_INTERNAL void m0_be_tx_bulk_run (struct m0_be_tx_bulk *tb, struct m0_be_op *op)
 
M0_INTERNAL bool m0_be_tx_bulk_put (struct m0_be_tx_bulk *tb, struct m0_be_op *op, struct m0_be_tx_credit *credit, m0_bcount_t payload_credit, uint64_t partition, void *user)
 
M0_INTERNAL void m0_be_tx_bulk_end (struct m0_be_tx_bulk *tb)
 
M0_INTERNAL int m0_be_tx_bulk_status (struct m0_be_tx_bulk *tb)
 
M0_INTERNAL void m0_be_tx_credit_add (struct m0_be_tx_credit *c0, const struct m0_be_tx_credit *c1)
 
M0_INTERNAL void m0_be_tx_credit_sub (struct m0_be_tx_credit *c0, const struct m0_be_tx_credit *c1)
 
M0_INTERNAL void m0_be_tx_credit_mul (struct m0_be_tx_credit *c, m0_bcount_t k)
 
M0_INTERNAL void m0_be_tx_credit_mul_bp (struct m0_be_tx_credit *c, unsigned bp)
 
M0_INTERNAL void m0_be_tx_credit_mac (struct m0_be_tx_credit *c, const struct m0_be_tx_credit *c1, m0_bcount_t k)
 
M0_INTERNAL bool m0_be_tx_credit_le (const struct m0_be_tx_credit *c0, const struct m0_be_tx_credit *c1)
 
M0_INTERNAL bool m0_be_tx_credit_eq (const struct m0_be_tx_credit *c0, const struct m0_be_tx_credit *c1)
 
M0_INTERNAL void m0_be_tx_credit_max (struct m0_be_tx_credit *c, const struct m0_be_tx_credit *c0, const struct m0_be_tx_credit *c1)
 
M0_INTERNAL void m0_be_tx_credit_add_max (struct m0_be_tx_credit *c, const struct m0_be_tx_credit *c0, const struct m0_be_tx_credit *c1)
 
 M0_TL_DESCR_DEFINE (rtxs, "m0_be_tx_group::tg_txs_recovering", static, struct be_recovering_tx, rtx_link, rtx_magic, M0_BE_TX_MAGIC, M0_BE_TX_GROUP_MAGIC)
 
 M0_TL_DEFINE (rtxs, static, struct be_recovering_tx)
 
 M0_TL_DESCR_DEFINE (grp, "m0_be_tx_group::tg_txs", M0_INTERNAL, struct m0_be_tx, t_group_linkage, t_magic, M0_BE_TX_MAGIC, M0_BE_TX_GROUP_MAGIC)
 
 M0_TL_DEFINE (grp, M0_INTERNAL, struct m0_be_tx)
 
M0_INTERNAL void m0_be_tx_group_stable (struct m0_be_tx_group *gr)
 
M0_INTERNAL struct m0_sm_group * m0_be_tx_group__sm_group (struct m0_be_tx_group *gr)
 
M0_INTERNAL bool m0_be_tx_group_is_recovering (struct m0_be_tx_group *gr)
 
static void be_tx_group_reg_area_gather (struct m0_be_tx_group *gr)
 
static void be_tx_group_payload_gather (struct m0_be_tx_group *gr)
 
static void be_tx_group_deconstruct (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_close (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_reset (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_prepare (struct m0_be_tx_group *gr, struct m0_be_op *op)
 
M0_INTERNAL int m0_be_tx_group_init (struct m0_be_tx_group *gr, struct m0_be_tx_group_cfg *gr_cfg)
 
M0_INTERNAL bool m0_be_tx_group__invariant (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_fini (struct m0_be_tx_group *gr)
 
static void be_tx_group_tx_to_gr_map (const struct m0_be_tx *tx, const struct m0_be_tx_group *gr)
 
static void be_tx_group_tx_add (struct m0_be_tx_group *gr, struct m0_be_tx *tx)
 
M0_INTERNAL int m0_be_tx_group_tx_add (struct m0_be_tx_group *gr, struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_tx_group_tx_closed (struct m0_be_tx_group *gr, struct m0_be_tx *tx)
 
M0_INTERNAL void m0_be_tx_group_tx_del (struct m0_be_tx_group *gr, struct m0_be_tx *tx)
 
M0_INTERNAL size_t m0_be_tx_group_tx_nr (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_open (struct m0_be_tx_group *gr)
 
M0_INTERNAL int m0_be_tx_group_start (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_stop (struct m0_be_tx_group *gr)
 
M0_INTERNAL int m0_be_tx_group__allocate (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group__deallocate (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_seg_place_prepare (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_seg_place (struct m0_be_tx_group *gr, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_tx_group_encode (struct m0_be_tx_group *gr)
 
M0_INTERNAL void m0_be_tx_group_log_write (struct m0_be_tx_group *gr, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_tx_group__tx_state_post (struct m0_be_tx_group *gr, enum m0_be_tx_state state, bool del_tx_from_group)
 
M0_INTERNAL void m0_be_tx_group_recovery_prepare (struct m0_be_tx_group *gr, struct m0_be_log *log)
 
M0_INTERNAL void m0_be_tx_group_log_read (struct m0_be_tx_group *gr, struct m0_be_op *op)
 
M0_INTERNAL int m0_be_tx_group_decode (struct m0_be_tx_group *gr)
 
static void be_tx_group_reconstruct_reg_area (struct m0_be_tx_group *gr)
 
static struct be_recovering_tx * tx2tx_group_recovering_tx (struct m0_be_tx *tx)
 
static bool be_tx_group_recovering_tx_open (struct m0_clink *clink)
 
static void be_tx_group_recovering_gc (struct m0_be_tx *tx, void *param)
 
static void be_tx_group_reconstruct_transactions (struct m0_be_tx_group *gr, struct m0_sm_group *sm_grp)
 
M0_INTERNAL int m0_be_tx_group_reconstruct (struct m0_be_tx_group *gr, struct m0_sm_group *sm_grp)
 
M0_INTERNAL void m0_be_tx_group_reconstruct_tx_open (struct m0_be_tx_group *gr, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_tx_group_reconstruct_tx_close (struct m0_be_tx_group *gr, struct m0_be_op *op_gc)
 
M0_INTERNAL int m0_be_tx_group_reapply (struct m0_be_tx_group *gr, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_tx_group_discard (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL void m0_be_tx_group_seg_io_credit (struct m0_be_tx_group_cfg *gr_cfg, struct m0_be_io_credit *io_cred)
 
 M0_TL_DESCR_DECLARE (grp, M0_EXTERN)
 
 M0_TL_DECLARE (grp, M0_INTERNAL, struct m0_be_tx)
 
static struct m0_be_tx_group_fom * fom2tx_group_fom (const struct m0_fom *fom)
 
static void tx_group_fom_fini (struct m0_fom *fom)
 
static int tx_group_fom_tick (struct m0_fom *fom)
 
static size_t tx_group_fom_locality (const struct m0_fom *fom)
 
static void be_tx_group_fom_handle (struct m0_sm_group *gr, struct m0_sm_ast *ast)
 
static void be_tx_group_fom_iff_waiting_wakeup (struct m0_fom *fom)
 
static void be_tx_group_fom_stable (struct m0_sm_group *_, struct m0_sm_ast *ast)
 
static void be_tx_group_fom_stop (struct m0_sm_group *gr, struct m0_sm_ast *ast)
 
M0_INTERNAL void m0_be_tx_group_fom_init (struct m0_be_tx_group_fom *m, struct m0_be_tx_group *gr, struct m0_reqh *reqh)
 
M0_INTERNAL void m0_be_tx_group_fom_fini (struct m0_be_tx_group_fom *m)
 
M0_INTERNAL void m0_be_tx_group_fom_reset (struct m0_be_tx_group_fom *m)
 
static void be_tx_group_fom_ast_post (struct m0_be_tx_group_fom *gf, struct m0_sm_ast *ast)
 
M0_INTERNAL int m0_be_tx_group_fom_start (struct m0_be_tx_group_fom *gf)
 
M0_INTERNAL void m0_be_tx_group_fom_stop (struct m0_be_tx_group_fom *gf)
 
M0_INTERNAL void m0_be_tx_group_fom_handle (struct m0_be_tx_group_fom *m)
 
M0_INTERNAL void m0_be_tx_group_fom_stable (struct m0_be_tx_group_fom *gf)
 
M0_INTERNAL struct m0_sm_group * m0_be_tx_group_fom__sm_group (struct m0_be_tx_group_fom *m)
 
M0_INTERNAL void m0_be_tx_group_fom_recovery_prepare (struct m0_be_tx_group_fom *m)
 
M0_INTERNAL void m0_be_tx_group_fom_mod_init (void)
 
M0_INTERNAL void m0_be_tx_group_fom_mod_fini (void)
 
static struct m0_be_group_format * be_group_format_module2gft (struct m0_module *module)
 
static int be_group_format_level_enter (struct m0_module *module)
 
static void be_group_format_level_leave (struct m0_module *module)
 
M0_INTERNAL void m0_be_group_format_reset (struct m0_be_group_format *gft)
 
M0_INTERNAL void m0_be_group_format_module_setup (struct m0_be_group_format *gft, struct m0_be_group_format_cfg *gft_cfg)
 
static void be_group_format_module_fini (struct m0_be_group_format *gft, bool deallocate)
 
static int be_group_format_module_init (struct m0_be_group_format *gft, struct m0_be_group_format_cfg *gft_cfg, bool allocate)
 
M0_INTERNAL int m0_be_group_format_init (struct m0_be_group_format *gft, struct m0_be_group_format_cfg *gft_cfg, struct m0_be_tx_group *group, struct m0_be_log *log)
 
M0_INTERNAL void m0_be_group_format_fini (struct m0_be_group_format *gft)
 
M0_INTERNAL bool m0_be_group_format__invariant (struct m0_be_group_format *go)
 
M0_INTERNAL int m0_be_group_format_allocate (struct m0_be_group_format *gft)
 
M0_INTERNAL void m0_be_group_format_deallocate (struct m0_be_group_format *gft)
 
M0_INTERNAL void m0_be_group_format_prepare (struct m0_be_group_format *gft, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_group_format_encode (struct m0_be_group_format *gft)
 
M0_INTERNAL int m0_be_group_format_decode (struct m0_be_group_format *gft)
 
M0_INTERNAL void m0_be_group_format_reg_log_add (struct m0_be_group_format *gft, const struct m0_be_reg_d *rd)
 
M0_INTERNAL void m0_be_group_format_reg_seg_add (struct m0_be_group_format *gft, const struct m0_be_reg_d *rd)
 
M0_INTERNAL uint32_t m0_be_group_format_reg_nr (const struct m0_be_group_format *gft)
 
M0_INTERNAL void m0_be_group_format_reg_get (const struct m0_be_group_format *gft, uint32_t index, struct m0_be_reg_d *rd)
 
M0_INTERNAL void m0_be_group_format_tx_add (struct m0_be_group_format *gft, struct m0_be_fmt_tx *ftx)
 
M0_INTERNAL uint32_t m0_be_group_format_tx_nr (const struct m0_be_group_format *gft)
 
M0_INTERNAL void m0_be_group_format_tx_get (const struct m0_be_group_format *gft, uint32_t index, struct m0_be_fmt_tx *ftx)
 
M0_INTERNAL struct m0_be_fmt_group_info * m0_be_group_format_group_info (struct m0_be_group_format *gft)
 
M0_INTERNAL m0_bcount_t m0_be_group_format_log_reserved_size (struct m0_be_log *log, struct m0_be_tx_credit *cred, m0_bcount_t cred_payload)
 
M0_INTERNAL m0_bindex_t m0_be_group_format_log_position (const struct m0_be_group_format *gft)
 
M0_INTERNAL m0_bindex_t m0_be_group_format_log_discarded (const struct m0_be_group_format *gft)
 
M0_INTERNAL void m0_be_group_format_log_use (struct m0_be_group_format *gft, m0_bcount_t size_reserved)
 
M0_INTERNAL void m0_be_group_format_recovery_prepare (struct m0_be_group_format *gft, struct m0_be_log *log)
 
M0_INTERNAL void m0_be_group_format_log_write (struct m0_be_group_format *gft, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_group_format_log_read (struct m0_be_group_format *gft, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_group_format_seg_place_prepare (struct m0_be_group_format *gft)
 
static void be_tx_group_format_seg_io_starting (struct m0_be_op *op, void *param)
 
static void be_tx_group_format_seg_io_finished (struct m0_be_op *op, void *param)
 
static void be_tx_group_format_seg_io_op_gc (struct m0_be_op *op, void *param)
 
M0_INTERNAL void m0_be_group_format_discard (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
M0_INTERNAL void m0_be_group_format_seg_place (struct m0_be_group_format *gft, struct m0_be_op *op)
 
M0_INTERNAL void m0_be_group_format_seg_io_credit (struct m0_be_group_format_cfg *gft_cfg, struct m0_be_io_credit *io_cred)
 
M0_INTERNAL bool m0_be_reg_d__invariant (const struct m0_be_reg_d *rd)
 
M0_INTERNAL bool m0_be_reg_d_is_in (const struct m0_be_reg_d *rd, void *ptr)
 
static bool be_reg_d_are_overlapping (const struct m0_be_reg_d *rd1, const struct m0_be_reg_d *rd2)
 
static bool be_reg_d_is_partof (const struct m0_be_reg_d *super, const struct m0_be_reg_d *sub)
 
static void * be_reg_d_fb (const struct m0_be_reg_d *rd)
 
static void * be_reg_d_fb1 (const struct m0_be_reg_d *rd)
 
static void * be_reg_d_lb (const struct m0_be_reg_d *rd)
 
static void * be_reg_d_lb1 (const struct m0_be_reg_d *rd)
 
static m0_bcount_t be_reg_d_size (const struct m0_be_reg_d *rd)
 
static void be_reg_d_sub_make (struct m0_be_reg_d *super, struct m0_be_reg_d *sub)
 
static void be_reg_d_arr_insert2 (void *arr[2], void *value)
 
static void be_reg_d_arr_first_subreg (struct m0_be_reg_d **rd_arr, int nr, void *start, void **addr, m0_bcount_t *size)
 
static bool be_rdt_contains (const struct m0_be_reg_d_tree *rdt, const struct m0_be_reg_d *rd)
 
M0_INTERNAL int m0_be_rdt_init (struct m0_be_reg_d_tree *rdt, size_t size_max)
 
M0_INTERNAL void m0_be_rdt_fini (struct m0_be_reg_d_tree *rdt)
 
M0_INTERNAL bool m0_be_rdt__invariant (const struct m0_be_reg_d_tree *rdt)
 
M0_INTERNAL size_t m0_be_rdt_size (const struct m0_be_reg_d_tree *rdt)
 
static bool be_rdt_check_i (const struct m0_be_reg_d_tree *rdt, void *addr, size_t index)
 
static size_t be_rdt_find_i (const struct m0_be_reg_d_tree *rdt, void *addr)
 
M0_INTERNAL struct m0_be_reg_d * m0_be_rdt_find (const struct m0_be_reg_d_tree *rdt, void *addr)
 
M0_INTERNAL struct m0_be_reg_d * m0_be_rdt_next (const struct m0_be_reg_d_tree *rdt, struct m0_be_reg_d *prev)
 
M0_INTERNAL void m0_be_rdt_ins (struct m0_be_reg_d_tree *rdt, const struct m0_be_reg_d *rd)
 
M0_INTERNAL struct m0_be_reg_d * m0_be_rdt_del (struct m0_be_reg_d_tree *rdt, const struct m0_be_reg_d *rd)
 
M0_INTERNAL void m0_be_rdt_reset (struct m0_be_reg_d_tree *rdt)
 
M0_INTERNAL int m0_be_regmap_init (struct m0_be_regmap *rm, const struct m0_be_regmap_ops *ops, void *ops_data, size_t size_max, bool split_on_absorb)
 
M0_INTERNAL void m0_be_regmap_fini (struct m0_be_regmap *rm)
 
M0_INTERNAL bool m0_be_regmap__invariant (const struct m0_be_regmap *rm)
 
static struct m0_be_reg_d * be_regmap_find_fb (struct m0_be_regmap *rm, const struct m0_be_reg_d *rd)
 
static void be_regmap_reg_d_cut (struct m0_be_regmap *rm, struct m0_be_reg_d *rd, m0_bcount_t cut_start, m0_bcount_t cut_end)
 
static void be_regmap_reg_d_split (struct m0_be_regmap *rm, struct m0_be_reg_d *rdi, struct m0_be_reg_d *rd, struct m0_be_reg_d *rd_new)
 
M0_INTERNAL void m0_be_regmap_add (struct m0_be_regmap *rm, struct m0_be_reg_d *rd)
 
M0_INTERNAL void m0_be_regmap_del (struct m0_be_regmap *rm, const struct m0_be_reg_d *rd)
 
M0_INTERNAL struct m0_be_reg_d * m0_be_regmap_first (struct m0_be_regmap *rm)
 
M0_INTERNAL struct m0_be_reg_d * m0_be_regmap_next (struct m0_be_regmap *rm, struct m0_be_reg_d *prev)
 
M0_INTERNAL size_t m0_be_regmap_size (const struct m0_be_regmap *rm)
 
M0_INTERNAL void m0_be_regmap_reset (struct m0_be_regmap *rm)
 
M0_INTERNAL int m0_be_reg_area_init (struct m0_be_reg_area *ra, const struct m0_be_tx_credit *prepared, enum m0_be_reg_area_type type)
 
M0_INTERNAL void m0_be_reg_area_fini (struct m0_be_reg_area *ra)
 
M0_INTERNAL bool m0_be_reg_area__invariant (const struct m0_be_reg_area *ra)
 
M0_INTERNAL void m0_be_reg_area_used (struct m0_be_reg_area *ra, struct m0_be_tx_credit *used)
 
M0_INTERNAL void m0_be_reg_area_prepared (struct m0_be_reg_area *ra, struct m0_be_tx_credit *prepared)
 
M0_INTERNAL void m0_be_reg_area_captured (struct m0_be_reg_area *ra, struct m0_be_tx_credit *captured)
 
static void be_reg_d_cpy (void *dst, const struct m0_be_reg_d *rd)
 
static void * be_reg_area_alloc (struct m0_be_reg_area *ra, m0_bcount_t size)
 
static void be_reg_area_add_copy (void *data, struct m0_be_reg_d *rd)
 
static void be_reg_area_add (void *data, struct m0_be_reg_d *rd)
 
static void be_reg_area_del (void *data, const struct m0_be_reg_d *rd)
 
static void be_reg_area_cpy_copy (void *data, const struct m0_be_reg_d *super, const struct m0_be_reg_d *rd)
 
static void be_reg_area_cpy (void *data, const struct m0_be_reg_d *super, const struct m0_be_reg_d *rd)
 
static void be_reg_area_cut (void *data, struct m0_be_reg_d *rd, m0_bcount_t cut_at_start, m0_bcount_t cut_at_end)
 
static void be_reg_area_split (void *data, struct m0_be_reg_d *rd, struct m0_be_reg_d *rd_new)
 
M0_INTERNAL void m0_be_reg_area_capture (struct m0_be_reg_area *ra, struct m0_be_reg_d *rd)
 
M0_INTERNAL void m0_be_reg_area_uncapture (struct m0_be_reg_area *ra, const struct m0_be_reg_d *rd)
 
M0_INTERNAL void m0_be_reg_area_merge_in (struct m0_be_reg_area *ra, struct m0_be_reg_area *src)
 
M0_INTERNAL void m0_be_reg_area_reset (struct m0_be_reg_area *ra)
 
M0_INTERNAL void m0_be_reg_area_optimize (struct m0_be_reg_area *ra)
 
M0_INTERNAL struct m0_be_reg_d * m0_be_reg_area_first (struct m0_be_reg_area *ra)
 
M0_INTERNAL struct m0_be_reg_d * m0_be_reg_area_next (struct m0_be_reg_area *ra, struct m0_be_reg_d *prev)
 
M0_INTERNAL int m0_be_reg_area_merger_init (struct m0_be_reg_area_merger *brm, int reg_area_nr_max)
 
M0_INTERNAL void m0_be_reg_area_merger_fini (struct m0_be_reg_area_merger *brm)
 
M0_INTERNAL void m0_be_reg_area_merger_reset (struct m0_be_reg_area_merger *brm)
 
M0_INTERNAL void m0_be_reg_area_merger_add (struct m0_be_reg_area_merger *brm, struct m0_be_reg_area *ra)
 
static void be_reg_area_merger_max_gen_idx (struct m0_be_reg_area_merger *brm, void *addr, m0_bcount_t size, struct m0_be_reg_d *rd_new)
 
M0_INTERNAL void m0_be_reg_area_merger_merge_to (struct m0_be_reg_area_merger *brm, struct m0_be_reg_area *ra)
 
static int txs_allocate (struct m0_reqh_service **out, const struct m0_reqh_service_type *stype)
 
M0_INTERNAL int m0_be_txs_register (void)
 
M0_INTERNAL void m0_be_txs_unregister (void)
 
static int txs_start (struct m0_reqh_service *service)
 
static void txs_stop (struct m0_reqh_service *service)
 
static void txs_fini (struct m0_reqh_service *service)
 
M0_INTERNAL int m0_be_tx_service_init (struct m0_be_engine *en, struct m0_reqh *reqh)
 
M0_INTERNAL void m0_be_tx_service_fini (struct m0_be_engine *en)
 
void m0_be_ut_fmt_log_header (void)
 
void m0_be_ut_fmt_cblock (void)
 
static bool fmt_group_eq (struct m0_be_fmt_group *left, struct m0_be_fmt_group *right)
 
static void be_fmt_group_populate (struct m0_be_fmt_group *group, void *payload, size_t payload_size, size_t TX_NR_MAX, size_t REG_NR_MAX)
 
static void spoil_nr (struct m0_be_ut_fmt_group_test *t, struct m0_buf *b)
 
void m0_be_ut_fmt_group_size_max (void)
 
static m0_bcount_t be_ut_fmt_group_size_max_check (struct m0_be_fmt_group_cfg *fg_cfg, uint64_t *seed)
 
static void be_ut_fmt_group_size_max_test (struct m0_be_fmt_group_cfg *fg_cfg2, uint64_t *seed)
 
void m0_be_ut_fmt_group_size_max_rnd (void)
 
void m0_be_ut_fmt_group (void)
 
static void be_ut_io_sched_io_ready_add (struct be_ut_io_sched_test *test, struct m0_be_io *bio, struct m0_be_op *op)
 
static void be_ut_io_sched_io_ready_get (struct be_ut_io_sched_test *test, struct m0_be_io **bio, struct m0_be_op **op)
 
static void be_ut_io_sched_io_state_add (struct be_ut_io_sched_test *test, struct be_ut_io_sched_io_state *state)
 
static void be_ut_io_sched_io_completion_cb (struct m0_be_op *op, void *param)
 
static void be_ut_io_sched_io_start_cb (struct m0_be_op *op, void *param)
 
static void be_ut_io_sched_thread (void *param)
 
static void be_ut_io_sched_states_check (struct be_ut_io_sched_io_state *states, int states_nr, struct m0_atomic64 *states_pos)
 
 M0_UT_THREADS_DEFINE (be_ut_io_sched, &be_ut_io_sched_thread)
 
void m0_be_ut_io_sched (void)
 
static void be_ut_log_discard_usecase_sync (struct m0_be_log_discard *ld, struct m0_be_op *op, struct m0_be_log_discard_item *ldi)
 
static void be_ut_log_discard_usecase_discard (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
void m0_be_ut_log_discard_usecase (void)
 
static void be_ut_log_discard_gp_sync (struct m0_be_log_discard *ld, struct m0_be_op *op, struct m0_be_log_discard_item *ldi)
 
static void be_ut_log_discard_gp_discard (struct m0_be_log_discard *ld, struct m0_be_log_discard_item *ldi)
 
static void be_ut_log_discard_gp_consume (struct be_ut_log_discard_gp_test *test)
 
static void be_ut_log_discard_gp_produce (struct be_ut_log_discard_gp_test *test)
 
static void be_ut_log_discard_gp_thread (void *param)
 
static void be_ut_log_discard_gp_set (struct be_ut_log_discard_gp_test_item *item, bool is_producer, int index, struct be_ut_log_discard_gp_test *test)
 
 M0_UT_THREADS_DEFINE (be_ut_log_discard_gp_producers, &be_ut_log_discard_gp_thread)
 
 M0_UT_THREADS_DEFINE (be_ut_log_discard_gp_consumers, &be_ut_log_discard_gp_thread)
 
void m0_be_ut_log_discard_getput (void)
 
void m0_be_ut_op_usecase (void)
 
static void be_ut_op_mt_thread_func (void *param)
 
 M0_UT_THREADS_DEFINE (be_ut_op_mt, &be_ut_op_mt_thread_func)
 
void m0_be_ut_op_mt (void)
 
void m0_be_ut_op_set_usecase (void)
 
static void be_ut_op_set_tree_swap (unsigned *a, unsigned *b)
 
static void be_ut_op_set_tree_random_shuffle (unsigned *arr, unsigned nr, bool keep_half_dist_order, uint64_t *seed)
 
static void be_ut_op_set_tree_do (struct m0_be_op *op, struct m0_be_op *child, enum be_ut_op_set_tree_cmd cmd)
 
static void be_ut_op_set_tree_recursive (struct m0_be_op *op, enum be_ut_op_set_tree_cmd cmd, int level, int index, uint64_t *seed)
 
void m0_be_ut_op_set_tree (void)
 
static void be_ut_pd_usecase_thread (void *param)
 
 M0_UT_THREADS_DEFINE (be_ut_pd_usecase, &be_ut_pd_usecase_thread)
 
void m0_be_ut_pd_usecase (void)
 
static uint64_t be_ut_queue_data_index (struct be_ut_queue_ctx *ctx, struct be_ut_queue_data *data)
 
static void be_ut_queue_try_peek (struct be_ut_queue_thread_param *param, struct be_ut_queue_ctx *ctx)
 
static void be_ut_queue_thread (void *_param)
 
static void be_ut_queue_with_cfg (struct be_ut_queue_cfg *test_cfg)
 
static void be_ut_queue (enum be_ut_queue_test test)
 
void m0_be_ut_queue_1_1_1 (void)
 
void m0_be_ut_queue_2_1_1 (void)
 
void m0_be_ut_queue_100_1_1 (void)
 
void m0_be_ut_queue_100_1_10 (void)
 
void m0_be_ut_queue_100_10_1 (void)
 
void m0_be_ut_queue_100_10_10 (void)
 
void m0_be_ut_queue_10_100_1 (void)
 
void m0_be_ut_queue_10_100_5 (void)
 
void m0_be_ut_queue_10_1_100 (void)
 
void m0_be_ut_queue_10_5_100 (void)
 
void m0_be_ut_queue_10_100_100 (void)
 
void m0_be_ut_queue_from_1_to_10 (void)
 
void m0_be_ut_tx_usecase_success (void)
 
void m0_be_ut_tx_usecase_failure (void)
 
static void be_ut_tx_test (size_t nr)
 
static void be_ut_tx_alloc_init (void **alloc, struct m0_be_seg *seg)
 
static void be_ut_tx_alloc_fini (void **alloc)
 
static void * be_ut_tx_alloc (void **alloc, m0_bcount_t size)
 
void m0_be_ut_tx_states (void)
 
void m0_be_ut_tx_empty (void)
 
void m0_be_ut_tx_single (void)
 
void m0_be_ut_tx_several (void)
 
static void be_ut_transact (struct be_ut_tx_x *x, struct m0_be_seg *seg, void **alloc)
 
static void be_ut_tx_do_force (struct be_ut_tx_x *xs, size_t nr)
 
static void be_ut_tx_force (size_t nr)
 
void m0_be_ut_tx_force (void)
 
static void be_ut_tx_reg_rand (struct m0_be_reg *reg, struct m0_be_seg *seg, uint64_t *seed)
 
static void be_ut_tx_reg_rand_fill (struct m0_be_reg *reg, uint64_t *seed)
 
void m0_be_ut_tx_persistence (void)
 
static bool be_ut_tx_fast_cb (struct m0_clink *clink)
 
static void be_ut_tx_fast_gc_free (struct m0_be_tx *tx, void *param)
 
void m0_be_ut_tx_fast (void)
 
static void be_ut_tx_run_tx_helper (struct be_ut_tx_thread_state *state, struct m0_be_tx *tx, bool exclusive)
 
static void be_ut_tx_thread (struct be_ut_tx_thread_state *state)
 
void m0_be_ut_tx_concurrent_helper (bool exclusive)
 
void m0_be_ut_tx_concurrent (void)
 
void m0_be_ut_tx_concurrent_excl (void)
 
 M0_BASSERT (BE_UT_TX_CAPTURING_RANGE >=sizeof(uint64_t))
 
void m0_be_ut_tx_capturing (void)
 
static bool be_ut_tx_gc_cb (struct m0_clink *clink)
 
static void be_ut_tx_gc_free (struct m0_be_tx *tx, void *param)
 
static void be_ut_tx_gc_free_tx_failed (struct m0_be_tx *tx, void *param)
 
void m0_be_ut_tx_gc (void)
 
static void be_ut_tx_buf_fill_random (char *data, m0_bcount_t size)
 
static void be_ut_tx_payload_test_nr (struct m0_be_ut_backend *ut_be, struct be_ut_tx_payload_test *test, size_t nr)
 
void m0_be_ut_tx_payload (void)
 
static void be_ut_tx_bulk_test_init (struct be_ut_tx_bulk_be_ctx **be_ctx_out, struct be_ut_tx_bulk_be_cfg *be_cfg, void(*test_prepare)(struct m0_be_ut_backend *ut_be, struct m0_be_ut_seg *ut_seg, void *ptr), void *ptr)
 
static void be_ut_tx_bulk_test_fini (struct be_ut_tx_bulk_be_ctx *be_ctx)
 
static void be_ut_tx_bulk_test_run (struct be_ut_tx_bulk_be_ctx *be_ctx, struct m0_be_tx_bulk_cfg *tb_cfg, void(*test_work_put)(struct m0_be_tx_bulk *tb, bool success, void *ptr), void *ptr, bool success)
 
static void be_ut_tx_bulk_usecase_work_put (struct m0_be_tx_bulk *tb, bool success, void *ptr)
 
static void be_ut_tx_bulk_usecase_do (struct m0_be_tx_bulk *tb, struct m0_be_tx *tx, struct m0_be_op *op, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void be_ut_tx_bulk_usecase_done (struct m0_be_tx_bulk *tb, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void be_ut_tx_bulk_usecase_test_prepare (struct m0_be_ut_backend *ut_be, struct m0_be_ut_seg *ut_seg, void *ptr)
 
void m0_be_ut_tx_bulk_usecase (void)
 
static void be_ut_tx_bulk_state_calc (struct be_ut_tx_bulk_state *tbs, bool calc_cred, struct m0_be_tx_credit *cred, m0_bcount_t *cred_payload)
 
static void be_ut_tx_bulk_state_work_put (struct m0_be_tx_bulk *tb, bool success, void *ptr)
 
static void be_ut_tx_bulk_state_do (struct m0_be_tx_bulk *tb, struct m0_be_tx *tx, struct m0_be_op *op, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void be_ut_tx_bulk_state_done (struct m0_be_tx_bulk *tb, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void be_ut_tx_bulk_state_test_prepare (struct m0_be_ut_backend *ut_be, struct m0_be_ut_seg *ut_seg, void *ptr)
 
static void be_ut_tx_bulk_state_test_run (struct be_ut_tx_bulk_state *tbs, struct be_ut_tx_bulk_be_cfg *be_cfg, bool success)
 
void m0_be_ut_tx_bulk_empty (void)
 
void m0_be_ut_tx_bulk_error_reg (void)
 
void m0_be_ut_tx_bulk_error_payload (void)
 
void m0_be_ut_tx_bulk_large_tx (void)
 
void m0_be_ut_tx_bulk_large_payload (void)
 
void m0_be_ut_tx_bulk_large_all (void)
 
void m0_be_ut_tx_bulk_small_tx (void)
 
void m0_be_ut_tx_bulk_medium_tx (void)
 
void m0_be_ut_tx_bulk_medium_tx_multi (void)
 
void m0_be_ut_tx_bulk_medium_cred (void)
 
void m0_be_ut_tx_bulk_large_cred (void)
 
static void be_ut_tx_bulk_parallel_test_prepare (struct m0_be_ut_backend *ut_be, struct m0_be_ut_seg *ut_seg, void *ptr)
 
static void be_ut_tx_bulk_parallel_work_put (struct m0_be_tx_bulk *tb, bool success, void *ptr)
 
static void be_ut_tx_bulk_parallel_do (struct m0_be_tx_bulk *tb, struct m0_be_tx *tx, struct m0_be_op *op, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void be_ut_tx_bulk_parallel_done (struct m0_be_tx_bulk *tb, void *datum, void *user, uint64_t worker_index, uint64_t partition)
 
static void be_ut_tx_bulk_parallel_thread (void *_param)
 
void m0_be_ut_tx_bulk_parallel_1_15 (void)
 

Variables

enum m0_avi_be_labels M0_XCA_ENUM
 
enum { ... }  M0_XCA_DOMAIN
 
enum m0_be_alloc_zone_type M0_XCA_ENUM
 
enum { ... }  M0_XCA_DOMAIN
 
M0_INTERNAL const struct m0_fid_type m0_btree_fid_type
 
enum m0_be_btree_format_version M0_XCA_DOMAIN
 
enum m0_be_btree_type M0_XCA_ENUM
 
M0_EXTERN const struct m0_fid_type m0_btree_fid_type
 
enum m0_be_bnode_format_version M0_XCA_DOMAIN
 
static const struct m0_be_0type m0_be_0type_seg
 
static const struct m0_modlev levels_be_domain []
 
struct m0_be_domain_cfg M0_XCA_DOMAIN
 
enum { ... }  M0_XCA_DOMAIN
 
struct m0_fmt_xcode_ctx M0_XCA_DOMAIN
 
struct m0_be_fmt_log_store_header_cfg M0_XCA_DOMAIN
 
struct m0_be_io_part M0_XCA_DOMAIN
 
enum m0_be_list_op M0_XCA_DOMAIN
 
static const struct m0_modlev be_log_levels []
 
static const struct m0_modlev be_log_store_levels []
 
static struct m0_sm_state_descr op_states []
 
static struct m0_sm_trans_descr op_trans []
 
M0_INTERNAL struct m0_sm_conf op_states_conf
 
static const uint64_t BE_POOL_MAGIC_POISON = 0xCCCCCCCCCCCC
 
struct m0_be_reg M0_XCA_DOMAIN
 
enum m0_be_seg_hdr_format_version M0_XCA_DOMAIN
 
static const struct recops btreeops
 
static const struct recops bnodeops
 
static const struct recops seghdrops
 
static const struct action_ops done_ops
 
static const struct action_ops ctg_ops
 
static const struct action_ops cob_ops
 
static struct rectype rt []
 
static struct btype bt []
 
static struct scanner beck_scanner
 
static struct builder beck_builder
 
static struct gen g [MAX_GEN] = {}
 
static struct m0_be_seg s_seg = {}
 
static struct nv_offset_info nv_off_info
 
static struct offset_info off_info
 
static bool dry_run = false
 
static bool disable_directio = false
 
static bool signaled = false
 
static bool resume_scan = false
 
static bool mmap_be_segment = false
 
static const char * offset_file = NULL
 
static struct m0_be_tx_bulk_cfg default_tb_cfg
 
static char iobuf [4 *1024 *1024]
 
static const struct action_ops emap_ops
 
static struct m0_betool_common_ctx betool_common_ctx
 
static const char * betool_help
 
static const char * betool_st_event_descr []
 
static const ptrdiff_t be_tx_ast_offset [M0_BTS_NR+1]
 
static struct m0_sm_state_descr be_tx_states [M0_BTS_NR]
 
static struct m0_sm_trans_descr be_tx_sm_trans []
 
struct m0_sm_conf be_tx_sm_conf
 
M0_EXTERN struct m0_sm_conf op_states_conf
 
enum { ... }  M0_XCA_DOMAIN
 
const struct m0_be_tx_credit m0_be_tx_credit_invalid
 
const struct m0_be_tx_credit m0_be_tx_credit_invalid
 
static struct m0_sm_state_descr tx_group_fom_states [TGS_NR]
 
static const struct m0_sm_conf tx_group_fom_conf
 
static const struct m0_fom_ops tx_group_fom_ops
 
static struct m0_fom_type tx_group_fom_type
 
static const struct m0_fom_type_ops tx_group_fom_type_ops
 
static const struct m0_modlev be_group_format_levels []
 
static const struct m0_be_regmap_ops be_reg_area_ops_data_copy
 
static const struct m0_be_regmap_ops be_reg_area_ops_data_nocopy
 
static const struct m0_be_regmap_ops * be_reg_area_ops []
 
static const struct m0_reqh_service_type_ops txs_stype_ops
 
struct m0_reqh_service_type m0_be_txs_stype
 
static const struct m0_reqh_service_ops txs_ops
 
struct m0_reqh_service_type m0_be_txs_stype
 
static struct m0_be_io_sched be_ut_io_sched_scheduler
 
static struct be_ut_queue_cfg be_ut_queue_tests_cfg [BE_UT_QUEUE_NR]
 
static struct be_ut_gc_test be_ut_gc_tests [BE_UT_TX_GC_TX_NR]
 
static uint64_t be_ut_tx_payload_seed
 
struct tpool_test test []
 

Detailed Description

This file contains BE details visible to the user.

Definitions

Interfaces available for BE user

BE domain initialisation

Mkfs mode:

Normal (non-mkfs) mode:

In either case after successful initialisation BE domain is ready to work.

See also
m0_be_domain_cfg, m0_be_domain_seg_create().

Interface

** There are 3 top-level objects in this file:

** There are 8 functions for each top-level object:

** Encoding

** Decoding

** Encoding with preallocation

Interface is designed to provide encode() and mutator functions to be free of allocations/deallocations.

** General

** Decoding Memory is allocated using m0_alloc() wherever it is needed. There is no optimisation like preallocation.

** Encoding

*** Fixed size structures m0_be_fmt_log_header and m0_be_fmt_cblock have fixed size, so their init() (fini()) functions don't have m0_alloc() (m0_free()) calls.

*** Variable size structures m0_be_fmt_group may have different encoded size depending on number of elements (tx, regions etc.). Memory for maximum number of elements is allocated in init() function.

Design highlights:

m0_be_log_discard is an abstraction to keep seg I/O accounting and to control BE log records discard. m0_be_log_discard_item represents group's m0_be_log_record + seg I/O for the group.

Legend

Highlights

Future directions

Highlights

Future directions

 *                 m0_be_queue_put()
 *                        |
 *                        v
 *          +---+---+---+---+         +---+---+---+---+---+---+
 *    head  |   |   |   |   | bq_q    |   |   |   |   |   |   | bq_q_unused
 *          +---+---+---+---+         +---+---+---+---+---+---+
 *            |
 *            v
 *     m0_be_queue_get()
 *
 * 
 *                                                  m0_be_queue_put()
 *                                                           |
 *                                                           v
 *                                                         +---+  +---+
 *                                                         |   |<<|   |
 *          +---+---+---+---+---+---+---+---+---+---+      +---+  +---+
 *          |   |   |   |   |   |   |   |   |   |   | bq_q |   |<<|   |
 *          +---+---+---+---+---+---+---+---+---+---+      +---+  +---+
 *            |                                              ^      ^
 *            v                                         this one    |
 *     m0_be_queue_get()                                is still    |
*                                                       in bq_q     |
 *                                                                  |
 *                                                      bq_op_put list
 *                                                      items point to the
 *                                                      items that are in
 *                                                      the put wait list
 *

Further directions

Transaction engine.

Main abstractions provided by this module are: 

- transaction m0_be_tx: is a group of updates to BE segment memory,
  atomic w.r.t. BE failures. A transaction can update memory within
  multiple segments in the same m0_be_domain. A BE user creates a
  transaction and then updates segment memory. After each update, the
  updated memory is "captured" in the transaction by calling
  m0_be_tx_capture();

- transaction credit m0_be_tx_credit: an object describing an update to
  segment memory that a transaction could make. Before a memory update
  can be captured in a transaction, the transaction should be "prepared"
  (m0_be_tx_prep()) for all forthcoming captures. This preparation
  reserves internal transaction resources (log space and memory) to avoid
  dead-locks;

- transaction engine m0_be_tx_engine: is a part of BE domain that
  contains all transaction related state.

Overview of operation.

When a memory region is captured in a transaction, the contents of this region, i.e., new values placed in the memory by the user, are copied in a transaction-private memory buffer. Eventually the transaction is closed, i.e., the user indicates that no more updates will be captured in the transaction. Closed transactions are collected in "transaction groups" (m0_be_tx_group), which are units of IO. When a group is formed it is written to the log. When log IO for the group completes, transactions from the group are written "in-place", that is, their captured updates are written to the corresponding places in the segment storage. Some time after a transaction is written in-place, it is discarded and the space it uses in the log is reclaimed.

Notes: 

- transaction engine implements redo-only WAL (write-ahead logging).
  There is no way to abort a transaction;

- serializibility and concurrency concerns are delegated to a user.
  Specifically, the user must call m0_be_tx_capture() while the lock,
  protecting the memory being captured is held. In the current
  implementation this lock must be held at least until the transaction
  is closed, in the future this requirement will be weakened;

- currently, the transaction engine writes modified memory in place,
  as described in the "Overview of operation" section. In the future,
  the transaction engine would leave this task to the (currently
  non-existing) segment page daemon;

- transaction close call (m0_be_tx_close()) does not guarantee
  transaction persistence. Transaction will become persistent later.
  The user can set a call-back m0_be_tx::t_persistent() that is called
  when the transaction becomes persistent;

- transactions become persistent in the same order as they close.

tx_bulk is an abstraction that allows user to execute uniform transactions as fast as possible.

See also
m0_be_ut_tx_bulk_usecase() for an example.

Future directions

** Initialisation phase

** Common begin of the loop

** Normal operation (middle of the loop)

** Recovery operation (middle of the loop)

** Common end of the loop

** Finalisation phase

This file contains implementation details of BE features.

Table of contents

components

implemented by BE implementation

Todo:
Interface tester

regions lifecycle: capturing, seg and log I/O

design highligts

tasks

Legend: (-) - not implemented; (+) - implemented.

m0_be_fl maintains persistent lists of all free allocator chunks.

There is 3 operations with free lists:

Algorithm.

Time and I/O complexity.

Locks m0_be_fl doesn't have any locks. User has to provide concurrency protection.

Limitations.

Known issues.

Future improvement directions.

TODO remove lg_records list because it is not needed anymore.

Future directions

Known issues

Tests to add:

Further directions

Macro Definition Documentation

◆ _B

#define _B (   t,
  proc 
)    [t] = { .b_type = (t), .b_proc = (proc) }

Definition at line 457 of file beck.c.

◆ _FILE_OFFSET_BITS

#define _FILE_OFFSET_BITS   64 /* for fseeko */

Definition at line 29 of file beck.c.

◆ _FT

#define _FT (   name)    M0_FORMAT_TYPE_ ## name

Definition at line 421 of file beck.c.

◆ _T

#define _T (   name,
  str,
  field,
  ops 
)
Value:
[_FT(name)] = { \
.r_tag = { _TAG(name), { offsetof(struct str, field) } }, \
.r_ops = (ops) \
}
name
const char * name
Definition: trace.c:110
field
static int field(struct ff2c_context *ctx, struct ff2c_term *term)
Definition: parser.c:84
_TAG
#define _TAG(name)
Definition: beck.c:422
_FT
#define _FT(name)
Definition: beck.c:421
ops
struct m0_fom_ops ops
Definition: io_foms.c:623
offsetof
#define offsetof(typ, memb)
Definition: misc.h:29

Definition at line 423 of file beck.c.

◆ _TAG

#define _TAG (   name)    M0_ ## name ## _FORMAT_VERSION , _FT(name)

Definition at line 422 of file beck.c.

◆ ARRAY_ALLOC_NZ

#define ARRAY_ALLOC_NZ (   arr,
  nr 
)    ((arr) = m0_alloc_nz((nr) * sizeof ((arr)[0])))

Definition at line 205 of file tx_regmap.c.

◆ BE_DOMAIN_LEVEL

#define BE_DOMAIN_LEVEL (   level)
Value:
[level] = { \
.ml_name = #level, \
.ml_enter = be_domain_level_enter, \
.ml_leave = be_domain_level_leave, \
}
level
enum m0_trace_level level
Definition: trace.c:111
be_domain_level_leave
static void be_domain_level_leave(struct m0_module *module)
Definition: domain.c:836
be_domain_level_enter
static int be_domain_level_enter(struct m0_module *module)
Definition: domain.c:665

Definition at line 924 of file domain.c.

◆ BE_IOCRED_F

#define BE_IOCRED_F
Value:
"(reg_nr=%" PRIu64 " reg_size=%" PRIu64 \
" part_nr=%" PRIu64 ")"
PRIu64
#define PRIu64
Definition: types.h:58

Definition at line 82 of file io.h.

◆ BE_IOCRED_P

#define BE_IOCRED_P (   iocred)    (iocred)->bic_reg_nr, (iocred)->bic_reg_size, (iocred)->bic_part_nr

Definition at line 84 of file io.h.

◆ BE_QUEUE_ITEM2BUF

#define BE_QUEUE_ITEM2BUF (   bq,
  bqi 
)    M0_BUF_INIT((bq)->bq_cfg.bqc_item_length, &(bqi)->bqi_data)

Definition at line 50 of file queue.c.

◆ BE_TX_LOCKED_AT_STATE

#define BE_TX_LOCKED_AT_STATE (   tx,
  states 
)
Value:
({ \
const struct m0_be_tx *__tx = (tx); \
\
_0C(be_tx_is_locked(__tx)) && m0_be_tx__invariant(__tx) && \
_0C(M0_IN(m0_be_tx_state(__tx), states)); \
})
m0_be_tx_state
M0_INTERNAL enum m0_be_tx_state m0_be_tx_state(const struct m0_be_tx *tx)
Definition: tx.c:412
_0C
#define _0C(exp)
Definition: assert.h:311
be_tx_is_locked
static bool be_tx_is_locked(const struct m0_be_tx *tx)
Definition: tx.c:561
m0_be_tx__invariant
M0_INTERNAL bool m0_be_tx__invariant(const struct m0_be_tx *tx)
Definition: tx.c:555
states
static struct m0_sm_state_descr states[C_NR]
Definition: sm.c:512
m0_be_tx
Definition: tx.h:280

Definition at line 58 of file tx.c.

◆ BE_UT_QUEUE_TEST

#define BE_UT_QUEUE_TEST (   q_size_max,
  producers,
  consumers,
  items_nr 
)
Value:
{ \
.butc_q_size_max = (q_size_max), \
.butc_producers = (producers), \
.butc_consumers = (consumers), \
.butc_items_nr = (items_nr) \
}

Definition at line 119 of file queue.c.

◆ BEQ_F

#define BEQ_F
Value:
"(queue=%p bq_enqueued=%" PRIu64 " bq_dequeued=%" PRIu64 " " \
"bq_the_end=%d)"
PRIu64
#define PRIu64
Definition: types.h:58

Definition at line 168 of file queue.h.

◆ BEQ_P

#define BEQ_P (   bq)
Value:
(bq), (bq)->bq_enqueued, (bq)->bq_dequeued, \
!!((bq)->bq_the_end)

Definition at line 170 of file queue.h.

◆ BETXCR_F

#define BETXCR_F   "(%lu,%lu)"

Format for the printf() family functions.

See also
BETXCR_P

Definition at line 102 of file tx_credit.h.

◆ BETXCR_P

#define BETXCR_P (   c)
Value:
(unsigned long)(c)->tc_reg_nr, \
(unsigned long)(c)->tc_reg_size
c
static struct m0_addb2_callback c
Definition: consumer.c:41

Example:

struct m0_be_tx_credit cred;
...
printf("cred = " BETXCR_F "\n", BETXCR_P(&cred));

Definition at line 113 of file tx_credit.h.

◆ BFLH_F

#define BFLH_F
Value:
"(flh_serial=%" PRIu64 " flh_discarded=%" PRIu64 " " \
"flh_group_lsn=%" PRIu64 " flh_group_size=%" PRIu64 ")"
PRIu64
#define PRIu64
Definition: types.h:58

Definition at line 209 of file fmt.h.

◆ BFLH_P

#define BFLH_P (   log_hdr)
Value:
(log_hdr)->flh_serial, (log_hdr)->flh_discarded, \
(log_hdr)->flh_group_lsn, (log_hdr)->flh_group_size
flh_group_lsn
m0_bindex_t flh_group_lsn
Definition: fmt.h:92
flh_serial
uint64_t flh_serial
Definition: fmt.h:90

Definition at line 211 of file fmt.h.

◆ BFLRH_F

#define BFLRH_F
Value:
"(pos=%" PRIu64 " size=%" PRIu64 " discarded=%" PRIu64 " " \
"prev_pos=%" PRIu64 " prev_size=%" PRIu64 \
" io_nr_max=%" PRIu64 ")"
PRIu64
#define PRIu64
Definition: types.h:58

Definition at line 268 of file fmt.h.

◆ BFLRH_P

#define BFLRH_P (   h)
Value:
(h)->lrh_pos, (h)->lrh_size, (h)->lrh_discarded, \
(h)->lrh_prev_pos, (h)->lrh_prev_size, \
(h)->lrh_io_nr_max
lrh_pos
m0_bindex_t lrh_pos
Definition: fmt.h:228
lrh_prev_size
m0_bindex_t lrh_prev_size
Definition: fmt.h:232
lrh_discarded
m0_bindex_t lrh_discarded
Definition: fmt.h:230

Definition at line 271 of file fmt.h.

◆ BL_F

#define BL_F
Value:
"(lg_current=%" PRIu64 " lg_discarded=%" PRIu64 \
" lg_free=%" PRIu64 ")"
PRIu64
#define PRIu64
Definition: types.h:58

Definition at line 318 of file log.h.

◆ BL_P

#define BL_P (   log)    (log)->lg_current, (log)->lg_discarded, (log)->lg_free

Definition at line 320 of file log.h.

◆ BLR_F

#define BLR_F
Value:
"(lgr_last_discarded=%" PRIu64 " lgr_position=%" PRIu64 " " \
"lgr_size=%" PRIu64 " " \
"lgr_prev_pos=%" PRIu64 " lgr_prev_size=%" PRIu64 ")"
PRIu64
#define PRIu64
Definition: types.h:58

Definition at line 378 of file log.h.

◆ BLR_P

#define BLR_P (   record)
Value:
(record)->lgr_last_discarded, (record)->lgr_position, \
(record)->lgr_size, \
(record)->lgr_prev_pos, (record)->lgr_prev_size
record
Definition: record.py:1

Definition at line 381 of file log.h.

◆ BTBI_F

#define BTBI_F
Value:
"(qdata=%p bbd_user=%p bbd_credit="BETXCR_F" " \
"bbd_payload_size=%" PRIu64 ")"
BETXCR_F
#define BETXCR_F
Definition: tx_credit.h:102
PRIu64
#define PRIu64
Definition: types.h:58

Definition at line 97 of file tx_bulk.c.

◆ BTBI_P

#define BTBI_P (   btbi)
Value:
(btbi), (btbi)->bbd_user, BETXCR_P(&(btbi)->bbd_credit), \
(btbi)->bbd_payload_size
BETXCR_P
#define BETXCR_P(c)
Definition: tx_credit.h:113

Definition at line 100 of file tx_bulk.c.

◆ CFG

#define CFG (   tx_nr_max,
  reg_nr_max,
  payload_sz_max,
  ra_sz_max 
)
Value:
(const struct m0_be_fmt_group_cfg) { \
.fgc_tx_nr_max = tx_nr_max, \
.fgc_reg_nr_max = reg_nr_max, \
.fgc_payload_size_max = payload_sz_max, \
.fgc_reg_size_max = ra_sz_max, \
}
m0_be_fmt_group_cfg
Definition: fmt.h:237

Definition at line 250 of file fmt.c.

◆ FLOG

#define FLOG (   level,
  rc,
  s 
)
Value:
M0_LOG(level, " rc=%d at offset: %" PRId64 " errno: %s (%i), eof: %i", \
(rc), (uint64_t)ftell(s->s_file), strerror(errno), \
errno, feof(s->s_file))
M0_LOG
#define M0_LOG(level,...)
Definition: trace.h:167
level
enum m0_trace_level level
Definition: trace.c:111
PRId64
#define PRId64
Definition: types.h:57
s
static struct m0_addb2_source * s
Definition: consumer.c:39
rc
int32_t rc
Definition: trigger_fop.h:47

Definition at line 547 of file beck.c.

◆ gft_fmt_group_choose

#define gft_fmt_group_choose (   gft)
Value:
(gft->gft_fmt_group_decoded != NULL ? \
gft->gft_fmt_group_decoded : \
&gft->gft_fmt_group)
NULL
#define NULL
Definition: misc.h:38

Definition at line 46 of file tx_group_format.c.

◆ M0_BE_ALLOC_ARR

#define M0_BE_ALLOC_ARR (   arr,
  nr,
  seg,
  tx,
  op 
)
Value:
m0_be_alloc(m0_be_seg_allocator(seg), (tx), (op), \
(void **)&(arr), (nr) * sizeof((arr)[0]))
nr
static size_t nr
Definition: dump.c:1505
op
op
Definition: libdemo.c:64
m0_be_seg_allocator
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator(struct m0_be_seg *seg)
Definition: stubs.c:113
m0_be_alloc
M0_INTERNAL void m0_be_alloc(struct m0_be_allocator *a, struct m0_be_tx *tx, struct m0_be_op *op, void **ptr, m0_bcount_t size)
Definition: alloc.c:1091
seg
static struct m0_be_seg * seg
Definition: btree.c:40

Allocate array of structures.

It is a wrapper around m0_be_alloc().

See also
m0_be_alloc(), M0_ALLOC_ARR().

Definition at line 322 of file alloc.h.

◆ M0_BE_ALLOC_ARR_SYNC

#define M0_BE_ALLOC_ARR_SYNC (   arr,
  nr,
  seg,
  tx 
)
Value:
M0_BE_OP_SYNC(__op, \
M0_BE_ALLOC_ARR((arr), (nr), (seg), (tx), &__op))
nr
static size_t nr
Definition: dump.c:1505
M0_BE_OP_SYNC
#define M0_BE_OP_SYNC(op_obj, action)
Definition: op.h:190
M0_BE_ALLOC_ARR
#define M0_BE_ALLOC_ARR(arr, nr, seg, tx, op)
Definition: alloc.h:322
seg
static struct m0_be_seg * seg
Definition: btree.c:40

Definition at line 335 of file alloc.h.

◆ M0_BE_ALLOC_BUF

#define M0_BE_ALLOC_BUF (   buf,
  seg,
  tx,
  op 
)
Value:
m0_be_alloc(m0_be_seg_allocator(seg), (tx), (op), \
&(buf)->b_addr, (buf)->b_nob)
buf
Definition: sock.c:887
op
op
Definition: libdemo.c:64
b_addr
void * b_addr
Definition: buf.h:231
m0_be_seg_allocator
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator(struct m0_be_seg *seg)
Definition: stubs.c:113
m0_be_alloc
M0_INTERNAL void m0_be_alloc(struct m0_be_allocator *a, struct m0_be_tx *tx, struct m0_be_op *op, void **ptr, m0_bcount_t size)
Definition: alloc.c:1091
seg
static struct m0_be_seg * seg
Definition: btree.c:40
b_nob
m0_bcount_t b_nob
Definition: buf.h:230

Definition at line 348 of file alloc.h.

◆ M0_BE_ALLOC_BUF_SYNC

#define M0_BE_ALLOC_BUF_SYNC (   buf,
  seg,
  tx 
)    M0_BE_OP_SYNC(__op, M0_BE_ALLOC_BUF((buf), (seg), (tx), &__op))

Definition at line 352 of file alloc.h.

◆ M0_BE_ALLOC_CREDIT_ARR

#define M0_BE_ALLOC_CREDIT_ARR (   arr,
  nr,
  seg,
  accum 
)
Value:
m0_be_allocator_credit(m0_be_seg_allocator(seg), \
M0_BAO_ALLOC, (nr) * sizeof((arr)[0]), 0, (accum))
nr
static size_t nr
Definition: dump.c:1505
M0_BAO_ALLOC
Definition: alloc.h:199
m0_be_seg_allocator
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator(struct m0_be_seg *seg)
Definition: stubs.c:113
seg
static struct m0_be_seg * seg
Definition: btree.c:40
m0_be_allocator_credit
M0_INTERNAL void m0_be_allocator_credit(struct m0_be_allocator *a, enum m0_be_allocator_op optype, m0_bcount_t size, unsigned shift, struct m0_be_tx_credit *accum)
Definition: alloc.c:900

Definition at line 363 of file alloc.h.

◆ M0_BE_ALLOC_CREDIT_BUF

#define M0_BE_ALLOC_CREDIT_BUF (   buf,
  seg,
  accum 
)
Value:
m0_be_allocator_credit(m0_be_seg_allocator(seg), \
M0_BAO_ALLOC, (buf)->b_nob, 0, (accum))
M0_BAO_ALLOC
Definition: alloc.h:199
buf
Definition: sock.c:887
m0_be_seg_allocator
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator(struct m0_be_seg *seg)
Definition: stubs.c:113
seg
static struct m0_be_seg * seg
Definition: btree.c:40
m0_be_allocator_credit
M0_INTERNAL void m0_be_allocator_credit(struct m0_be_allocator *a, enum m0_be_allocator_op optype, m0_bcount_t size, unsigned shift, struct m0_be_tx_credit *accum)
Definition: alloc.c:900
b_nob
m0_bcount_t b_nob
Definition: buf.h:230

Definition at line 371 of file alloc.h.

◆ M0_BE_ALLOC_CREDIT_PTR

#define M0_BE_ALLOC_CREDIT_PTR (   ptr,
  seg,
  accum 
)
Value:
m0_be_allocator_credit(m0_be_seg_allocator(seg), \
M0_BAO_ALLOC, sizeof *(ptr), 0, (accum))
ptr
static void ptr(struct m0_addb2__context *ctx, const uint64_t *v, char *buf)
Definition: dump.c:440
M0_BAO_ALLOC
Definition: alloc.h:199
m0_be_seg_allocator
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator(struct m0_be_seg *seg)
Definition: stubs.c:113
seg
static struct m0_be_seg * seg
Definition: btree.c:40
m0_be_allocator_credit
M0_INTERNAL void m0_be_allocator_credit(struct m0_be_allocator *a, enum m0_be_allocator_op optype, m0_bcount_t size, unsigned shift, struct m0_be_tx_credit *accum)
Definition: alloc.c:900

Definition at line 355 of file alloc.h.

◆ M0_BE_ALLOC_PTR

#define M0_BE_ALLOC_PTR (   ptr,
  seg,
  tx,
  op 
)    M0_BE_ALLOC_ARR((ptr), 1, (seg), (tx), (op))

Allocate structure.

It is a wrapper around m0_be_alloc().

See also
m0_be_alloc(), M0_ALLOC_PTR(), M0_BE_ALLOC_ARR().

Definition at line 332 of file alloc.h.

◆ M0_BE_ALLOC_PTR_SYNC

#define M0_BE_ALLOC_PTR_SYNC (   ptr,
  seg,
  tx 
)    M0_BE_OP_SYNC(__op, M0_BE_ALLOC_PTR((ptr), (seg), (tx), &__op))

Definition at line 339 of file alloc.h.

◆ M0_BE_CREDIT_DEC

#define M0_BE_CREDIT_DEC (   cr_user,
  tx 
)

Definition at line 465 of file tx.h.

◆ M0_BE_CREDIT_INC

#define M0_BE_CREDIT_INC (   n,
  cr_user,
  credit 
)

Definition at line 464 of file tx.h.

◆ M0_BE_FMT_DECLARE

#define M0_BE_FMT_DECLARE (   name)
Value:
struct m0_be_fmt_##name; \
struct m0_be_fmt_##name##_cfg; \
M0_INTERNAL int \
m0_be_fmt_##name##_init(struct m0_be_fmt_##name *obj, \
const struct m0_be_fmt_##name##_cfg *cfg); \
M0_INTERNAL void m0_be_fmt_##name##_fini(struct m0_be_fmt_##name *obj); \
M0_INTERNAL void m0_be_fmt_##name##_reset(struct m0_be_fmt_##name *obj); \
M0_INTERNAL m0_bcount_t \
m0_be_fmt_##name##_size(struct m0_be_fmt_##name *obj); \
M0_INTERNAL m0_bcount_t \
m0_be_fmt_##name##_size_max(const struct m0_be_fmt_##name##_cfg *cfg); \
M0_INTERNAL int m0_be_fmt_##name##_encode(struct m0_be_fmt_##name *obj, \
struct m0_bufvec_cursor *cur); \
M0_INTERNAL int m0_be_fmt_##name##_encode_buf(struct m0_be_fmt_##name *obj, \
struct m0_buf *buf); \
M0_INTERNAL int \
m0_be_fmt_##name##_decode(struct m0_be_fmt_##name **obj, \
struct m0_bufvec_cursor *cur, \
const struct m0_be_fmt_decode_cfg *cfg); \
M0_INTERNAL int \
m0_be_fmt_##name##_decode_buf(struct m0_be_fmt_##name **obj, \
struct m0_buf *buf, \
const struct m0_be_fmt_decode_cfg *cfg); \
M0_INTERNAL void m0_be_fmt_##name##_decoded_free(struct m0_be_fmt_##name *obj)
cur
static struct buffer * cur(struct m0_addb2_mach *mach, m0_bcount_t space)
Definition: addb2.c:791
_fini
static void _fini(void)
Definition: ub.c:456
m0_be_fmt_decode_cfg
Definition: fmt.h:279
_reset
static void _reset(void)
Definition: module.c:147
obj
static struct foo * obj
Definition: tlist.c:302
buf
Definition: sock.c:887
m0_buf
Definition: buf.h:37
name
const char * name
Definition: trace.c:110
m0_bufvec_cursor
Definition: vec.h:319
_encode
static int _encode(size_t *n, struct m0_confx *enc, const struct m0_conf_obj *obj)
Definition: confd_fom.c:158
_init
static void _init(bool mkfs, bool use_small_credits)
Definition: service_ut.c:137

Definition at line 306 of file fmt.h.

◆ M0_BE_FMT_DECODE_CFG_DEFAULT

#define M0_BE_FMT_DECODE_CFG_DEFAULT
Value:
(&(const struct m0_be_fmt_decode_cfg) { \
.dc_group_size_max = 1 << 24, \
.dc_iter = NULL, \
.dc_iter_end = NULL, \
})
NULL
#define NULL
Definition: misc.h:38
m0_be_fmt_decode_cfg
Definition: fmt.h:279

Definition at line 291 of file fmt.h.

◆ M0_BE_FMT_DECODE_CFG_DEFAULT_WITH_TRACE

#define M0_BE_FMT_DECODE_CFG_DEFAULT_WITH_TRACE
Value:
(&(const struct m0_be_fmt_decode_cfg) { \
.dc_group_size_max = 1 << 24, \
.dc_iter = m0_be_fmt_type_trace, \
.dc_iter_end = m0_be_fmt_type_trace_end, \
})
m0_be_fmt_decode_cfg
Definition: fmt.h:279
m0_be_fmt_type_trace_end
M0_INTERNAL void m0_be_fmt_type_trace_end(const struct m0_xcode_cursor *it)
Definition: fmt.c:213
m0_be_fmt_type_trace
M0_INTERNAL int m0_be_fmt_type_trace(const struct m0_xcode_cursor *it)
Definition: fmt.c:218

Definition at line 298 of file fmt.h.

◆ M0_BE_FMT_DEFINE_INIT_SIMPLE

#define M0_BE_FMT_DEFINE_INIT_SIMPLE (   name)
Value:
M0_INTERNAL int \
m0_be_fmt_##name##_init(struct m0_be_fmt_##name *obj, \
const struct m0_be_fmt_##name##_cfg *cfg) \
{ \
return 0; \
} \
M0_INTERNAL void m0_be_fmt_##name##_fini(struct m0_be_fmt_##name *obj) \
{} \
M0_INTERNAL void m0_be_fmt_##name##_reset(struct m0_be_fmt_##name *obj) \
{} \
M0_INTERNAL m0_bcount_t \
m0_be_fmt_##name##_size_max(const struct m0_be_fmt_##name##_cfg *cfg) \
{ \
return m0_be_fmt_##name##_size(NULL); \
}
NULL
#define NULL
Definition: misc.h:38
_fini
static void _fini(void)
Definition: ub.c:456
_reset
static void _reset(void)
Definition: module.c:147
obj
static struct foo * obj
Definition: tlist.c:302
name
const char * name
Definition: trace.c:110
_init
static void _init(bool mkfs, bool use_small_credits)
Definition: service_ut.c:137

Definition at line 503 of file fmt.c.

◆ M0_BE_FMT_DEFINE_XCODE

#define M0_BE_FMT_DEFINE_XCODE (   name)

Definition at line 520 of file fmt.c.

◆ M0_BE_FMT_REG

#define M0_BE_FMT_REG (   size,
  addr,
  buf 
)
Value:
(struct m0_be_fmt_reg){ \
.fr_size = (size), \
.fr_addr = (addr), \
.fr_buf = (buf), \
}
m0_be_fmt_reg
Definition: fmt.h:343
buf
static int void * buf
Definition: dir.c:1019
addr
Definition: xcode.h:73
m0_be_fmt_reg::fr_addr
void * fr_addr
Definition: fmt.h:345
size
m0_bcount_t size
Definition: di.c:39

Definition at line 349 of file fmt.h.

◆ M0_BE_FMT_TX

#define M0_BE_FMT_TX (   payload,
  id 
)
Value:
(struct m0_be_fmt_tx){ \
.bft_payload = (payload), \
.bft_id = (id), \
}
m0_be_fmt_tx
Definition: fmt.h:363
m0_be_fmt_tx::bft_id
uint64_t bft_id
Definition: fmt.h:365
payload
const uint64_t payload[]
Definition: base.c:65

Definition at line 368 of file fmt.h.

◆ M0_BE_FREE_CREDIT_ARR

#define M0_BE_FREE_CREDIT_ARR (   arr,
  nr,
  seg,
  accum 
)
Value:
m0_be_allocator_credit(m0_be_seg_allocator(seg), \
M0_BAO_FREE, (nr) * sizeof((arr)[0]), 0, (accum))
nr
static size_t nr
Definition: dump.c:1505
M0_BAO_FREE
Definition: alloc.h:201
m0_be_seg_allocator
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator(struct m0_be_seg *seg)
Definition: stubs.c:113
seg
static struct m0_be_seg * seg
Definition: btree.c:40
m0_be_allocator_credit
M0_INTERNAL void m0_be_allocator_credit(struct m0_be_allocator *a, enum m0_be_allocator_op optype, m0_bcount_t size, unsigned shift, struct m0_be_tx_credit *accum)
Definition: alloc.c:900

Definition at line 367 of file alloc.h.

◆ M0_BE_FREE_CREDIT_PTR

#define M0_BE_FREE_CREDIT_PTR (   ptr,
  seg,
  accum 
)
Value:
m0_be_allocator_credit(m0_be_seg_allocator(seg), \
M0_BAO_FREE, sizeof *(ptr), 0, (accum))
ptr
static void ptr(struct m0_addb2__context *ctx, const uint64_t *v, char *buf)
Definition: dump.c:440
M0_BAO_FREE
Definition: alloc.h:201
m0_be_seg_allocator
M0_INTERNAL struct m0_be_allocator * m0_be_seg_allocator(struct m0_be_seg *seg)
Definition: stubs.c:113
seg
static struct m0_be_seg * seg
Definition: btree.c:40
m0_be_allocator_credit
M0_INTERNAL void m0_be_allocator_credit(struct m0_be_allocator *a, enum m0_be_allocator_op optype, m0_bcount_t size, unsigned shift, struct m0_be_tx_credit *accum)
Definition: alloc.c:900

Definition at line 359 of file alloc.h.

◆ M0_BE_FREE_PTR

#define M0_BE_FREE_PTR (   ptr,
  seg,
  tx,
  op 
)    m0_be_free(m0_be_seg_allocator(seg), (tx), (op), (ptr))

Definition at line 342 of file alloc.h.

◆ M0_BE_FREE_PTR_SYNC

#define M0_BE_FREE_PTR_SYNC (   ptr,
  seg,
  tx 
)    M0_BE_OP_SYNC(__op, M0_BE_FREE_PTR((ptr), (seg), (tx), &__op))

Definition at line 345 of file alloc.h.

◆ M0_BE_IO_CREDIT

#define M0_BE_IO_CREDIT (   reg_nr,
  reg_size,
  part_nr 
)
Value:
(struct m0_be_io_credit){ \
.bic_reg_nr = (reg_nr), \
.bic_reg_size = (reg_size), \
.bic_part_nr = (part_nr), \
}
m0_be_io_credit
Definition: io.h:70
m0_be_io_credit::bic_reg_size
m0_bcount_t bic_reg_size
Definition: io.h:72

Definition at line 76 of file io.h.

◆ M0_BE_LIST_DECLARE

#define M0_BE_LIST_DECLARE (   name,
  scope,
  amb_type 
)

Declaration of typed functions.

Definition at line 211 of file list.h.

◆ M0_BE_LIST_DEFINE

#define M0_BE_LIST_DEFINE (   name,
  scope,
  amb_type 
)

Definition of typed functions.

Definition at line 253 of file list.h.

◆ M0_BE_LIST_DESCR

#define M0_BE_LIST_DESCR (   name,
  amb_type,
  link_field,
  magic_field,
  link_magic,
  head_magic 
)
Value:
{ \
.bld_name = name, \
.bld_link_offset = offsetof(amb_type, link_field), \
.bld_link_magic_offset = offsetof(amb_type, magic_field), \
.bld_link_magic = link_magic, \
.bld_head_magic = head_magic, \
.bld_container_size = sizeof(amb_type), \
}; \
M0_BASSERT(M0_HAS_TYPE(M0_FIELD_VALUE(amb_type, link_field), \
struct m0_be_list_link)); \
M0_BASSERT(M0_HAS_TYPE(M0_FIELD_VALUE(amb_type, magic_field), \
uint64_t))
M0_FIELD_VALUE
#define M0_FIELD_VALUE(type, field)
Definition: misc.h:339
m0_be_list_link
Definition: list.h:66
M0_HAS_TYPE
#define M0_HAS_TYPE(expr, type)
Definition: misc.h:344
name
const char * name
Definition: trace.c:110
offsetof
#define offsetof(typ, memb)
Definition: misc.h:29

Initialisator for BE list descriptor.

Definition at line 184 of file list.h.

◆ M0_BE_LIST_DESCR_DEFINE

#define M0_BE_LIST_DESCR_DEFINE (   name,
  hname,
  scope,
  amb_type,
  link_field,
  magic_field,
  link_magic,
  head_magic 
)
Value:
scope const struct m0_be_list_descr name ## _be_list_d = \
M0_BE_LIST_DESCR(hname, amb_type, link_field, magic_field, \
link_magic, head_magic)
name
const char * name
Definition: trace.c:110
m0_be_list_descr
Definition: list.h:57

Definition of BE list descriptor.

Definition at line 202 of file list.h.

◆ m0_be_list_endfor

#define m0_be_list_endfor   ;(void)__bl; } while (0)

Definition at line 369 of file list.h.

◆ m0_be_list_for

#define m0_be_list_for (   name,
  head,
  obj 
)
Value:
do { \
const struct m0_be_list_descr *__descr = &name ## _be_list_d; \
void *__bl; \
struct m0_be_list *__head = (head); \
\
for (obj = m0_be_list_head(__head, __descr); \
obj != NULL && \
((void)(__bl = m0_be_list_next(__head, __descr, obj)), true); \
obj = __bl)
NULL
#define NULL
Definition: misc.h:38
m0_be_list_head
M0_INTERNAL void * m0_be_list_head(struct m0_be_list *blist, const struct m0_be_list_descr *descr)
Definition: list.c:259
m0_be_list_next
M0_INTERNAL void * m0_be_list_next(struct m0_be_list *blist, const struct m0_be_list_descr *descr, const void *obj)
Definition: list.c:300
obj
static struct foo * obj
Definition: tlist.c:302
head
static int head(struct m0_sm *mach)
Definition: sm.c:468
name
const char * name
Definition: trace.c:110
m0_be_list_descr
Definition: list.h:57
m0_be_list
Definition: list.h:76

Definition at line 358 of file list.h.

◆ m0_be_list_forall

#define m0_be_list_forall (   name,
  var,
  head,
  ... 
)
Value:
({ \
void *var; \
\
m0_be_list_for(name, head, var) { \
if (!({ __VA_ARGS__ ; })) \
break; \
} m0_be_list_endfor; \
var == NULL; \
})
NULL
#define NULL
Definition: misc.h:38
head
static int head(struct m0_sm *mach)
Definition: sm.c:468
name
const char * name
Definition: trace.c:110
m0_be_list_endfor
#define m0_be_list_endfor
Definition: list.h:369
m0_be_list_for
#define m0_be_list_for(name, head, obj)
Definition: list.h:358

Definition at line 371 of file list.h.

◆ M0_BE_OP_SYNC

#define M0_BE_OP_SYNC (   op_obj,
  action 
)
Value:
({ \
struct m0_be_op op_obj = {}; \
M0_BE_OP_SYNC_WITH(&op_obj, action); \
})
action
Definition: beck.c:189
m0_be_op
Definition: op.h:74

Performs the action, waiting for its completion.

Example:

M0_BE_OP_SYNC(op, m0_be_btree_destroy(tree, tx, &op));
M0_BE_OP_SYNC(op, rc = m0_fol_init(fol, seg, tx, &op));

Definition at line 190 of file op.h.

◆ M0_BE_OP_SYNC_RC

#define M0_BE_OP_SYNC_RC (   op_obj,
  action 
)
Value:
({ \
struct m0_be_op op_obj = {}; \
M0_BE_OP_SYNC_WITH_RC(&op_obj, action); \
})
action
Definition: beck.c:189
m0_be_op
Definition: op.h:74

Definition at line 196 of file op.h.

◆ M0_BE_OP_SYNC_RET

#define M0_BE_OP_SYNC_RET (   op_obj,
  action,
  member 
)
Value:
({ \
struct m0_be_op op_obj = {}; \
M0_BE_OP_SYNC_RET_WITH(&op_obj, action, member); \
})
action
Definition: beck.c:189
m0_be_op
Definition: op.h:74

Performs the action, waits for its completion, and returns result of operation.

Example:

int rc;
rc = M0_BE_OP_SYNC_RET(op, m0_be_btree_create(tree, tx, &op),
bo_u.u_btree.t_rc);

Definition at line 243 of file op.h.

◆ M0_BE_OP_SYNC_RET_WITH

#define M0_BE_OP_SYNC_RET_WITH (   op,
  action,
  member 
)
Value:
({ \
struct m0_be_op *__opp = (op); \
typeof(__opp->member) __result; \
\
m0_be_op_init(__opp); \
action; \
m0_be_op_wait(__opp); \
__result = __opp->member; \
m0_be_op_fini(__opp); \
__result; \
})
action
Definition: beck.c:189
op
op
Definition: libdemo.c:64
m0_be_op_fini
M0_INTERNAL void m0_be_op_fini(struct m0_be_op *op)
Definition: stubs.c:92
m0_be_op
Definition: op.h:74
m0_be_op_init
M0_INTERNAL void m0_be_op_init(struct m0_be_op *op)
Definition: stubs.c:87
m0_be_op_wait
M0_INTERNAL void m0_be_op_wait(struct m0_be_op *op)
Definition: stubs.c:96

Similar to M0_BE_OP_SYNC_RET, but works with a caller-supplied operation structure.

Definition at line 253 of file op.h.

◆ M0_BE_OP_SYNC_WITH

#define M0_BE_OP_SYNC_WITH (   op,
  action 
)
Value:
({ \
struct m0_be_op *__opp = (op); \
\
m0_be_op_init(__opp); \
action; \
m0_be_op_wait(__opp); \
m0_be_op_fini(__opp); \
})
op
op
Definition: libdemo.c:64
m0_be_op
Definition: op.h:74
m0_be_op_init
M0_INTERNAL void m0_be_op_init(struct m0_be_op *op)
Definition: stubs.c:87

Similar to M0_BE_OP_SYNC, but works with a caller-supplied operation structure.

Definition at line 207 of file op.h.

◆ M0_BE_OP_SYNC_WITH_RC

#define M0_BE_OP_SYNC_WITH_RC (   op,
  action 
)
Value:
({ \
struct m0_be_op *__opp = (op); \
int __op_rc; \
\
m0_be_op_init(__opp); \
action; \
m0_be_op_wait(__opp); \
__op_rc = m0_be_op_rc(__opp); \
m0_be_op_fini(__opp); \
__op_rc; \
})
m0_be_op_rc
M0_INTERNAL int m0_be_op_rc(struct m0_be_op *op)
Definition: op.c:324
op
op
Definition: libdemo.c:64
m0_be_op
Definition: op.h:74
m0_be_op_init
M0_INTERNAL void m0_be_op_init(struct m0_be_op *op)
Definition: stubs.c:87

Definition at line 217 of file op.h.

◆ M0_BE_POOL_DEFINE

#define M0_BE_POOL_DEFINE (   name,
  scope,
  amb_type 
)

Definition at line 141 of file pool.h.

◆ M0_BE_POOL_DESCR

#define M0_BE_POOL_DESCR (   hname,
  amb_type,
  pool_field,
  pool_magic_field,
  pool_magic 
)
Value:
{ \
.bpld_name = hname, \
.bpld_item_offset = offsetof(amb_type, pool_field), \
.bpld_magic_offset = offsetof(amb_type, pool_magic_field), \
.bpld_magic = pool_magic, \
}; \
M0_BASSERT(M0_HAS_TYPE(M0_FIELD_VALUE(amb_type, pool_field), \
struct m0_be_pool_item)); \
M0_BASSERT(M0_HAS_TYPE(M0_FIELD_VALUE(amb_type, pool_magic_field), \
uint64_t))
M0_FIELD_VALUE
#define M0_FIELD_VALUE(type, field)
Definition: misc.h:339
M0_HAS_TYPE
#define M0_HAS_TYPE(expr, type)
Definition: misc.h:344
m0_be_pool_item
Definition: pool.h:77
offsetof
#define offsetof(typ, memb)
Definition: misc.h:29

Definition at line 122 of file pool.h.

◆ M0_BE_POOL_DESCR_DEFINE

#define M0_BE_POOL_DESCR_DEFINE (   name,
  hname,
  scope,
  amb_type,
  pool_field,
  pool_magic_field,
  pool_magic 
)
Value:
scope const struct m0_be_pool_descr name ## _pool_d = \
M0_BE_POOL_DESCR(hname, amb_type, pool_field, pool_magic_field, \
pool_magic)
name
const char * name
Definition: trace.c:110
m0_be_pool_descr
Definition: pool.h:86

Definition at line 135 of file pool.h.

◆ M0_BE_QUEUE_GET

#define M0_BE_QUEUE_GET (   bq,
  op,
  ptr,
  successful 
)    m0_be_queue_get(bq, op, &M0_BUF_INIT_PTR(ptr), successful)

Definition at line 238 of file queue.h.

◆ M0_BE_QUEUE_PEEK

#define M0_BE_QUEUE_PEEK (   bq,
  ptr 
)    m0_be_queue_peek(bq, &M0_BUF_INIT_PTR(ptr))

Definition at line 240 of file queue.h.

◆ M0_BE_QUEUE_PUT

#define M0_BE_QUEUE_PUT (   bq,
  op,
  ptr 
)    m0_be_queue_put(bq, op, &M0_BUF_INIT_PTR(ptr))

Definition at line 236 of file queue.h.

◆ M0_BE_REG

#define M0_BE_REG (   seg,
  size,
  addr 
)
Value:
((struct m0_be_reg) { \
.br_seg = (seg), \
.br_size = (size), \
.br_addr = (addr) })
m0_be_reg::br_size
m0_bcount_t br_size
Definition: seg.h:144
addr
static char * addr
Definition: node_k.c:37
m0_be_reg
Definition: seg.h:142
size
m0_bcount_t size
Definition: di.c:39
seg
static struct m0_be_seg * seg
Definition: btree.c:40

Definition at line 148 of file seg.h.

◆ M0_BE_REG_AREA_FORALL

#define M0_BE_REG_AREA_FORALL (   ra,
  rd 
)
Value:
for ((rd) = m0_be_reg_area_first(ra); \
(rd) != NULL; \
(rd) = m0_be_reg_area_next((ra), (rd)))
NULL
#define NULL
Definition: misc.h:38
m0_be_reg_area_first
M0_INTERNAL struct m0_be_reg_d * m0_be_reg_area_first(struct m0_be_reg_area *ra)
Definition: tx_regmap.c:814
m0_be_reg_area_next
M0_INTERNAL struct m0_be_reg_d * m0_be_reg_area_next(struct m0_be_reg_area *ra, struct m0_be_reg_d *prev)
Definition: tx_regmap.c:820

Definition at line 299 of file tx_regmap.h.

◆ M0_BE_REG_D

#define M0_BE_REG_D (   reg,
  buf 
)
Value:
(struct m0_be_reg_d) \
{ .rd_reg = (reg), .rd_buf = (buf) }
m0_be_reg_d
Definition: tx_regmap.h:49
buf
Definition: sock.c:887
m0_be_reg_d::rd_buf
void * rd_buf
Definition: tx_regmap.h:58

Definition at line 67 of file tx_regmap.h.

◆ M0_BE_REG_D_CREDIT

#define M0_BE_REG_D_CREDIT (   rd)    M0_BE_TX_CREDIT(1, (rd)->rd_reg.br_size)

Definition at line 69 of file tx_regmap.h.

◆ M0_BE_REG_PTR

#define M0_BE_REG_PTR (   seg,
  ptr 
)    M0_BE_REG((seg), sizeof *(ptr), (ptr))

Definition at line 154 of file seg.h.

◆ M0_BE_REG_SEG

#define M0_BE_REG_SEG (   seg)    M0_BE_REG((seg), (seg)->bs_size, (seg)->bs_addr)

Definition at line 155 of file seg.h.

◆ M0_BE_SEG_GEOM0

#define M0_BE_SEG_GEOM0
Value:
((struct m0_be_seg_geom) { \
.sg_size = (0ULL), \
.sg_addr = (NULL), \
.sg_offset = (0ULL), \
.sg_id = (0ULL) \
})
NULL
#define NULL
Definition: misc.h:38
m0_be_seg_geom::sg_addr
void * sg_addr
Definition: seg.h:91
m0_be_seg_geom
Definition: seg.h:89
m0_be_seg_geom::sg_id
uint64_t sg_id
Definition: seg.h:93

Definition at line 100 of file seg.h.

◆ M0_BE_SEG_PG_PIN_CNT_MASK

#define M0_BE_SEG_PG_PIN_CNT_MASK   (~M0_BE_SEG_PG_PRESENT)

Definition at line 64 of file seg.h.

◆ M0_BE_SEG_PG_PRESENT

#define M0_BE_SEG_PG_PRESENT   0x8000000000000000ULL

Definition at line 63 of file seg.h.

◆ M0_BE_TX_CAPTURE_ARR

#define M0_BE_TX_CAPTURE_ARR (   seg,
  tx,
  arr,
  nr 
)    m0_be_tx_capture((tx), &M0_BE_REG((seg), (nr) * sizeof((arr)[0]), (arr)))

Definition at line 507 of file tx.h.

◆ M0_BE_TX_CAPTURE_BUF

#define M0_BE_TX_CAPTURE_BUF (   seg,
  tx,
  buf 
)    m0_be_tx_capture((tx), &M0_BE_REG((seg), (buf)->b_nob, (buf)->b_addr))

Definition at line 509 of file tx.h.

◆ M0_BE_TX_CAPTURE_PTR

#define M0_BE_TX_CAPTURE_PTR (   seg,
  tx,
  ptr 
)    m0_be_tx_capture((tx), &M0_BE_REG((seg), sizeof *(ptr), (ptr)))

Definition at line 505 of file tx.h.

◆ M0_BE_TX_CREDIT

#define M0_BE_TX_CREDIT (   nr,
  size 
)    (struct m0_be_tx_credit){ .tc_reg_nr = (nr), .tc_reg_size = (size) }

Definition at line 94 of file tx_credit.h.

◆ M0_BE_TX_CREDIT_BUF

#define M0_BE_TX_CREDIT_BUF (   buf)    M0_BE_TX_CREDIT(1, (buf)->b_nob)

Definition at line 99 of file tx_credit.h.

◆ M0_BE_TX_CREDIT_PTR

#define M0_BE_TX_CREDIT_PTR (   ptr)    M0_BE_TX_CREDIT(1, sizeof *(ptr))

Definition at line 98 of file tx_credit.h.

◆ M0_BE_TX_CREDIT_TYPE

#define M0_BE_TX_CREDIT_TYPE (   type)    M0_BE_TX_CREDIT(1, sizeof(type))

Definition at line 97 of file tx_credit.h.

◆ M0_BE_TX_GROUP_TX_ENDFOR

#define M0_BE_TX_GROUP_TX_ENDFOR   m0_tl_endfor

Definition at line 265 of file tx_group.h.

◆ M0_BE_TX_GROUP_TX_FORALL

#define M0_BE_TX_GROUP_TX_FORALL (   gr,
  tx 
)    m0_tl_for(grp, &(gr)->tg_txs, (tx))

Definition at line 262 of file tx_group.h.

◆ M0_DEBUG_BE_CREDITS

#define M0_DEBUG_BE_CREDITS   (1)

Credit represents resources that a transaction could consume: 

- for each region captured by an active transaction, contents of captured
  region must be stored somewhere (to be written to the log later). That
  requires memory, which must be pre-allocated before transaction
  captures anything to avoid dead-locks;

- similarly, for each captured region, a fixed size region descriptor
  (m0_be_reg_d) should be stored. The memory for the descriptor must be
  pre-allocated;

- finally, before transaction captures anything, transaction engine must
  assure that there is enough free space in the log to write
  transaction's updates. The space required is proportional to total
  number of regions captured by the transaction and to total size of
  these regions.

Hence, the user should inform the engine about amount and size of regions that the transaction would modify. This is achieved by calling m0_be_tx_prep() (possibly multiple times), while the transaction is in PREPARE state. The calls to m0_be_tx_prep() must be conservative: it is fine to prepare for more updates than the transaction will actually make (the latter quantity is usually impossible to know beforehand anyway), but the transaction must never capture more than it prepared.

See also
M0_BE_TX_CREDIT(), M0_BE_TX_CREDIT_TYPE().

Definition at line 67 of file tx_credit.h.

◆ M0_TRACE_SUBSYSTEM [1/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BTREE

Definition at line 29 of file btree.c.

◆ M0_TRACE_SUBSYSTEM [2/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 30 of file queue.c.

◆ M0_TRACE_SUBSYSTEM [3/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 30 of file main.c.

◆ M0_TRACE_SUBSYSTEM [4/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT

Definition at line 30 of file op.c.

◆ M0_TRACE_SUBSYSTEM [5/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 30 of file queue.c.

◆ M0_TRACE_SUBSYSTEM [6/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT

Definition at line 30 of file pd.c.

◆ M0_TRACE_SUBSYSTEM [7/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 30 of file log_discard.c.

◆ M0_TRACE_SUBSYSTEM [8/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 30 of file common.c.

◆ M0_TRACE_SUBSYSTEM [9/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 30 of file io_sched.c.

◆ M0_TRACE_SUBSYSTEM [10/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT

Definition at line 32 of file tx.c.

◆ M0_TRACE_SUBSYSTEM [11/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 33 of file pd.c.

◆ M0_TRACE_SUBSYSTEM [12/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT

Definition at line 33 of file tx_bulk.c.

◆ M0_TRACE_SUBSYSTEM [13/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_UT

Definition at line 34 of file io_sched.c.

◆ M0_TRACE_SUBSYSTEM [14/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 35 of file log_discard.c.

◆ M0_TRACE_SUBSYSTEM [15/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 35 of file st.c.

◆ M0_TRACE_SUBSYSTEM [16/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 43 of file beck.c.

◆ M0_TRACE_SUBSYSTEM [17/17]

#define M0_TRACE_SUBSYSTEM   M0_TRACE_SUBSYS_BE

Definition at line 66 of file tx_bulk.c.

◆ REG

#define REG (   size,
  addr,
  buf 
)
Value:
(const struct m0_be_fmt_reg) { \
.fr_size = size, \
.fr_addr = addr, \
.fr_buf = buf \
}
m0_be_fmt_reg
Definition: fmt.h:343
buf
Definition: sock.c:887
addr
static char * addr
Definition: node_k.c:37
size
m0_bcount_t size
Definition: di.c:39

Definition at line 257 of file fmt.c.

◆ REGD_EXT

#define REGD_EXT (   rd)
Value:
(struct m0_ext) { \
.e_start = (m0_bindex_t)(rd)->rd_reg.br_addr, \
.e_end = (m0_bindex_t)(rd)->rd_reg.br_addr + (rd)->rd_reg.br_size \
}
m0_bindex_t
uint64_t m0_bindex_t
Definition: types.h:80
m0_ext
Definition: ext.h:37
Note
don't forget to undefine this at the end of the file

Definition at line 45 of file tx_regmap.c.

◆ RLOG

#define RLOG (   level,
  prefix,
  s,
  r,
  tag 
)
Value:
M0_LOG(level, prefix " %" PRIu64 " %s %hu:%hu:%u", s->s_off, recname(r), \
(tag)->ot_version, (tag)->ot_type, (tag)->ot_size)
tag
static uint64_t tag(uint8_t code, uint64_t id)
Definition: addb2.c:1047
M0_LOG
#define M0_LOG(level,...)
Definition: trace.h:167
level
enum m0_trace_level level
Definition: trace.c:111
prefix
static struct m0_uint128 prefix
Definition: extmap.c:45
PRIu64
#define PRIu64
Definition: types.h:58
recname
static const char * recname(const struct rectype *rt)
Definition: beck.c:1200
r
static int r[NR]
Definition: thread.c:46
s
static struct m0_addb2_source * s
Definition: consumer.c:39

Definition at line 552 of file beck.c.

◆ TX

#define TX (   p_addr,
  p_nob,
  id 
)
Value:
(const struct m0_be_fmt_tx) { \
.bft_payload = { \
.b_addr = p_addr, \
.b_nob = p_nob, \
}, \
.bft_id = id, \
}
id
uint64_t id
Definition: cob.h:2380
m0_be_fmt_tx
Definition: fmt.h:363

Definition at line 263 of file fmt.c.

◆ TX_PAYLOAD_TEST

#define TX_PAYLOAD_TEST (   credit,
  fill,
  capture,
  offset 
)
Value:
{ \
.tpt_credit = (credit), \
.tpt_fill = (fill), \
.tpt_capture = (capture), \
.tpt_offset = (offset), \
}
offset
static m0_bindex_t offset
Definition: dump.c:173

Definition at line 997 of file tx.c.

Typedef Documentation

◆ m0_be_group_format_reg_area_rebuild_t

typedef void(* m0_be_group_format_reg_area_rebuild_t) (struct m0_be_reg_area *ra, struct m0_be_reg_area *ra_new, void *param)

Definition at line 84 of file tx_group_format.h.

◆ m0_be_log_full_cb_t

typedef void(* m0_be_log_full_cb_t) (struct m0_be_log *log)

Definition at line 232 of file log.h.

◆ m0_be_log_got_space_cb_t

typedef void(* m0_be_log_got_space_cb_t) (struct m0_be_log *log)

Definition at line 230 of file log.h.

◆ m0_be_log_record_cb_t

typedef void(* m0_be_log_record_cb_t) (struct m0_be_log_record *record)

Definition at line 231 of file log.h.

◆ m0_be_op_cb_t

typedef void(* m0_be_op_cb_t) (struct m0_be_op *op, void *param)

Definition at line 72 of file op.h.

◆ m0_be_tx_cb_t

typedef void(* m0_be_tx_cb_t) (const struct m0_be_tx *tx)

Definition at line 277 of file tx.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_ALLOC_SHIFT_MIN 

Allocated memory will be aligned using at least this shift.

See also
m0_be_alloc(), m0_be_allocator_credit().

Definition at line 42 of file alloc.h.

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_ALLOCATOR_STATS_BOUNDARY 
M0_BE_ALLOCATOR_STATS_PRINT_INTERVAL 

Definition at line 61 of file alloc.h.

◆ anonymous enum

anonymous enum
Enumerator
BTREE_ALLOC_SHIFT 

Definition at line 42 of file btree.c.

◆ anonymous enum

anonymous enum

Btree configuration constants.

Enumerator
BTREE_FAN_OUT 
BTREE_HEIGHT_MAX 

Definition at line 572 of file btree.h.

◆ anonymous enum

anonymous enum
Enumerator
KV_NR 

Definition at line 39 of file btree_internal.h.

◆ anonymous enum

anonymous enum

Levels of m0_be_domain module.

Enumerator
M0_BE_DOMAIN_LEVEL_INIT 
M0_BE_DOMAIN_LEVEL_0TYPES_REGISTER 
M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_DESTROY 
M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_CREATE 
M0_BE_DOMAIN_LEVEL_NORMAL_STOB_DOMAIN_INIT 
M0_BE_DOMAIN_LEVEL_LOG_CONFIGURE 
M0_BE_DOMAIN_LEVEL_MKFS_LOG_CREATE 
M0_BE_DOMAIN_LEVEL_NORMAL_LOG_OPEN 
M0_BE_DOMAIN_LEVEL_PD_INIT 
M0_BE_DOMAIN_LEVEL_NORMAL_SEG0_OPEN 
M0_BE_DOMAIN_LEVEL_NORMAL_0TYPES_VISIT 
M0_BE_DOMAIN_LEVEL_LOG_DISCARD_INIT 
M0_BE_DOMAIN_LEVEL_ENGINE_INIT 
M0_BE_DOMAIN_LEVEL_ENGINE_START 
M0_BE_DOMAIN_LEVEL_MKFS_SEG0_CREATE 
M0_BE_DOMAIN_LEVEL_MKFS_SEG0_STRUCTS_CREATE 
M0_BE_DOMAIN_LEVEL_MKFS_SEG0_0TYPE 
M0_BE_DOMAIN_LEVEL_MKFS_SEGMENTS_CREATE 
M0_BE_DOMAIN_LEVEL_READY 

Definition at line 154 of file domain.h.

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_FL_STEP 

each size is aligned on this boundary

M0_BE_FL_NR 

number of free lists

M0_BE_FL_PICK_SCAN_LIMIT 

scan limit for best-fit search for chunks with size >= M0_BE_FL_NR * M0_BE_FL_STEP

Definition at line 39 of file fl.h.

◆ anonymous enum

anonymous enum
Enumerator
BE_LIST_POISON_BYTE 

Definition at line 39 of file list.c.

◆ anonymous enum

anonymous enum

BE log record states

Enumerator
LGR_NEW 
LGR_USED 
LGR_SCHEDULED 
LGR_DONE 
LGR_DISCARDED 
LGR_FINI 

Definition at line 47 of file log.c.

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_LOG_RECORD_IO_NR_MAX 

Definition at line 234 of file log.h.

◆ anonymous enum

anonymous enum
Enumerator
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 

Definition at line 238 of file log.h.

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_LOG_STORE_WRITE_SIZE_MAX 

Definition at line 47 of file log_store.c.

◆ anonymous enum

anonymous enum

Log store provides an interface to an infinite persistent storage. It also has an interface for redundant buffer I/O. Although it is impossible to have a trully unlimited storage, it is possible to have some abstractions over finite storage that allows I/O within some I/O window.

Definitions

  • I/O window - range for which it is guaranteed that read I/O will give the same data as was previously written by write I/O. For any two I/O windows [offset1, offset1 + length1) and [offset2, offset2 + length2): (offset1 <= offset2) => ((offset1 + length1) <= (offset2 + length2));
  • redundant buffer - a buffer that has multiple copies on persistent storage;
  • backing storage - persistent storage for I/O;
  • absolute offset - offset within infinite storage;
  • real offset - offset within backing storage. It is a value used for backing storage I/O.

Highlights

  • log store uses stobs as a backing store.

Log store hides such knowledge as number of stobs, fragmentation, redundant buffers and their positions.

*
* |<------------------------------ fsh_size ------------------------------>|
* |                                                                        |
* +-----------+--------------------------------+---------------------------+
* | Log store | Redundant buffers              | Circular buffer with data |
* |  header   | (contain copies of log header) |                           |
* +-----------+--------------------------------+---------------------------+
*             |<------- fsh_rbuf_size -------->|<----- fsh_cbuf_size ----->|
*             |                                |
*       fsh_rbuf_offset                  fsh_cbuf_offset
*
*

Interface:

Limitations

  • infinite persistent storage is actually limited by M0_BINDEX_MAX, so interface provides I/O for range [0, M0_BINDEX_MAX];
  • current implementation uses one stob as a backing storage.

Future directions

  • interface for log store expand/shrink.
Enumerator
M0_BE_LOG_STORE_LEVEL_ASSIGNS 
M0_BE_LOG_STORE_LEVEL_STOB_DOMAIN 
M0_BE_LOG_STORE_LEVEL_STOB_FIND 
M0_BE_LOG_STORE_LEVEL_STOB_LOCATE 
M0_BE_LOG_STORE_LEVEL_STOB_CREATE 
M0_BE_LOG_STORE_LEVEL_ZERO 
M0_BE_LOG_STORE_LEVEL_LS_HEADER_INIT 
M0_BE_LOG_STORE_LEVEL_LS_HEADER_BUF_ALLOC 
M0_BE_LOG_STORE_LEVEL_HEADER_CREATE 
M0_BE_LOG_STORE_LEVEL_HEADER_ENCODE 
M0_BE_LOG_STORE_LEVEL_HEADER_IO 
M0_BE_LOG_STORE_LEVEL_HEADER_DECODE 
M0_BE_LOG_STORE_LEVEL_RBUF_ARR_ALLOC 
M0_BE_LOG_STORE_LEVEL_RBUF_INIT 
M0_BE_LOG_STORE_LEVEL_RBUF_ASSIGN 
M0_BE_LOG_STORE_LEVEL_READY 

Definition at line 106 of file log_store.h.

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_SEG_HEADER_OFFSET 
M0_BE_SEG_READ_SIZE_MAX 

Maximum size for segment I/O while reading in m0_be_seg_open().

M0_BE_SEG_CORE_DUMP_LIMIT 

Core dump only first given MBs of the segment.

M0_BE_SEG_FAKE_ID 

Fake segment id, used before m0_be_seg_create_multiple is used everywhere around the code

M0_BE_SEG_PAGE_SIZE 

Segments' addr, size, offset has to be aligned by this boundary

Definition at line 50 of file seg.h.

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_SEG_HDR_GEOM_ITMES_MAX 
M0_BE_SEG_HDR_VERSION_LEN_MAX 

Definition at line 41 of file seg_internal.h.

◆ anonymous enum

anonymous enum
Enumerator
MAX_WORKERS_NR 

Definition at line 184 of file beck.c.

◆ anonymous enum

anonymous enum
Enumerator
CACHE_SIZE 

Definition at line 221 of file beck.c.

◆ anonymous enum

anonymous enum
Enumerator
NV_OFFSET_SAVE_DELTA_IN_BYTES 

Definition at line 222 of file beck.c.

◆ anonymous enum

anonymous enum
Enumerator
NV_OFFSET_SAVE_ACT_DELTA 

Definition at line 223 of file beck.c.

◆ anonymous enum

anonymous enum
Enumerator
MAX_GEN 
MAX_SCAN_QUEUED 
MAX_QUEUED 
MAX_REC_SIZE 
MAX_GEN_DIFF_SEC 

The value in MAX_GEN_DIFF_SEC is arrived on the basis of max time difference between mkfs run on local and remote node and the assumption that clock time delta between nodes is negligible.

MAX_KEY_LEN 
MAX_VALUE_LEN 
DEFAULT_BE_SEG_LOAD_ADDR 
DEFAULT_BE_MAX_TX_REG_SZ 

The value of 44MB for DEFAULT_BE_MAX_TX_REG_SZ was picked from the routine m0_be_ut_backend_cfg_default()

Definition at line 480 of file beck.c.

◆ anonymous enum

anonymous enum
Enumerator
DELTA 

Definition at line 823 of file beck.c.

◆ anonymous enum

anonymous enum
Enumerator
BETOOL_ST_SEG_SIZE 
BETOOL_ST_TX_STEP 
BETOOL_ST_CAPTURE_STEP 
BETOOL_ST_CAPTURE_BLOCK 

Definition at line 50 of file st.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_TX_BULK_WORKER_MAX 

Maximum number of be_tx_bulk_worker-s in m0_be_tx_bulk.

This value can be tuned to increase performance.

Definition at line 82 of file tx_bulk.c.

◆ anonymous enum

anonymous enum
Enumerator
GFT_GROUP_IO 
GFT_GROUP_CB_IO 

Definition at line 50 of file tx_group_format.c.

◆ anonymous enum

anonymous enum
Enumerator
M0_BE_GROUP_FORMAT_LEVEL_ASSIGNS 
M0_BE_GROUP_FORMAT_LEVEL_OP_INIT 
M0_BE_GROUP_FORMAT_LEVEL_FMT_GROUP_INIT 
M0_BE_GROUP_FORMAT_LEVEL_FMT_CBLOCK_INIT 
M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_INIT 
M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_IO_CREATE_GROUP 
M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_IO_CREATE_CBLOCK 
M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_ITER_INIT 
M0_BE_GROUP_FORMAT_LEVEL_INITED 
M0_BE_GROUP_FORMAT_LEVEL_LOG_RECORD_ALLOCATE 
M0_BE_GROUP_FORMAT_LEVEL_ALLOCATED 

Definition at line 88 of file tx_group_format.h.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_FMT_GROUP_SIZE_MAX_RND_NR 
BE_UT_FMT_GROUP_SIZE_MAX_RND_ITER 

Definition at line 382 of file fmt.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_IO_SCHED_THREAD_NR 
BE_UT_IO_SCHED_IO_NR 
BE_UT_IO_SCHED_ADD_NR 
BE_UT_IO_SCHED_IO_OFFSET_MAX 
BE_UT_IO_SCHED_EXT_SIZE_MAX 

Definition at line 52 of file io_sched.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_LOG_DISCARD_USECASE_ITEMS_MAX 
BE_UT_LOG_DISCARD_USECASE_ITEMS_THRESHOLD 

Definition at line 50 of file log_discard.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_LOG_DISCARD_GP_ITEM_MAX 
BE_UT_LOG_DISCARD_GP_CONSUMERS 
BE_UT_LOG_DISCARD_GP_PRODUCERS 
BE_UT_LOG_DISCARD_GP_OPERATION_NR 
BE_UT_LOG_DISCARD_GP_OPERATION_STEP 

Definition at line 111 of file log_discard.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_OP_SET_USECASE_NR 

Definition at line 229 of file op.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_OP_SET_TREE_LEVEL_SIZE 
BE_UT_OP_SET_TREE_LEVEL_NR 
BE_UT_OP_SET_TREE_RNG_SEED 
BE_UT_OP_SET_TREE_SHUFFLE_ITER 

Definition at line 281 of file op.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_PD_USECASE_POS_START 
BE_UT_PD_USECASE_PD_IO_NR 
BE_UT_PD_USECASE_REG_NR 
BE_UT_PD_USECASE_THREAD_NR 
BE_UT_PD_USECASE_ITER_NR 

Definition at line 46 of file pd.c.

◆ anonymous enum

anonymous enum
Enumerator
SHIFT 

Definition at line 251 of file tx.c.

◆ anonymous enum

anonymous enum

constants for backend UT for transaction persistence

Enumerator
BE_UT_TX_P_SEG_SIZE 
BE_UT_TX_P_TX_NR 
BE_UT_TX_P_REG_NR 
BE_UT_TX_P_REG_SIZE_MAX 

Definition at line 459 of file tx.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_F_SEG_SIZE 
BE_UT_TX_F_TX_NR 
BE_UT_TX_F_TX_CONCUR 
BE_UT_TX_F_INIT 
BE_UT_TX_F_CAPTURE 

Definition at line 545 of file tx.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_C_THREAD_NR 
BE_UT_TX_C_TX_PER_THREAD 

Definition at line 659 of file tx.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_CAPTURING_SEG_SIZE 
BE_UT_TX_CAPTURING_TX_NR 
BE_UT_TX_CAPTURING_NR 
BE_UT_TX_CAPTURING_RANGE 

Definition at line 741 of file tx.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_GC_SEG_SIZE 
BE_UT_TX_GC_TX_NR 
BE_UT_TX_GC_RAND_DENOMINATOR 

Definition at line 790 of file tx.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_PAYLOAD_SEG_SIZE 
BE_UT_TX_PAYLOAD_TEST_NR 
BE_UT_TX_PAYLOAD_SIZE_MAX 

Definition at line 976 of file tx.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_BULK_Q_SIZE_MAX 
BE_UT_TX_BULK_SEG_SIZE 
BE_UT_TX_BULK_TX_SIZE_MAX_BP 
BE_UT_TX_BULK_WORKERS 

Definition at line 50 of file tx_bulk.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_BULK_USECASE_ALLOC 

Definition at line 165 of file tx_bulk.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_BULK_TX_NR_EMPTY 
BE_UT_TX_BULK_TX_NR_ERROR 
BE_UT_TX_BULK_TX_NR_LARGE_TX 
BE_UT_TX_BULK_TX_NR_LARGE_PAYLOAD 
BE_UT_TX_BULK_TX_NR_LARGE_ALL 
BE_UT_TX_BULK_TX_NR_SMALL_TX 
BE_UT_TX_BULK_TX_NR_MEDIUM_TX 
BE_UT_TX_BULK_TX_NR_LARGE_CRED 
BE_UT_TX_BULK_TX_NR_MEDIUM_CRED 
BE_UT_TX_BULK_BUF_NR 
BE_UT_TX_BULK_BUF_SIZE 

Definition at line 258 of file tx_bulk.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_BULK_FILL_NOTHING 
BE_UT_TX_BULK_FILL_TX 
BE_UT_TX_BULK_FILL_PAYLOAD 
BE_UT_TX_BULK_ERROR_REG 
BE_UT_TX_BULK_ERROR_PAYLOAD 

Definition at line 416 of file tx_bulk.c.

◆ anonymous enum

anonymous enum
Enumerator
BE_UT_TX_BULK_PARALLEL_THREADS_NR 
BE_UT_TX_BULK_PARALLEL_QUEUE_SIZE_MAX 
BE_UT_TX_BULK_PARALLEL_PARTITIONS_NR_MAX 
BE_UT_TX_BULK_PARALLEL_WORKERS_NR_MAX 
BE_UT_TX_BULK_PARALLEL_ALLOC 
BE_UT_TX_BULK_PARALLEL_Q_SIZE_MAX 
BE_UT_TX_BULK_PARALLEL_ITEMS_PER_PARTITION 
BE_UT_TX_BULK_PARALLEL_ITEMS_PER_TX_MAX 

Definition at line 632 of file tx_bulk.c.

◆ action_opcode

enum action_opcode
Enumerator
AO_INIT 
AO_DONE 
AO_CTG 
AO_COB 
AO_EMAP_FIRST 
AO_NR 

Definition at line 175 of file beck.c.

◆ be_log_discard_item_state

enum be_log_discard_item_state
Enumerator
LDI_INIT 
LDI_STARTING 
LDI_FINISHED 
LDI_SYNCED 
LDI_DISCARDED 

Definition at line 48 of file log_discard.c.

◆ be_ut_io_sched_io_op

enum be_ut_io_sched_io_op
Enumerator
BE_UT_IO_SCHED_IO_START 
BE_UT_IO_SCHED_IO_FINISH 

Definition at line 60 of file io_sched.c.

◆ be_ut_log_discard_gp_role

enum be_ut_log_discard_gp_role
Enumerator
BE_UT_LOG_DISCARD_GP_PRODUCER 
BE_UT_LOG_DISCARD_GP_CONSUMER 

Definition at line 119 of file log_discard.c.

◆ be_ut_op_mt_cmd

enum be_ut_op_mt_cmd
Enumerator
BE_UT_OP_MT_INIT 
BE_UT_OP_MT_WAIT1 
BE_UT_OP_MT_ACTIVE 
BE_UT_OP_MT_WAIT2 
BE_UT_OP_MT_DONE 
BE_UT_OP_MT_WAIT3 
BE_UT_OP_MT_FINI 
BE_UT_OP_MT_CMD_NR 

Definition at line 53 of file op.c.

◆ be_ut_op_mt_dep_type

enum be_ut_op_mt_dep_type
Enumerator
BE_UT_OP_MT_WAIT_BEFORE 
BE_UT_OP_MT_WAIT_AFTER 

Definition at line 64 of file op.c.

◆ be_ut_op_set_tree_cmd

enum be_ut_op_set_tree_cmd
Enumerator
BE_UT_OP_SET_TREE_INIT 
BE_UT_OP_SET_TREE_SET_ADD 
BE_UT_OP_SET_TREE_STATES 
BE_UT_OP_SET_TREE_FINI 
BE_UT_OP_SET_TREE_SET_ACTIVE 
BE_UT_OP_SET_TREE_SET_DONE 
BE_UT_OP_SET_TREE_ASSERT_DONE 
BE_UT_OP_SET_TREE_ASSERT_NOT_DONE 

Definition at line 288 of file op.c.

◆ be_ut_queue_test

enum be_ut_queue_test
Enumerator
BE_UT_QUEUE_1_1_1 
BE_UT_QUEUE_2_1_1 
BE_UT_QUEUE_100_1_1 
BE_UT_QUEUE_100_1_10 
BE_UT_QUEUE_100_10_1 
BE_UT_QUEUE_100_10_10 
BE_UT_QUEUE_10_100_1 
BE_UT_QUEUE_10_100_5 
BE_UT_QUEUE_10_1_100 
BE_UT_QUEUE_10_5_100 
BE_UT_QUEUE_10_100_100 
BE_UT_QUEUE_NR 

Definition at line 49 of file queue.c.

◆ betool_st_event

enum betool_st_event
Enumerator
BETOOL_ST_TIME_BEGIN 
BETOOL_ST_TIME_TX_OPEN 
BETOOL_ST_TIME_SEG_FILL 
BETOOL_ST_TIME_TX_CAPTURE 
BETOOL_ST_TIME_TX_CLOSE_WAIT 
BETOOL_ST_TIME_END 
BETOOL_ST_TIME_NR 

Definition at line 144 of file st.c.

◆ btree_save_optype

enum btree_save_optype
Enumerator
BTREE_SAVE_INSERT 
BTREE_SAVE_UPDATE 
BTREE_SAVE_OVERWRITE 

Definition at line 46 of file btree.c.

◆ m0_avi_be_labels

enum m0_avi_be_labels
Enumerator
M0_AVI_BE_TX_STATE 
M0_AVI_BE_TX_COUNTER 
M0_AVI_BE_TX_COUNTER_END 
M0_AVI_BE_OP_COUNTER 
M0_AVI_BE_OP_COUNTER_END 
M0_AVI_BE_TX_TO_GROUP 
M0_AVI_BE_TX_ATTR_PAYLOAD_NOB 
M0_AVI_BE_TX_ATTR_PAYLOAD_PREP 
M0_AVI_BE_TX_ATTR_LOG_RESERVED_SZ 
M0_AVI_BE_TX_ATTR_LOG_USED 
M0_AVI_BE_TX_ATTR_RA_AREA_USED 
M0_AVI_BE_TX_ATTR_RA_PREP_TC_REG_NR 
M0_AVI_BE_TX_ATTR_RA_PREP_TC_REG_SIZE 
M0_AVI_BE_TX_ATTR_RA_CAPT_TC_REG_NR 
M0_AVI_BE_TX_ATTR_RA_CAPT_TC_REG_SIZE 

Definition at line 37 of file addb2.h.

◆ m0_be_alloc_zone_type

enum m0_be_alloc_zone_type

Zones within BE segment allocator space.

Each zone occupies a fixed fraction of total segment space, which is specified when the allocator is initialised. Space can be requested from particular zones using zones bit mask.

Zones in enumeration are sorted by priority in ascending order. For example, if zones M0_BAP_NORMAL and M0_BAP_REPAIR are specified in allocation request, then space in M0_BAP_NORMAL will be allocated only if there is not enough space in M0_BAP_REPAIR.

The memory is allocated exactly in one zone and can't be distributed among several zones even if several zones are specified in an allocation request.

Zones don't have predefined memory boundaries and can be viewed as "labels" for allocated memory chunks. Particular memory chunk can reside in different zones during system life cycle.

Enumerator
M0_BAP_REPAIR 

Repair zone is used by index repair to allocate space for spare units.

M0_BAP_NORMAL 

Normal zone contains the bulk of segment space. It is used for usual allocations.

M0_BAP_NR 

Definition at line 85 of file alloc.h.

◆ m0_be_allocator_op

enum m0_be_allocator_op

Allocator operation.

See also
m0_be_allocator_credit().
Enumerator
M0_BAO_CREATE 

Allocator credit for m0_be_allocator_create()

M0_BAO_DESTROY 

Allocator credit for m0_be_allocator_destroy()

M0_BAO_ALLOC 

Allocator credit for m0_be_alloc()

M0_BAO_ALLOC_ALIGNED 

Allocator credit for m0_be_alloc_aligned()

M0_BAO_FREE 

Allocator credit for m0_be_free()

M0_BAO_FREE_ALIGNED 

Allocator credit for m0_be_free_aligned()

Definition at line 196 of file alloc.h.

◆ m0_be_bnode_format_version

enum m0_be_bnode_format_version
Enumerator
M0_BE_BNODE_FORMAT_VERSION_1 
M0_BE_BNODE_FORMAT_VERSION 

Current version, should point to the latest version present

Definition at line 63 of file btree_internal.h.

◆ m0_be_btree_format_version

enum m0_be_btree_format_version
Enumerator
M0_BE_BTREE_FORMAT_VERSION_1 
M0_BE_BTREE_FORMAT_VERSION 

Current version, should point to the latest version present

Definition at line 81 of file btree.h.

◆ m0_be_btree_op

enum m0_be_btree_op

Type of persistent operation over the tree.

These values are also re-used to define transaction credit types.

Enumerator
M0_BBO_CREATE 

Used for m0_be_btree_create()

M0_BBO_DESTROY 

.. m0_be_btree_destroy()

M0_BBO_INSERT 

.. m0_be_btree_{,inplace_}insert()

M0_BBO_DELETE 

.. m0_be_btree_{,inplace_}delete()

M0_BBO_UPDATE 

.. m0_be_btree_{,inplace_}update()

M0_BBO_LOOKUP 

.. m0_be_btree_lookup()

M0_BBO_MAXKEY 

.. m0_be_btree_maxkey()

M0_BBO_MINKEY 

.. m0_be_btree_minkey()

M0_BBO_CURSOR_GET 

.. m0_be_btree_cursor_get()

M0_BBO_CURSOR_NEXT 

.. m0_be_btree_cursor_next()

M0_BBO_CURSOR_PREV 

.. m0_be_btree_cursor_prev()

Definition at line 139 of file btree.h.

◆ m0_be_btree_type

enum m0_be_btree_type

Stored in m0_be_btree_backlink::bl_type

Enumerator
M0_BBT_INVALID 
M0_BBT_BALLOC_GROUP_EXTENTS 
M0_BBT_BALLOC_GROUP_DESC 
M0_BBT_EMAP_EM_MAPPING 
M0_BBT_CAS_CTG 
M0_BBT_COB_NAMESPACE 
M0_BBT_COB_OBJECT_INDEX 
M0_BBT_COB_FILEATTR_BASIC 
M0_BBT_COB_FILEATTR_EA 
M0_BBT_COB_FILEATTR_OMG 
M0_BBT_COB_BYTECOUNT 
M0_BBT_CONFDB 
M0_BBT_UT_KV_OPS 
M0_BBT_NR 

Definition at line 117 of file btree.h.

◆ m0_be_credit_users

enum m0_be_credit_users
Enumerator
M0_BE_CU_BTREE_INSERT 
M0_BE_CU_BTREE_DELETE 
M0_BE_CU_BTREE_UPDATE 
M0_BE_CU_EMAP_SPLIT 
M0_BE_CU_EMAP_PASTE 
M0_BE_CU_NR 

Definition at line 70 of file tx_credit.h.

◆ m0_be_fl_op

enum m0_be_fl_op

m0_be_fl operation.

See also
m0_be_fl_credit()
Enumerator
M0_BFL_CREATE 
M0_BFL_DESTROY 
M0_BFL_ADD 
M0_BFL_DEL 

Definition at line 50 of file fl.h.

◆ m0_be_list_format_version

enum m0_be_list_format_version
Enumerator
M0_BE_LIST_FORMAT_VERSION_1 
M0_BE_LIST_FORMAT_VERSION 

Current version, should point to the latest version present

Definition at line 46 of file list.h.

◆ m0_be_list_op

enum m0_be_list_op

List operations that modify memory.

Enumerator
M0_BLO_CREATE 

m0_be_list_create()

M0_BLO_DESTROY 

m0_be_list_destroy()

M0_BLO_ADD 

m0_be_list_add(), m0_be_list_add_after(), m0_be_list_add_before(), m0_be_list_add_tail()

M0_BLO_DEL 

m0_be_list_del()

M0_BLO_TLINK_CREATE 

m0_be_tlink_create()

M0_BLO_TLINK_DESTROY 

m0_be_tlink_destroy()

M0_BLO_NR 

Definition at line 84 of file list.h.

◆ m0_be_log_store_io_type

enum m0_be_log_store_io_type
Enumerator
M0_BE_LOG_STORE_IO_READ 
M0_BE_LOG_STORE_IO_WRITE 

Definition at line 125 of file log_store.h.

◆ m0_be_op_state

enum m0_be_op_state
Enumerator
M0_BOS_INVALID 
M0_BOS_INIT 
M0_BOS_ACTIVE 
M0_BOS_DONE 
M0_BOS_GC 

It's not a state. It's used to set garbage collector callbak.

See also
m0_be_op::bo_cb_gc, m0_be_op_callback_set().

Definition at line 55 of file op.h.

◆ m0_be_op_type

enum m0_be_op_type
Enumerator
M0_BOP_TREE 
M0_BOP_LIST 

Definition at line 67 of file op.h.

◆ m0_be_pd_io_state

enum m0_be_pd_io_state
Enumerator
M0_BPD_IO_IDLE 
M0_BPD_IO_IN_PROGRESS 
M0_BPD_IO_DONE 
M0_BPD_IO_STATE_NR 

Definition at line 47 of file pd.h.

◆ m0_be_reg_area_type

enum m0_be_reg_area_type

reg_area type.

See also
m0_be_reg_area
Enumerator
M0_BE_REG_AREA_DATA_COPY 

m0_be_reg_area copies entire regions passed to m0_be_reg_area_capture() to it's internal memory buffer (m0_be_reg_area::bra_area). m0_be_reg_area overwrites previously written regions data if new region intersects with the reg_area.

m0_be_reg_area saves pointer to the copy of the region data to m0_be_reg_d::rd_buf.

M0_BE_REG_AREA_DATA_NOCOPY 

The same as M0_BE_REG_AREA_DATA_COPY except it is assumed that m0_be_reg_d already has the copy of the data in m0_be_reg_d::rd_buf, so m0_be_reg_area doesn't copy data from m0_be_reg_d::rd_reg to m0_be_reg_d::rd_buf.

Definition at line 208 of file tx_regmap.h.

◆ m0_be_seg_hdr_format_version

enum m0_be_seg_hdr_format_version
Enumerator
M0_BE_SEG_HDR_FORMAT_VERSION_1 
M0_BE_SEG_HDR_FORMAT_VERSION 

Current version, should point to the latest version present

Definition at line 60 of file seg_internal.h.

◆ m0_be_seg_states

enum m0_be_seg_states
Enumerator
M0_BSS_INIT 
M0_BSS_OPENED 
M0_BSS_CLOSED 

Definition at line 44 of file seg.h.

◆ m0_be_tx_group_state

enum m0_be_tx_group_state
Enumerator
M0_BGS_READY 
M0_BGS_OPEN 
M0_BGS_FROZEN 
M0_BGS_CLOSED 
M0_BGS_NR 

Definition at line 47 of file tx_group.h.

◆ m0_be_tx_state

enum m0_be_tx_state

Transaction state machine.

*
*                        | m0_be_tx_init()
*                        |
*                        V
*                     PREPARE
*                        |
*        m0_be_tx_open() |   no free memory or engine thinks that
*                        |   the transaction can't be opened
*                        V                V
*                     OPENING---------->FAILED
*                        |
*                        | log space reserved for the transaction
*                        |
*                        V
*                      ACTIVE
*                        |
*       m0_be_tx_close() |
*                        |
*                        V
*                      CLOSED
*                        |
*                        | added to group
*                        |
*                        V
*                     GROUPED
*                        |
*                        | log io complete
*                        |
*                        V
*                     LOGGED
*                        |
*                        | in-place io complete
*                        |
*                        V
*                      PLACED
*                        |
*                        | number of m0_be_tx_get() == number of m0_be_tx_put()
*                        | for the transaction
*                        V
*                      DONE
*
*

A transaction goes through the states sequentially. The table below corresponds to sequence of transactions in the system history. An individual transaction, as it gets older, moves through this table bottom-up.

*
*      transaction          log record
*         state                state
* |                    |                     |
* |                    |                     |
* | DONE               |  record discarded   |
* | (updates in place) |                     |
* |                    |                     |
* +--------------------+---------------------+----> start
* |                    |                     |
* | PLACED             |  persistent         |
* | (updates in place  |                     |
* |  and in log)       |                     |
* |                    |                     |
* +--------------------+---------------------+----> placed
* |                    |                     |
* | ``LOGGED''         |  persistent         |
* | (updates in log)   |                     |
* |                    |                     |
* +--------------------+---------------------+----> logged
* |                    |                     |
* | ``SUBMITTED''      |  in flight          |
* | (updates in flight |                     |
* |  to log)           |                     |
* |                    |                     |
* +--------------------+---------------------+----> submitted
* |                    |                     |
* | GROUPED            |  in memory,         |
* | (grouped)          |  log location       |
* |                    |  assigned           |
* |                    |                     |
* +--------------------+---------------------+----> grouped
* |                    |                     |
* | CLOSED             |  in memory,         |
* | (ungrouped)        |  log location       |
* |                    |  not assigned       |
* |                    |                     |
* +--------------------+---------------------+----> inmem
* |                    |                     |
* | ACTIVE             |  in memory,         |
* | (capturing         |  log space          |
* |  updates)          |  reserved           |
* |                    |                     |
* +--------------------+---------------------+----> prepared
* |                    |                     |
* | OPENING            |  no records         |
* | (waiting for log   |                     |
* |  space             |                     |
* |                    |                     |
* +--------------------+---------------------+
* |                    |                     |
* | PREPARE            | no records          |
* | (accumulating      |                     |
* |  credits)          |                     |
* +--------------------+---------------------+
*
*
Enumerator
M0_BTS_FAILED 

Transaction failed. It cannot be used further and should be finalised (m0_be_tx_fini()).

Currently, the only way a transaction can reach this state is by failing to allocate internal memory in m0_be_tx_open() call or by growing too large (larger than the total log space) in prepare state.

M0_BTS_PREPARE 

State in which transaction is being prepared to opening; initial state after m0_be_tx_init().

In this state, m0_be_tx_prep() calls should be made to reserve internal resources for the future captures. It is allowed to prepare for more than will be actually captured: typically it is impossible to precisely estimate updates that will be done as part of transaction, so a user should conservatively prepare for the worst-case.

M0_BTS_OPENING 

In this state transaction waits for internal resource to be allocated.

Specifically, the transaction is in this state until there is enough free space in the log to store transaction updates.

M0_BTS_GROUPING 

XXX Transaction is a member of transaction group.

M0_BTS_ACTIVE 

In this state transaction is used to capture updates.

M0_BTS_CLOSED 

Transaction is closed.

M0_BTS_LOGGED 
M0_BTS_PLACED 

All transaction in-place updates completed.

M0_BTS_DONE 

Transaction reached M0_BTS_PLACED state and the number of m0_be_tx_get() is equal to the number of m0_be_tx_put() for the transaction.

M0_BTS_NR 

Definition at line 214 of file tx.h.

◆ position_t

enum position_t
Enumerator
P_LEFT 
P_RIGHT 

Definition at line 191 of file btree.c.

◆ tx_group_fom_state

enum tx_group_fom_state

Phases of tx_group fom.

*
*       INIT ----> FAILED ----------.
*        |                          |
*        v                          v
* ,---> OPEN ----> STOPPING ----> FINISH
* |      |
* |      v
* |    LOGGING ----> RECONSTRUCT
* |      |                |
* |      |                v
* |      |             TX_OPEN
* |      |                |
* |      |                v
* |      |             TX_CLOSE
* |      |                |
* |      v                v
* |    PLACING <------ REAPPLY
* |      |
* |      v
* |    PLACED
* |      |
* |      v
* |  STABILIZING
* |      |
* |      v
* |    STABLE ----- TX_GC_WAIT
* |      |             |
* |      v             |
* `--- RESET <---------/
*
*
Enumerator
TGS_INIT 
TGS_FINISH 
TGS_OPEN 

tx_group gets populated with transactions, that are added with tx_group_add().

TGS_PREPARE 

Log stobio is in progress.

TGS_LOGGING 
TGS_RECONSTRUCT 

Group is reconstructing

TGS_TX_OPEN 
TGS_TX_CLOSE 
TGS_REAPPLY 
TGS_PLACING 

In-place (segment) stobio is in progress.

TGS_PLACED 
TGS_STABILIZING 

Waiting for transactions to stabilize.

TGS_STABLE 

m0_be_tx_stable() has been called for all transactions of the tx_group.

TGS_TX_GC_WAIT 
TGS_RESET 
TGS_STOPPING 
TGS_FAILED 
TGS_NR 

Definition at line 82 of file tx_group_fom.c.

Function Documentation

◆ _0types_visit()

static int _0types_visit ( struct m0_be_domain *  dom,
bool  init 
)
static

Definition at line 119 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ad_dom_fini()

static void ad_dom_fini ( struct builder *  b)
static

Definition at line 2109 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ad_dom_init()

static int ad_dom_init ( struct builder *  b)
static

Definition at line 1939 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ addb2_add_tx_attrs()

static void addb2_add_tx_attrs ( const struct m0_be_tx *  tx)
static

Definition at line 335 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_0type_seg_fini()

static void be_0type_seg_fini ( struct m0_be_domain *  dom,
const char *  suffix,
const struct m0_buf *  data 
)
static

Definition at line 332 of file domain.c.

Here is the call graph for this function:

◆ be_0type_seg_init()

static int be_0type_seg_init ( struct m0_be_domain *  dom,
const char *  suffix,
const struct m0_buf *  data 
)
static

Definition at line 307 of file domain.c.

Here is the call graph for this function:

◆ be_btree_compare()

static int be_btree_compare ( const struct m0_be_btree *  btree,
const void *  key0,
const void *  key1 
)
static

Definition at line 162 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_delete_key()

static int be_btree_delete_key ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_bnode *  bnode,
void *  key 
)
static

Delete a key from btree.

This routine will delete the entry specified by .

Parameters
treepointer to btree.
txpointer to BE transaction.
nodepointer to root node on btree.
keypointer to key which would needs to be deleted.
Returns
0 (success) or -1 (failure).

Definition at line 911 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_delete_key_from_node()

void be_btree_delete_key_from_node ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct btree_node_pos *  bnode_pos 
)
static

Delete a key from node.

This routine will delete a key from node in btree.

Parameters
treepointer to btree.
txpointer to BE transaction.
node_pospointer to node position from which key would to be deleted.

Definition at line 839 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_destroy()

static void be_btree_destroy ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx 
)
static

Definition at line 1150 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_get_btree_node()

struct btree_node_pos be_btree_get_btree_node ( struct m0_be_btree_cursor *  it,
const void *  key,
bool  slant 
)
static

Get a node containing the given key.

This routine will return node position containing specified .

Parameters
itpointer to btree cursor used to traverse btree.
keypointer to key which is used to search node.
slantbool to decide searching needs to be on leaf node. if true, search leaf node, else search in non-leaf node
Returns
struct btree_node_pos.

Definition at line 1102 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_get_max_key()

static void* be_btree_get_max_key ( struct m0_be_btree *  tree)
static

Get a maximum key in btree.

This routine will return a max key in btree.

Parameters
treepointer to btree.
Returns
maximum key in btree.

Definition at line 1319 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_get_max_key_pos()

static void be_btree_get_max_key_pos ( struct m0_be_bnode *  node,
struct btree_node_pos *  pos 
)
static

Get maxinimum key position in btree.

This routine will return position of maximum key in btree.

Parameters
nodepointer to root node of btree.
pospointer to position structure in which return values are copied.

Definition at line 619 of file btree.c.

Here is the caller graph for this function:

◆ be_btree_get_min_key()

static void* be_btree_get_min_key ( struct m0_be_btree *  tree)
static

Get a minimum key in btree.

This routine will return a min key in btree.

Parameters
treepointer to btree.
Returns
minimum key in btree.

Definition at line 1338 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_get_min_key_pos()

static void be_btree_get_min_key_pos ( struct m0_be_bnode *  node,
struct btree_node_pos *  pos 
)
static

Get mininimum key position in btree.

This routine will return position of minimum key in btree.

Parameters
nodepointer to root node of btree.
pospointer to position structure in which return values are copied.

Definition at line 638 of file btree.c.

Here is the caller graph for this function:

◆ be_btree_insert()

static void be_btree_insert ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
const struct m0_buf *  val,
struct m0_be_btree_anchor *  anchor,
uint64_t  zonemask 
)
static

Definition at line 1892 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_insert_into_nonfull()

static void be_btree_insert_into_nonfull ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
struct m0_be_bnode *  node,
struct be_btree_key_val *  kv 
)
static

Inserts entry into the non-full .

Parameters
btreethe btree where the kv is to be inserted
txthe pointer to tx
nodethe non-full node where the kv is to be inserted
kvthe key value to be inserted
Returns
none

Definition at line 529 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_insert_newkey()

static void be_btree_insert_newkey ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
struct be_btree_key_val *  kv 
)
static

Inserts entry into .

Parameters
btreethe btree where the kv is to be inserted
txthe pointer to tx
kvthe key value to be inserted
Returns
none

Definition at line 574 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_ksize()

static m0_bcount_t be_btree_ksize ( const struct m0_be_btree *  btree,
const void *  key 
)
static

Definition at line 147 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_lookup()

static void be_btree_lookup ( struct m0_be_btree *  tree,
struct m0_be_op *  op,
const struct m0_buf *  key_in,
struct m0_buf *  key_out,
struct m0_buf *  value 
)
static

Definition at line 1985 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_merge_siblings()

static struct m0_be_bnode* be_btree_merge_siblings ( struct m0_be_tx *  tx,
struct m0_be_btree *  tree,
struct m0_be_bnode *  parent,
unsigned int  idx 
)
static

Merge siblings.

This routine will merge siblings in btree.

Parameters
txpointer to BE transaction.
treepointer to btree.
parentpointer to parent node.
idxIndex of the child array of parent node.
Returns
m0_be_bnode pointer to node after merging.

Definition at line 680 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_move_parent_key()

static void be_btree_move_parent_key ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_bnode *  parent,
enum position_t  pos,
unsigned int  idx 
)
static

Move parent key to child.

This routine will move keys from parent to left or right child node.

Parameters
treepointer to btree.
txpointer to BE transaction.
parentpointer to parent node.
idxIndex of the child array of parent node.
posposition to move keys to LEFT or RIGHT child.

Definition at line 795 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_move_parent_key_to_left_child()

static void be_btree_move_parent_key_to_left_child ( struct m0_be_bnode *  parent,
struct m0_be_bnode *  lch,
struct m0_be_bnode *  rch,
unsigned int  idx 
)
static

Definition at line 760 of file btree.c.

Here is the caller graph for this function:

◆ be_btree_move_parent_key_to_right_child()

static void be_btree_move_parent_key_to_right_child ( struct m0_be_bnode *  parent,
struct m0_be_bnode *  lch,
struct m0_be_bnode *  rch,
unsigned int  idx 
)
static

Definition at line 737 of file btree.c.

Here is the caller graph for this function:

◆ be_btree_node_alloc()

static struct m0_be_bnode * be_btree_node_alloc ( const struct m0_be_btree *  btree,
struct m0_be_tx *  tx 
)
static

This function is used to allocate memory for the btree node

Parameters
btreethe btree node to which the node is to be allocated
txthe pointer to tx
Returns
the allocated btree node

Definition at line 414 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_search()

static struct be_btree_key_val * be_btree_search ( struct m0_be_btree *  btree,
void *  key 
)
static

Definition at line 1295 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_set_node_params()

static void be_btree_set_node_params ( struct m0_be_bnode *  p_node,
unsigned int  num_active_key,
unsigned int  level,
bool  isleaf 
)
static

Definition at line 396 of file btree.c.

Here is the caller graph for this function:

◆ be_btree_shift_key_vals()

static void be_btree_shift_key_vals ( struct m0_be_bnode *  dest,
struct m0_be_bnode *  src,
unsigned int  start_index,
unsigned int  key_src_offset,
unsigned int  key_dest_offset,
unsigned int  child_src_offset,
unsigned int  child_dest_offset,
unsigned int  stop_index 
)
static

Definition at line 648 of file btree.c.

Here is the caller graph for this function:

◆ be_btree_split_child()

static void be_btree_split_child ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
struct m0_be_bnode *  parent,
unsigned int  index 
)
static

Splits the child node at and updates the .

Parameters
btreethe btree to which the node is to be allocated
txthe pointer to tx
parentthe parent node
indexthe index of the node to be split
Returns
none

Definition at line 462 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_btree_vsize()

static m0_bcount_t be_btree_vsize ( const struct m0_be_btree *  btree,
const void *  data 
)
static

Definition at line 154 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_cfg_default_init()

static void be_cfg_default_init ( struct m0_be_domain_cfg *  dom_cfg,
struct m0_be_tx_bulk_cfg *  tb_cfg 
)
static

These values provided the maximum builder performance after experiments on hardware.

Definition at line 2154 of file beck.c.

Here is the caller graph for this function:

◆ be_cfg_from_yaml_update()

static int be_cfg_from_yaml_update ( const char *  yaml_file,
struct m0_be_domain_cfg *  cfg 
)
static

Definition at line 2282 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_cfg_update()

static void be_cfg_update ( struct m0_be_domain_cfg *  cfg,
const char *  str_key,
const char *  str_value 
)
static

Cover variables accepting two comma-separated values.

Cover variables accepting a single 32-bit value
These variables accept a single 64-bit value.

Definition at line 2182 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_ldsc_sync()

static void be_domain_ldsc_sync ( struct m0_be_log_discard *  ld,
struct m0_be_op *  op,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 426 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_level_enter()

static int be_domain_level_enter ( struct m0_module *  module)
static

Definition at line 665 of file domain.c.

Here is the call graph for this function:

◆ be_domain_level_leave()

static void be_domain_level_leave ( struct m0_module *  module)
static

Definition at line 836 of file domain.c.

Here is the call graph for this function:

◆ be_domain_lock()

static void be_domain_lock ( struct m0_be_domain *  dom)
static

Definition at line 53 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_log_cleanup()

M0_INTERNAL void be_domain_log_cleanup ( const char *  stob_domain_location,
struct m0_be_log_cfg *  log_cfg,
bool  create 
)

Definition at line 363 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_mkfs_seg0()

static int be_domain_mkfs_seg0 ( struct m0_be_domain *  dom,
const struct m0_be_0type_seg_cfg *  seg0_cfg 
)
static

Definition at line 399 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_seg_close()

static int be_domain_seg_close ( struct m0_be_domain *  dom,
struct m0_be_seg *  seg,
bool  destroy 
)
static
Postcondition
ergo(!destroy, rc == 0)

Definition at line 211 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_seg_create()

static int be_domain_seg_create ( struct m0_be_domain *  dom,
struct m0_be_tx *  tx,
struct m0_be_seg *  seg,
const struct m0_be_0type_seg_cfg *  seg_cfg 
)
static

Definition at line 265 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_seg_destroy()

static int be_domain_seg_destroy ( struct m0_be_domain *  dom,
uint64_t  seg_id 
)
static

Definition at line 256 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_seg_open()

static int be_domain_seg_open ( struct m0_be_domain *  dom,
struct m0_be_seg *  seg,
uint64_t  stob_key 
)
static

Definition at line 229 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_seg_structs_create()

static int be_domain_seg_structs_create ( struct m0_be_domain *  dom,
struct m0_be_tx *  tx,
struct m0_be_seg *  seg 
)
static

Definition at line 169 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_seg_suffix_make()

static void be_domain_seg_suffix_make ( const struct m0_be_domain *  dom,
uint64_t  seg_id,
char *  str,
size_t  str_size 
)
static

Definition at line 499 of file domain.c.

Here is the caller graph for this function:

◆ be_domain_stob_open()

static int be_domain_stob_open ( struct m0_be_domain *  dom,
uint64_t  stob_key,
const char *  stob_create_cfg,
struct m0_stob **  out,
bool  create 
)
static

Definition at line 145 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_domain_unlock()

static void be_domain_unlock ( struct m0_be_domain *  dom)
static

Definition at line 58 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_cfg_validate()

static int be_engine_cfg_validate ( struct m0_be_engine_cfg *  en_cfg)
static

Definition at line 89 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_got_tx_closed()

static void be_engine_got_tx_closed ( struct m0_be_engine *  en,
struct m0_be_tx *  tx 
)
static

Definition at line 582 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_got_tx_done()

static void be_engine_got_tx_done ( struct m0_be_engine *  en,
struct m0_be_tx *  tx 
)
static

Definition at line 595 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_got_tx_grouping()

static void be_engine_got_tx_grouping ( struct m0_be_engine *  en)
static

Definition at line 551 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_got_tx_open()

static void be_engine_got_tx_open ( struct m0_be_engine *  en,
struct m0_be_tx *  tx 
)
static

Definition at line 287 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_find()

static struct m0_be_tx_group* be_engine_group_find ( struct m0_be_engine *  en)
static

Definition at line 446 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_freeze()

static void be_engine_group_freeze ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr 
)
static

Definition at line 383 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_start()

static int be_engine_group_start ( struct m0_be_engine *  en,
size_t  index 
)
static

Definition at line 772 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_stop_nr()

static void be_engine_group_stop_nr ( struct m0_be_engine *  en,
size_t  nr 
)
static

Definition at line 754 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_timeout_arm()

static void be_engine_group_timeout_arm ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr 
)
static

Definition at line 420 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_timer_arm()

static void be_engine_group_timer_arm ( struct m0_sm_group *  sm_grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 352 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_timer_cb()

static void be_engine_group_timer_cb ( struct m0_sm_timer *  timer)
static

Definition at line 336 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_timer_disarm()

static void be_engine_group_timer_disarm ( struct m0_sm_group *  sm_grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 369 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_group_tryclose()

static void be_engine_group_tryclose ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr 
)
static

Definition at line 392 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_invariant()

static bool be_engine_invariant ( struct m0_be_engine *  en)
static

Definition at line 221 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_is_locked()

static bool be_engine_is_locked ( const struct m0_be_engine *  en)
static

Definition at line 216 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_lock()

static void be_engine_lock ( struct m0_be_engine *  en)
static

Definition at line 206 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_recovery_finish()

static void be_engine_recovery_finish ( struct m0_be_engine *  en)
static

Definition at line 508 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_recovery_is_finished()

static bool be_engine_recovery_is_finished ( struct m0_be_engine *  en)
static

Definition at line 499 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_recovery_tx_find()

static struct m0_be_tx* be_engine_recovery_tx_find ( struct m0_be_engine *  en,
enum m0_be_tx_state  state 
)
static

Definition at line 541 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_try_recovery()

static void be_engine_try_recovery ( struct m0_be_engine *  en)
static

Definition at line 516 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_tx_group_open()

static void be_engine_tx_group_open ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr 
)
static

Definition at line 716 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_tx_group_ready()

static void be_engine_tx_group_ready ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr 
)
static

Definition at line 726 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_tx_group_state_move()

static void be_engine_tx_group_state_move ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr,
enum m0_be_tx_group_state  state 
)
static

Definition at line 63 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_tx_id_allocate()

static uint64_t be_engine_tx_id_allocate ( struct m0_be_engine *  en)
static

Definition at line 226 of file engine.c.

Here is the caller graph for this function:

◆ be_engine_tx_opening_peek()

static struct m0_be_tx* be_engine_tx_opening_peek ( struct m0_be_engine *  en)
static

Definition at line 267 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_tx_peek()

static struct m0_be_tx* be_engine_tx_peek ( struct m0_be_engine *  en,
enum m0_be_tx_state  state 
)
static

Definition at line 231 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_tx_state_post()

static void be_engine_tx_state_post ( struct m0_be_engine *  en,
struct m0_be_tx *  tx,
enum m0_be_tx_state  state 
)
static

Definition at line 239 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_tx_trygroup()

static int be_engine_tx_trygroup ( struct m0_be_engine *  en,
struct m0_be_tx *  tx 
)
static

Definition at line 452 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_engine_unlock()

static void be_engine_unlock ( struct m0_be_engine *  en)
static

Definition at line 211 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fl_index_round_down_chunk()

static unsigned long be_fl_index_round_down_chunk ( struct m0_be_fl *  fl,
const struct be_alloc_chunk *  chunk 
)
static

Definition at line 136 of file fl.c.

Here is the caller graph for this function:

◆ be_fl_index_round_up()

static unsigned long be_fl_index_round_up ( struct m0_be_fl *  fl,
m0_bcount_t  size 
)
static

Definition at line 128 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fl_list()

static struct m0_be_list* be_fl_list ( struct m0_be_fl *  fl,
unsigned long  index 
)
static

Definition at line 98 of file fl.c.

Here is the caller graph for this function:

◆ be_fl_list_is_empty()

static bool be_fl_list_is_empty ( struct m0_be_fl *  fl,
unsigned long  index 
)
static

Definition at line 105 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fmt_alloc()

static void* be_fmt_alloc ( struct m0_xcode_cursor *  it,
size_t  nob 
)
static

Definition at line 92 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fmt_content_bufs_init()

static void be_fmt_content_bufs_init ( struct m0_be_fmt_group *  fg)
static

Definition at line 195 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fmt_decode()

static int be_fmt_decode ( struct m0_xcode_type *  type,
void **  object,
struct m0_bufvec_cursor *  cur,
const struct m0_be_fmt_decode_cfg *  cfg 
)
static

Definition at line 134 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fmt_decoded_free()

static void be_fmt_decoded_free ( struct m0_xcode_type *  type,
void *  object 
)
static

Definition at line 170 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fmt_encode()

static int be_fmt_encode ( struct m0_xcode_type *  type,
void *  object,
struct m0_bufvec_cursor *  cur 
)
static

Definition at line 65 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fmt_group_populate()

static void be_fmt_group_populate ( struct m0_be_fmt_group *  group,
void *  payload,
size_t  payload_size,
size_t  TX_NR_MAX,
size_t  REG_NR_MAX 
)
static

Definition at line 272 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_fmt_xcoded_size()

static m0_bcount_t be_fmt_xcoded_size ( struct m0_xcode_type *  type,
void *  object 
)
static

Definition at line 52 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_group_format_level_enter()

static int be_group_format_level_enter ( struct m0_module *  module)
static

Definition at line 62 of file tx_group_format.c.

Here is the call graph for this function:

◆ be_group_format_level_leave()

static void be_group_format_level_leave ( struct m0_module *  module)
static

Definition at line 111 of file tx_group_format.c.

Here is the call graph for this function:

◆ be_group_format_module2gft()

static struct m0_be_group_format* be_group_format_module2gft ( struct m0_module *  module)
static

Definition at line 56 of file tx_group_format.c.

Here is the caller graph for this function:

◆ be_group_format_module_fini()

static void be_group_format_module_fini ( struct m0_be_group_format *  gft,
bool  deallocate 
)
static

Definition at line 259 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_group_format_module_init()

static int be_group_format_module_init ( struct m0_be_group_format *  gft,
struct m0_be_group_format_cfg *  gft_cfg,
bool  allocate 
)
static

Definition at line 267 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_cb()

static bool be_io_cb ( struct m0_clink *  link)
static

Definition at line 559 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_empty_ast()

static void be_io_empty_ast ( struct m0_sm_group *  grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 591 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_finished()

static void be_io_finished ( struct m0_be_io *  bio)
static

Definition at line 529 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_free()

static void be_io_free ( struct m0_be_io *  bio)
static

Definition at line 64 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_part_add()

static bool be_io_part_add ( struct m0_be_io_part *  bip,
void *  ptr_user,
m0_bindex_t  offset_stob,
m0_bcount_t  size 
)
static

Definition at line 132 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_part_fini()

static void be_io_part_fini ( struct m0_be_io_part *  bip)
static

Definition at line 82 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_part_init()

static void be_io_part_init ( struct m0_be_io_part *  bip,
struct m0_be_io *  bio 
)
static

Definition at line 73 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_part_intersect()

static bool be_io_part_intersect ( const struct m0_be_io_part *  bip1,
const struct m0_be_io_part *  bip2 
)
static

Definition at line 708 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_part_invariant()

static bool be_io_part_invariant ( struct m0_be_io_part *  bip)
static

Definition at line 89 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_part_launch()

static int be_io_part_launch ( struct m0_be_io_part *  bip)
static

Definition at line 99 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_part_reset()

static void be_io_part_reset ( struct m0_be_io_part *  bip)
static

Definition at line 119 of file io.c.

Here is the caller graph for this function:

◆ be_io_sched_cb()

static void be_io_sched_cb ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 125 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_sched_insert()

static void be_io_sched_insert ( struct m0_be_io_sched *  sched,
struct m0_be_io *  io 
)
static

Definition at line 145 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_sched_invariant()

static bool be_io_sched_invariant ( struct m0_be_io_sched *  sched)
static

Definition at line 85 of file io_sched.c.

Here is the caller graph for this function:

◆ be_io_sched_launch_next()

static void be_io_sched_launch_next ( struct m0_be_io_sched *  sched)
static

Definition at line 93 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_sched_launch_next_locked()

static void be_io_sched_launch_next_locked ( struct m0_be_io_sched *  sched)
static

Definition at line 118 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_size_pack()

static m0_bcount_t be_io_size_pack ( m0_bcount_t  size,
uint32_t  bshift 
)
static

Definition at line 54 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_size_unpack()

static m0_bcount_t be_io_size_unpack ( m0_bcount_t  size,
uint32_t  bshift 
)
static

Definition at line 59 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_stob_offset_pack()

static m0_bindex_t be_io_stob_offset_pack ( m0_bindex_t  offset,
uint32_t  bshift 
)
static

Definition at line 49 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_vec_cut()

static void be_io_vec_cut ( struct m0_be_io *  bio,
struct m0_be_io_part *  bip 
)
static

Definition at line 266 of file io.c.

Here is the caller graph for this function:

◆ be_io_vec_fork()

static void be_io_vec_fork ( struct m0_be_io *  bio,
unsigned  index 
)
static

Definition at line 325 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_io_vec_index_by_ptr()

static unsigned be_io_vec_index_by_ptr ( struct m0_be_io *  bio,
m0_bindex_t *  iv_ptr 
)
static

Definition at line 376 of file io.c.

Here is the caller graph for this function:

◆ be_list_capture()

static void be_list_capture ( struct m0_be_list *  blist,
struct m0_be_tx *  tx 
)
static

Definition at line 102 of file list.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_list_invariant()

static bool be_list_invariant ( const struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr 
)
static

Definition at line 43 of file list.c.

Here is the caller graph for this function:

◆ be_list_link2obj()

static void* be_list_link2obj ( struct m0_be_list_link *  link,
const struct m0_be_list_descr *  descr 
)
static

Definition at line 125 of file list.c.

Here is the caller graph for this function:

◆ be_list_obj2link()

static struct m0_be_list_link* be_list_obj2link ( const void *  obj,
const struct m0_be_list_descr *  descr 
)
static

Definition at line 116 of file list.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_ast()

static void be_log_discard_ast ( struct m0_sm_group *  grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 250 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_check_sync()

static void be_log_discard_check_sync ( struct m0_be_log_discard *  ld,
bool  force 
)
static

Definition at line 189 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_flush_finished()

static void be_log_discard_flush_finished ( struct m0_be_log_discard *  ld)
static

Definition at line 178 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_is_locked()

static bool be_log_discard_is_locked ( struct m0_be_log_discard *  ld)
static

Definition at line 173 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_item_discard()

static void be_log_discard_item_discard ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 226 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_item_reset()

static void be_log_discard_item_reset ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 430 of file log_discard.c.

Here is the caller graph for this function:

◆ be_log_discard_item_trydiscard()

static void be_log_discard_item_trydiscard ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 239 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_lock()

static void be_log_discard_lock ( struct m0_be_log_discard *  ld)
static

Definition at line 163 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_sync_done_cb()

static void be_log_discard_sync_done_cb ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 287 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_timer_cancel()

static void be_log_discard_timer_cancel ( struct m0_be_log_discard *  ld)
static

Definition at line 348 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_timer_cancel_loc()

static int be_log_discard_timer_cancel_loc ( void *  param)
static

Definition at line 339 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_timer_cb()

static void be_log_discard_timer_cb ( struct m0_sm_timer *  timer)
static

Definition at line 354 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_timer_start()

static void be_log_discard_timer_start ( struct m0_be_log_discard *  ld)
static

Definition at line 333 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_timer_start_loc()

static int be_log_discard_timer_start_loc ( void *  param)
static

Definition at line 312 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_unlock()

static void be_log_discard_unlock ( struct m0_be_log_discard *  ld)
static

Definition at line 168 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_discard_wait()

static void be_log_discard_wait ( struct m0_be_log_discard *  ld)
static

Definition at line 384 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_header_io()

static void be_log_header_io ( struct m0_be_log *  log,
enum m0_be_log_store_io_type  io_type,
struct m0_be_op *  op 
)
static

Definition at line 303 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_header_io_sync()

static void be_log_header_io_sync ( struct m0_be_log *  log,
enum m0_be_log_store_io_type  io_type 
)
static

Definition at line 328 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_header_update()

static void be_log_header_update ( struct m0_be_log *  log)
static

Definition at line 910 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_header_write()

static int be_log_header_write ( struct m0_be_log *  log,
struct m0_be_fmt_log_header *  log_hdr 
)
static

Definition at line 938 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_io_credit()

static void be_log_io_credit ( struct m0_be_log *  log,
struct m0_be_io_credit *  accum 
)
static

Definition at line 552 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_level_enter()

static int be_log_level_enter ( struct m0_module *  module)
static

Definition at line 72 of file log.c.

Here is the call graph for this function:

◆ be_log_level_leave()

static void be_log_level_leave ( struct m0_module *  module)
static

Definition at line 149 of file log.c.

Here is the call graph for this function:

◆ be_log_module2log()

static struct m0_be_log* be_log_module2log ( struct m0_module *  module)
static

Definition at line 66 of file log.c.

Here is the caller graph for this function:

◆ be_log_module_fini()

static void be_log_module_fini ( struct m0_be_log *  log,
bool  destroy_mode 
)
static

Definition at line 244 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_module_init()

static int be_log_module_init ( struct m0_be_log *  log,
struct m0_be_log_cfg *  log_cfg,
bool  create_mode 
)
static

Definition at line 257 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_read_plain()

static int be_log_read_plain ( struct m0_be_log *  log,
m0_bindex_t  pos,
m0_bcount_t  size,
void *  out 
)
static

Definition at line 1021 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_record_footer_size()

static m0_bcount_t be_log_record_footer_size ( void  )
static

Definition at line 353 of file log.c.

Here is the caller graph for this function:

◆ be_log_record_header_copy()

static void be_log_record_header_copy ( struct m0_be_fmt_log_record_header *  dest,
struct m0_be_fmt_log_record_header *  src 
)
static

Definition at line 1072 of file log.c.

Here is the caller graph for this function:

◆ be_log_record_header_init()

static int be_log_record_header_init ( struct m0_be_fmt_log_record_header *  hdr)
static

Definition at line 607 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_record_header_size()

static m0_bcount_t be_log_record_header_size ( void  )
static

Definition at line 344 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_record_io_done_cb()

static void be_log_record_io_done_cb ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 380 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_record_iter_read()

static int be_log_record_iter_read ( struct m0_be_log *  log,
struct m0_be_log_record_iter *  iter,
m0_bindex_t  pos 
)
static

Definition at line 1089 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_resize()

static int be_log_resize ( char *  path,
uint64_t  size 
)
static

Definition at line 192 of file main.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_buf_alloc_aligned()

static int be_log_store_buf_alloc_aligned ( struct m0_be_log_store *  ls,
struct m0_buf *  buf,
m0_bcount_t  size 
)
static

Definition at line 51 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_buf_free_aligned()

static void be_log_store_buf_free_aligned ( struct m0_be_log_store *  ls,
struct m0_buf *  buf 
)
static

Definition at line 64 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_header_validate()

static bool be_log_store_header_validate ( struct m0_be_fmt_log_store_header *  header,
uint64_t  alignment 
)
static

Definition at line 107 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_level_enter()

static int be_log_store_level_enter ( struct m0_module *  module)
static

Definition at line 234 of file log_store.c.

Here is the call graph for this function:

◆ be_log_store_level_leave()

static void be_log_store_level_leave ( struct m0_module *  module)
static

Definition at line 396 of file log_store.c.

Here is the call graph for this function:

◆ be_log_store_module2store()

static struct m0_be_log_store* be_log_store_module2store ( struct m0_module *  module)
static

Definition at line 100 of file log_store.c.

Here is the caller graph for this function:

◆ be_log_store_module_fini()

static void be_log_store_module_fini ( struct m0_be_log_store *  ls,
bool  destroy_mode 
)
static

Definition at line 549 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_module_init()

static int be_log_store_module_init ( struct m0_be_log_store *  ls,
struct m0_be_log_store_cfg *  ls_cfg,
bool  create_mode 
)
static

Definition at line 556 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_phys_addr()

static m0_bindex_t be_log_store_phys_addr ( struct m0_be_log_store *  ls,
m0_bindex_t  position 
)
static

Definition at line 630 of file log_store.c.

Here is the caller graph for this function:

◆ be_log_store_rbuf_alloc()

static int be_log_store_rbuf_alloc ( struct m0_be_log_store *  ls,
struct m0_buf *  buf 
)
static

Definition at line 133 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_rbuf_arr_free()

static void be_log_store_rbuf_arr_free ( struct m0_be_log_store *  ls)
static

Definition at line 225 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_rbuf_fini()

static void be_log_store_rbuf_fini ( struct m0_be_log_store *  ls)
static

Definition at line 203 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_rbuf_fini_nr()

static void be_log_store_rbuf_fini_nr ( struct m0_be_log_store *  ls,
int  nr 
)
static

Definition at line 194 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_rbuf_free()

static void be_log_store_rbuf_free ( struct m0_be_log_store *  ls,
struct m0_buf *  buf 
)
static

Definition at line 140 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_rbuf_init()

static int be_log_store_rbuf_init ( struct m0_be_log_store *  ls)
static

Definition at line 209 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_rbuf_init_fini_index()

static int be_log_store_rbuf_init_fini_index ( struct m0_be_log_store *  ls,
int  i,
bool  init 
)
static

Definition at line 146 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_log_store_rbuf_io_and_op()

static struct m0_be_log_io* be_log_store_rbuf_io_and_op ( struct m0_be_log_store *  ls,
enum m0_be_log_store_io_type  io_type,
struct m0_be_op **  op,
unsigned  index 
)
static

Definition at line 676 of file log_store.c.

Here is the caller graph for this function:

◆ be_log_store_zero()

static int be_log_store_zero ( struct m0_be_log_store *  ls,
m0_bcount_t  ls_size 
)
static

Definition at line 78 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_op_set_add()

static void be_op_set_add ( struct m0_be_op *  parent,
struct m0_be_op *  child 
)
static

Definition at line 130 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_op_set_del()

static bool be_op_set_del ( struct m0_be_op *  parent,
struct m0_be_op *  child 
)
static

Definition at line 139 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_op_sm_fini()

static void be_op_sm_fini ( struct m0_be_op *  op)
static

Definition at line 81 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_op_sm_init()

static void be_op_sm_init ( struct m0_be_op *  op)
static

Definition at line 74 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_op_state_change()

static void be_op_state_change ( struct m0_be_op *  op,
enum m0_be_op_state  state 
)
static

Definition at line 163 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pd_io_move()

static void be_pd_io_move ( struct m0_be_pd *  pd,
struct m0_be_pd_io *  pdio,
enum m0_be_pd_io_state  state 
)
static

Definition at line 62 of file pd.c.

Here is the caller graph for this function:

◆ be_pd_io_op_done()

static void be_pd_io_op_done ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 78 of file pd.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pd_sync_run()

static void be_pd_sync_run ( struct m0_sm_group *  grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 190 of file pd.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pool_amb()

static void* be_pool_amb ( const struct m0_be_pool_descr *  d,
struct m0_be_pool_item *  item 
)
static

Definition at line 108 of file pool.c.

Here is the caller graph for this function:

◆ be_pool_get()

static void be_pool_get ( const struct m0_be_pool_descr *  d,
struct m0_be_pool *  pool,
void **  obj 
)
static

Definition at line 147 of file pool.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pool_got_free_item()

static void be_pool_got_free_item ( const struct m0_be_pool_descr *  d,
struct m0_be_pool *  pool 
)
static

Definition at line 165 of file pool.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pool_is_locked()

static bool be_pool_is_locked ( struct m0_be_pool *  pool)
static

Definition at line 103 of file pool.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pool_item()

static struct m0_be_pool_item* be_pool_item ( const struct m0_be_pool_descr *  d,
void *  obj 
)
static

Definition at line 116 of file pool.c.

Here is the caller graph for this function:

◆ be_pool_lock()

static void be_pool_lock ( struct m0_be_pool *  pool)
static

Definition at line 93 of file pool.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pool_magic()

static uint64_t be_pool_magic ( const struct m0_be_pool_descr *  d,
void *  obj 
)
static

Definition at line 122 of file pool.c.

Here is the caller graph for this function:

◆ be_pool_magic_set()

static void be_pool_magic_set ( const struct m0_be_pool_descr *  d,
void *  obj,
uint64_t  magic 
)
static

Definition at line 128 of file pool.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pool_obj__invariant()

static bool be_pool_obj__invariant ( const struct m0_be_pool_descr *  d,
void *  obj 
)
static

Definition at line 138 of file pool.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_pool_unlock()

static void be_pool_unlock ( struct m0_be_pool *  pool)
static

Definition at line 98 of file pool.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_invariant()

static bool be_queue_invariant ( struct m0_be_queue *  bq)
static

Definition at line 87 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_is_empty()

static bool be_queue_is_empty ( struct m0_be_queue *  bq)
static

Definition at line 208 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_is_full()

static bool be_queue_is_full ( struct m0_be_queue *  bq)
static

Definition at line 213 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_items_nr()

static uint64_t be_queue_items_nr ( struct m0_be_queue *  bq)
static

Definition at line 200 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_op_get()

static void be_queue_op_get ( struct m0_be_queue *  bq,
struct m0_be_op *  op,
struct m0_buf *  data,
bool *  successful 
)
static

Definition at line 299 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_op_get_done()

static void be_queue_op_get_done ( struct m0_be_queue *  bq,
bool  success 
)
static

Definition at line 320 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_op_get_is_waiting()

static bool be_queue_op_get_is_waiting ( struct m0_be_queue *  bq)
static

Definition at line 339 of file queue.c.

Here is the caller graph for this function:

◆ be_queue_op_put()

static void be_queue_op_put ( struct m0_be_queue *  bq,
struct m0_be_op *  op,
struct be_queue_item *  bqi 
)
static

Definition at line 262 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_op_put_done()

static void be_queue_op_put_done ( struct m0_be_queue *  bq)
static

Definition at line 281 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_op_put_is_waiting()

static bool be_queue_op_put_is_waiting ( struct m0_be_queue *  bq)
static

Definition at line 294 of file queue.c.

Here is the caller graph for this function:

◆ be_queue_q_get()

static void be_queue_q_get ( struct m0_be_queue *  bq,
struct m0_buf *  data,
bool *  successful 
)
static

Definition at line 245 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_q_peek()

static void be_queue_q_peek ( struct m0_be_queue *  bq,
struct m0_buf *  data 
)
static

Definition at line 233 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_q_put()

static struct be_queue_item* be_queue_q_put ( struct m0_be_queue *  bq,
const struct m0_buf *  data 
)
static

Definition at line 218 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_queue_qitem()

static struct be_queue_item* be_queue_qitem ( struct m0_be_queue *  bq,
uint64_t  index 
)
static

Definition at line 78 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_rdt_check_i()

static bool be_rdt_check_i ( const struct m0_be_reg_d_tree *  rdt,
void *  addr,
size_t  index 
)
static

Time complexity is O(1)

Definition at line 247 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_rdt_contains()

static bool be_rdt_contains ( const struct m0_be_reg_d_tree *  rdt,
const struct m0_be_reg_d *  rd 
)
static

Definition at line 199 of file tx_regmap.c.

Here is the caller graph for this function:

◆ be_rdt_find_i()

static size_t be_rdt_find_i ( const struct m0_be_reg_d_tree *  rdt,
void *  addr 
)
static

Time complexity is O(log(m0_be_rdt_size(rdt) + 1))

Definition at line 268 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_recovery_run()

static void be_recovery_run ( char *  path)
static

Definition at line 171 of file main.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_area_add()

static void be_reg_area_add ( void *  data,
struct m0_be_reg_d *  rd 
)
static

Definition at line 671 of file tx_regmap.c.

◆ be_reg_area_add_copy()

static void be_reg_area_add_copy ( void *  data,
struct m0_be_reg_d *  rd 
)
static

Definition at line 660 of file tx_regmap.c.

Here is the call graph for this function:

◆ be_reg_area_alloc()

static void* be_reg_area_alloc ( struct m0_be_reg_area *  ra,
m0_bcount_t  size 
)
static

Definition at line 650 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_area_cpy()

static void be_reg_area_cpy ( void *  data,
const struct m0_be_reg_d *  super,
const struct m0_be_reg_d *  rd 
)
static

Definition at line 697 of file tx_regmap.c.

Here is the call graph for this function:

◆ be_reg_area_cpy_copy()

static void be_reg_area_cpy_copy ( void *  data,
const struct m0_be_reg_d *  super,
const struct m0_be_reg_d *  rd 
)
static

Definition at line 681 of file tx_regmap.c.

Here is the call graph for this function:

◆ be_reg_area_cut()

static void be_reg_area_cut ( void *  data,
struct m0_be_reg_d *  rd,
m0_bcount_t  cut_at_start,
m0_bcount_t  cut_at_end 
)
static

Definition at line 712 of file tx_regmap.c.

◆ be_reg_area_del()

static void be_reg_area_del ( void *  data,
const struct m0_be_reg_d *  rd 
)
static

Definition at line 676 of file tx_regmap.c.

◆ be_reg_area_merger_max_gen_idx()

static void be_reg_area_merger_max_gen_idx ( struct m0_be_reg_area_merger *  brm,
void *  addr,
m0_bcount_t  size,
struct m0_be_reg_d *  rd_new 
)
static

Definition at line 865 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_area_split()

static void be_reg_area_split ( void *  data,
struct m0_be_reg_d *  rd,
struct m0_be_reg_d *  rd_new 
)
static

Definition at line 720 of file tx_regmap.c.

◆ be_reg_d_are_overlapping()

static bool be_reg_d_are_overlapping ( const struct m0_be_reg_d *  rd1,
const struct m0_be_reg_d *  rd2 
)
static

Definition at line 68 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_d_arr_first_subreg()

static void be_reg_d_arr_first_subreg ( struct m0_be_reg_d **  rd_arr,
int  nr,
void *  start,
void **  addr,
m0_bcount_t *  size 
)
static

Definition at line 163 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_d_arr_insert2()

static void be_reg_d_arr_insert2 ( void *  arr[2],
void *  value 
)
static

Definition at line 120 of file tx_regmap.c.

Here is the caller graph for this function:

◆ be_reg_d_cpy()

static void be_reg_d_cpy ( void *  dst,
const struct m0_be_reg_d *  rd 
)
static

Definition at line 645 of file tx_regmap.c.

Here is the caller graph for this function:

◆ be_reg_d_fb()

static void* be_reg_d_fb ( const struct m0_be_reg_d *  rd)
static

Return address of the first byte inside the region.

Definition at line 81 of file tx_regmap.c.

Here is the caller graph for this function:

◆ be_reg_d_fb1()

static void* be_reg_d_fb1 ( const struct m0_be_reg_d *  rd)
static

Return address of the byte before be_reg_d_fb(rd).

Definition at line 87 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_d_is_partof()

static bool be_reg_d_is_partof ( const struct m0_be_reg_d *  super,
const struct m0_be_reg_d *  sub 
)
static

Definition at line 74 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_d_lb()

static void* be_reg_d_lb ( const struct m0_be_reg_d *  rd)
static

Return address of the last byte inside the region.

Definition at line 93 of file tx_regmap.c.

Here is the caller graph for this function:

◆ be_reg_d_lb1()

static void* be_reg_d_lb1 ( const struct m0_be_reg_d *  rd)
static

Return address of the byte after be_reg_d_lb(rd).

Definition at line 99 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_reg_d_size()

static m0_bcount_t be_reg_d_size ( const struct m0_be_reg_d *  rd)
static

Definition at line 104 of file tx_regmap.c.

Here is the caller graph for this function:

◆ be_reg_d_sub_make()

static void be_reg_d_sub_make ( struct m0_be_reg_d *  super,
struct m0_be_reg_d *  sub 
)
static

Definition at line 109 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_regmap_find_fb()

static struct m0_be_reg_d* be_regmap_find_fb ( struct m0_be_regmap *  rm,
const struct m0_be_reg_d *  rd 
)
static

Definition at line 406 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_regmap_reg_d_cut()

static void be_regmap_reg_d_cut ( struct m0_be_regmap *  rm,
struct m0_be_reg_d *  rd,
m0_bcount_t  cut_start,
m0_bcount_t  cut_end 
)
static

Definition at line 412 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_regmap_reg_d_split()

static void be_regmap_reg_d_split ( struct m0_be_regmap *  rm,
struct m0_be_reg_d *  rdi,
struct m0_be_reg_d *  rd,
struct m0_be_reg_d *  rd_new 
)
static

Definition at line 433 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_seg_dict_find()

static struct be_seg_dict_keyval* be_seg_dict_find ( struct m0_be_seg *  seg,
const char *  user_key,
bool(*)(const char *dict_key, const char *user_key)  compare 
)
static

Definition at line 84 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_seg_dict_get()

static struct m0_be_list* be_seg_dict_get ( const struct m0_be_seg *  seg)
static

Definition at line 66 of file seg_dict.c.

Here is the caller graph for this function:

◆ be_seg_dict_iterate()

static int be_seg_dict_iterate ( struct m0_be_seg *  seg,
const char *  prefix,
const char *  start_key,
const char **  this_key,
void **  this_rec,
bool(*)(const char *dict_key, const char *user_key)  compare 
)
static

Definition at line 208 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_seg_dict_kv_begin()

static bool be_seg_dict_kv_begin ( const char *  dict_key,
const char *  user_key 
)
static

Definition at line 196 of file seg_dict.c.

Here is the caller graph for this function:

◆ be_seg_dict_kv_eq()

static bool be_seg_dict_kv_eq ( const char *  dict_key,
const char *  user_key 
)
static

Definition at line 105 of file seg_dict.c.

Here is the caller graph for this function:

◆ be_seg_dict_kv_get()

static void be_seg_dict_kv_get ( const struct be_seg_dict_keyval *  kv)
static

Definition at line 71 of file seg_dict.c.

Here is the caller graph for this function:

◆ be_seg_dict_kv_next()

static bool be_seg_dict_kv_next ( const char *  dict_key,
const char *  user_key 
)
static

Definition at line 202 of file seg_dict.c.

Here is the caller graph for this function:

◆ be_seg_dict_kv_put()

static void be_seg_dict_kv_put ( const struct be_seg_dict_keyval *  kv)
static

Definition at line 77 of file seg_dict.c.

Here is the caller graph for this function:

◆ be_seg_geom_find_by_id()

static const struct m0_be_seg_geom* be_seg_geom_find_by_id ( const struct m0_be_seg_hdr *  hdr,
uint64_t  id 
)
static

Definition at line 51 of file seg.c.

Here is the caller graph for this function:

◆ be_seg_geom_has_no_overlapps()

static bool be_seg_geom_has_no_overlapps ( const struct m0_be_seg_geom *  geom,
int  len 
)
static

Definition at line 156 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_seg_geom_len()

static int be_seg_geom_len ( const struct m0_be_seg_geom *  geom)
static

Definition at line 62 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_seg_hdr_create()

static int be_seg_hdr_create ( struct m0_stob *  stob,
struct m0_be_seg_hdr *  hdr 
)
static

Definition at line 80 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_seg_hdr_size()

static int be_seg_hdr_size ( void  )
static

Definition at line 75 of file seg.c.

Here is the caller graph for this function:

◆ be_seg_io()

static int be_seg_io ( struct m0_be_reg *  reg,
void *  ptr,
enum m0_stob_io_opcode  opcode 
)
static

Definition at line 441 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_seg_madvise()

static void be_seg_madvise ( struct m0_be_seg *  seg,
m0_bcount_t  dump_limit,
int  flag 
)
static

Definition at line 299 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_should_break()

static bool be_should_break ( struct m0_be_engine *  eng,
uint64_t  fraction,
const struct m0_be_tx_credit *  accum,
const struct m0_be_tx_credit *  delta 
)
static

Definition at line 696 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tlink_capture()

static void be_tlink_capture ( struct m0_be_list_link *  link,
struct m0_be_tx *  tx 
)
static

Definition at line 109 of file list.c.

Here is the caller graph for this function:

◆ be_tlink_invariant()

static bool be_tlink_invariant ( const struct m0_be_list_link *  link,
const struct m0_be_list_descr *  descr 
)
static

Definition at line 50 of file list.c.

Here is the caller graph for this function:

◆ be_tlink_is_head()

static bool be_tlink_is_head ( struct m0_be_list *  blist,
struct m0_be_list_link *  link 
)
static

Definition at line 224 of file list.c.

Here is the caller graph for this function:

◆ be_tlink_is_in_list()

static bool be_tlink_is_in_list ( struct m0_be_list_link *  link)
static

Definition at line 230 of file list.c.

Here is the caller graph for this function:

◆ be_tlink_is_tail()

static bool be_tlink_is_tail ( struct m0_be_list *  blist,
struct m0_be_list_link *  link 
)
static

Definition at line 218 of file list.c.

Here is the caller graph for this function:

◆ be_tx_ast()

static struct m0_sm_ast* be_tx_ast ( struct m0_be_tx *  tx,
enum m0_be_tx_state  state 
)
static

Definition at line 105 of file tx.c.

Here is the caller graph for this function:

◆ be_tx_ast_cb()

static void be_tx_ast_cb ( struct m0_sm_group *  sm_group,
struct m0_sm_ast *  ast 
)
static

Definition at line 94 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_close_cb()

static void be_tx_bulk_close_cb ( struct m0_sm_group *  grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 518 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_finish_cb()

static void be_tx_bulk_finish_cb ( struct m0_sm_group *  grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 335 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_gc_cb()

static void be_tx_bulk_gc_cb ( struct m0_be_tx *  tx,
void *  param 
)
static

Definition at line 542 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_init_cb()

static void be_tx_bulk_init_cb ( struct m0_sm_group *  grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 436 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_lock()

static void be_tx_bulk_lock ( struct m0_be_tx_bulk *  tb)
static

Definition at line 306 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_open()

static void be_tx_bulk_open ( struct be_tx_bulk_worker *  worker,
struct m0_be_tx_credit *  cred,
m0_bcount_t  cred_payload 
)
static

Definition at line 414 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_open_cb()

static bool be_tx_bulk_open_cb ( struct m0_clink *  clink)
static

Definition at line 479 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_queue_get_cb()

static void be_tx_bulk_queue_get_cb ( struct m0_sm_group *  grp,
struct m0_sm_ast *  ast 
)
static

Definition at line 370 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_queue_get_done_cb()

static void be_tx_bulk_queue_get_done_cb ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 399 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_queues_drain()

static void be_tx_bulk_queues_drain ( struct m0_be_tx_bulk *  tb)
static

Definition at line 317 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_bulk_unlock()

static void be_tx_bulk_unlock ( struct m0_be_tx_bulk *  tb)
static

Definition at line 311 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_gc()

static void be_tx_gc ( struct m0_be_tx *  tx)
static

Definition at line 465 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_deconstruct()

static void be_tx_group_deconstruct ( struct m0_be_tx_group *  gr)
static

Definition at line 129 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_fom_ast_post()

static void be_tx_group_fom_ast_post ( struct m0_be_tx_group_fom *  gf,
struct m0_sm_ast *  ast 
)
static

Definition at line 375 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_fom_handle()

static void be_tx_group_fom_handle ( struct m0_sm_group *  gr,
struct m0_sm_ast *  ast 
)
static

Definition at line 282 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_fom_iff_waiting_wakeup()

static void be_tx_group_fom_iff_waiting_wakeup ( struct m0_fom *  fom)
static

Definition at line 299 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_fom_stable()

static void be_tx_group_fom_stable ( struct m0_sm_group *  _,
struct m0_sm_ast *  ast 
)
static

Definition at line 309 of file tx_group_fom.c.

Here is the caller graph for this function:

◆ be_tx_group_fom_stop()

static void be_tx_group_fom_stop ( struct m0_sm_group *  gr,
struct m0_sm_ast *  ast 
)
static

Definition at line 320 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_format_seg_io_finished()

static void be_tx_group_format_seg_io_finished ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 533 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_format_seg_io_op_gc()

static void be_tx_group_format_seg_io_op_gc ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 541 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_format_seg_io_starting()

static void be_tx_group_format_seg_io_starting ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 525 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_payload_gather()

static void be_tx_group_payload_gather ( struct m0_be_tx_group *  gr)
static

Definition at line 114 of file tx_group.c.

Here is the caller graph for this function:

◆ be_tx_group_reconstruct_reg_area()

static void be_tx_group_reconstruct_reg_area ( struct m0_be_tx_group *  gr)
static

Definition at line 481 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_reconstruct_transactions()

static void be_tx_group_reconstruct_transactions ( struct m0_be_tx_group *  gr,
struct m0_sm_group *  sm_grp 
)
static

Highlighs:

  • transactions are reconstructed in the given sm group;
  • transactions are allocated using m0_alloc();
  • transactions are freed using m0_be_tx_gc_enable().

Definition at line 541 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_recovering_gc()

static void be_tx_group_recovering_gc ( struct m0_be_tx *  tx,
void *  param 
)
static

Definition at line 525 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_recovering_tx_open()

static bool be_tx_group_recovering_tx_open ( struct m0_clink *  clink)
static

Definition at line 513 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_reg_area_gather()

static void be_tx_group_reg_area_gather ( struct m0_be_tx_group *  gr)
static

Definition at line 83 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_tx_add()

static void be_tx_group_tx_add ( struct m0_be_tx_group *  gr,
struct m0_be_tx *  tx 
)
static

Definition at line 277 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_group_tx_to_gr_map()

static void be_tx_group_tx_to_gr_map ( const struct m0_be_tx *  tx,
const struct m0_be_tx_group *  gr 
)
static

Definition at line 268 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_is_locked()

static bool be_tx_is_locked ( const struct m0_be_tx *  tx)
static

Definition at line 561 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_make_reg_d()

static void be_tx_make_reg_d ( struct m0_be_tx *  tx,
struct m0_be_reg_d *  rd,
const struct m0_be_reg *  reg 
)
static

Definition at line 299 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_memory_allocate()

static int be_tx_memory_allocate ( struct m0_be_tx *  tx)
static

Definition at line 442 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_state_invariant()

static bool be_tx_state_invariant ( const struct m0_sm *  mach)
static

Definition at line 50 of file tx.c.

Here is the call graph for this function:

◆ be_tx_state_move()

static void be_tx_state_move ( struct m0_be_tx *  tx,
enum m0_be_tx_state  state,
int  rc 
)
static

Definition at line 481 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_tx_state_move_ast()

static void be_tx_state_move_ast ( struct m0_be_tx *  tx,
enum m0_be_tx_state  state 
)
static

Definition at line 422 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_fmt_group_size_max_check()

static m0_bcount_t be_ut_fmt_group_size_max_check ( struct m0_be_fmt_group_cfg *  fg_cfg,
uint64_t *  seed 
)
static

Definition at line 388 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_fmt_group_size_max_test()

static void be_ut_fmt_group_size_max_test ( struct m0_be_fmt_group_cfg *  fg_cfg2,
uint64_t *  seed 
)
static

Definition at line 442 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_io_sched_io_completion_cb()

static void be_ut_io_sched_io_completion_cb ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 161 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_io_sched_io_ready_add()

static void be_ut_io_sched_io_ready_add ( struct be_ut_io_sched_test *  test,
struct m0_be_io *  bio,
struct m0_be_op *  op 
)
static

Definition at line 114 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_io_sched_io_ready_get()

static void be_ut_io_sched_io_ready_get ( struct be_ut_io_sched_test *  test,
struct m0_be_io **  bio,
struct m0_be_op **  op 
)
static

Definition at line 127 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_io_sched_io_start_cb()

static void be_ut_io_sched_io_start_cb ( struct m0_be_op *  op,
void *  param 
)
static

Definition at line 174 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_io_sched_io_state_add()

static void be_ut_io_sched_io_state_add ( struct be_ut_io_sched_test *  test,
struct be_ut_io_sched_io_state *  state 
)
static

Definition at line 151 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_io_sched_states_check()

static void be_ut_io_sched_states_check ( struct be_ut_io_sched_io_state *  states,
int  states_nr,
struct m0_atomic64 *  states_pos 
)
static

Definition at line 259 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_io_sched_thread()

static void be_ut_io_sched_thread ( void *  param)
static

Definition at line 185 of file io_sched.c.

Here is the call graph for this function:

◆ be_ut_log_discard_gp_consume()

static void be_ut_log_discard_gp_consume ( struct be_ut_log_discard_gp_test *  test)
static

Definition at line 155 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_log_discard_gp_discard()

static void be_ut_log_discard_gp_discard ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 149 of file log_discard.c.

Here is the caller graph for this function:

◆ be_ut_log_discard_gp_produce()

static void be_ut_log_discard_gp_produce ( struct be_ut_log_discard_gp_test *  test)
static

Definition at line 168 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_log_discard_gp_set()

static void be_ut_log_discard_gp_set ( struct be_ut_log_discard_gp_test_item *  item,
bool  is_producer,
int  index,
struct be_ut_log_discard_gp_test *  test 
)
static

Definition at line 209 of file log_discard.c.

Here is the caller graph for this function:

◆ be_ut_log_discard_gp_sync()

static void be_ut_log_discard_gp_sync ( struct m0_be_log_discard *  ld,
struct m0_be_op *  op,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 142 of file log_discard.c.

Here is the caller graph for this function:

◆ be_ut_log_discard_gp_thread()

static void be_ut_log_discard_gp_thread ( void *  param)
static

Definition at line 180 of file log_discard.c.

Here is the call graph for this function:

◆ be_ut_log_discard_usecase_discard()

static void be_ut_log_discard_usecase_discard ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 64 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_log_discard_usecase_sync()

static void be_ut_log_discard_usecase_sync ( struct m0_be_log_discard *  ld,
struct m0_be_op *  op,
struct m0_be_log_discard_item *  ldi 
)
static

Definition at line 55 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_op_mt_thread_func()

static void be_ut_op_mt_thread_func ( void *  param)
static

Definition at line 85 of file op.c.

Here is the call graph for this function:

◆ be_ut_op_set_tree_do()

static void be_ut_op_set_tree_do ( struct m0_be_op *  op,
struct m0_be_op *  child,
enum be_ut_op_set_tree_cmd  cmd 
)
static

Definition at line 338 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_op_set_tree_random_shuffle()

static void be_ut_op_set_tree_random_shuffle ( unsigned *  arr,
unsigned  nr,
bool  keep_half_dist_order,
uint64_t *  seed 
)
static

Definition at line 308 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_op_set_tree_recursive()

static void be_ut_op_set_tree_recursive ( struct m0_be_op *  op,
enum be_ut_op_set_tree_cmd  cmd,
int  level,
int  index,
uint64_t *  seed 
)
static

Definition at line 373 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_op_set_tree_swap()

static void be_ut_op_set_tree_swap ( unsigned *  a,
unsigned *  b 
)
static

Definition at line 299 of file op.c.

Here is the caller graph for this function:

◆ be_ut_pd_usecase_thread()

static void be_ut_pd_usecase_thread ( void *  param)
static

Definition at line 64 of file pd.c.

Here is the call graph for this function:

◆ be_ut_queue()

static void be_ut_queue ( enum be_ut_queue_test  test)
static

Definition at line 362 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_queue_data_index()

static uint64_t be_ut_queue_data_index ( struct be_ut_queue_ctx *  ctx,
struct be_ut_queue_data *  data 
)
static

Definition at line 143 of file queue.c.

Here is the caller graph for this function:

◆ be_ut_queue_thread()

static void be_ut_queue_thread ( void *  _param)
static

Definition at line 167 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_queue_try_peek()

static void be_ut_queue_try_peek ( struct be_ut_queue_thread_param *  param,
struct be_ut_queue_ctx *  ctx 
)
static

Definition at line 149 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_queue_with_cfg()

static void be_ut_queue_with_cfg ( struct be_ut_queue_cfg *  test_cfg)
static

The test launches be_ut_queue_cfg::butc_producers + be_ut_queue_cfg::butc_consumers threads for producers and consumers respectively. Each producer/consumer thread does M0_BE_QUEUE_PUT()/M0_BE_QUEUE_GET() in a loop, and it also tries to M0_BE_QUEUE_PEEK() before each put()/get().

Definition at line 235 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_transact()

static void be_ut_transact ( struct be_ut_tx_x *  x,
struct m0_be_seg *  seg,
void **  alloc 
)
static

Definition at line 254 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_alloc()

static void* be_ut_tx_alloc ( void **  alloc,
m0_bcount_t  size 
)
static

Definition at line 118 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_alloc_fini()

static void be_ut_tx_alloc_fini ( void **  alloc)
static

Definition at line 113 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_alloc_init()

static void be_ut_tx_alloc_init ( void **  alloc,
struct m0_be_seg *  seg 
)
static

Definition at line 108 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_buf_fill_random()

static void be_ut_tx_buf_fill_random ( char *  data,
m0_bcount_t  size 
)
static

Definition at line 1006 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_parallel_do()

static void be_ut_tx_bulk_parallel_do ( struct m0_be_tx_bulk *  tb,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 703 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_parallel_done()

static void be_ut_tx_bulk_parallel_done ( struct m0_be_tx_bulk *  tb,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 722 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_parallel_test_prepare()

static void be_ut_tx_bulk_parallel_test_prepare ( struct m0_be_ut_backend *  ut_be,
struct m0_be_ut_seg *  ut_seg,
void *  ptr 
)
static

Definition at line 664 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_parallel_thread()

static void be_ut_tx_bulk_parallel_thread ( void *  _param)
static

Definition at line 733 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_parallel_work_put()

static void be_ut_tx_bulk_parallel_work_put ( struct m0_be_tx_bulk *  tb,
bool  success,
void *  ptr 
)
static

Definition at line 676 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_state_calc()

static void be_ut_tx_bulk_state_calc ( struct be_ut_tx_bulk_state *  tbs,
bool  calc_cred,
struct m0_be_tx_credit *  cred,
m0_bcount_t *  cred_payload 
)
static

Definition at line 300 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_state_do()

static void be_ut_tx_bulk_state_do ( struct m0_be_tx_bulk *  tb,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 347 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_state_done()

static void be_ut_tx_bulk_state_done ( struct m0_be_tx_bulk *  tb,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 385 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_state_test_prepare()

static void be_ut_tx_bulk_state_test_prepare ( struct m0_be_ut_backend *  ut_be,
struct m0_be_ut_seg *  ut_seg,
void *  ptr 
)
static

Definition at line 399 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_state_test_run()

static void be_ut_tx_bulk_state_test_run ( struct be_ut_tx_bulk_state *  tbs,
struct be_ut_tx_bulk_be_cfg *  be_cfg,
bool  success 
)
static

Definition at line 424 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_state_work_put()

static void be_ut_tx_bulk_state_work_put ( struct m0_be_tx_bulk *  tb,
bool  success,
void *  ptr 
)
static

Definition at line 324 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_test_fini()

static void be_ut_tx_bulk_test_fini ( struct be_ut_tx_bulk_be_ctx *  be_ctx)
static

Definition at line 117 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_test_init()

static void be_ut_tx_bulk_test_init ( struct be_ut_tx_bulk_be_ctx **  be_ctx_out,
struct be_ut_tx_bulk_be_cfg *  be_cfg,
void(*)(struct m0_be_ut_backend *ut_be, struct m0_be_ut_seg *ut_seg, void *ptr)  test_prepare,
void *  ptr 
)
static

Definition at line 67 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_test_run()

static void be_ut_tx_bulk_test_run ( struct be_ut_tx_bulk_be_ctx *  be_ctx,
struct m0_be_tx_bulk_cfg *  tb_cfg,
void(*)(struct m0_be_tx_bulk *tb, bool success, void *ptr)  test_work_put,
void *  ptr,
bool  success 
)
static

Definition at line 126 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_usecase_do()

static void be_ut_tx_bulk_usecase_do ( struct m0_be_tx_bulk *  tb,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 192 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_usecase_done()

static void be_ut_tx_bulk_usecase_done ( struct m0_be_tx_bulk *  tb,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 209 of file tx_bulk.c.

Here is the caller graph for this function:

◆ be_ut_tx_bulk_usecase_test_prepare()

static void be_ut_tx_bulk_usecase_test_prepare ( struct m0_be_ut_backend *  ut_be,
struct m0_be_ut_seg *  ut_seg,
void *  ptr 
)
static

Definition at line 218 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_bulk_usecase_work_put()

static void be_ut_tx_bulk_usecase_work_put ( struct m0_be_tx_bulk *  tb,
bool  success,
void *  ptr 
)
static

Definition at line 175 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_do_force()

static void be_ut_tx_do_force ( struct be_ut_tx_x *  xs,
size_t  nr 
)
static

Definition at line 337 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_fast_cb()

static bool be_ut_tx_fast_cb ( struct m0_clink *  clink)
static

Definition at line 561 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_fast_gc_free()

static void be_ut_tx_fast_gc_free ( struct m0_be_tx *  tx,
void *  param 
)
static

Definition at line 576 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_force()

static void be_ut_tx_force ( size_t  nr)
static

Tests m0_be_tx_force().

Parameters
nrNumber of transactions to use.

Definition at line 383 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_gc_cb()

static bool be_ut_tx_gc_cb ( struct m0_clink *  clink)
static

Definition at line 810 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_gc_free()

static void be_ut_tx_gc_free ( struct m0_be_tx *  tx,
void *  param 
)
static

Definition at line 827 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_gc_free_tx_failed()

static void be_ut_tx_gc_free_tx_failed ( struct m0_be_tx *  tx,
void *  param 
)
static

Definition at line 846 of file tx.c.

Here is the caller graph for this function:

◆ be_ut_tx_payload_test_nr()

static void be_ut_tx_payload_test_nr ( struct m0_be_ut_backend *  ut_be,
struct be_ut_tx_payload_test *  test,
size_t  nr 
)
static

Definition at line 1014 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_reg_rand()

static void be_ut_tx_reg_rand ( struct m0_be_reg *  reg,
struct m0_be_seg *  seg,
uint64_t *  seed 
)
static

Definition at line 466 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_reg_rand_fill()

static void be_ut_tx_reg_rand_fill ( struct m0_be_reg *  reg,
uint64_t *  seed 
)
static

Definition at line 479 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_run_tx_helper()

static void be_ut_tx_run_tx_helper ( struct be_ut_tx_thread_state *  state,
struct m0_be_tx *  tx,
bool  exclusive 
)
static

Definition at line 670 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_test()

static void be_ut_tx_test ( size_t  nr)
static
Parameters
nrNumber of transactions to use.

Definition at line 281 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ be_ut_tx_thread()

static void be_ut_tx_thread ( struct be_ut_tx_thread_state *  state)
static

Definition at line 686 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ betool_st_data_check()

static void betool_st_data_check ( struct m0_be_ut_backend *  ut_be,
struct m0_be_seg *  seg,
uint64_t *  fill 
)
static

Definition at line 71 of file st.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ betool_st_data_write()

static void betool_st_data_write ( struct m0_be_ut_backend *  ut_be,
struct m0_be_seg *  seg,
uint64_t  fill,
uint64_t  fill_end 
)
static

Definition at line 195 of file st.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ betool_st_event_time()

static void betool_st_event_time ( m0_time_t *  time,
enum betool_st_event  event 
)
static

Definition at line 164 of file st.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ betool_st_event_time_print()

static void betool_st_event_time_print ( m0_time_t *  time,
const char *  info,
uint64_t  fill 
)
static

Definition at line 170 of file st.c.

Here is the caller graph for this function:

◆ bname()

static const char * bname ( const struct btype *  bt)
static

Definition at line 1205 of file beck.c.

Here is the caller graph for this function:

◆ bnode()

static int bnode ( struct scanner *  s,
struct rectype *  r,
char *  buf 
)
static

Definition at line 1316 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ bnode_check()

static int bnode_check ( struct scanner *  s,
struct rectype *  r,
char *  buf 
)
static

Definition at line 1351 of file beck.c.

Here is the call graph for this function:

◆ bq_queue_items_max()

static uint64_t bq_queue_items_max ( struct m0_be_queue *  bq)
static

Definition at line 73 of file queue.c.

Here is the caller graph for this function:

◆ btree()

static int btree ( struct scanner *  s,
struct rectype *  r,
char *  buf 
)
static

Definition at line 1270 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_backlink_invariant()

static bool btree_backlink_invariant ( const struct m0_be_btree_backlink *  h,
const struct m0_be_seg *  seg,
const uint64_t *  parent 
)
static

Btree backlink invariant implementation:

  • checks that cookie is valid.
  • btree type is valid.
  • btree generation factor is valid.
    Parameters
    hlink back to the btree.
    segbackend segment.
    parentcookie of btree.
    Returns
    true if cookie, btree type and generation factor are valid, else false.

Definition at line 240 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_bad_kv_count_update()

static void btree_bad_kv_count_update ( uint64_t  type,
int  count 
)
static

Definition at line 2434 of file beck.c.

Here is the caller graph for this function:

◆ btree_check()

static int btree_check ( struct scanner *  s,
struct rectype *  r,
char *  buf 
)
static

Definition at line 1291 of file beck.c.

Here is the call graph for this function:

◆ btree_count_items()

static int btree_count_items ( struct m0_be_btree *  tree,
m0_bcount_t *  ksize,
m0_bcount_t *  vsize 
)
static

Definition at line 1794 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_create()

static void btree_create ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
const struct m0_fid *  btree_fid 
)
static

Used to create a btree with just the root node

Definition at line 375 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_credit()

static void btree_credit ( const struct m0_be_btree *  tree,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1618 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_cursor_seek()

static int btree_cursor_seek ( struct m0_be_btree_cursor *  cur,
void *  key 
)
static

Definition at line 2341 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_dbg_print()

void btree_dbg_print ( struct m0_be_btree *  tree)

Definition at line 2505 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_invariant()

static bool btree_invariant ( const struct m0_be_btree *  btree)
inlinestatic

Btree invariant implementation:

  • assuming that the tree is completely in memory.
  • header and checksum are valid.
  • btree backlink is valid.

Definition at line 337 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_kv_is_valid()

static bool btree_kv_is_valid ( struct m0_be_bnode *  node,
int  index,
struct m0_buf *  key 
)
static

Definition at line 2419 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_kv_post_is_valid()

static bool btree_kv_post_is_valid ( struct scanner *  s,
struct m0_buf *  key,
struct m0_buf *  val 
)
static

Definition at line 2428 of file beck.c.

Here is the caller graph for this function:

◆ btree_mem_alloc_credit()

static void btree_mem_alloc_credit ( const struct m0_be_btree *  btree,
m0_bcount_t  size,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 131 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_mem_free_credit()

static void btree_mem_free_credit ( const struct m0_be_btree *  btree,
m0_bcount_t  size,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 139 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_alloc_credit()

static void btree_node_alloc_credit ( const struct m0_be_btree *  tree,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1590 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_child_delete()

static void btree_node_child_delete ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
struct m0_be_bnode *  node,
unsigned  index,
struct btree_node_pos *  child,
bool  left 
)
static

Definition at line 881 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_free()

static void btree_node_free ( struct m0_be_bnode *  node,
const struct m0_be_btree *  btree,
struct m0_be_tx *  tx 
)
static

Frees the .

Definition at line 443 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_free_credit()

static void btree_node_free_credit ( const struct m0_be_btree *  tree,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1608 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_invariant()

static bool btree_node_invariant ( const struct m0_be_btree *  btree,
const struct m0_be_bnode *  node,
bool  root 
)
static

Btree node invariant implementation:

  • assuming that the tree is completely in memory.
  • checks that keys are in order.
  • node backlink to btree is valid.
  • nodes have expected occupancy: [1..2*order-1] for root and [order-1..2*order-1] for leafs.

Definition at line 262 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_keyval_update()

static void btree_node_keyval_update ( struct m0_be_bnode *  node,
const struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
unsigned int  index 
)
static

Definition at line 361 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_post_is_valid()

static bool btree_node_post_is_valid ( const struct m0_be_bnode *  node,
const struct m0_be_btree_kv_ops *  ops 
)
static

Definition at line 2409 of file beck.c.

Here is the caller graph for this function:

◆ btree_node_pre_is_valid()

static bool btree_node_pre_is_valid ( const struct m0_be_bnode *  node,
struct scanner *  s 
)
static

Definition at line 2392 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_split_child_credit()

static void btree_node_split_child_credit ( const struct m0_be_btree *  tree,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1667 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_subtree_invariant()

static bool btree_node_subtree_invariant ( const struct m0_be_btree *  btree,
const struct m0_be_bnode *  node 
)
static

Definition at line 308 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_update()

static void btree_node_update ( struct m0_be_bnode *  node,
const struct m0_be_btree *  btree,
struct m0_be_tx *  tx 
)
static

Definition at line 344 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_node_update_credit()

static void btree_node_update_credit ( struct m0_be_tx_credit *  accum,
m0_bcount_t  nr 
)
static

Definition at line 1596 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_op_fill()

static void btree_op_fill ( struct m0_be_op *  op,
struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
enum m0_be_btree_op  optype,
struct m0_be_btree_anchor *  anchor 
)
static

Definition at line 78 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_pair_release()

static void btree_pair_release ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
struct be_btree_key_val *  kv 
)
static

Definition at line 1349 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_rebalance_credit()

static void btree_rebalance_credit ( const struct m0_be_btree *  tree,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1627 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_root_set()

static void btree_root_set ( struct m0_be_btree *  btree,
struct m0_be_bnode *  new_root 
)
static

Definition at line 68 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_rwlock()

static struct m0_rwlock * btree_rwlock ( struct m0_be_btree *  tree)
static

Definition at line 2516 of file btree.c.

Here is the caller graph for this function:

◆ btree_save()

static void btree_save ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
const struct m0_buf *  val,
struct m0_be_btree_anchor *  anchor,
enum btree_save_optype  optype,
uint64_t  zonemask 
)
static

Inserts or updates value by key

Parameters
treeThe btree
txThe transaction
opThe operation
keyKey of the node to be searched
valueValue to be copied
optypeSave operation type: insert, update or overwrite
zonemaskBitmask of allowed allocation zones for memory allocation

Definition at line 1365 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ btree_truncate()

static void btree_truncate ( struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
m0_bcount_t  limit 
)
static

Truncate btree: truncate the tree till the limit provided in argument.

That function can be called multiple times, having maximum number of records to be deleted limited to not exceed transaction capacity. After first call tree can't be used for operations other than truncate or destroy.

Parameters
bteebtree to truncate
txtransaction
limitmaximum number of records to delete

Definition at line 1202 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ builder_action()

static void * builder_action ( struct builder *  b,
size_t  len,
enum action_opcode  opc,
const struct action_ops *  ops 
)
static

Definition at line 2365 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ builder_do()

static void builder_do ( struct m0_be_tx_bulk *  tb,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 1824 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ builder_done()

static void builder_done ( struct m0_be_tx_bulk *  tb,
void *  datum,
void *  user,
uint64_t  worker_index,
uint64_t  partition 
)
static

Definition at line 1848 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ builder_fini()

static void builder_fini ( struct builder *  b)
static

Definition at line 2128 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ builder_init()

static int builder_init ( struct builder *  b)
static

Initialise cob ios domain.
Initialise cob mds domain.

Definition at line 2029 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ builder_thread()

static void builder_thread ( struct builder *  b)
static

Below clean up used as m0_be_ut_backend_fini() fails because of unlocked thread's sm group. Simplify this task and call the exit function for builder thread.

Definition at line 1906 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ builder_work_put()

static void builder_work_put ( struct m0_be_tx_bulk *  tb,
struct builder *  b 
)
static

Definition at line 1873 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cache_insert()

static struct cache_slot * cache_insert ( struct cache *  c,
const struct m0_fid *  fid 
)
static

Definition at line 2463 of file beck.c.

Here is the caller graph for this function:

◆ cache_lookup()

static struct cache_slot * cache_lookup ( struct cache *  c,
struct m0_fid *  fid 
)
static

Definition at line 2447 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cob_act()

static void cob_act ( struct action *  act,
struct m0_be_tx *  tx 
)
static

Inserts the valid cob namespace key and records to cob namepace and object index btree.

Parameters
[in]actbuilder action.
[in]txbackend transaction.

Definition at line 3041 of file beck.c.

Here is the call graph for this function:

◆ cob_fini()

static void cob_fini ( struct action *  act)
static

Finalises the cob namespace operation.

Parameters
[in]actbuilder action.

Definition at line 3106 of file beck.c.

Here is the call graph for this function:

◆ cob_kv_get()

static int cob_kv_get ( struct scanner *  s,
const struct be_btree_key_val *  kv,
struct m0_buf *  key,
struct m0_buf *  val 
)
static

Reads and stores cob namespace tree key value pair.

Parameters
[in]sscanner.
[in]kvkey value pair read by scanner.
[out]keystores cob namespace key.
[out]valstores cob namespace record.

Read cob nskey.
Read cob nsvalue.

Definition at line 2916 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cob_prep()

static int cob_prep ( struct action *  act,
struct m0_be_tx_credit *  accum 
)
static

Allocates the credits for cob addition and deletion operation.

Parameters
[in]actbuilder action.
[out]credcredits allocated for addition and deletion operation.

Definition at line 3015 of file beck.c.

Here is the call graph for this function:

◆ cob_proc()

static int cob_proc ( struct scanner *  s,
struct btype *  b,
struct m0_be_bnode *  node,
off_t  node_offset 
)
static

Reads the cob namespace key and record from cob namespace btree key value pair. Puts the read cob namespae key and record in queue.

Parameters
sscanner.
bbtree type.
nodebtree node.

Definition at line 2954 of file beck.c.

Here is the call graph for this function:

◆ ctg_act()

static void ctg_act ( struct action *  act,
struct m0_be_tx *  tx 
)
static

Definition at line 2722 of file beck.c.

Here is the call graph for this function:

◆ ctg_btree_fid_get()

static int ctg_btree_fid_get ( struct m0_buf *  kbuf,
struct m0_fid *  fid 
)
static

Definition at line 2569 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ctg_create_meta()

static struct m0_cas_ctg* ctg_create_meta ( struct ctg_action *  ca,
struct m0_be_tx *  tx 
)
static

Definition at line 2698 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ctg_fini()

static void ctg_fini ( struct action *  act)
static

Definition at line 2764 of file beck.c.

Here is the call graph for this function:

◆ ctg_getslot_insertcred()

static struct cache_slot* ctg_getslot_insertcred ( struct ctg_action *  ca,
struct builder *  b,
struct m0_fid *  cas_ctg_fid,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 2662 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ctg_k_get()

static int ctg_k_get ( struct scanner *  s,
const void *  addr,
struct m0_buf *  kbuf 
)
static

Allocates space for key buf and makes it point to valid addr.

Definition at line 2519 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ctg_prep()

static int ctg_prep ( struct action *  act,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 2684 of file beck.c.

Here is the call graph for this function:

◆ ctg_proc()

static int ctg_proc ( struct scanner *  s,
struct btype *  b,
struct m0_be_bnode *  node,
off_t  node_offset 
)
static

Definition at line 2579 of file beck.c.

Here is the call graph for this function:

◆ ctg_pver_fid_get()

static int ctg_pver_fid_get ( struct m0_fid *  fid)
static

Get config root pool version fid from key and value which are generated by mkfs. In EES, Layout is fixed with this pool fid.

Definition at line 2481 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ctg_v_get()

static int ctg_v_get ( struct scanner *  s,
const void *  addr,
struct m0_buf *  vbuf 
)
static

Allocates space for val buf and makes it point to valid addr.

Definition at line 2544 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ delete_credit()

static void delete_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1704 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ deref()

static int deref ( struct scanner *  s,
const void *  addr,
void *  buf,
size_t  nob 
)
static

Definition at line 1242 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ disabled_xcode_alloc()

static void* disabled_xcode_alloc ( struct m0_xcode_cursor *  it,
size_t  nob 
)
static

Definition at line 42 of file fmt.c.

Here is the caller graph for this function:

◆ disabled_xcode_free()

static void disabled_xcode_free ( struct m0_xcode_cursor *  it)
static

Definition at line 47 of file fmt.c.

Here is the caller graph for this function:

◆ emap_act()

static void emap_act ( struct action *  act,
struct m0_be_tx *  tx 
)
static

Definition at line 1516 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ emap_dom_find()

static struct m0_stob_ad_domain* emap_dom_find ( const struct action *  act,
const struct m0_fid *  emap_fid,
int *  lockid 
)
static

Definition at line 1362 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ emap_entry_lookup()

static int emap_entry_lookup ( struct m0_stob_ad_domain *  adom,
struct m0_uint128  prefix,
m0_bindex_t  offset,
struct m0_be_emap_cursor *  it 
)
static

Definition at line 1465 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ emap_fini()

static void emap_fini ( struct action *  act)
static

Definition at line 1603 of file beck.c.

◆ emap_kv_get()

static int emap_kv_get ( struct scanner *  s,
const struct be_btree_key_val *  kv,
struct m0_buf *  key_buf,
struct m0_buf *  val_buf 
)
static

Definition at line 1607 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ emap_prep()

static int emap_prep ( struct action *  act,
struct m0_be_tx_credit *  cred 
)
static

Definition at line 1480 of file beck.c.

Here is the call graph for this function:

◆ emap_proc()

static int emap_proc ( struct scanner *  s,
struct btype *  b,
struct m0_be_bnode *  node,
off_t  node_offset 
)
static

Definition at line 1410 of file beck.c.

Here is the call graph for this function:

◆ emap_to_gob_convert()

static void emap_to_gob_convert ( const struct m0_uint128 *  emap_prefix,
struct m0_fid *  out 
)
static

Convert emap to stob_id

Convert stob_id to cob id
Convert COB id to GOB id

Definition at line 1386 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ fid_without_type_eq()

static bool fid_without_type_eq ( const struct m0_fid *  fid0,
const struct m0_fid *  fid1 
)
static

Definition at line 2440 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ fini()

static void fini ( void  )
static

Definition at line 1148 of file beck.c.

Here is the caller graph for this function:

◆ fmt_group_eq()

static bool fmt_group_eq ( struct m0_be_fmt_group *  left,
struct m0_be_fmt_group *  right 
)
static

Definition at line 207 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ fom2tx_group_fom()

static struct m0_be_tx_group_fom * fom2tx_group_fom ( const struct m0_fom *  fom)
static

Definition at line 276 of file tx_group_fom.c.

Here is the caller graph for this function:

◆ format_header_verify()

static int format_header_verify ( const struct m0_format_header *  h,
uint16_t  rtype 
)
static

Definition at line 2381 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ genadd()

static void genadd ( uint64_t  gen)
static

Definition at line 1663 of file beck.c.

Here is the caller graph for this function:

◆ generation_id_get()

static void generation_id_get ( FILE *  fp,
uint64_t *  gen_id 
)
static

Definition at line 873 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ generation_id_print()

static void generation_id_print ( uint64_t  gen)
static

Definition at line 825 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ generation_id_verify()

static int generation_id_verify ( struct scanner *  s,
uint64_t  gen 
)
static

Definition at line 918 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get()

static int get ( struct scanner *  s,
void *  buf,
size_t  nob 
)
static

Definition at line 1253 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ getat()

static int getat ( struct scanner *  s,
off_t  off,
void *  buf,
size_t  nob 
)
static

Definition at line 1210 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ id_cut()

static const char* id_cut ( const char *  prefix,
const char *  key 
)
static

Definition at line 105 of file domain.c.

Here is the caller graph for this function:

◆ init()

static int init ( void  )
static

Definition at line 1099 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ insert_credit()

static void insert_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum,
bool  use_current_height 
)
static

Definition at line 1674 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_engine_at_stopped_or_done()

static bool is_engine_at_stopped_or_done ( const struct m0_be_engine *  en,
bool  stopped 
)
static

If engine is stopped for new exclusive transaction, otherwize exclusive transaction is at M0_BTS_DONE state.

Definition at line 253 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ isqempty()

static bool isqempty ( struct queue *  q)
static

Definition at line 2883 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ iter_prepare()

static int iter_prepare ( struct m0_be_bnode *  node,
bool  print 
)
static

Definition at line 2228 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ key_eq()

static int key_eq ( const struct m0_be_btree *  btree,
const void *  key0,
const void *  key1 
)
inlinestatic

Definition at line 181 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ key_gt()

static int key_gt ( const struct m0_be_btree *  btree,
const void *  key0,
const void *  key1 
)
inlinestatic

Definition at line 175 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ key_lt()

static int key_lt ( const struct m0_be_btree *  btree,
const void *  key0,
const void *  key1 
)
inlinestatic

Definition at line 169 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ kv_delete_credit()

static void kv_delete_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1652 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ kv_insert_credit()

static void kv_insert_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)
static

Definition at line 1639 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_backend_fini()

M0_INTERNAL void m0_backend_fini ( void  )

Definition at line 156 of file be.c.

Here is the call graph for this function:

◆ m0_backend_init()

M0_INTERNAL int m0_backend_init ( void  )

Definition at line 150 of file be.c.

Here is the call graph for this function:

◆ M0_BASSERT() [1/7]

M0_BASSERT ( )

◆ M0_BASSERT() [2/7]

M0_BASSERT ( sizeof(bool)  = =1)

◆ M0_BASSERT() [3/7]

M0_BASSERT ( sizeof(struct be_alloc_chunk) %(1UL<< M0_BE_ALLOC_SHIFT_MIN)  = =0)

◆ M0_BASSERT() [4/7]

M0_BASSERT ( ARRAY_SIZE(betool_st_event_descr)  = =BETOOL_ST_TIME_NR)

◆ M0_BASSERT() [5/7]

M0_BASSERT ( sizeof(((struct m0_be_fmt_group *) NULL) ->fg_cfg)  = =sizeof(struct m0_be_fmt_group_cfg *))

◆ M0_BASSERT() [6/7]

M0_BASSERT ( ARRAY_SIZE(rt)  = =M0_FORMAT_TYPE_NR+1)

◆ M0_BASSERT() [7/7]

M0_BASSERT ( BE_UT_TX_CAPTURING_RANGE >=  sizeofuint64_t)

◆ m0_be_0type_add()

int m0_be_0type_add ( struct m0_be_0type *  zt,
struct m0_be_domain *  dom,
struct m0_be_tx *  tx,
const char *  suffix,
const struct m0_buf *  data 
)

Adds a record about 0type instance to the seg0 dictionary.

Definition at line 79 of file seg0.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_0type_add_credit()

void m0_be_0type_add_credit ( struct m0_be_domain *  dom,
const struct m0_be_0type *  zt,
const char *  suffix,
const struct m0_buf *  data,
struct m0_be_tx_credit *  credit 
)

Calculates BE-credit for m0_be_0type_add().

Definition at line 139 of file seg0.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_0type_del()

int m0_be_0type_del ( struct m0_be_0type *  zt,
struct m0_be_domain *  dom,
struct m0_be_tx *  tx,
const char *  suffix 
)

Deletes a record about 0type instance from the seg0 dictionary.

Definition at line 112 of file seg0.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_0type_del_credit()

void m0_be_0type_del_credit ( struct m0_be_domain *  dom,
const struct m0_be_0type *  zt,
const char *  suffix,
struct m0_be_tx_credit *  credit 
)

Calculates BE-credit for m0_be_0type_del().

Definition at line 156 of file seg0.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_0type_register()

void m0_be_0type_register ( struct m0_be_domain *  dom,
struct m0_be_0type *  zt 
)

Registers new 0type.

Definition at line 65 of file seg0.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_0type_unregister()

void m0_be_0type_unregister ( struct m0_be_domain *  dom,
struct m0_be_0type *  zt 
)

Registers new 0type.

Definition at line 72 of file seg0.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_alloc()

M0_INTERNAL void m0_be_alloc ( struct m0_be_allocator *  a,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void **  ptr,
m0_bcount_t  size 
)

Allocate memory.

The memory allocated is guaranteed to be suitably aligned for any kind of variable. See m0_be_alloc_aligned() for parameters description.

See also
m0_be_alloc_aligned(), M0_BAO_ALLOC, m0_alloc().

Definition at line 1091 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_alloc_aligned()

M0_INTERNAL void m0_be_alloc_aligned ( struct m0_be_allocator *  a,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void **  ptr,
m0_bcount_t  size,
unsigned  shift,
uint64_t  zonemask 
)

Allocate memory.

Parameters
aAllocator
txAllocation will be done in this transaction
opSee m0_be_op.
ptrPointer to allocated memory will be stored to *ptr. *ptr shouldn't be used before completion of the operation. Can be NULL.
sizeMemory size
shiftMemory will be aligned on (shift^2)-byte boundary. It can be less than M0_BE_ALLOC_SHIFT_MIN - in this case allocation will be done as if it is equal to M0_BE_ALLOC_SHIFT_MIN.
zonemaskBit mask of the zones where memory should be allocated. The first zone from the bit mask with sufficient space will be chosen for allocation, see m0_be_alloc_zone_type.

The memory should be freed using m0_be_free_aligned().

See also
m0_be_alloc(), m0_be_allocator_credit(), M0_BAO_ALLOC_ALIGNED, m0_alloc_aligned(), M0_BE_ALLOC_SHIFT_MIN.

Definition at line 1020 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_alloc_stats()

M0_INTERNAL void m0_be_alloc_stats ( struct m0_be_allocator *  a,
struct m0_be_allocator_stats *  out 
)

Return allocator statistics.

Note
Not implemented yet.
See also
m0_be_allocator_stats.

Definition at line 1159 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_alloc_stats_capture()

M0_INTERNAL void m0_be_alloc_stats_capture ( struct m0_be_allocator *  a,
struct m0_be_tx *  tx 
)

Definition at line 1175 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_alloc_stats_credit()

M0_INTERNAL void m0_be_alloc_stats_credit ( struct m0_be_allocator *  a,
struct m0_be_tx_credit *  accum 
)

Definition at line 1168 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_allocator__invariant()

M0_INTERNAL bool m0_be_allocator__invariant ( struct m0_be_allocator *  a)

Allocator invariant.

It will perform detailed verification of allocator data structures. It will ignore all user data.

Definition at line 758 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_allocator_create()

M0_INTERNAL int m0_be_allocator_create ( struct m0_be_allocator *  a,
struct m0_be_tx *  tx,
uint32_t *  zone_percent,
uint32_t  zones_nr 
)

Create allocator on the segment.

See also
m0_be_allocator.ba_seg, m0_be_allocator_init(), m0_be_allocator_header.

Definition at line 821 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_allocator_credit()

M0_INTERNAL void m0_be_allocator_credit ( struct m0_be_allocator *  a,
enum m0_be_allocator_op  optype,
m0_bcount_t  size,
unsigned  shift,
struct m0_be_tx_credit *  accum 
)

Accumulate credits for optype in accum.

Parameters
aAllocator
optypeAllocator operation type
sizeSize of allocation. Makes sense only for M0_IN(optype, (M0_BAO_ALLOC_ALIGNED, M0_BAO_ALLOC)). It is ignored for other optypes.
shiftMemory alignment shift. Makes sense only for optype == M0_BAO_ALLOC_ALIGNED. It is ignored for other optypes.
accumAccumulator for credits.
See also
m0_be_alloc_aligned(), m0_be_alloc(), m0_be_free(), m0_be_free_aligned(), m0_be_allocator_op, m0_be_tx_credit.

Definition at line 900 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_allocator_destroy()

M0_INTERNAL void m0_be_allocator_destroy ( struct m0_be_allocator *  a,
struct m0_be_tx *  tx 
)

Destroy allocator on the segment.

All memory allocations obtained from m0_be_alloc{,_aligned}() should be m0_be_free{,_aligned}()'d before calling this function.

Definition at line 883 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_allocator_fini()

M0_INTERNAL void m0_be_allocator_fini ( struct m0_be_allocator *  a)

Finalize allocator structure.

It will not affect allocated memory, allocator space or allocator header.

Definition at line 745 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_allocator_init()

M0_INTERNAL int m0_be_allocator_init ( struct m0_be_allocator *  a,
struct m0_be_seg *  seg 
)

Initialize allocator structure.

See also
m0_be_allocator_header.

Definition at line 719 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_clear_credit()

M0_INTERNAL void m0_be_btree_clear_credit ( struct m0_be_btree *  tree,
struct m0_be_tx_credit *  fixed_part,
struct m0_be_tx_credit *  single_record,
m0_bcount_t *  records_nr 
)

Calculates the credit needed to destroy index tree.

Separate credits by components to handle big btree clear not fitting into single transaction. The total number of credits to destroy index tree is fixed_part + single_record * records_nr.

Parameters
treebtree to proceed
fixed_partfixed credits part which definitely must be reserved
single_recordcredits to delete single index record
records_nrnumber of records in that index

Definition at line 1862 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_create()

M0_INTERNAL void m0_be_btree_create ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_fid *  btree_fid 
)

Creates btree on segment.

The operation is asynchronous. Use m0_be_op_wait() or m0_be_op_tick_ret() to wait for its completion.

Example:

m0_be_btree_init(&tree, seg, kv_ops);
m0_be_btree_create(&tree, tx, op, btree_fid);
m0_be_op_wait(op);
if (op->bo_u.u_btree.t_rc == 0) {
... // work with newly created tree
}
Parameters
btree_fidIt should be unique within a BE segment for a btree type. For example, btree fid is constructed from m0_be_btree_type and domain id.
&M0_FID_TINIT('b', M0_BBT_xxx, dom_id)

Definition at line 1512 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_create_credit()

M0_INTERNAL void m0_be_btree_create_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
struct m0_be_tx_credit *  accum 
)

Calculates the credit needed to create nodes and adds this credit to .

Definition at line 1783 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_fini()

M0_INTERNAL void m0_be_btree_cursor_fini ( struct m0_be_btree_cursor *  it)

Finalizes cursor.

Note: interface is synchronous.

Definition at line 2290 of file btree.c.

Here is the caller graph for this function:

◆ m0_be_btree_cursor_first_sync()

M0_INTERNAL int m0_be_btree_cursor_first_sync ( struct m0_be_btree_cursor *  it)

Moves cursor to the first key in the btree.

Note
The call is synchronous.

Definition at line 2348 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_get()

M0_INTERNAL void m0_be_btree_cursor_get ( struct m0_be_btree_cursor *  it,
const struct m0_buf *  key,
bool  slant 
)

Fills cursor internal buffers with current key and value obtained from the tree. Operation may cause IO depending on cursor::bc_op state

Note: interface is asynchronous and relies on cursor::bc_op::bo_sm. When it transits into M0_BOS_DONE, the operation is believed to be finished.

Note: allowed sequence of cursor calls is: m0_be_btree_cursor_init() ( m0_be_btree_cursor_get() ( m0_be_btree_cursor_next() | m0_be_btree_cursor_prev() | m0_be_btree_cursor_get() | m0_be_btree_cursor_kv_get() )* m0_be_btree_cursor_put() )* m0_be_btree_cursor_fini()

Parameters
slant[in]if slant == true then cursor will return a minimum key not less than given, otherwise it'll be set on exact key if it's possible.

Definition at line 2295 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_get_sync()

M0_INTERNAL int m0_be_btree_cursor_get_sync ( struct m0_be_btree_cursor *  it,
const struct m0_buf *  key,
bool  slant 
)

Synchronous version of m0_be_btree_cursor_get().

Definition at line 2331 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_init()

M0_INTERNAL void m0_be_btree_cursor_init ( struct m0_be_btree_cursor *  it,
struct m0_be_btree *  tree 
)

Initialises cursor and its internal structures.

Note: interface is synchronous.

Definition at line 2281 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_kv_get()

M0_INTERNAL void m0_be_btree_cursor_kv_get ( struct m0_be_btree_cursor *  it,
struct m0_buf *  key,
struct m0_buf *  val 
)

Sets key and value buffers to point on internal structures of cursor representing current key and value, cursor is placed on.

Any of and pointers can be NULL, but not both.

Note: interface is synchronous.

Definition at line 2485 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_last_sync()

M0_INTERNAL int m0_be_btree_cursor_last_sync ( struct m0_be_btree_cursor *  it)

Moves cursor to the last key in the btree.

Note
The call is synchronous.

Definition at line 2353 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_next()

M0_INTERNAL void m0_be_btree_cursor_next ( struct m0_be_btree_cursor *  it)

Fills cursor internal buffers with key and value obtained from the next position in tree. The operation is unprotected from concurrent btree updates and user should protect it with external lock. Operation may cause IO depending on cursor::bc_op state.

Note:

See also
m0_be_btree_cursor_get note.

Definition at line 2358 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_next_sync()

M0_INTERNAL int m0_be_btree_cursor_next_sync ( struct m0_be_btree_cursor *  it)

Synchronous version of m0_be_btree_cursor_next().

Definition at line 2464 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_prev()

M0_INTERNAL void m0_be_btree_cursor_prev ( struct m0_be_btree_cursor *  it)

Fills cursor internal buffers with prev key and value obtained from the tree. Operation may cause IO depending on cursor::bc_op state

Note:

See also
m0_be_btree_cursor_get note.

Definition at line 2411 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_prev_sync()

M0_INTERNAL int m0_be_btree_cursor_prev_sync ( struct m0_be_btree_cursor *  it)

Synchronous version of m0_be_btree_cursor_prev().

Definition at line 2472 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_cursor_put()

M0_INTERNAL void m0_be_btree_cursor_put ( struct m0_be_btree_cursor *  it)

Unpins pages associated with cursor, releases cursor values.

Note: interface is synchronous.

Definition at line 2480 of file btree.c.

Here is the caller graph for this function:

◆ m0_be_btree_delete()

M0_INTERNAL void m0_be_btree_delete ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key 
)

Deletes the entry by the given from btree. Operation is asynchronous.

-ENOENT is set to ->bo_u.u_btree.t_rc if not found.

See also
m0_be_btree_insert()

Definition at line 1958 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_delete_credit()

M0_INTERNAL void m0_be_btree_delete_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)

Calculates how many internal resources of tx_engine, described by m0_be_tx_credit, is needed to perform the delete operation over the . Function updates structure which is an input for m0_be_tx_prep().

Parameters
nrNumber of operations.
ksizeKey data size.
vsizeValue data size.

Definition at line 1740 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_destroy()

M0_INTERNAL void m0_be_btree_destroy ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op 
)

Deletes btree from segment, asynchronously.

Definition at line 1538 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_destroy_credit()

M0_INTERNAL void m0_be_btree_destroy_credit ( struct m0_be_btree *  tree,
struct m0_be_tx_credit *  accum 
)

Calculates the credit needed to destroy nodes and adds this credit to .

Definition at line 1831 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_fini()

M0_INTERNAL void m0_be_btree_fini ( struct m0_be_btree *  tree)

Finalises in-memory structures of btree.

Does not touch segment on disk.

See also
m0_be_btree_destroy(), which does remove tree structure from the segment.

Definition at line 1503 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_init()

M0_INTERNAL void m0_be_btree_init ( struct m0_be_btree *  tree,
struct m0_be_seg *  seg,
const struct m0_be_btree_kv_ops *  ops 
)

Initalises internal structures of the (e.g., mutexes, ), located in virtual memory of the program and not in mmaped() segment memory.

Definition at line 1487 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_insert()

M0_INTERNAL void m0_be_btree_insert ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
const struct m0_buf *  value 
)

Inserts and into btree. Operation is asynchronous.

Note0: interface is asynchronous and relies on op::bo_sm. Operation is considered to be finished after op::bo_sm transits to M0_BOS_DONE - after that point other operations will see the effect of this one.

Definition at line 1932 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_insert_credit()

M0_INTERNAL void m0_be_btree_insert_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)

Calculates how many internal resources of tx_engine, described by m0_be_tx_credit, is needed to perform the insert operation over the . Function updates structure which is an input for m0_be_tx_prep().

Parameters
nrNumber of operations.
ksizeKey data size.
vsizeValue data size.

Definition at line 1720 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_insert_credit2()

M0_INTERNAL void m0_be_btree_insert_credit2 ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)

The same as m0_be_btree_insert_credit() but uses the current btree height for credit calculation making it more accurate. It should be used with caution since it may hide the problems with credits until btree gets filled up. For example, it may be possible that the same operation which successfully works on less filled btree won't work when btree is more filled up because the number of required credits exceed the maximum size of possible credits in the transaction.

Definition at line 1730 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_insert_inplace()

M0_INTERNAL void m0_be_btree_insert_inplace ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
struct m0_be_btree_anchor *  anchor,
uint64_t  zonemask 
)

Inserts given into and returns the value placeholder at

Definition at line 2126 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_is_empty()

M0_INTERNAL bool m0_be_btree_is_empty ( struct m0_be_btree *  tree)
Precondition
tree->bb_root != NULL

Definition at line 2499 of file btree.c.

Here is the caller graph for this function:

◆ m0_be_btree_lookup()

M0_INTERNAL void m0_be_btree_lookup ( struct m0_be_btree *  tree,
struct m0_be_op *  op,
const struct m0_buf *  key,
struct m0_buf *  dest_value 
)

Looks up for a by the given in btree. The result is copied into provided buffer.

-ENOENT is set to ->bo_u.u_btree.t_rc if not found.

See also
m0_be_btree_create() regarding structure "mission".

Definition at line 2033 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_lookup_inplace()

M0_INTERNAL void m0_be_btree_lookup_inplace ( struct m0_be_btree *  tree,
struct m0_be_op *  op,
const struct m0_buf *  key,
struct m0_be_btree_anchor *  anchor 
)

Looks up a value stored in the by the given .

-ENOENT is set to ->bo_u.u_btree.t_rc if not found.

See also
m0_be_btree_update_inplace()

Definition at line 2152 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_lookup_slant()

M0_INTERNAL void m0_be_btree_lookup_slant ( struct m0_be_btree *  tree,
struct m0_be_op *  op,
struct m0_buf *  key,
struct m0_buf *  value 
)

Looks up for a record with the closest key >= given . The result is copied into provided and buffers.

-ENOENT is set to ->bo_u.u_btree.t_rc if not found.

See also
m0_be_btree_create() regarding structure "mission".

Definition at line 2041 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_maxkey()

M0_INTERNAL void m0_be_btree_maxkey ( struct m0_be_btree *  tree,
struct m0_be_op *  op,
struct m0_buf *  out 
)

Looks up for a maximum key value in the given .

See also
m0_be_btree_create() regarding structure "mission".

Definition at line 2049 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_minkey()

M0_INTERNAL void m0_be_btree_minkey ( struct m0_be_btree *  tree,
struct m0_be_op *  op,
struct m0_buf *  out 
)

Looks up for a minimum key value in the given .

See also
m0_be_btree_create() regarding structure "mission".

Definition at line 2070 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_release()

M0_INTERNAL void m0_be_btree_release ( struct m0_be_tx *  tx,
struct m0_be_btree_anchor *  anchor 
)

Completes m0_be_btree_*_inplace() operation by capturing all affected regions with m0_be_tx_capture() (if needed) and unlocking the tree.

Definition at line 2180 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_save()

M0_INTERNAL void m0_be_btree_save ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
const struct m0_buf *  val,
bool  overwrite 
)

This function:

  • Inserts given and in btree if does not exist.
  • Updates given in btree if exists and overwrite flag is set to true. NOTE: caller must always consider delete credits if it sets overwrite flag to true. Operation is asynchronous.

It's a shortcut for m0_be_btree_lookup() with successive m0_be_btree_insert() if key is not found or m0_be_btree_update() if key exists and overwrite flag is set. This function looks up the key only once compared to double lookup made by m0_btree_lookup() + m0_be_btree_insert()/update().

Credits for this operation should be calculated by m0_be_btree_insert_credit() or m0_be_btree_insert_credit2(), because in the worst case insertion is required.

See also
m0_be_btree_insert()

Definition at line 1912 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_save_inplace()

M0_INTERNAL void m0_be_btree_save_inplace ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
struct m0_be_btree_anchor *  anchor,
bool  overwrite,
uint64_t  zonemask 
)

This function:

  • Inserts given and in btree if does not exist.
  • Updates given in btree if exists and overwrite flag is set to true. User has to allocate his own buffer and capture node buffer in which is inserted.
See also
m0_be_btree_update_inplace()

Definition at line 2136 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_truncate()

M0_INTERNAL void m0_be_btree_truncate ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
m0_bcount_t  limit 
)

Truncate btree: delete all records, keep empty root.

That routine may be called more than once to fit into transaction. Btree between calls is not in usable state. Typically new transaction must be started for each call. It is ok to continue tree truncate after system restart. 'Limit' is a maximum number of records to be deleted.

Definition at line 1564 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_update()

M0_INTERNAL void m0_be_btree_update ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
const struct m0_buf *  value 
)

Updates the at the in btree. Operation is asynchronous.

-ENOENT is set to ->bo_u.u_btree.t_rc if not found.

See also
m0_be_btree_insert()

Definition at line 1941 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_update_credit()

M0_INTERNAL void m0_be_btree_update_credit ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)

Calculates how many internal resources of tx_engine, described by m0_be_tx_credit, is needed to perform the update operation over the . Function updates structure which is an input for m0_be_tx_prep(). Should be used for data which has fixed length when existing value area is re-used for a new value and no alloc/free operations are needed.

Parameters
nrNumber of operations.
vsizeValue data size.

Definition at line 1750 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_update_credit2()

M0_INTERNAL void m0_be_btree_update_credit2 ( const struct m0_be_btree *  tree,
m0_bcount_t  nr,
m0_bcount_t  ksize,
m0_bcount_t  vsize,
struct m0_be_tx_credit *  accum 
)

The same as m0_be_btree_update_credit() but should be used for data which has variable length and alloc/free operations may be needed.

Parameters
nrNumber of operations.
ksizeKey data size.
vsizeValue data size.

Definition at line 1772 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_btree_update_inplace()

M0_INTERNAL void m0_be_btree_update_inplace ( struct m0_be_btree *  tree,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
const struct m0_buf *  key,
struct m0_be_btree_anchor *  anchor 
)

Returns the record for update at the given . User provides the size of the value buffer that will be updated via

Definition at line 2095 of file btree.c.

Here is the call graph for this function:

◆ m0_be_domain__0type_register()

M0_INTERNAL void m0_be_domain__0type_register ( struct m0_be_domain *  dom,
struct m0_be_0type *  type 
)

Definition at line 647 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain__0type_unregister()

M0_INTERNAL void m0_be_domain__0type_unregister ( struct m0_be_domain *  dom,
struct m0_be_0type *  type 
)

Definition at line 655 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain__group_limits()

M0_INTERNAL void m0_be_domain__group_limits ( struct m0_be_domain *  dom,
uint32_t *  group_nr,
uint32_t *  tx_per_group 
)

Definition at line 968 of file domain.c.

Here is the call graph for this function:

◆ m0_be_domain_cleanup_by_location()

M0_INTERNAL void m0_be_domain_cleanup_by_location ( const char *  stob_domain_location)

Definition at line 442 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_engine()

M0_INTERNAL struct m0_be_engine * m0_be_domain_engine ( struct m0_be_domain *  dom)

Definition at line 461 of file domain.c.

Here is the caller graph for this function:

◆ m0_be_domain_is_locked()

M0_INTERNAL bool m0_be_domain_is_locked ( const struct m0_be_domain *  dom)

Definition at line 641 of file domain.c.

Here is the caller graph for this function:

◆ m0_be_domain_is_stob_log()

M0_INTERNAL bool m0_be_domain_is_stob_log ( struct m0_be_domain *  dom,
const struct m0_stob_id *  stob_id 
)

Check if the stob with the stob_id is used as a log stob for the given domain.

Definition at line 975 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_is_stob_seg()

M0_INTERNAL bool m0_be_domain_is_stob_seg ( struct m0_be_domain *  dom,
const struct m0_stob_id *  stob_id 
)

Check if the stob with the stob_id is used as a seg stob for the given domain.

Definition at line 986 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_log()

M0_INTERNAL struct m0_be_log * m0_be_domain_log ( struct m0_be_domain *  dom)

Definition at line 471 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_module_setup()

M0_INTERNAL void m0_be_domain_module_setup ( struct m0_be_domain *  dom,
const struct m0_be_domain_cfg *  cfg 
)

Definition at line 952 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_seg()

M0_INTERNAL struct m0_be_seg * m0_be_domain_seg ( const struct m0_be_domain *  dom,
const void *  addr 
)

Returns existing BE segment if is inside it. Returns NULL otherwise.

Definition at line 476 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_seg0_get()

M0_INTERNAL struct m0_be_seg * m0_be_domain_seg0_get ( struct m0_be_domain *  dom)

Definition at line 466 of file domain.c.

Here is the caller graph for this function:

◆ m0_be_domain_seg_by_addr()

M0_INTERNAL struct m0_be_seg * m0_be_domain_seg_by_addr ( struct m0_be_domain *  dom,
void *  addr 
)

Returns m0_be_seg the void * pointer is a part of. Returns NULL if there is no such segment.

Note: please don't cache m0_be_seg if it doesn't significantly improve the general performance significanly.

See also
m0_be_domain_seg_is_valid().

Definition at line 999 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_seg_by_id()

M0_INTERNAL struct m0_be_seg * m0_be_domain_seg_by_id ( const struct m0_be_domain *  dom,
uint64_t  id 
)

Returns existing be-segment by its . If no segments found return NULL.

Definition at line 493 of file domain.c.

Here is the caller graph for this function:

◆ m0_be_domain_seg_create()

M0_INTERNAL int m0_be_domain_seg_create ( struct m0_be_domain *  dom,
struct m0_be_tx *  tx,
const struct m0_be_0type_seg_cfg *  seg_cfg,
struct m0_be_seg **  out 
)

Definition at line 550 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_seg_create_credit()

M0_INTERNAL void m0_be_domain_seg_create_credit ( struct m0_be_domain *  dom,
const struct m0_be_0type_seg_cfg *  seg_cfg,
struct m0_be_tx_credit *  cred 
)

Definition at line 510 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_seg_destroy()

M0_INTERNAL int m0_be_domain_seg_destroy ( struct m0_be_domain *  dom,
struct m0_be_tx *  tx,
struct m0_be_seg *  seg 
)

Destroy functions for the segment dictionary and for the segment allocator are not called.

Current code doesn't do all necessary cleaning to be sure that nothing is allocated and there is no entry in segment dictionary before segment is destroyed.

However, it may be a problem with seg0 entries if objects they are describing were on destroyed segment. It may even lead to ABA problem. There is no such mechanism (yet) to keep track of these "lost" entries, so they are responsibility of a developer.

Definition at line 621 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_seg_destroy_credit()

M0_INTERNAL void m0_be_domain_seg_destroy_credit ( struct m0_be_domain *  dom,
struct m0_be_seg *  seg,
struct m0_be_tx_credit *  cred 
)

Definition at line 539 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_domain_seg_first()

M0_INTERNAL struct m0_be_seg * m0_be_domain_seg_first ( const struct m0_be_domain *  dom)

Returns be-segment first after seg0 or NULL if not existing.

Definition at line 486 of file domain.c.

Here is the caller graph for this function:

◆ m0_be_domain_seg_is_valid()

M0_INTERNAL bool m0_be_domain_seg_is_valid ( struct m0_be_domain *  dom,
struct m0_be_seg *  seg 
)

The primary use for this function is to use it with conjunction with m0_be_domain_seg_by_addr(). The typical use case is to cache the segment and then check on each access if it's still valid. The pointer can't be just dereferenced directly because the segment can be destroyed at any moment and current interface doesn't provide a way to track this event.

Definition at line 1015 of file domain.c.

Here is the call graph for this function:

◆ m0_be_domain_tx_find()

M0_INTERNAL struct m0_be_tx * m0_be_domain_tx_find ( struct m0_be_domain *  dom,
uint64_t  id 
)

Definition at line 455 of file domain.c.

Here is the call graph for this function:

◆ m0_be_domain_tx_size_max()

M0_INTERNAL void m0_be_domain_tx_size_max ( struct m0_be_domain *  dom,
struct m0_be_tx_credit *  cred,
m0_bcount_t *  payload_size 
)

Definition at line 961 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__exclusive_open_invariant()

M0_INTERNAL int m0_be_engine__exclusive_open_invariant ( struct m0_be_engine *  en,
struct m0_be_tx *  excl 
)

Definition at line 921 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__group_limits()

M0_INTERNAL void m0_be_engine__group_limits ( struct m0_be_engine *  en,
uint32_t *  group_nr,
uint32_t *  tx_per_group 
)

Definition at line 947 of file engine.c.

Here is the caller graph for this function:

◆ m0_be_engine__invariant()

M0_INTERNAL bool m0_be_engine__invariant ( struct m0_be_engine *  en)

Definition at line 612 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__tx_find()

M0_INTERNAL struct m0_be_tx * m0_be_engine__tx_find ( struct m0_be_engine *  en,
uint64_t  id 
)

Definition at line 887 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__tx_fini()

M0_INTERNAL void m0_be_engine__tx_fini ( struct m0_be_engine *  en,
struct m0_be_tx *  tx 
)

Definition at line 631 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__tx_force()

M0_INTERNAL void m0_be_engine__tx_force ( struct m0_be_engine *  en,
struct m0_be_tx *  tx 
)

Forces the tx group fom to move to LOGGING state and eventually commits all txs to disk.

Definition at line 684 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__tx_group_discard()

M0_INTERNAL void m0_be_engine__tx_group_discard ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr 
)

◆ m0_be_engine__tx_group_ready()

M0_INTERNAL void m0_be_engine__tx_group_ready ( struct m0_be_engine *  en,
struct m0_be_tx_group *  gr 
)

Definition at line 738 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__tx_init()

M0_INTERNAL void m0_be_engine__tx_init ( struct m0_be_engine *  en,
struct m0_be_tx *  tx,
enum m0_be_tx_state  state 
)

Definition at line 623 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine__tx_state_set()

M0_INTERNAL void m0_be_engine__tx_state_set ( struct m0_be_engine *  en,
struct m0_be_tx *  tx,
enum m0_be_tx_state  state 
)

Definition at line 639 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine_fini()

M0_INTERNAL void m0_be_engine_fini ( struct m0_be_engine *  en)

Definition at line 171 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine_full_log_cb()

M0_INTERNAL void m0_be_engine_full_log_cb ( struct m0_be_log *  log)

Definition at line 874 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine_got_log_space_cb()

M0_INTERNAL void m0_be_engine_got_log_space_cb ( struct m0_be_log *  log)

Definition at line 860 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine_init()

M0_INTERNAL int m0_be_engine_init ( struct m0_be_engine *  en,
struct m0_be_domain *  dom,
struct m0_be_engine_cfg *  en_cfg 
)

Definition at line 103 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine_start()

M0_INTERNAL int m0_be_engine_start ( struct m0_be_engine *  en)

Definition at line 792 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine_stop()

M0_INTERNAL void m0_be_engine_stop ( struct m0_be_engine *  en)

Definition at line 847 of file engine.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_engine_tx_size_max()

M0_INTERNAL void m0_be_engine_tx_size_max ( struct m0_be_engine *  en,
struct m0_be_tx_credit *  cred,
m0_bcount_t *  payload_size 
)

Definition at line 937 of file engine.c.

Here is the caller graph for this function:

◆ m0_be_fl__invariant()

M0_INTERNAL bool m0_be_fl__invariant ( struct m0_be_fl *  fl)

Definition at line 143 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fl_add()

M0_INTERNAL void m0_be_fl_add ( struct m0_be_fl *  fl,
struct m0_be_tx *  tx,
struct be_alloc_chunk *  chunk 
)

Definition at line 151 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fl_create()

M0_INTERNAL void m0_be_fl_create ( struct m0_be_fl *  fl,
struct m0_be_tx *  tx,
struct m0_be_seg *  seg 
)

Definition at line 110 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fl_credit()

M0_INTERNAL void m0_be_fl_credit ( struct m0_be_fl *  fl,
enum m0_be_fl_op  fl_op,
struct m0_be_tx_credit *  accum 
)

Definition at line 218 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fl_del()

M0_INTERNAL void m0_be_fl_del ( struct m0_be_fl *  fl,
struct m0_be_tx *  tx,
struct be_alloc_chunk *  chunk 
)

Definition at line 165 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fl_destroy()

M0_INTERNAL void m0_be_fl_destroy ( struct m0_be_fl *  fl,
struct m0_be_tx *  tx 
)

Definition at line 120 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fl_pick()

M0_INTERNAL struct be_alloc_chunk * m0_be_fl_pick ( struct m0_be_fl *  fl,
m0_bcount_t  size 
)

find free chunk with size at least ‘size’

Definition at line 178 of file fl.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ M0_BE_FMT_DECLARE() [1/6]

M0_BE_FMT_DECLARE ( group  )

◆ M0_BE_FMT_DECLARE() [2/6]

M0_BE_FMT_DECLARE ( log_store_header  )

◆ M0_BE_FMT_DECLARE() [3/6]

M0_BE_FMT_DECLARE ( log_record_footer  )

◆ M0_BE_FMT_DECLARE() [4/6]

M0_BE_FMT_DECLARE ( log_header  )

◆ M0_BE_FMT_DECLARE() [5/6]

M0_BE_FMT_DECLARE ( cblock  )

◆ M0_BE_FMT_DECLARE() [6/6]

M0_BE_FMT_DECLARE ( log_record_header  )

◆ M0_BE_FMT_DEFINE_INIT_SIMPLE() [1/4]

M0_BE_FMT_DEFINE_INIT_SIMPLE ( log_record_footer  )

◆ M0_BE_FMT_DEFINE_INIT_SIMPLE() [2/4]

M0_BE_FMT_DEFINE_INIT_SIMPLE ( log_store_header  )

◆ M0_BE_FMT_DEFINE_INIT_SIMPLE() [3/4]

M0_BE_FMT_DEFINE_INIT_SIMPLE ( cblock  )

◆ M0_BE_FMT_DEFINE_INIT_SIMPLE() [4/4]

M0_BE_FMT_DEFINE_INIT_SIMPLE ( log_header  )

◆ M0_BE_FMT_DEFINE_XCODE() [1/5]

M0_BE_FMT_DEFINE_XCODE ( log_record_header  )

◆ M0_BE_FMT_DEFINE_XCODE() [2/5]

M0_BE_FMT_DEFINE_XCODE ( log_record_footer  )

◆ M0_BE_FMT_DEFINE_XCODE() [3/5]

M0_BE_FMT_DEFINE_XCODE ( log_store_header  )

◆ M0_BE_FMT_DEFINE_XCODE() [4/5]

M0_BE_FMT_DEFINE_XCODE ( cblock  )

◆ M0_BE_FMT_DEFINE_XCODE() [5/5]

M0_BE_FMT_DEFINE_XCODE ( log_header  )

◆ m0_be_fmt_group__invariant()

static bool m0_be_fmt_group__invariant ( struct m0_be_fmt_group *  fg)
static

Definition at line 180 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_group_decode()

M0_INTERNAL int m0_be_fmt_group_decode ( struct m0_be_fmt_group **  fg,
struct m0_bufvec_cursor *  cur,
const struct m0_be_fmt_decode_cfg *  cfg 
)

Definition at line 355 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_decoded_free()

M0_INTERNAL void m0_be_fmt_group_decoded_free ( struct m0_be_fmt_group *  fg)

Definition at line 362 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_encode()

M0_INTERNAL int m0_be_fmt_group_encode ( struct m0_be_fmt_group *  fg,
struct m0_bufvec_cursor *  cur 
)

Definition at line 347 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_fini()

M0_INTERNAL void m0_be_fmt_group_fini ( struct m0_be_fmt_group *  fg)

Definition at line 286 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_info_get()

M0_INTERNAL struct m0_be_fmt_group_info * m0_be_fmt_group_info_get ( struct m0_be_fmt_group *  fg)

Definition at line 460 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_group_init()

M0_INTERNAL int m0_be_fmt_group_init ( struct m0_be_fmt_group *  fg,
const struct m0_be_fmt_group_cfg *  cfg 
)

Definition at line 237 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_reg_add()

M0_INTERNAL void m0_be_fmt_group_reg_add ( struct m0_be_fmt_group *  fg,
const struct m0_be_fmt_reg *  freg 
)

Definition at line 367 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_group_reg_by_id()

M0_INTERNAL void m0_be_fmt_group_reg_by_id ( const struct m0_be_fmt_group *  fg,
uint32_t  index,
struct m0_be_fmt_reg *  freg 
)

Definition at line 397 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_reg_nr()

M0_INTERNAL uint32_t m0_be_fmt_group_reg_nr ( const struct m0_be_fmt_group *  fg)

Definition at line 392 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_group_reset()

M0_INTERNAL void m0_be_fmt_group_reset ( struct m0_be_fmt_group *  fg)

Definition at line 297 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_sanity_check()

M0_INTERNAL bool m0_be_fmt_group_sanity_check ( struct m0_be_fmt_group *  fg)

Definition at line 465 of file fmt.c.

◆ m0_be_fmt_group_size()

M0_INTERNAL m0_bcount_t m0_be_fmt_group_size ( struct m0_be_fmt_group *  fg)

Definition at line 318 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_size_max()

M0_INTERNAL m0_bcount_t m0_be_fmt_group_size_max ( const struct m0_be_fmt_group_cfg *  cfg)

Definition at line 324 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_group_tx_add()

M0_INTERNAL void m0_be_fmt_group_tx_add ( struct m0_be_fmt_group *  fg,
const struct m0_be_fmt_tx *  ftx 
)

Definition at line 414 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_tx_by_id()

M0_INTERNAL void m0_be_fmt_group_tx_by_id ( const struct m0_be_fmt_group *  fg,
uint32_t  index,
struct m0_be_fmt_tx *  ftx 
)

Definition at line 443 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_group_tx_nr()

M0_INTERNAL uint32_t m0_be_fmt_group_tx_nr ( const struct m0_be_fmt_group *  fg)

Definition at line 438 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_log_record_header__invariant()

M0_INTERNAL bool m0_be_fmt_log_record_header__invariant ( struct m0_be_fmt_log_record_header *  header,
struct m0_be_log *  log 
)

Definition at line 1050 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_log_record_header_fini()

M0_INTERNAL void m0_be_fmt_log_record_header_fini ( struct m0_be_fmt_log_record_header *  obj)

Definition at line 578 of file fmt.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_fmt_log_record_header_init()

M0_INTERNAL int m0_be_fmt_log_record_header_init ( struct m0_be_fmt_log_record_header *  obj,
const struct m0_be_fmt_log_record_header_cfg *  cfg 
)

Definition at line 567 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_log_record_header_io_size_add()

M0_INTERNAL void m0_be_fmt_log_record_header_io_size_add ( struct m0_be_fmt_log_record_header *  obj,
m0_bcount_t  size 
)

Definition at line 602 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_log_record_header_reset()

M0_INTERNAL void m0_be_fmt_log_record_header_reset ( struct m0_be_fmt_log_record_header *  obj)

Definition at line 584 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_log_record_header_size_max()

M0_INTERNAL m0_bcount_t m0_be_fmt_log_record_header_size_max ( const struct m0_be_fmt_log_record_header_cfg *  cfg)

Definition at line 589 of file fmt.c.

Here is the caller graph for this function:

◆ m0_be_fmt_type_trace()

M0_INTERNAL int m0_be_fmt_type_trace ( const struct m0_xcode_cursor *  it)

Trace function for fmt types, when types are iterated generates log output.

Definition at line 218 of file fmt.c.

Here is the call graph for this function:

◆ m0_be_fmt_type_trace_end()

M0_INTERNAL void m0_be_fmt_type_trace_end ( const struct m0_xcode_cursor *  it)

Definition at line 213 of file fmt.c.

◆ m0_be_free()

M0_INTERNAL void m0_be_free ( struct m0_be_allocator *  a,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void *  ptr 
)

Free memory allocated with m0_be_alloc().

See also
m0_be_free_aligned(), M0_BAO_FREE.

Definition at line 1151 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_free_aligned()

M0_INTERNAL void m0_be_free_aligned ( struct m0_be_allocator *  a,
struct m0_be_tx *  tx,
struct m0_be_op *  op,
void *  ptr 
)

Free memory allocated with m0_be_alloc_aligned().

Parameters
aAllocator
txFree operation will be done in this transaction
opSee m0_be_op.
ptrPointer to memory to release. May be NULL - in this case call to this function is no-op. If ptr is not NULL, then it should be exactly the pointer returned from m0_be_alloc() for allocator a. Double m0_be_free() is not allowed for the same pointer from one call to m0_be_alloc().
See also
m0_be_alloc_aligned(), M0_BAO_FREE_ALIGNED, m0_be_allocator_destroy().

Definition at line 1101 of file alloc.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format__invariant()

M0_INTERNAL bool m0_be_group_format__invariant ( struct m0_be_group_format *  go)

Definition at line 297 of file tx_group_format.c.

◆ m0_be_group_format_allocate()

M0_INTERNAL int m0_be_group_format_allocate ( struct m0_be_group_format *  gft)

Definition at line 302 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_deallocate()

M0_INTERNAL void m0_be_group_format_deallocate ( struct m0_be_group_format *  gft)

Definition at line 307 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_decode()

M0_INTERNAL int m0_be_group_format_decode ( struct m0_be_group_format *  gft)

Definition at line 345 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_discard()

M0_INTERNAL void m0_be_group_format_discard ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)

Definition at line 550 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_encode()

M0_INTERNAL void m0_be_group_format_encode ( struct m0_be_group_format *  gft)

Definition at line 327 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_fini()

M0_INTERNAL void m0_be_group_format_fini ( struct m0_be_group_format *  gft)

Definition at line 292 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_group_info()

M0_INTERNAL struct m0_be_fmt_group_info * m0_be_group_format_group_info ( struct m0_be_group_format *  gft)

Definition at line 431 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_init()

M0_INTERNAL int m0_be_group_format_init ( struct m0_be_group_format *  gft,
struct m0_be_group_format_cfg *  gft_cfg,
struct m0_be_tx_group *  group,
struct m0_be_log *  log 
)

Definition at line 283 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_log_discarded()

M0_INTERNAL m0_bindex_t m0_be_group_format_log_discarded ( const struct m0_be_group_format *  gft)

Returns BE log discarded pointer at m0_be_group_format_log_use() time.

Definition at line 461 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_log_position()

M0_INTERNAL m0_bindex_t m0_be_group_format_log_position ( const struct m0_be_group_format *  gft)

Returns absolutute position of this group in BE log

Definition at line 455 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_log_read()

M0_INTERNAL void m0_be_group_format_log_read ( struct m0_be_group_format *  gft,
struct m0_be_op *  op 
)

Definition at line 504 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_log_reserved_size()

M0_INTERNAL m0_bcount_t m0_be_group_format_log_reserved_size ( struct m0_be_log *  log,
struct m0_be_tx_credit *  cred,
m0_bcount_t  cred_payload 
)

Definition at line 437 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_log_use()

M0_INTERNAL void m0_be_group_format_log_use ( struct m0_be_group_format *  gft,
m0_bcount_t  size_reserved 
)

Definition at line 467 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_log_write()

M0_INTERNAL void m0_be_group_format_log_write ( struct m0_be_group_format *  gft,
struct m0_be_op *  op 
)

Definition at line 497 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_module_setup()

M0_INTERNAL void m0_be_group_format_module_setup ( struct m0_be_group_format *  gft,
struct m0_be_group_format_cfg *  gft_cfg 
)

Definition at line 249 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_prepare()

M0_INTERNAL void m0_be_group_format_prepare ( struct m0_be_group_format *  gft,
struct m0_be_op *  op 
)

Definition at line 312 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_recovery_prepare()

M0_INTERNAL void m0_be_group_format_recovery_prepare ( struct m0_be_group_format *  gft,
struct m0_be_log *  log 
)

Definition at line 487 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_reg_get()

M0_INTERNAL void m0_be_group_format_reg_get ( const struct m0_be_group_format *  gft,
uint32_t  index,
struct m0_be_reg_d *  rd 
)

Definition at line 391 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_reg_log_add()

M0_INTERNAL void m0_be_group_format_reg_log_add ( struct m0_be_group_format *  gft,
const struct m0_be_reg_d *  rd 
)

Definition at line 366 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_reg_nr()

M0_INTERNAL uint32_t m0_be_group_format_reg_nr ( const struct m0_be_group_format *  gft)

Definition at line 385 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_reg_seg_add()

M0_INTERNAL void m0_be_group_format_reg_seg_add ( struct m0_be_group_format *  gft,
const struct m0_be_reg_d *  rd 
)

Definition at line 376 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_reset()

M0_INTERNAL void m0_be_group_format_reset ( struct m0_be_group_format *  gft)

Definition at line 163 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_seg_io_credit()

M0_INTERNAL void m0_be_group_format_seg_io_credit ( struct m0_be_group_format_cfg *  gft_cfg,
struct m0_be_io_credit *  io_cred 
)

Definition at line 591 of file tx_group_format.c.

Here is the caller graph for this function:

◆ m0_be_group_format_seg_place()

M0_INTERNAL void m0_be_group_format_seg_place ( struct m0_be_group_format *  gft,
struct m0_be_op *  op 
)

Definition at line 566 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_seg_place_prepare()

M0_INTERNAL void m0_be_group_format_seg_place_prepare ( struct m0_be_group_format *  gft)

Definition at line 511 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_tx_add()

M0_INTERNAL void m0_be_group_format_tx_add ( struct m0_be_group_format *  gft,
struct m0_be_fmt_tx *  ftx 
)

Definition at line 408 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_tx_get()

M0_INTERNAL void m0_be_group_format_tx_get ( const struct m0_be_group_format *  gft,
uint32_t  index,
struct m0_be_fmt_tx *  ftx 
)

Definition at line 421 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_group_format_tx_nr()

M0_INTERNAL uint32_t m0_be_group_format_tx_nr ( const struct m0_be_group_format *  gft)

Definition at line 415 of file tx_group_format.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io__invariant()

M0_INTERNAL bool m0_be_io__invariant ( struct m0_be_io *  bio)

Definition at line 228 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_add()

M0_INTERNAL void m0_be_io_add ( struct m0_be_io *  bio,
struct m0_stob *  stob,
void *  ptr_user,
m0_bindex_t  offset_stob,
m0_bcount_t  size 
)

Definition at line 280 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_add_nostob()

M0_INTERNAL void m0_be_io_add_nostob ( struct m0_be_io *  bio,
void *  ptr_user,
m0_bindex_t  offset_stob,
m0_bcount_t  size 
)

Definition at line 313 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_allocate()

M0_INTERNAL int m0_be_io_allocate ( struct m0_be_io *  bio,
struct m0_be_io_credit *  iocred 
)

Definition at line 180 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_configure()

M0_INTERNAL void m0_be_io_configure ( struct m0_be_io *  bio,
enum m0_stob_io_opcode  opcode 
)

Definition at line 516 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_credit_add()

M0_INTERNAL void m0_be_io_credit_add ( struct m0_be_io_credit *  iocred0,
const struct m0_be_io_credit *  iocred1 
)

iocred0 += iocred1

Definition at line 779 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_credit_le()

M0_INTERNAL bool m0_be_io_credit_le ( const struct m0_be_io_credit *  iocred0,
const struct m0_be_io_credit *  iocred1 
)

iocred0 <= iocred1

Definition at line 787 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_deallocate()

M0_INTERNAL void m0_be_io_deallocate ( struct m0_be_io *  bio)

Definition at line 215 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_fini()

M0_INTERNAL void m0_be_io_fini ( struct m0_be_io *  bio)

Definition at line 224 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_init()

M0_INTERNAL int m0_be_io_init ( struct m0_be_io *  bio)

Definition at line 175 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_intersect()

M0_INTERNAL bool m0_be_io_intersect ( const struct m0_be_io *  bio1,
const struct m0_be_io *  bio2 
)

Definition at line 732 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_is_empty()

M0_INTERNAL bool m0_be_io_is_empty ( struct m0_be_io *  bio)

Definition at line 646 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_launch()

M0_INTERNAL void m0_be_io_launch ( struct m0_be_io *  bio,
struct m0_be_op *  op 
)

Definition at line 599 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_offset_stob_is_eq()

M0_INTERNAL bool m0_be_io_offset_stob_is_eq ( const struct m0_be_io *  bio1,
const struct m0_be_io *  bio2 
)
Note
only one part and only one buffer in indexvec is supported atm.

Definition at line 764 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_opcode()

M0_INTERNAL enum m0_stob_io_opcode m0_be_io_opcode ( struct m0_be_io *  io)

Definition at line 641 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_ptr_user_is_eq()

M0_INTERNAL bool m0_be_io_ptr_user_is_eq ( const struct m0_be_io *  bio1,
const struct m0_be_io *  bio2 
)
Note
only one part and only one buffer in bufvec is supported atm.

Definition at line 748 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_reset()

M0_INTERNAL void m0_be_io_reset ( struct m0_be_io *  bio)

Definition at line 651 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sched_add()

M0_INTERNAL void m0_be_io_sched_add ( struct m0_be_io_sched *  sched,
struct m0_be_io *  io,
struct m0_ext *  ext,
struct m0_be_op *  op 
)

Definition at line 176 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sched_fini()

M0_INTERNAL void m0_be_io_sched_fini ( struct m0_be_io_sched *  sched)

Definition at line 64 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sched_init()

M0_INTERNAL int m0_be_io_sched_init ( struct m0_be_io_sched *  sched,
struct m0_be_io_sched_cfg *  cfg 
)

Definition at line 51 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sched_is_locked()

M0_INTERNAL bool m0_be_io_sched_is_locked ( struct m0_be_io_sched *  sched)

Definition at line 80 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sched_lock()

M0_INTERNAL void m0_be_io_sched_lock ( struct m0_be_io_sched *  sched)

Definition at line 70 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sched_unlock()

M0_INTERNAL void m0_be_io_sched_unlock ( struct m0_be_io_sched *  sched)

Definition at line 75 of file io_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_single()

M0_INTERNAL int m0_be_io_single ( struct m0_stob *  stob,
enum m0_stob_io_opcode  opcode,
void *  ptr_user,
m0_bindex_t  offset_stob,
m0_bcount_t  size 
)

Definition at line 682 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_size()

M0_INTERNAL m0_bcount_t m0_be_io_size ( struct m0_be_io *  bio)

Definition at line 500 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sort()

M0_INTERNAL void m0_be_io_sort ( struct m0_be_io *  bio)

Definition at line 664 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_stob_assign()

M0_INTERNAL void m0_be_io_stob_assign ( struct m0_be_io *  bio,
struct m0_stob *  stob,
m0_bindex_t  offset,
m0_bcount_t  size 
)

Definition at line 389 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_stob_move()

M0_INTERNAL void m0_be_io_stob_move ( struct m0_be_io *  bio,
struct m0_stob *  stob,
m0_bindex_t  offset,
m0_bindex_t  win_start,
m0_bcount_t  win_size 
)

Moves I/O vectors of the stob to the offset. Wraps them within window. Works only for sequential stob I/O and unpacked I/O vectors.

Definition at line 416 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_io_sync_enable()

M0_INTERNAL void m0_be_io_sync_enable ( struct m0_be_io *  bio)

call fdatasync() for linux stob after IO completion

Definition at line 631 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_sync_is_enabled()

M0_INTERNAL bool m0_be_io_sync_is_enabled ( struct m0_be_io *  bio)

Definition at line 636 of file io.c.

◆ m0_be_io_user_data()

M0_INTERNAL void * m0_be_io_user_data ( struct m0_be_io *  bio)

Definition at line 677 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_user_data_set()

M0_INTERNAL void m0_be_io_user_data_set ( struct m0_be_io *  bio,
void *  data 
)

Definition at line 672 of file io.c.

Here is the caller graph for this function:

◆ m0_be_io_vec_pack()

M0_INTERNAL void m0_be_io_vec_pack ( struct m0_be_io *  bio)

Packs I/O vectors.

The bio must be filled through m0_be_io_add_nostob() and all parts must be assigned with stobs.

Definition at line 470 of file io.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_list_add()

M0_INTERNAL void m0_be_list_add ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx,
void *  obj 
)

Definition at line 326 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_add_after()

M0_INTERNAL void m0_be_list_add_after ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx,
void *  obj,
void *  obj_new 
)

Definition at line 363 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_add_before()

M0_INTERNAL void m0_be_list_add_before ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx,
void *  obj,
void *  obj_new 
)

Definition at line 407 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_add_tail()

M0_INTERNAL void m0_be_list_add_tail ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx,
void *  obj 
)

Definition at line 451 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_create()

M0_INTERNAL void m0_be_list_create ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx 
)

Definition at line 134 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_credit()

M0_INTERNAL void m0_be_list_credit ( enum m0_be_list_op  optype,
m0_bcount_t  nr,
struct m0_be_tx_credit *  accum 
)

Calculates the credit needed to perform list operations of type and adds this credit to .

Definition at line 56 of file list.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ M0_BE_LIST_DEFINE() [1/2]

M0_BE_LIST_DEFINE ( be_seg_dict  ,
static  ,
struct be_seg_dict_keyval   
)

◆ M0_BE_LIST_DEFINE() [2/2]

M0_BE_LIST_DEFINE ( fl  ,
static  ,
struct be_alloc_chunk   
)

◆ m0_be_list_del()

M0_INTERNAL void m0_be_list_del ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx,
void *  obj 
)

Definition at line 488 of file list.c.

Here is the call graph for this function:

◆ M0_BE_LIST_DESCR_DEFINE() [1/2]

M0_BE_LIST_DESCR_DEFINE ( be_seg_dict  ,
"be_seg_dict"  ,
static  ,
struct be_seg_dict_keyval  ,
dkv_link  ,
dkv_magic  ,
M0_BE_SEG_DICT_MAGIC  ,
M0_BE_SEG_DICT_HEAD_MAGIC   
)

◆ M0_BE_LIST_DESCR_DEFINE() [2/2]

M0_BE_LIST_DESCR_DEFINE ( fl  ,
"m0_be_fl"  ,
static  ,
struct be_alloc_chunk  ,
bac_linkage_free  ,
bac_magic_free  ,
M0_BE_ALLOC_FREE_LINK_MAGIC  ,
M0_BE_ALLOC_FREE_MAGIC   
)

◆ m0_be_list_destroy()

M0_INTERNAL void m0_be_list_destroy ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx 
)

Definition at line 156 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_head()

M0_INTERNAL void * m0_be_list_head ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr 
)

Definition at line 259 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_is_empty()

M0_INTERNAL bool m0_be_list_is_empty ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr 
)

Definition at line 171 of file list.c.

Here is the caller graph for this function:

◆ m0_be_list_next()

M0_INTERNAL void * m0_be_list_next ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
const void *  obj 
)

Definition at line 300 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_prev()

M0_INTERNAL void * m0_be_list_prev ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr,
const void *  obj 
)

Definition at line 278 of file list.c.

Here is the call graph for this function:

◆ m0_be_list_tail()

M0_INTERNAL void * m0_be_list_tail ( struct m0_be_list *  blist,
const struct m0_be_list_descr *  descr 
)

Definition at line 235 of file list.c.

Here is the call graph for this function:

◆ m0_be_log__invariant()

M0_INTERNAL bool m0_be_log__invariant ( struct m0_be_log *  log)

Definition at line 270 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_bshift()

M0_INTERNAL uint32_t m0_be_log_bshift ( struct m0_be_log *  log)

Returns optimal block shift for the underlying storage.

Definition at line 883 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_close()

M0_INTERNAL void m0_be_log_close ( struct m0_be_log *  log)

Definition at line 287 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_contains_stob()

M0_INTERNAL bool m0_be_log_contains_stob ( struct m0_be_log *  log,
const struct m0_stob_id *  stob_id 
)

Definition at line 1233 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_create()

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

Definition at line 292 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_destroy()

M0_INTERNAL void m0_be_log_destroy ( struct m0_be_log *  log)

Definition at line 298 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_discard_fini()

M0_INTERNAL void m0_be_log_discard_fini ( struct m0_be_log_discard *  ld)

Definition at line 135 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_discard_flush()

M0_INTERNAL void m0_be_log_discard_flush ( struct m0_be_log_discard *  ld,
struct m0_be_op *  op 
)

Definition at line 374 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_discard_init()

M0_INTERNAL int m0_be_log_discard_init ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_cfg *  ld_cfg 
)

Definition at line 85 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_discard_item_ext()

M0_INTERNAL struct m0_ext * m0_be_log_discard_item_ext ( struct m0_be_log_discard_item *  ldi)

Definition at line 481 of file log_discard.c.

Here is the caller graph for this function:

◆ m0_be_log_discard_item_ext_set()

M0_INTERNAL void m0_be_log_discard_item_ext_set ( struct m0_be_log_discard_item *  ldi,
struct m0_ext *  ext 
)

Definition at line 474 of file log_discard.c.

Here is the caller graph for this function:

◆ m0_be_log_discard_item_finished()

M0_INTERNAL void m0_be_log_discard_item_finished ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)

Definition at line 417 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_discard_item_get()

M0_INTERNAL void m0_be_log_discard_item_get ( struct m0_be_log_discard *  ld,
struct m0_be_op *  op,
struct m0_be_log_discard_item **  ldi 
)

Definition at line 444 of file log_discard.c.

Here is the caller graph for this function:

◆ m0_be_log_discard_item_put()

M0_INTERNAL void m0_be_log_discard_item_put ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)

Definition at line 451 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_discard_item_starting()

M0_INTERNAL void m0_be_log_discard_item_starting ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)

Definition at line 400 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_discard_item_user_data()

M0_INTERNAL void * m0_be_log_discard_item_user_data ( struct m0_be_log_discard_item *  ldi)

Definition at line 468 of file log_discard.c.

Here is the caller graph for this function:

◆ m0_be_log_discard_item_user_data_set()

M0_INTERNAL void m0_be_log_discard_item_user_data_set ( struct m0_be_log_discard_item *  ldi,
void *  data 
)

Definition at line 461 of file log_discard.c.

Here is the caller graph for this function:

◆ m0_be_log_discard_sync()

M0_INTERNAL void m0_be_log_discard_sync ( struct m0_be_log_discard *  ld)

Definition at line 367 of file log_discard.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_header__is_eq()

M0_INTERNAL bool m0_be_log_header__is_eq ( struct m0_be_fmt_log_header *  hdr1,
struct m0_be_fmt_log_header *  hdr2 
)

Definition at line 902 of file log.c.

Here is the caller graph for this function:

◆ m0_be_log_header__repair()

M0_INTERNAL bool m0_be_log_header__repair ( struct m0_be_fmt_log_header **  hdrs,
int  nr,
struct m0_be_fmt_log_header *  out 
)

Definition at line 953 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_header__set()

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 
)

Definition at line 888 of file log.c.

Here is the caller graph for this function:

◆ m0_be_log_header_read()

M0_INTERNAL int m0_be_log_header_read ( struct m0_be_log *  log,
struct m0_be_fmt_log_header *  log_hdr 
)

Reads log header. Returned log_hdr structure is valid even if one log header is corrupted. It is achieved by storing redundant log headers.

Definition at line 973 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_io_allocate()

M0_INTERNAL int m0_be_log_io_allocate ( struct m0_be_log_io *  lio,
struct m0_be_io_credit *  iocred,
uint32_t  log_bshift 
)

Definition at line 114 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_io_be_io()

M0_INTERNAL struct m0_be_io * m0_be_log_io_be_io ( struct m0_be_log_io *  lio)

Definition at line 164 of file log_sched.c.

Here is the caller graph for this function:

◆ m0_be_log_io_bufvec()

M0_INTERNAL struct m0_bufvec * m0_be_log_io_bufvec ( struct m0_be_log_io *  lio)

Definition at line 159 of file log_sched.c.

Here is the caller graph for this function:

◆ m0_be_log_io_deallocate()

M0_INTERNAL void m0_be_log_io_deallocate ( struct m0_be_log_io *  lio)

Definition at line 150 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_io_fini()

M0_INTERNAL void m0_be_log_io_fini ( struct m0_be_log_io *  lio)

Definition at line 102 of file log_sched.c.

Here is the caller graph for this function:

◆ m0_be_log_io_init()

M0_INTERNAL int m0_be_log_io_init ( struct m0_be_log_io *  lio)

Definition at line 97 of file log_sched.c.

Here is the caller graph for this function:

◆ m0_be_log_io_is_empty()

M0_INTERNAL bool m0_be_log_io_is_empty ( struct m0_be_log_io *  lio)

Definition at line 180 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_io_reset()

M0_INTERNAL void m0_be_log_io_reset ( struct m0_be_log_io *  lio)

Definition at line 106 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_io_user_data()

M0_INTERNAL void * m0_be_log_io_user_data ( struct m0_be_log_io *  lio)

Definition at line 175 of file log_sched.c.

◆ m0_be_log_io_user_data_set()

M0_INTERNAL void m0_be_log_io_user_data_set ( struct m0_be_log_io *  lio,
void *  data 
)

Definition at line 169 of file log_sched.c.

◆ m0_be_log_module_setup()

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

Definition at line 233 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_open()

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

Definition at line 281 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_allocate()

M0_INTERNAL int m0_be_log_record_allocate ( struct m0_be_log_record *  record)

Allocates buffers for log i/o that were created through m0_be_log_record_io_create().

Postcondition
m0_be_log_record_io_create() isn't called for this record anymore

Definition at line 615 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_assign()

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

Assigns log record iterator to log record. Copies information from iter to record for further reading of the record's buffers.

Parameters
recordInitialised and allocated log record. After execution represents log record which is specified by iter. Record's buffers have uninitialised content.
need_discardSpecifies if the record will be discarded. Record should be discarded only if user reads it for re-applying.

Definition at line 467 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_deallocate()

M0_INTERNAL void m0_be_log_record_deallocate ( struct m0_be_log_record *  record)

Definition at line 630 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_discard()

M0_INTERNAL void m0_be_log_record_discard ( struct m0_be_log *  log,
m0_bcount_t  size 
)

Discards used space withing log.

Definition at line 523 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_discarded()

M0_INTERNAL m0_bindex_t m0_be_log_record_discarded ( const struct m0_be_log_record *  record)

Returns BE log discarded pointer before or at the time the record was written to the log.

Definition at line 844 of file log.c.

Here is the caller graph for this function:

◆ m0_be_log_record_ext()

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

Definition at line 496 of file log.c.

Here is the caller graph for this function:

◆ m0_be_log_record_fini()

M0_INTERNAL void m0_be_log_record_fini ( struct m0_be_log_record *  record)

Definition at line 410 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_init()

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

Initialises log record.

Parameters
cbcallback is called when all operations for the log record are finished.

Definition at line 390 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_initial()

M0_INTERNAL int m0_be_log_record_initial ( struct m0_be_log *  log,
struct m0_be_log_record_iter *  curr 
)

Definition at line 1167 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_io_bufvec()

M0_INTERNAL struct m0_bufvec * m0_be_log_record_io_bufvec ( struct m0_be_log_record *  record,
int  index 
)

Definition at line 830 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_io_create()

M0_INTERNAL int m0_be_log_record_io_create ( struct m0_be_log_record *  record,
m0_bcount_t  size_max 
)

Definition at line 558 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_io_launch()

M0_INTERNAL void m0_be_log_record_io_launch ( struct m0_be_log_record *  record,
struct m0_be_op *  op 
)

Schedule log record. Log owns the log record until user is signalled about completion.

Definition at line 795 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_io_prepare()

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 
)

Definition at line 660 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_io_size_set()

M0_INTERNAL void m0_be_log_record_io_size_set ( struct m0_be_log_record *  record,
int  index,
m0_bcount_t  size 
)

Definition at line 636 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_iter_copy()

M0_INTERNAL void m0_be_log_record_iter_copy ( struct m0_be_log_record_iter *  dest,
struct m0_be_log_record_iter *  src 
)

Definition at line 1161 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_iter_fini()

M0_INTERNAL void m0_be_log_record_iter_fini ( struct m0_be_log_record_iter *  iter)

Definition at line 1156 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_iter_init()

M0_INTERNAL int m0_be_log_record_iter_init ( struct m0_be_log_record_iter *  iter)

Definition at line 1151 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_next()

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 
)

Definition at line 1191 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_position()

M0_INTERNAL m0_bindex_t m0_be_log_record_position ( const struct m0_be_log_record *  record)

Returns absolute position of this log record in BE log

Definition at line 838 of file log.c.

Here is the caller graph for this function:

◆ m0_be_log_record_prev()

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 
)

Definition at line 1202 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_reset()

M0_INTERNAL void m0_be_log_record_reset ( struct m0_be_log_record *  record)

Resets log record.

Definition at line 433 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_record_skip_discard()

M0_INTERNAL void m0_be_log_record_skip_discard ( struct m0_be_log_record *  record)

Skips discarding of a record. The record will remain non-discarded.

Definition at line 505 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_recovery_discarded()

M0_INTERNAL m0_bindex_t m0_be_log_recovery_discarded ( struct m0_be_log *  log)

Definition at line 1228 of file log.c.

Here is the caller graph for this function:

◆ m0_be_log_recovery_record_available()

M0_INTERNAL bool m0_be_log_recovery_record_available ( struct m0_be_log *  log)

Definition at line 1214 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_recovery_record_get()

M0_INTERNAL void m0_be_log_recovery_record_get ( struct m0_be_log *  log,
struct m0_be_log_record_iter *  iter 
)

Definition at line 1221 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_reserve()

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

Reserves space for a log record. Reserved size can be bigger than actual size of the log record.

Definition at line 850 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_reserved_size()

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

Definition at line 358 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_sched_add()

M0_INTERNAL void m0_be_log_sched_add ( struct m0_be_log_sched *  sched,
struct m0_be_log_io *  lio,
struct m0_be_op *  op 
)

Definition at line 67 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_sched_fini()

M0_INTERNAL void m0_be_log_sched_fini ( struct m0_be_log_sched *  sched)

Definition at line 47 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_sched_init()

M0_INTERNAL int m0_be_log_sched_init ( struct m0_be_log_sched *  sched,
struct m0_be_log_sched_cfg *  cfg 
)

Definition at line 38 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_sched_is_locked()

M0_INTERNAL bool m0_be_log_sched_is_locked ( struct m0_be_log_sched *  sched)

Definition at line 62 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_sched_lock()

M0_INTERNAL void m0_be_log_sched_lock ( struct m0_be_log_sched *  sched)

Definition at line 52 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_sched_unlock()

M0_INTERNAL void m0_be_log_sched_unlock ( struct m0_be_log_sched *  sched)

Definition at line 57 of file log_sched.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store__invariant()

M0_INTERNAL bool m0_be_log_store__invariant ( struct m0_be_log_store *  ls)

Definition at line 73 of file log_store.c.

◆ m0_be_log_store_bshift()

M0_INTERNAL uint32_t m0_be_log_store_bshift ( struct m0_be_log_store *  ls)

Definition at line 591 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_buf_size()

M0_INTERNAL m0_bcount_t m0_be_log_store_buf_size ( struct m0_be_log_store *  ls)

Definition at line 596 of file log_store.c.

Here is the caller graph for this function:

◆ m0_be_log_store_close()

M0_INTERNAL void m0_be_log_store_close ( struct m0_be_log_store *  ls)

Definition at line 586 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_contains_stob()

M0_INTERNAL bool m0_be_log_store_contains_stob ( struct m0_be_log_store *  ls,
const struct m0_stob_id *  stob_id 
)

Definition at line 768 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_create()

M0_INTERNAL int m0_be_log_store_create ( struct m0_be_log_store *  ls,
struct m0_be_log_store_cfg *  ls_cfg 
)

Definition at line 575 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_destroy()

M0_INTERNAL void m0_be_log_store_destroy ( struct m0_be_log_store *  ls)

Definition at line 581 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_io_credit()

M0_INTERNAL void m0_be_log_store_io_credit ( struct m0_be_log_store *  ls,
struct m0_be_io_credit *  accum 
)

Definition at line 601 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_io_discard()

M0_INTERNAL void m0_be_log_store_io_discard ( struct m0_be_log_store *  ls,
m0_bindex_t  offset,
struct m0_be_op *  op 
)

Discards information about range [0, offset).

Note
It is not persistent in the current implementation, but it still can be used for invariants.

Definition at line 619 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_io_translate()

M0_INTERNAL void m0_be_log_store_io_translate ( struct m0_be_log_store *  ls,
m0_bindex_t  position,
struct m0_be_io *  bio 
)

Re-calculates stob indexes for BE I/O operation. Logically, this function adds position value to the stob indexes and translates them into proper pysical offsets. This operation may add new I/O vector to the bio or even new stob. Therefore, user must allocate additional space in m0_be_io structure.

Parameters
positionlogical offset
Todo:
s/io_prepare/io_translate/g

Definition at line 637 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_io_window()

M0_INTERNAL int m0_be_log_store_io_window ( struct m0_be_log_store *  ls,
m0_bindex_t  offset,
m0_bcount_t *  length 
)

Get I/O window for the given offset.

Returns
-EINVAL information about byte at the given offset was already discarded.

Definition at line 607 of file log_store.c.

Here is the caller graph for this function:

◆ m0_be_log_store_module_setup()

M0_INTERNAL void m0_be_log_store_module_setup ( struct m0_be_log_store *  ls,
struct m0_be_log_store_cfg *  ls_cfg,
bool  create_mode 
)

Definition at line 534 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_open()

M0_INTERNAL int m0_be_log_store_open ( struct m0_be_log_store *  ls,
struct m0_be_log_store_cfg *  ls_cfg 
)

Definition at line 569 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_overwrites()

M0_INTERNAL bool m0_be_log_store_overwrites ( struct m0_be_log_store *  ls,
m0_bindex_t  index,
m0_bcount_t  size,
m0_bindex_t  position 
)

Definition at line 752 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_rbuf_io_first()

M0_INTERNAL struct m0_be_log_io * m0_be_log_store_rbuf_io_first ( struct m0_be_log_store *  ls,
enum m0_be_log_store_io_type  io_type,
struct m0_be_op **  op,
unsigned *  iter 
)

Definition at line 692 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_rbuf_io_next()

M0_INTERNAL struct m0_be_log_io * m0_be_log_store_rbuf_io_next ( struct m0_be_log_store *  ls,
enum m0_be_log_store_io_type  io_type,
struct m0_be_op **  op,
unsigned *  iter 
)

Definition at line 702 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_rbuf_io_reset()

M0_INTERNAL void m0_be_log_store_rbuf_io_reset ( struct m0_be_log_store *  ls,
enum m0_be_log_store_io_type  io_type 
)

Definition at line 718 of file log_store.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_log_store_rbuf_read_buf_first()

M0_INTERNAL struct m0_buf * m0_be_log_store_rbuf_read_buf_first ( struct m0_be_log_store *  ls,
unsigned *  iter 
)

Definition at line 660 of file log_store.c.

Here is the caller graph for this function:

◆ m0_be_log_store_rbuf_read_buf_next()

M0_INTERNAL struct m0_buf * m0_be_log_store_rbuf_read_buf_next ( struct m0_be_log_store *  ls,
unsigned *  iter 
)

Definition at line 668 of file log_store.c.

Here is the caller graph for this function:

◆ m0_be_log_store_rbuf_write_buf()

M0_INTERNAL struct m0_buf * m0_be_log_store_rbuf_write_buf ( struct m0_be_log_store *  ls)
Todo:
Make interface for redundant buffer simplier.

m0_be_log_store can provide interface to:

  • set redundant buffer size and number of redundant buffers in m0_be_log_store_create();
  • get bufvec of the redundant buffer;
  • get all m0_be_log_io to perform I/O for redundant buffer.

In this case m0_be_log_store can use any kind of data as a redundant buffer, not just m0_be_log_header.

Definition at line 654 of file log_store.c.

Here is the caller graph for this function:

◆ m0_be_log_unreserve()

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

Unreserves space that was previously reserved with m0_be_log_reserve(). Used if tx failed, but log space is already reserved.

Definition at line 868 of file log.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_active()

M0_INTERNAL void m0_be_op_active ( struct m0_be_op *  op)

Moves op to M0_BOS_ACTIVE state.

Definition at line 220 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_callback_set()

M0_INTERNAL void m0_be_op_callback_set ( struct m0_be_op *  op,
m0_be_op_cb_t  cb,
void *  param,
enum m0_be_op_state  state 
)

Definition at line 239 of file op.c.

Here is the caller graph for this function:

◆ m0_be_op_done()

M0_INTERNAL void m0_be_op_done ( struct m0_be_op *  op)

Moves op to M0_BOS_DONE state.

Definition at line 227 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_fini()

M0_INTERNAL void m0_be_op_fini ( struct m0_be_op *  op)

Definition at line 107 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_init()

M0_INTERNAL void m0_be_op_init ( struct m0_be_op *  op)

Definition at line 94 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_is_done()

M0_INTERNAL bool m0_be_op_is_done ( struct m0_be_op *  op)

Is op in M0_BOS_DONE state?

Definition at line 234 of file op.c.

Here is the caller graph for this function:

◆ m0_be_op_is_locked()

M0_INTERNAL bool m0_be_op_is_locked ( const struct m0_be_op *  op)

Definition at line 125 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_lock()

M0_INTERNAL void m0_be_op_lock ( struct m0_be_op *  op)

Definition at line 115 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_rc()

M0_INTERNAL int m0_be_op_rc ( struct m0_be_op *  op)

Definition at line 324 of file op.c.

Here is the call graph for this function:

◆ m0_be_op_rc_set()

M0_INTERNAL void m0_be_op_rc_set ( struct m0_be_op *  op,
int  rc 
)

Definition at line 314 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_reset()

M0_INTERNAL void m0_be_op_reset ( struct m0_be_op *  op)

Definition at line 152 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_set_add()

M0_INTERNAL void m0_be_op_set_add ( struct m0_be_op *  parent,
struct m0_be_op *  child 
)

Adds to , making the latter an "op set".

Definition at line 297 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_tick_ret()

M0_INTERNAL int m0_be_op_tick_ret ( struct m0_be_op *  op,
struct m0_fom *  fom,
int  next_state 
)

Moves the fom to the "next_state" and arranges for state transitions to continue when "op" completes. Returns value suitable to be returned from m0_fom_ops::fo_tick() implementation.

Definition at line 267 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_unlock()

M0_INTERNAL void m0_be_op_unlock ( struct m0_be_op *  op)

Definition at line 120 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_op_wait()

M0_INTERNAL void m0_be_op_wait ( struct m0_be_op *  op)

Waits for the operation to complete.

See also
M0_BE_OP_SYNC(), M0_BE_OP_SYNC_RET()

Definition at line 286 of file op.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_pd_fini()

M0_INTERNAL void m0_be_pd_fini ( struct m0_be_pd *  pd)

Definition at line 127 of file pd.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_pd_init()

M0_INTERNAL int m0_be_pd_init ( struct m0_be_pd *  pd,
struct m0_be_pd_cfg *  pd_cfg 
)

Definition at line 86 of file pd.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_pd_io_add()

M0_INTERNAL void m0_be_pd_io_add ( struct m0_be_pd *  pd,
struct m0_be_pd_io *  pdio,
struct m0_ext *  ext,
struct m0_be_op *  op 
)

Definition at line 149 of file pd.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_pd_io_be_io()

M0_INTERNAL struct m0_be_io * m0_be_pd_io_be_io ( struct m0_be_pd_io *  pdio)

Definition at line 185 of file pd.c.

Here is the caller graph for this function:

◆ m0_be_pd_io_get()

M0_INTERNAL void m0_be_pd_io_get ( struct m0_be_pd *  pd,
struct m0_be_pd_io **  pdio,
struct m0_be_op *  op 
)

Definition at line 169 of file pd.c.

Here is the caller graph for this function:

◆ m0_be_pd_io_put()

M0_INTERNAL void m0_be_pd_io_put ( struct m0_be_pd *  pd,
struct m0_be_pd_io *  pdio 
)

Definition at line 176 of file pd.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_pd_sync()

M0_INTERNAL void m0_be_pd_sync ( struct m0_be_pd *  pd,
m0_bindex_t  pos,
struct m0_stob **  stobs,
int  nr,
struct m0_be_op *  op 
)

Run fdatasync() for the given set of stobs.

Note
pos parameter is ignored for now.

Definition at line 216 of file pd.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_pool_add()

M0_INTERNAL void m0_be_pool_add ( const struct m0_be_pool_descr *  d,
struct m0_be_pool *  pool,
void *  obj 
)

Adds an object to the pool.

Definition at line 191 of file pool.c.

Here is the call graph for this function:

◆ M0_BE_POOL_DEFINE() [1/2]

M0_BE_POOL_DEFINE ( pdio  ,
static  ,
struct m0_be_pd_io   
)

◆ M0_BE_POOL_DEFINE() [2/2]

M0_BE_POOL_DEFINE ( ld  ,
static  ,
struct m0_be_log_discard_item   
)

◆ m0_be_pool_del()

M0_INTERNAL void * m0_be_pool_del ( const struct m0_be_pool_descr *  d,
struct m0_be_pool *  pool 
)

Removes an object from the pool and returns the object.

Definition at line 207 of file pool.c.

Here is the call graph for this function:

◆ M0_BE_POOL_DESCR_DEFINE() [1/2]

M0_BE_POOL_DESCR_DEFINE ( pdio  ,
"pd_io pool"  ,
static  ,
struct m0_be_pd_io  ,
bpi_pool_item  ,
bpi_pool_magic  ,
M0_BE_PD_IO_MAGIC   
)

◆ M0_BE_POOL_DESCR_DEFINE() [2/2]

M0_BE_POOL_DESCR_DEFINE ( ld  ,
"m0_be_log_discard::lds_item_pool"  ,
static  ,
struct m0_be_log_discard_item  ,
ldi_pool_item  ,
ldi_pool_magic  ,
M0_BE_LOG_DISCARD_POOL_MAGIC   
)

◆ m0_be_pool_fini()

M0_INTERNAL void m0_be_pool_fini ( struct m0_be_pool *  pool)

Definition at line 78 of file pool.c.

Here is the call graph for this function:

◆ m0_be_pool_get()

M0_INTERNAL void m0_be_pool_get ( const struct m0_be_pool_descr *  d,
struct m0_be_pool *  pool,
void **  obj,
struct m0_be_op *  op 
)

Asynchronously gets an object from the pool. op is signalled on completion.

Definition at line 226 of file pool.c.

Here is the call graph for this function:

◆ m0_be_pool_init()

M0_INTERNAL int m0_be_pool_init ( struct m0_be_pool *  pool,
struct m0_be_pool_cfg *  cfg 
)

Definition at line 58 of file pool.c.

Here is the call graph for this function:

◆ m0_be_pool_put()

M0_INTERNAL void m0_be_pool_put ( const struct m0_be_pool_descr *  d,
struct m0_be_pool *  pool,
void *  obj 
)

Returns the object to the pool.

Definition at line 253 of file pool.c.

Here is the call graph for this function:

◆ m0_be_queue_end()

M0_INTERNAL void m0_be_queue_end ( struct m0_be_queue *  bq)

Definition at line 377 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_queue_fini()

M0_INTERNAL void m0_be_queue_fini ( struct m0_be_queue *  bq)

Definition at line 148 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_queue_get()

M0_INTERNAL void m0_be_queue_get ( struct m0_be_queue *  bq,
struct m0_be_op *  op,
struct m0_buf *  data,
bool *  successful 
)

Definition at line 392 of file queue.c.

Here is the call graph for this function:

◆ m0_be_queue_init()

M0_INTERNAL int m0_be_queue_init ( struct m0_be_queue *  bq,
struct m0_be_queue_cfg *  cfg 
)

Definition at line 94 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_queue_lock()

M0_INTERNAL void m0_be_queue_lock ( struct m0_be_queue *  bq)

Definition at line 190 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_queue_peek()

M0_INTERNAL bool m0_be_queue_peek ( struct m0_be_queue *  bq,
struct m0_buf *  data 
)

Definition at line 422 of file queue.c.

Here is the call graph for this function:

◆ m0_be_queue_put()

M0_INTERNAL void m0_be_queue_put ( struct m0_be_queue *  bq,
struct m0_be_op *  op,
const struct m0_buf *  data 
)

Definition at line 344 of file queue.c.

Here is the call graph for this function:

◆ m0_be_queue_unlock()

M0_INTERNAL void m0_be_queue_unlock ( struct m0_be_queue *  bq)

Definition at line 195 of file queue.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt__invariant()

M0_INTERNAL bool m0_be_rdt__invariant ( const struct m0_be_reg_d_tree *  rdt)

Definition at line 224 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_del()

M0_INTERNAL struct m0_be_reg_d * m0_be_rdt_del ( struct m0_be_reg_d_tree *  rdt,
const struct m0_be_reg_d *  rd 
)

Delete a region from the tree.

Parameters
rdtm0_be_reg_d tree
rdregion to delete
Returns
pointer to the next item after the deleted
NULL if the last item was deleted
See also
m0_be_rdt_init().

Definition at line 347 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_find()

M0_INTERNAL struct m0_be_reg_d * m0_be_rdt_find ( const struct m0_be_reg_d_tree *  rdt,
void *  addr 
)

Find region by address.

  • find first m0_be_reg_d that contains byte with the given address or
  • first region after the given address or
  • get first region in the tree if the given address is NULL.
See also
m0_be_rdt_init(), m0_be_rdt_next().

Definition at line 299 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_fini()

M0_INTERNAL void m0_be_rdt_fini ( struct m0_be_reg_d_tree *  rdt)

Finalize m0_be_reg_d tree. Free all memory allocated

Definition at line 218 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_init()

M0_INTERNAL int m0_be_rdt_init ( struct m0_be_reg_d_tree *  rdt,
size_t  size_max 
)

Initialize m0_be_reg_d tree.

  • memory allocation takes place only in this function;
  • m0_be_reg_d given to the m0_be_rdt_ins() will be copied to the tree;
  • m0_be_reg_d in the tree are ordered by a region start address;
  • there is no overlapping between regions in the tree;
  • regions in the tree have size > 0;
  • all fields of m0_be_reg_d except rd_reg are completely ignored in a tree functions;

Region is from the tree iff it is returned by m0_be_rdt_find(), m0_be_rdt_next(), m0_be_rdt_del().

Note
Current implementation is based on array, so technically it is not a tree. Optimizations should be made to make it a real tree.

Definition at line 207 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_ins()

M0_INTERNAL void m0_be_rdt_ins ( struct m0_be_reg_d_tree *  rdt,
const struct m0_be_reg_d *  rd 
)

Insert a region in the tree.

Precondition
rd->rd_reg.br_size > 0
Note
rd will be copied to the tree.
See also
m0_be_rdt_init().

Definition at line 328 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_next()

M0_INTERNAL struct m0_be_reg_d * m0_be_rdt_next ( const struct m0_be_reg_d_tree *  rdt,
struct m0_be_reg_d *  prev 
)

Find next region after the given region.

Parameters
rdtm0_be_reg_d tree
prevregion to find after. Should be a region from the tree.
Returns
NULL if prev is the last region in the tree or next region after the prev if it is not.
See also
m0_be_rdt_init().

Definition at line 314 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_reset()

M0_INTERNAL void m0_be_rdt_reset ( struct m0_be_reg_d_tree *  rdt)

Definition at line 367 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_rdt_size()

M0_INTERNAL size_t m0_be_rdt_size ( const struct m0_be_reg_d_tree *  rdt)

Return current size of the tree, in number of m0_be_reg_d

Definition at line 241 of file tx_regmap.c.

Here is the caller graph for this function:

◆ m0_be_recovery_fini()

M0_INTERNAL void m0_be_recovery_fini ( struct m0_be_recovery *  rvr)

Definition at line 158 of file recovery.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_recovery_init()

M0_INTERNAL void m0_be_recovery_init ( struct m0_be_recovery *  rvr,
struct m0_be_recovery_cfg *  cfg 
)

Definition at line 150 of file recovery.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_recovery_log_record_available()

M0_INTERNAL bool m0_be_recovery_log_record_available ( struct m0_be_recovery *  rvr)

Returns true if there is a log record which needs to be re-applied.

Definition at line 310 of file recovery.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_recovery_log_record_get()

M0_INTERNAL void m0_be_recovery_log_record_get ( struct m0_be_recovery *  rvr,
struct m0_be_log_record_iter *  iter 
)

Picks the next log record from the list of log-only records. Must not be called if m0_be_recovery_log_record_available() returns false.

Parameters
iterLog record iterator where header of the log record is stored.

Definition at line 322 of file recovery.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_recovery_run()

M0_INTERNAL int m0_be_recovery_run ( struct m0_be_recovery *  rvr)

Scans log for all log records that need to be re-applied and stores them in the list of log-only records.

Definition at line 184 of file recovery.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg__invariant()

M0_INTERNAL bool m0_be_reg__invariant ( const struct m0_be_reg *  reg)

XXX

Todo:
make m0_be_reg_copy_to(reg, dst_addr) and m0_be_reg_copy_from(reg, src_addr)

Definition at line 290 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg__read()

M0_INTERNAL int m0_be_reg__read ( struct m0_be_reg *  reg)

Definition at line 457 of file seg.c.

Here is the call graph for this function:

◆ m0_be_reg__write()

M0_INTERNAL int m0_be_reg__write ( struct m0_be_reg *  reg)

Definition at line 462 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area__invariant()

M0_INTERNAL bool m0_be_reg_area__invariant ( const struct m0_be_reg_area *  ra)

Definition at line 609 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_capture()

M0_INTERNAL void m0_be_reg_area_capture ( struct m0_be_reg_area *  ra,
struct m0_be_reg_d *  rd 
)

Definition at line 751 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_captured()

M0_INTERNAL void m0_be_reg_area_captured ( struct m0_be_reg_area *  ra,
struct m0_be_tx_credit *  captured 
)

Definition at line 637 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_fini()

M0_INTERNAL void m0_be_reg_area_fini ( struct m0_be_reg_area *  ra)

Definition at line 602 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_first()

M0_INTERNAL struct m0_be_reg_d * m0_be_reg_area_first ( struct m0_be_reg_area *  ra)

Definition at line 814 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_init()

M0_INTERNAL int m0_be_reg_area_init ( struct m0_be_reg_area *  ra,
const struct m0_be_tx_credit *  prepared,
enum m0_be_reg_area_type  type 
)

Initialises reg_area of the given kind.

Parameters
rareg_area
preparedmaximum size for reg_area.
typetype of m0_be_reg_area.
See also
m0_be_reg_area_type.

Maximum size has the following meaning:

Definition at line 559 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_merge_in()

M0_INTERNAL void m0_be_reg_area_merge_in ( struct m0_be_reg_area *  ra,
struct m0_be_reg_area *  src 
)

Definition at line 787 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_merger_add()

M0_INTERNAL void m0_be_reg_area_merger_add ( struct m0_be_reg_area_merger *  brm,
struct m0_be_reg_area *  ra 
)

Definition at line 857 of file tx_regmap.c.

Here is the caller graph for this function:

◆ m0_be_reg_area_merger_fini()

M0_INTERNAL void m0_be_reg_area_merger_fini ( struct m0_be_reg_area_merger *  brm)

Definition at line 846 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_merger_init()

M0_INTERNAL int m0_be_reg_area_merger_init ( struct m0_be_reg_area_merger *  brm,
int  reg_area_nr_max 
)

Definition at line 826 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_merger_merge_to()

M0_INTERNAL void m0_be_reg_area_merger_merge_to ( struct m0_be_reg_area_merger *  brm,
struct m0_be_reg_area *  ra 
)

Definition at line 894 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_merger_reset()

M0_INTERNAL void m0_be_reg_area_merger_reset ( struct m0_be_reg_area_merger *  brm)

Definition at line 852 of file tx_regmap.c.

Here is the caller graph for this function:

◆ m0_be_reg_area_next()

M0_INTERNAL struct m0_be_reg_d * m0_be_reg_area_next ( struct m0_be_reg_area *  ra,
struct m0_be_reg_d *  prev 
)

Definition at line 820 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_optimize()

M0_INTERNAL void m0_be_reg_area_optimize ( struct m0_be_reg_area *  ra)

Definition at line 808 of file tx_regmap.c.

Here is the caller graph for this function:

◆ m0_be_reg_area_prepared()

M0_INTERNAL void m0_be_reg_area_prepared ( struct m0_be_reg_area *  ra,
struct m0_be_tx_credit *  prepared 
)

Definition at line 629 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_reset()

M0_INTERNAL void m0_be_reg_area_reset ( struct m0_be_reg_area *  ra)

Definition at line 797 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_uncapture()

M0_INTERNAL void m0_be_reg_area_uncapture ( struct m0_be_reg_area *  ra,
const struct m0_be_reg_d *  rd 
)

Definition at line 775 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_area_used()

M0_INTERNAL void m0_be_reg_area_used ( struct m0_be_reg_area *  ra,
struct m0_be_tx_credit *  used 
)

Definition at line 616 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_d__invariant()

M0_INTERNAL bool m0_be_reg_d__invariant ( const struct m0_be_reg_d *  rd)

m0_be_reg__invariant() can't be used here because it checks m0_be_reg segment, and UT can test m0_be_reg_d-related structures without m0_be_seg initialization.

Definition at line 50 of file tx_regmap.c.

Here is the caller graph for this function:

◆ m0_be_reg_d_is_in()

M0_INTERNAL bool m0_be_reg_d_is_in ( const struct m0_be_reg_d *  rd,
void *  ptr 
)

Definition at line 62 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_eq()

M0_INTERNAL bool m0_be_reg_eq ( const struct m0_be_reg *  r1,
const struct m0_be_reg *  r2 
)

Definition at line 410 of file seg.c.

Here is the caller graph for this function:

◆ m0_be_reg_gen_idx()

M0_INTERNAL unsigned long m0_be_reg_gen_idx ( const struct m0_be_reg *  reg)

Returns generation index for a region.

It is guaranteed that subsequent call to this function with the same region or region that intersects with the current region gives value greater than previous.

Todo:
add UT similar to libm0-ut:time.

Definition at line 469 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_reg_offset()

M0_INTERNAL m0_bindex_t m0_be_reg_offset ( const struct m0_be_reg *  reg)

Definition at line 425 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap__invariant()

M0_INTERNAL bool m0_be_regmap__invariant ( const struct m0_be_regmap *  rm)

Definition at line 401 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_add()

M0_INTERNAL void m0_be_regmap_add ( struct m0_be_regmap *  rm,
struct m0_be_reg_d *  rd 
)

Definition at line 458 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_del()

M0_INTERNAL void m0_be_regmap_del ( struct m0_be_regmap *  rm,
const struct m0_be_reg_d *  rd 
)

Definition at line 493 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_fini()

M0_INTERNAL void m0_be_regmap_fini ( struct m0_be_regmap *  rm)

Definition at line 395 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_first()

M0_INTERNAL struct m0_be_reg_d * m0_be_regmap_first ( struct m0_be_regmap *  rm)

Definition at line 527 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_init()

M0_INTERNAL int m0_be_regmap_init ( struct m0_be_regmap *  rm,
const struct m0_be_regmap_ops *  ops,
void *  ops_data,
size_t  size_max,
bool  split_on_absorb 
)

Definition at line 378 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_next()

M0_INTERNAL struct m0_be_reg_d * m0_be_regmap_next ( struct m0_be_regmap *  rm,
struct m0_be_reg_d *  prev 
)

Definition at line 532 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_reset()

M0_INTERNAL void m0_be_regmap_reset ( struct m0_be_regmap *  rm)

Definition at line 544 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_regmap_size()

M0_INTERNAL size_t m0_be_regmap_size ( const struct m0_be_regmap *  rm)

Definition at line 538 of file tx_regmap.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg__invariant()

M0_INTERNAL bool m0_be_seg__invariant ( const struct m0_be_seg *  seg)

Definition at line 283 of file seg.c.

◆ m0_be_seg__read()

M0_INTERNAL int m0_be_seg__read ( struct m0_be_reg *  reg,
void *  dst 
)

Definition at line 447 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg__write()

M0_INTERNAL int m0_be_seg__write ( struct m0_be_reg *  reg,
void *  src 
)

Definition at line 452 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_allocator()

M0_INTERNAL struct m0_be_allocator* m0_be_seg_allocator ( struct m0_be_seg *  seg)

Definition at line 435 of file seg.c.

◆ m0_be_seg_close()

M0_INTERNAL void m0_be_seg_close ( struct m0_be_seg *  seg)

Definition at line 394 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_contains()

M0_INTERNAL bool m0_be_seg_contains ( const struct m0_be_seg *  seg,
const void *  addr 
)

Definition at line 404 of file seg.c.

Here is the caller graph for this function:

◆ m0_be_seg_contains_stob()

M0_INTERNAL bool m0_be_seg_contains_stob ( struct m0_be_seg *  seg,
const struct m0_stob_id *  stob_id 
)

Definition at line 484 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_create()

M0_INTERNAL int m0_be_seg_create ( struct m0_be_seg *  seg,
m0_bcount_t  size,
void *  addr 
)

Creates the segment of specified size on the storage.

Definition at line 224 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_create_multiple()

M0_INTERNAL int m0_be_seg_create_multiple ( struct m0_stob *  stob,
const struct m0_be_seg_geom *  geom 
)

Definition at line 195 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_destroy()

M0_INTERNAL int m0_be_seg_destroy ( struct m0_be_seg *  seg)

Definition at line 243 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_begin()

M0_INTERNAL int m0_be_seg_dict_begin ( struct m0_be_seg *  seg,
const char *  start_key,
const char **  this_key,
void **  this_rec 
)

Definition at line 236 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_create()

M0_INTERNAL void m0_be_seg_dict_create ( struct m0_be_seg *  seg,
struct m0_be_tx *  tx 
)

Definition at line 342 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_create_credit()

M0_INTERNAL void m0_be_seg_dict_create_credit ( struct m0_be_seg *  seg,
struct m0_be_tx_credit *  accum 
)

Definition at line 144 of file seg_dict.c.

Here is the caller graph for this function:

◆ m0_be_seg_dict_delete()

M0_INTERNAL int m0_be_seg_dict_delete ( struct m0_be_seg *  seg,
struct m0_be_tx *  tx,
const char *  name 
)

Definition at line 316 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_delete_credit()

M0_INTERNAL void m0_be_seg_dict_delete_credit ( struct m0_be_seg *  seg,
const char *  name,
struct m0_be_tx_credit *  accum 
)

Definition at line 131 of file seg_dict.c.

Here is the caller graph for this function:

◆ m0_be_seg_dict_destroy()

M0_INTERNAL void m0_be_seg_dict_destroy ( struct m0_be_seg *  seg,
struct m0_be_tx *  tx 
)

Definition at line 354 of file seg_dict.c.

Here is the call graph for this function:

◆ m0_be_seg_dict_destroy_credit()

M0_INTERNAL void m0_be_seg_dict_destroy_credit ( struct m0_be_seg *  seg,
struct m0_be_tx_credit *  accum 
)

Definition at line 150 of file seg_dict.c.

◆ m0_be_seg_dict_fini()

M0_INTERNAL void m0_be_seg_dict_fini ( struct m0_be_seg *  seg)

Definition at line 170 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_init()

M0_INTERNAL void m0_be_seg_dict_init ( struct m0_be_seg *  seg)

Definition at line 160 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_insert()

M0_INTERNAL int m0_be_seg_dict_insert ( struct m0_be_seg *  seg,
struct m0_be_tx *  tx,
const char *  name,
void *  value 
)

Definition at line 255 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_insert_credit()

M0_INTERNAL void m0_be_seg_dict_insert_credit ( struct m0_be_seg *  seg,
const char *  name,
struct m0_be_tx_credit *  accum 
)

Definition at line 114 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_lookup()

M0_INTERNAL int m0_be_seg_dict_lookup ( struct m0_be_seg *  seg,
const char *  name,
void **  out 
)

Definition at line 180 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_dict_next()

M0_INTERNAL int m0_be_seg_dict_next ( struct m0_be_seg *  seg,
const char *  prefix,
const char *  start_key,
const char **  this_key,
void **  this_rec 
)

Definition at line 245 of file seg_dict.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_fini()

M0_INTERNAL void m0_be_seg_fini ( struct m0_be_seg *  seg)

Definition at line 275 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_geom_eq()

M0_INTERNAL bool m0_be_seg_geom_eq ( const struct m0_be_seg_geom *  left,
const struct m0_be_seg_geom *  right 
)

Definition at line 150 of file seg.c.

Here is the caller graph for this function:

◆ m0_be_seg_init()

M0_INTERNAL void m0_be_seg_init ( struct m0_be_seg *  seg,
struct m0_stob *  stob,
struct m0_be_domain *  dom,
uint64_t  seg_id 
)

Definition at line 253 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_offset()

M0_INTERNAL m0_bindex_t m0_be_seg_offset ( const struct m0_be_seg *  seg,
const void *  addr 
)

Definition at line 418 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_open()

M0_INTERNAL int m0_be_seg_open ( struct m0_be_seg *  seg)

Opens existing stob, reads segment header from it, etc.

Definition at line 324 of file seg.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_seg_reserved()

M0_INTERNAL m0_bcount_t m0_be_seg_reserved ( const struct m0_be_seg *  seg)

XXX

Todo:
s/bs_reserved/m0_be_seg_reserved/ everywhere

Definition at line 430 of file seg.c.

Here is the caller graph for this function:

◆ m0_be_segobj_opt_begin()

M0_INTERNAL int m0_be_segobj_opt_begin ( struct m0_be_seg *  dict,
const struct m0_be_0type *  objtype,
struct m0_buf *  opt,
char **  suffix 
)

Definition at line 97 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_segobj_opt_iterate()

static int m0_be_segobj_opt_iterate ( struct m0_be_seg *  dict,
const struct m0_be_0type *  objtype,
struct m0_buf *  opt,
char **  suffix,
bool  begin 
)
static

Definition at line 63 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_segobj_opt_next()

M0_INTERNAL int m0_be_segobj_opt_next ( struct m0_be_seg *  dict,
const struct m0_be_0type *  objtype,
struct m0_buf *  opt,
char **  suffix 
)

Definition at line 89 of file domain.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_should_break()

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 
)

Definition at line 714 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_should_break_half()

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 
)

Definition at line 721 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tlink_create()

M0_INTERNAL void m0_be_tlink_create ( void *  obj,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx 
)

Definition at line 185 of file list.c.

Here is the call graph for this function:

◆ m0_be_tlink_destroy()

M0_INTERNAL void m0_be_tlink_destroy ( void *  obj,
const struct m0_be_list_descr *  descr,
struct m0_be_tx *  tx 
)

Definition at line 200 of file list.c.

Here is the call graph for this function:

◆ m0_be_tx__group_assign()

M0_INTERNAL void m0_be_tx__group_assign ( struct m0_be_tx *  tx,
struct m0_be_tx_group *  gr 
)

Definition at line 689 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx__invariant()

M0_INTERNAL bool m0_be_tx__invariant ( const struct m0_be_tx *  tx)

Definition at line 555 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx__is_exclusive()

M0_INTERNAL bool m0_be_tx__is_exclusive ( const struct m0_be_tx *  tx)

true if transaction is opened exclusively. Private for BE.

Definition at line 649 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx__is_fast()

M0_INTERNAL bool m0_be_tx__is_fast ( struct m0_be_tx *  tx)

Used by engine to check whether tx_group should be closed immediately.

Todo:
Remove when m0_be_tx_close_sync() is removed.

Definition at line 625 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx__is_recovering()

M0_INTERNAL bool m0_be_tx__is_recovering ( struct m0_be_tx *  tx)

Definition at line 659 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx__recovering_set()

M0_INTERNAL void m0_be_tx__recovering_set ( struct m0_be_tx *  tx)

Mark tx as a tx that is recovering from log.

Such transaction has the following properties:

  • it is already in log, so:
    • log space is not reserved;
    • it isn't going to log;
  • reg_area and payload buf are not allocated;
  • it can't fail on m0_be_tx_open();
  • it doesn't have new tx id allocated - it uses the old one from the log.
Note
This function is used by recovery only.

Definition at line 654 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx__reg_area()

M0_INTERNAL struct m0_be_reg_area * m0_be_tx__reg_area ( struct m0_be_tx *  tx)

Definition at line 566 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx__state_post()

M0_INTERNAL void m0_be_tx__state_post ( struct m0_be_tx *  tx,
enum m0_be_tx_state  state 
)

Posts an AST that will move transaction's state machine to given state.

Definition at line 524 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_bulk_end()

M0_INTERNAL void m0_be_tx_bulk_end ( struct m0_be_tx_bulk *  tb)

Definition at line 619 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_bulk_fini()

M0_INTERNAL void m0_be_tx_bulk_fini ( struct m0_be_tx_bulk *  tb)

Definition at line 288 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_bulk_init()

M0_INTERNAL int m0_be_tx_bulk_init ( struct m0_be_tx_bulk *  tb,
struct m0_be_tx_bulk_cfg *  tb_cfg 
)

Definition at line 136 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_bulk_put()

M0_INTERNAL bool m0_be_tx_bulk_put ( struct m0_be_tx_bulk *  tb,
struct m0_be_op *  op,
struct m0_be_tx_credit *  credit,
m0_bcount_t  payload_credit,
uint64_t  partition,
void *  user 
)

Add more work.

Definition at line 583 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_bulk_run()

M0_INTERNAL void m0_be_tx_bulk_run ( struct m0_be_tx_bulk *  tb,
struct m0_be_op *  op 
)

Runs the work. op is signalled after all work is done or some of m0_be_tx_open() failed.

Definition at line 565 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_bulk_status()

M0_INTERNAL int m0_be_tx_bulk_status ( struct m0_be_tx_bulk *  tb)

Gets m0_be_tx_bulk result. Can be called only after op from m0_be_tx_bulk_run is signalled.

Definition at line 630 of file tx_bulk.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_capture()

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

Definition at line 312 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_close()

M0_INTERNAL void m0_be_tx_close ( struct m0_be_tx *  tx)

Definition at line 362 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_close_sync()

M0_INTERNAL void m0_be_tx_close_sync ( struct m0_be_tx *  tx)

Calls m0_be_tx_close() and then waits until transaction reaches M0_BTS_DONE state.

Definition at line 604 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_credit_add()

M0_INTERNAL void m0_be_tx_credit_add ( struct m0_be_tx_credit *  c0,
const struct m0_be_tx_credit *  c1 
)

c0 += c1

Definition at line 44 of file tx_credit.c.

Here is the caller graph for this function:

◆ m0_be_tx_credit_add_max()

M0_INTERNAL void m0_be_tx_credit_add_max ( struct m0_be_tx_credit *  c,
const struct m0_be_tx_credit *  c0,
const struct m0_be_tx_credit *  c1 
)

Definition at line 120 of file tx_credit.c.

Here is the call graph for this function:

◆ m0_be_tx_credit_eq()

M0_INTERNAL bool m0_be_tx_credit_eq ( const struct m0_be_tx_credit *  c0,
const struct m0_be_tx_credit *  c1 
)

Definition at line 105 of file tx_credit.c.

Here is the caller graph for this function:

◆ m0_be_tx_credit_le()

M0_INTERNAL bool m0_be_tx_credit_le ( const struct m0_be_tx_credit *  c0,
const struct m0_be_tx_credit *  c1 
)

Definition at line 98 of file tx_credit.c.

Here is the caller graph for this function:

◆ m0_be_tx_credit_mac()

M0_INTERNAL void m0_be_tx_credit_mac ( struct m0_be_tx_credit *  c,
const struct m0_be_tx_credit *  c1,
m0_bcount_t  k 
)

c += c1 * k Multiply-accumulate operation.

Definition at line 88 of file tx_credit.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_credit_max()

M0_INTERNAL void m0_be_tx_credit_max ( struct m0_be_tx_credit *  c,
const struct m0_be_tx_credit *  c0,
const struct m0_be_tx_credit *  c1 
)

c = smallest credit that meets the following requirement: m0_be_tx_credit_le(c0, c) && m0_be_tx_credit_le(c1, c)

Definition at line 112 of file tx_credit.c.

Here is the caller graph for this function:

◆ m0_be_tx_credit_mul()

M0_INTERNAL void m0_be_tx_credit_mul ( struct m0_be_tx_credit *  c,
m0_bcount_t  k 
)

c *= k

Definition at line 73 of file tx_credit.c.

Here is the caller graph for this function:

◆ m0_be_tx_credit_mul_bp()

M0_INTERNAL void m0_be_tx_credit_mul_bp ( struct m0_be_tx_credit *  c,
unsigned  bp 
)

c *= bp / 10000.0

Note
bp is basis point.

Definition at line 82 of file tx_credit.c.

Here is the caller graph for this function:

◆ m0_be_tx_credit_sub()

M0_INTERNAL void m0_be_tx_credit_sub ( struct m0_be_tx_credit *  c0,
const struct m0_be_tx_credit *  c1 
)

c0 -= c1

Definition at line 55 of file tx_credit.c.

Here is the caller graph for this function:

◆ m0_be_tx_deconstruct()

M0_INTERNAL void m0_be_tx_deconstruct ( struct m0_be_tx *  tx,
struct m0_be_fmt_tx *  ftx 
)

Definition at line 664 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx_exclusive_open()

M0_INTERNAL void m0_be_tx_exclusive_open ( struct m0_be_tx *  tx)

Definition at line 588 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_exclusive_open_sync()

M0_INTERNAL int m0_be_tx_exclusive_open_sync ( struct m0_be_tx *  tx)

Definition at line 594 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_fini()

M0_INTERNAL void m0_be_tx_fini ( struct m0_be_tx *  tx)

Definition at line 237 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_fol_add()

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

Adds fol record into the transaction payload

Definition at line 630 of file tx.c.

Here is the call graph for this function:

◆ m0_be_tx_force()

M0_INTERNAL void m0_be_tx_force ( struct m0_be_tx *  tx)

Forces the tx's group to close immediately by explictly calling m0_be_tx_group_close(), which in turn triggers the logging of all the lingering transactions in this group.

Forces the tx to move forward to PLACED state, which will in turn force all the transactions in the same tx group to commit to disk as well.

Definition at line 638 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_gc_enable()

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

Calls function after tx reaches M0_BTS_DONE state. Signals to just before call. Garbage collector may be enabled at any time before m0_be_tx_close().

Note
User should handle M0_BTS_FAILED state explicitly.

Typical use case:

struct m0_be_tx *tx;
M0_ALLOC_PTR(tx);
if (tx == NULL)
...;
m0_be_tx_init(tx, <...>);
m0_be_tx_gc_enable(tx, NULL, NULL);
< prepare credits >
m0_be_tx_open(tx);
< wait until tx reaches M0_BTS_ACTIVE or M0_BTS_FAILED state >;
if (m0_be_tx_state(tx) == M0_BTS_FAILED) {
m0_be_tx_fini(tx);
m0_free(tx);
} else {
< capture >;
m0_be_tx_close(tx);
}
< tx pointer should be considered invalid after this point >
// m0_free() will be automatically called when tx reaches M0_BTS_DONE state.
Note
m0_be_tx_timedwait() can't be used on transaction with gc enabled after transaction reaches M0_BTS_ACTIVE state.
can be NULL. m0_free() is called in this case to free tx.

Definition at line 728 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx_get()

M0_INTERNAL void m0_be_tx_get ( struct m0_be_tx *  tx)

Gets additional reference to the transaction.

Precondition
!M0_IN(m0_be_tx_state(tx), (M0_BTS_FAILED, M0_BTS_DONE))
See also
m0_be_tx_put()

Definition at line 373 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group__allocate()

M0_INTERNAL int m0_be_tx_group__allocate ( struct m0_be_tx_group *  gr)

Definition at line 403 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group__deallocate()

M0_INTERNAL void m0_be_tx_group__deallocate ( struct m0_be_tx_group *  gr)

Definition at line 408 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group__invariant()

M0_INTERNAL bool m0_be_tx_group__invariant ( struct m0_be_tx_group *  gr)

Definition at line 247 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group__sm_group()

M0_INTERNAL struct m0_sm_group * m0_be_tx_group__sm_group ( struct m0_be_tx_group *  gr)

Definition at line 73 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group__tx_state_post()

M0_INTERNAL void m0_be_tx_group__tx_state_post ( struct m0_be_tx_group *  gr,
enum m0_be_tx_state  state,
bool  del_tx_from_group 
)

m0_be_tx__state_post()s each transaction of the group. XXX RENAMEME

Definition at line 442 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_close()

M0_INTERNAL void m0_be_tx_group_close ( struct m0_be_tx_group *  gr)

Definition at line 147 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_decode()

M0_INTERNAL int m0_be_tx_group_decode ( struct m0_be_tx_group *  gr)

Definition at line 476 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_discard()

M0_INTERNAL void m0_be_tx_group_discard ( struct m0_be_log_discard *  ld,
struct m0_be_log_discard_item *  ldi 
)

Definition at line 635 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_encode()

M0_INTERNAL void m0_be_tx_group_encode ( struct m0_be_tx_group *  gr)

Definition at line 430 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fini()

M0_INTERNAL void m0_be_tx_group_fini ( struct m0_be_tx_group *  gr)

Definition at line 252 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fom__sm_group()

M0_INTERNAL struct m0_sm_group * m0_be_tx_group_fom__sm_group ( struct m0_be_tx_group_fom *  m)

Definition at line 418 of file tx_group_fom.c.

Here is the caller graph for this function:

◆ m0_be_tx_group_fom_fini()

M0_INTERNAL void m0_be_tx_group_fom_fini ( struct m0_be_tx_group_fom *  m)

Definition at line 359 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fom_handle()

M0_INTERNAL void m0_be_tx_group_fom_handle ( struct m0_be_tx_group_fom *  m)

Definition at line 407 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fom_init()

M0_INTERNAL void m0_be_tx_group_fom_init ( struct m0_be_tx_group_fom *  m,
struct m0_be_tx_group *  gr,
struct m0_reqh *  reqh 
)
Todo:
XXX TODO s/gf/m/ in function parameters

Definition at line 331 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fom_mod_fini()

M0_INTERNAL void m0_be_tx_group_fom_mod_fini ( void  )

Definition at line 436 of file tx_group_fom.c.

Here is the caller graph for this function:

◆ m0_be_tx_group_fom_mod_init()

M0_INTERNAL void m0_be_tx_group_fom_mod_init ( void  )

Definition at line 429 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fom_recovery_prepare()

M0_INTERNAL void m0_be_tx_group_fom_recovery_prepare ( struct m0_be_tx_group_fom *  m)

Definition at line 424 of file tx_group_fom.c.

Here is the caller graph for this function:

◆ m0_be_tx_group_fom_reset()

M0_INTERNAL void m0_be_tx_group_fom_reset ( struct m0_be_tx_group_fom *  m)

Definition at line 369 of file tx_group_fom.c.

Here is the caller graph for this function:

◆ m0_be_tx_group_fom_stable()

M0_INTERNAL void m0_be_tx_group_fom_stable ( struct m0_be_tx_group_fom *  gf)

Definition at line 412 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fom_start()

M0_INTERNAL int m0_be_tx_group_fom_start ( struct m0_be_tx_group_fom *  gf)

Definition at line 381 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_fom_stop()

M0_INTERNAL void m0_be_tx_group_fom_stop ( struct m0_be_tx_group_fom *  gf)

Definition at line 399 of file tx_group_fom.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_init()

M0_INTERNAL int m0_be_tx_group_init ( struct m0_be_tx_group *  gr,
struct m0_be_tx_group_cfg *  gr_cfg 
)

Definition at line 201 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_is_recovering()

M0_INTERNAL bool m0_be_tx_group_is_recovering ( struct m0_be_tx_group *  gr)

Definition at line 78 of file tx_group.c.

Here is the caller graph for this function:

◆ m0_be_tx_group_log_read()

M0_INTERNAL void m0_be_tx_group_log_read ( struct m0_be_tx_group *  gr,
struct m0_be_op *  op 
)

Definition at line 470 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_log_write()

M0_INTERNAL void m0_be_tx_group_log_write ( struct m0_be_tx_group *  gr,
struct m0_be_op *  op 
)

Definition at line 435 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_open()

M0_INTERNAL void m0_be_tx_group_open ( struct m0_be_tx_group *  gr)

Definition at line 388 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_prepare()

M0_INTERNAL void m0_be_tx_group_prepare ( struct m0_be_tx_group *  gr,
struct m0_be_op *  op 
)

Definition at line 195 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_reapply()

M0_INTERNAL int m0_be_tx_group_reapply ( struct m0_be_tx_group *  gr,
struct m0_be_op *  op 
)

Definition at line 620 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_reconstruct()

M0_INTERNAL int m0_be_tx_group_reconstruct ( struct m0_be_tx_group *  gr,
struct m0_sm_group *  sm_grp 
)

Definition at line 577 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_reconstruct_tx_close()

M0_INTERNAL void m0_be_tx_group_reconstruct_tx_close ( struct m0_be_tx_group *  gr,
struct m0_be_op *  op_gc 
)
Note
Don't wait on op after the function call.

Definition at line 601 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_reconstruct_tx_open()

M0_INTERNAL void m0_be_tx_group_reconstruct_tx_open ( struct m0_be_tx_group *  gr,
struct m0_be_op *  op 
)

Definition at line 585 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_recovery_prepare()

M0_INTERNAL void m0_be_tx_group_recovery_prepare ( struct m0_be_tx_group *  gr,
struct m0_be_log *  log 
)

Definition at line 462 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_reset()

M0_INTERNAL void m0_be_tx_group_reset ( struct m0_be_tx_group *  gr)

Makes the tx_group ready for reuse.

Definition at line 178 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_seg_io_credit()

M0_INTERNAL void m0_be_tx_group_seg_io_credit ( struct m0_be_tx_group_cfg *  gr_cfg,
struct m0_be_io_credit *  io_cred 
)

Definition at line 642 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_seg_place()

M0_INTERNAL void m0_be_tx_group_seg_place ( struct m0_be_tx_group *  gr,
struct m0_be_op *  op 
)

Definition at line 424 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_seg_place_prepare()

M0_INTERNAL void m0_be_tx_group_seg_place_prepare ( struct m0_be_tx_group *  gr)

Definition at line 413 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_stable()

M0_INTERNAL void m0_be_tx_group_stable ( struct m0_be_tx_group *  gr)

Notifies the group that all of its transactions have reached M0_BTS_DONE state.

Definition at line 65 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_start()

M0_INTERNAL int m0_be_tx_group_start ( struct m0_be_tx_group *  gr)

Definition at line 393 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_stop()

M0_INTERNAL void m0_be_tx_group_stop ( struct m0_be_tx_group *  gr)

Definition at line 398 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_tx_add()

M0_INTERNAL int m0_be_tx_group_tx_add ( struct m0_be_tx_group *  gr,
struct m0_be_tx *  tx 
)

Adds the transaction to m0_be_tx_group::tg_txs.

Definition at line 286 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_tx_closed()

M0_INTERNAL void m0_be_tx_group_tx_closed ( struct m0_be_tx_group *  gr,
struct m0_be_tx *  tx 
)

Definition at line 325 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_tx_del()

M0_INTERNAL void m0_be_tx_group_tx_del ( struct m0_be_tx_group *  gr,
struct m0_be_tx *  tx 
)

Deletes the transaction from m0_be_tx_group::tg_txs.

Definition at line 375 of file tx_group.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_group_tx_nr()

M0_INTERNAL size_t m0_be_tx_group_tx_nr ( struct m0_be_tx_group *  gr)

Number of transactions in the group.

Definition at line 383 of file tx_group.c.

Here is the caller graph for this function:

◆ m0_be_tx_init()

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(*)(struct m0_be_tx *tx, void *payload)  filler,
void *  datum 
)

Definition at line 188 of file tx.c.

Here is the call graph for this function:

◆ m0_be_tx_lsn_get()

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

Definition at line 761 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx_lsn_set()

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

Definition at line 743 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_mod_fini()

M0_INTERNAL void m0_be_tx_mod_fini ( void  )

Definition at line 784 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_mod_init()

M0_INTERNAL int m0_be_tx_mod_init ( void  )

Definition at line 775 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_open()

M0_INTERNAL void m0_be_tx_open ( struct m0_be_tx *  tx)

Definition at line 281 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_open_sync()

M0_INTERNAL int m0_be_tx_open_sync ( struct m0_be_tx *  tx)

Calls m0_be_tx_open() and then waits until transaction reaches M0_BTS_ACTIVE or M0_BTS_FAILED state.

Postcondition
equi(rc == 0, m0_be_tx_state(tx) == M0_BTS_ACTIVE)
equi(rc != 0, m0_be_tx_state(tx) == M0_BTS_FAILED)

Definition at line 571 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_payload_prep()

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

Accumulates transaction payload size.

This function adds size to the number of bytes which is allocated for the payload area.

See also
m0_be_tx::t_payload

Definition at line 271 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx_prep()

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

Definition at line 260 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_put()

M0_INTERNAL void m0_be_tx_put ( struct m0_be_tx *  tx)

Puts reference to the transaction.

Transaction is not shifted to M0_BTS_DONE state until number of m0_be_tx_get() calls is equal to the number of m0_be_tx_put() calls for the transaction.

See also
m0_be_tx_get()

Definition at line 383 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_reconstruct()

M0_INTERNAL void m0_be_tx_reconstruct ( struct m0_be_tx *  tx,
const struct m0_be_fmt_tx *  ftx 
)

Definition at line 670 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_service_fini()

M0_INTERNAL void m0_be_tx_service_fini ( struct m0_be_engine *  en)

Definition at line 125 of file tx_service.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_service_init()

M0_INTERNAL int m0_be_tx_service_init ( struct m0_be_engine *  en,
struct m0_reqh *  reqh 
)

Definition at line 117 of file tx_service.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_should_break()

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

◆ m0_be_tx_state()

M0_INTERNAL enum m0_be_tx_state m0_be_tx_state ( const struct m0_be_tx *  tx)

Definition at line 412 of file tx.c.

Here is the caller graph for this function:

◆ m0_be_tx_state_name()

M0_INTERNAL const char * m0_be_tx_state_name ( enum m0_be_tx_state  state)

Definition at line 417 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_timedwait()

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

Waits until transacion reaches one of the given states.

Note
To wait for a M0_BTS_PLACED state, caller must guarantee that the transaction are not in M0_BTS_DONE state, e.g., by calling m0_be_tx_get().

Definition at line 394 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_tx_uncapture()

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

Definition at line 325 of file tx.c.

Here is the call graph for this function:

◆ m0_be_txs_register()

M0_INTERNAL int m0_be_txs_register ( void  )

Definition at line 58 of file tx_service.c.

Here is the call graph for this function:

◆ m0_be_txs_unregister()

M0_INTERNAL void m0_be_txs_unregister ( void  )

Definition at line 63 of file tx_service.c.

Here is the call graph for this function:

◆ m0_be_ut_fmt_cblock()

void m0_be_ut_fmt_cblock ( void  )

Definition at line 134 of file fmt.c.

Here is the call graph for this function:

◆ m0_be_ut_fmt_group()

void m0_be_ut_fmt_group ( void  )

Definition at line 504 of file fmt.c.

Here is the call graph for this function:

◆ m0_be_ut_fmt_group_size_max()

void m0_be_ut_fmt_group_size_max ( void  )

Definition at line 319 of file fmt.c.

Here is the call graph for this function:

◆ m0_be_ut_fmt_group_size_max_rnd()

void m0_be_ut_fmt_group_size_max_rnd ( void  )

Definition at line 468 of file fmt.c.

Here is the call graph for this function:

◆ m0_be_ut_fmt_log_header()

void m0_be_ut_fmt_log_header ( void  )

Definition at line 53 of file fmt.c.

Here is the call graph for this function:

◆ m0_be_ut_io_sched()

void m0_be_ut_io_sched ( void  )

The test: 1) Creates BE_UT_IO_SCHED_THREAD_NR threads. 2) Each thread:

  • creates st_io_nr structs m0_be_io;
  • st_sched_add_nr times adds one m0_be_io that is either never added to the scheduler queue or completion callback was called for it; 3) Checks that all start and completion callbacks for m0_be_io was called in the right order.
Note
Currently m0_be_io_sched executes m0_be_io one by one in the order they are added to the scheduler queue.

Definition at line 284 of file io_sched.c.

Here is the call graph for this function:

◆ m0_be_ut_log_discard_getput()

void m0_be_ut_log_discard_getput ( void  )

Definition at line 227 of file log_discard.c.

Here is the call graph for this function:

◆ m0_be_ut_log_discard_usecase()

void m0_be_ut_log_discard_usecase ( void  )

Definition at line 72 of file log_discard.c.

Here is the call graph for this function:

◆ m0_be_ut_op_mt()

void m0_be_ut_op_mt ( void  )

+------------—+ | | | V | INIT —> WAIT1 | | | | V V | ACTIVE –> WAIT2 | | | | V V +– DONE —> WAIT3 –> FINI

Definition at line 154 of file op.c.

Here is the call graph for this function:

◆ m0_be_ut_op_set_tree()

void m0_be_ut_op_set_tree ( void  )

Definition at line 461 of file op.c.

Here is the call graph for this function:

◆ m0_be_ut_op_set_usecase()

void m0_be_ut_op_set_usecase ( void  )

Definition at line 240 of file op.c.

Here is the call graph for this function:

◆ m0_be_ut_op_usecase()

void m0_be_ut_op_usecase ( void  )

BE UT types

  • usecase - shows typical component use case;
  • simple - simple test that checks predefined patterns;
  • mt - multithreaded test;
  • random - test that uses RNG to test as much use cases as possible.

Definition at line 40 of file op.c.

Here is the call graph for this function:

◆ m0_be_ut_pd_usecase()

void m0_be_ut_pd_usecase ( void  )

Definition at line 119 of file pd.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_100_10_1()

void m0_be_ut_queue_100_10_1 ( void  )

Definition at line 372 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_100_10_10()

void m0_be_ut_queue_100_10_10 ( void  )

Definition at line 373 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_100_1_1()

void m0_be_ut_queue_100_1_1 ( void  )

Definition at line 370 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_100_1_10()

void m0_be_ut_queue_100_1_10 ( void  )

Definition at line 371 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_10_100_1()

void m0_be_ut_queue_10_100_1 ( void  )

Definition at line 374 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_10_100_100()

void m0_be_ut_queue_10_100_100 ( void  )

Definition at line 378 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_10_100_5()

void m0_be_ut_queue_10_100_5 ( void  )

Definition at line 375 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_10_1_100()

void m0_be_ut_queue_10_1_100 ( void  )

Definition at line 376 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_10_5_100()

void m0_be_ut_queue_10_5_100 ( void  )

Definition at line 377 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_1_1_1()

void m0_be_ut_queue_1_1_1 ( void  )

Definition at line 368 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_2_1_1()

void m0_be_ut_queue_2_1_1 ( void  )

Definition at line 369 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_queue_from_1_to_10()

void m0_be_ut_queue_from_1_to_10 ( void  )

Definition at line 380 of file queue.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_empty()

void m0_be_ut_tx_bulk_empty ( void  )

Definition at line 463 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_error_payload()

void m0_be_ut_tx_bulk_error_payload ( void  )

Definition at line 493 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_error_reg()

void m0_be_ut_tx_bulk_error_reg ( void  )

Definition at line 478 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_large_all()

void m0_be_ut_tx_bulk_large_all ( void  )

Definition at line 538 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_large_cred()

void m0_be_ut_tx_bulk_large_cred ( void  )

Definition at line 617 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_large_payload()

void m0_be_ut_tx_bulk_large_payload ( void  )

Definition at line 523 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_large_tx()

void m0_be_ut_tx_bulk_large_tx ( void  )

Definition at line 508 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_medium_cred()

void m0_be_ut_tx_bulk_medium_cred ( void  )

Definition at line 602 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_medium_tx()

void m0_be_ut_tx_bulk_medium_tx ( void  )

Definition at line 568 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_medium_tx_multi()

void m0_be_ut_tx_bulk_medium_tx_multi ( void  )

Definition at line 584 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_parallel_1_15()

void m0_be_ut_tx_bulk_parallel_1_15 ( void  )

Definition at line 788 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_small_tx()

void m0_be_ut_tx_bulk_small_tx ( void  )

Definition at line 553 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_bulk_usecase()

void m0_be_ut_tx_bulk_usecase ( void  )

Definition at line 231 of file tx_bulk.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_capturing()

void m0_be_ut_tx_capturing ( void  )

Definition at line 750 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_concurrent()

void m0_be_ut_tx_concurrent ( void  )

Definition at line 731 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_concurrent_excl()

void m0_be_ut_tx_concurrent_excl ( void  )

Definition at line 736 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_concurrent_helper()

void m0_be_ut_tx_concurrent_helper ( bool  exclusive)

Definition at line 700 of file tx.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_be_ut_tx_empty()

void m0_be_ut_tx_empty ( void  )

Definition at line 196 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_fast()

void m0_be_ut_tx_fast ( void  )

Definition at line 585 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_force()

void m0_be_ut_tx_force ( void  )

Definition at line 452 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_gc()

void m0_be_ut_tx_gc ( void  )

Definition at line 851 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_payload()

void m0_be_ut_tx_payload ( void  )

Definition at line 1054 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_persistence()

void m0_be_ut_tx_persistence ( void  )

Definition at line 487 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_several()

void m0_be_ut_tx_several ( void  )

Definition at line 230 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_single()

void m0_be_ut_tx_single ( void  )

Definition at line 225 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_states()

void m0_be_ut_tx_states ( void  )

Definition at line 126 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_usecase_failure()

void m0_be_ut_tx_usecase_failure ( void  )

Definition at line 83 of file tx.c.

Here is the call graph for this function:

◆ m0_be_ut_tx_usecase_success()

void m0_be_ut_tx_usecase_success ( void  )

Definition at line 44 of file tx.c.

Here is the call graph for this function:

◆ m0_betool_m0_fini()

void m0_betool_m0_fini ( void  )

Definition at line 52 of file common.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_betool_m0_init()

void m0_betool_m0_init ( void  )

Definition at line 42 of file common.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_betool_st_mkfs()

int m0_betool_st_mkfs ( void  )

Definition at line 57 of file st.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ m0_betool_st_run()

int m0_betool_st_run ( void  )

Definition at line 261 of file st.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ M0_TL_DECLARE() [1/2]

M0_TL_DECLARE ( ad_domains  ,
M0_EXTERN  ,
struct ad_domain_map   
)

◆ M0_TL_DECLARE() [2/2]

M0_TL_DECLARE ( grp  ,
M0_INTERNAL  ,
struct m0_be_tx   
)

◆ M0_TL_DEFINE() [1/13]

M0_TL_DEFINE ( bos  ,
static  ,
struct m0_be_op   
)

◆ M0_TL_DEFINE() [2/13]

M0_TL_DEFINE ( sched_io  ,
static  ,
struct m0_be_io   
)

◆ M0_TL_DEFINE() [3/13]

M0_TL_DEFINE ( etx  ,
M0_INTERNAL  ,
struct m0_be_tx   
)

◆ M0_TL_DEFINE() [4/13]

M0_TL_DEFINE ( be_pool  ,
static  ,
struct m0_be_pool_item   
)

◆ M0_TL_DEFINE() [5/13]

M0_TL_DEFINE ( zt  ,
M0_EXTERN  ,
struct m0_be_0type   
)

◆ M0_TL_DEFINE() [6/13]

M0_TL_DEFINE ( egr  ,
static  ,
struct m0_be_tx_group   
)

◆ M0_TL_DEFINE() [7/13]

M0_TL_DEFINE ( be_pool_q  ,
static  ,
struct be_pool_queue_item   
)

◆ M0_TL_DEFINE() [8/13]

M0_TL_DEFINE ( rtxs  ,
static  ,
struct be_recovering_tx   
)

◆ M0_TL_DEFINE() [9/13]

M0_TL_DEFINE ( grp  ,
M0_INTERNAL  ,
struct m0_be_tx   
)

◆ M0_TL_DEFINE() [10/13]

M0_TL_DEFINE ( record  ,
static  ,
struct m0_be_log_record   
)

◆ M0_TL_DEFINE() [11/13]

M0_TL_DEFINE ( bqq  ,
static  ,
struct be_queue_item   
)

◆ M0_TL_DEFINE() [12/13]

M0_TL_DEFINE ( bqop  ,
static  ,
struct be_queue_wait_op   
)

◆ M0_TL_DEFINE() [13/13]

M0_TL_DEFINE ( ld_start  ,
static  ,
struct m0_be_log_discard_item   
)

◆ M0_TL_DESCR_DECLARE() [1/3]

M0_TL_DESCR_DECLARE ( zt  ,
M0_EXTERN   
)

◆ M0_TL_DESCR_DECLARE() [2/3]

M0_TL_DESCR_DECLARE ( ad_domains  ,
M0_EXTERN   
)

◆ M0_TL_DESCR_DECLARE() [3/3]

M0_TL_DESCR_DECLARE ( grp  ,
M0_EXTERN   
)

◆ M0_TL_DESCR_DEFINE() [1/12]

M0_TL_DESCR_DEFINE ( bos  ,
"m0_be_op::bo_children"  ,
static  ,
struct m0_be_op  ,
bo_set_link  ,
bo_set_link_magic  ,
M0_BE_OP_SET_LINK_MAGIC  ,
M0_BE_OP_SET_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [2/12]

M0_TL_DESCR_DEFINE ( etx  ,
"m0_be_engine::eng_txs"  [],
M0_INTERNAL  ,
struct m0_be_tx  ,
t_engine_linkage  ,
t_magic  ,
M0_BE_TX_MAGIC  ,
M0_BE_TX_ENGINE_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [3/12]

M0_TL_DESCR_DEFINE ( sched_io  ,
"be log scheduler IOs"  ,
static  ,
struct m0_be_io  ,
bio_sched_link  ,
bio_sched_magic  ,
M0_BE_IO_SCHED_MAGIC  ,
M0_BE_IO_SCHED_HEAD_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [4/12]

M0_TL_DESCR_DEFINE ( be_pool  ,
"list of be_pool_items"  ,
static  ,
struct m0_be_pool_item  ,
bpli_link  ,
bpli_magic  ,
M0_BE_POOL_MAGIC  ,
M0_BE_POOL_HEAD_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [5/12]

M0_TL_DESCR_DEFINE ( egr  ,
"m0_be_engine::eng_groups"  [],
static  ,
struct m0_be_tx_group  ,
tg_engine_linkage  ,
tg_magic  ,
M0_BE_TX_MAGIC  ,
M0_BE_TX_ENGINE_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [6/12]

M0_TL_DESCR_DEFINE ( be_pool_q  ,
"list of be_pool_queue_items"  ,
static  ,
struct be_pool_queue_item  ,
bplq_link  ,
bplq_magic  ,
M0_BE_POOL_QUEUE_MAGIC  ,
M0_BE_POOL_QUEUE_HEAD_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [7/12]

M0_TL_DESCR_DEFINE ( rtxs  ,
"m0_be_tx_group::tg_txs_recovering"  ,
static  ,
struct be_recovering_tx  ,
rtx_link  ,
rtx_magic  ,
M0_BE_TX_MAGIC  ,
M0_BE_TX_GROUP_MAGIC   
)

A list of transactions that are currently being recovered.

◆ M0_TL_DESCR_DEFINE() [8/12]

M0_TL_DESCR_DEFINE ( grp  ,
"m0_be_tx_group::tg_txs"  ,
M0_INTERNAL  ,
struct m0_be_tx  ,
t_group_linkage  ,
t_magic  ,
M0_BE_TX_MAGIC  ,
M0_BE_TX_GROUP_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [9/12]

M0_TL_DESCR_DEFINE ( record  ,
"be log records"  ,
static  ,
struct m0_be_log_record  ,
lgr_linkage  ,
lgr_magic  ,
M0_BE_LOG_RECORD_MAGIC  ,
M0_BE_LOG_RECORD_HEAD_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [10/12]

M0_TL_DESCR_DEFINE ( bqq  ,
"m0_be_queue::bq_q*"  [],
static  ,
struct be_queue_item  ,
bqi_link  ,
bqi_magic  ,
M0_BE_QUEUE_Q_MAGIC  ,
M0_BE_QUEUE_Q_HEAD_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [11/12]

M0_TL_DESCR_DEFINE ( bqop  ,
"m0_be_queue::bq_op_*"  [],
static  ,
struct be_queue_wait_op  ,
bbo_link  ,
bbo_magic  ,
M0_BE_QUEUE_OP_MAGIC  ,
M0_BE_QUEUE_OP_HEAD_MAGIC   
)

◆ M0_TL_DESCR_DEFINE() [12/12]

M0_TL_DESCR_DEFINE ( ld_start  ,
"m0_be_log_discard::lds_start_q"  ,
static  ,
struct m0_be_log_discard_item  ,
ldi_start_link  ,
ldi_magic  ,
M0_BE_LOG_DISCARD_MAGIC  ,
M0_BE_LOG_DISCARD_HEAD_MAGIC   
)

◆ M0_UT_THREADS_DEFINE() [1/5]

M0_UT_THREADS_DEFINE ( be_ut_pd_usecase  ,
&  be_ut_pd_usecase_thread 
)

◆ M0_UT_THREADS_DEFINE() [2/5]

M0_UT_THREADS_DEFINE ( be_ut_op_mt  ,
&  be_ut_op_mt_thread_func 
)

◆ M0_UT_THREADS_DEFINE() [3/5]

M0_UT_THREADS_DEFINE ( be_ut_log_discard_gp_producers  ,
&  be_ut_log_discard_gp_thread 
)

◆ M0_UT_THREADS_DEFINE() [4/5]

M0_UT_THREADS_DEFINE ( be_ut_log_discard_gp_consumers  ,
&  be_ut_log_discard_gp_thread 
)

◆ M0_UT_THREADS_DEFINE() [5/5]

M0_UT_THREADS_DEFINE ( be_ut_io_sched  ,
&  be_ut_io_sched_thread 
)

◆ M0_XCA_DOMAIN() [1/2]

struct m0_be_tx_remid M0_XCA_DOMAIN ( be|  rpc)

◆ M0_XCA_DOMAIN() [2/2]

struct m0_be_allocator_call_stat M0_XCA_DOMAIN ( be  )

◆ main() [1/2]

int main ( int  argc,
char *  argv[] 
)

Definition at line 245 of file main.c.

Here is the call graph for this function:

◆ main() [2/2]

int main ( int  argc,
char **  argv 
)

Since we do not have builder variables holding segment data, we use the global variable s_seg for this purpose.

Definition at line 562 of file beck.c.

Here is the call graph for this function:

◆ mem_alloc()

static void* mem_alloc ( const struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
m0_bcount_t  size,
uint64_t  zonemask 
)
inlinestatic

Definition at line 116 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mem_free()

static void mem_free ( const struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
void *  ptr 
)
inlinestatic

Definition at line 102 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mem_update()

static void mem_update ( const struct m0_be_btree *  btree,
struct m0_be_tx *  tx,
void *  ptr,
m0_bcount_t  size 
)
inlinestatic

Definition at line 110 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ node_pop()

static struct m0_be_bnode* node_pop ( struct m0_be_btree_cursor *  it,
int *  idx 
)
static

Definition at line 1077 of file btree.c.

Here is the caller graph for this function:

◆ node_push()

static void node_push ( struct m0_be_btree_cursor *  it,
struct m0_be_bnode *  node,
int  idx 
)
static

Definition at line 1066 of file btree.c.

Here is the caller graph for this function:

◆ noop_act()

static void noop_act ( struct action *  act,
struct m0_be_tx *  tx 
)
static

Definition at line 3118 of file beck.c.

◆ noop_fini()

static void noop_fini ( struct action *  act)
static

Definition at line 3122 of file beck.c.

◆ noop_prep()

static int noop_prep ( struct action *  act,
struct m0_be_tx_credit *  cred 
)
static

Definition at line 3113 of file beck.c.

◆ nv_scan_offset_fini()

static void nv_scan_offset_fini ( void  )
static

Definition at line 1697 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ nv_scan_offset_get()

static off_t nv_scan_offset_get ( off_t  snapshot_size)
static

Definition at line 1706 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ nv_scan_offset_init()

static int nv_scan_offset_init ( uint64_t  workers_nr,
uint64_t  partitions_nr 
)
static

update MAX_WORKERS_NR limit if below pre-condition fails while tunning for performance

Definition at line 1676 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ nv_scan_offset_update()

static void nv_scan_offset_update ( void  )
static

Definition at line 1798 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ op_tree()

static struct m0_be_op__btree * op_tree ( struct m0_be_op *  op)
static

Definition at line 2510 of file btree.c.

Here is the caller graph for this function:

◆ parse()

static int parse ( struct scanner *  s)
static

Definition at line 1059 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ print_single_node()

static void print_single_node ( struct m0_be_bnode *  node)
static

Definition at line 2207 of file btree.c.

Here is the caller graph for this function:

◆ qfini()

static void qfini ( struct queue *  q)
static

Definition at line 2804 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ qget()

static struct action * qget ( struct queue *  q)
static

Definition at line 2857 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ qinit()

static void qinit ( struct queue *  q,
uint64_t  maxnr 
)
static

Definition at line 2792 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ qinvariant()

static bool qinvariant ( const struct queue *  q)
static

Definition at line 2780 of file beck.c.

Here is the caller graph for this function:

◆ qpeek()

static struct action * qpeek ( struct queue *  q)
static

Definition at line 2837 of file beck.c.

Here is the caller graph for this function:

◆ qput()

static void qput ( struct queue *  q,
struct action *  act 
)
static

Definition at line 2815 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ qtry()

static struct action * qtry ( struct queue *  q)
static

Definition at line 2871 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ recdo()

static int recdo ( struct scanner *  s,
const struct m0_format_tag *  tag,
struct rectype *  rt 
)
static

Check generation identifier before format footer verification. Only process the records whose generation identifier matches or is within +/- MAX_GEN_DIFF_SEC seconds of segment's generation identifier.

Definition at line 1152 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ recname()

static const char * recname ( const struct rectype *  rt)
static

Definition at line 1200 of file beck.c.

Here is the caller graph for this function:

◆ scan() [1/2]

static void scan ( char *  path,
char *  what 
)
static

Definition at line 217 of file main.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ scan() [2/2]

static int scan ( struct scanner *  s)
static

save scanner offset if scanner and bnode queue's are empty and scanner has progressed by delta bytes

Definition at line 963 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ scan_btree()

static void scan_btree ( struct m0_be_domain *  dom,
bool  print_btree 
)
static

Definition at line 131 of file main.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ scanner_action()

static void * scanner_action ( size_t  len,
enum action_opcode  opc,
const struct action_ops *  ops 
)
static

Definition at line 1302 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ scanner_cache_init()

static int scanner_cache_init ( struct scanner *  s)
static

Definition at line 942 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ scanner_fini()

static void scanner_fini ( struct scanner *  s)
static

Definition at line 958 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ scanner_init()

static int scanner_init ( struct scanner *  s)
static

Definition at line 933 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ scanner_thread()

static void scanner_thread ( struct scanner *  s)
static

Definition at line 802 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ seg_get()

static void seg_get ( FILE *  fp,
struct m0_be_seg *  out 
)
static

Update the values from the segment in file passed as parameter

If file has corrupted segment then use these hardcoded values.

Definition at line 884 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ seg_hdr_get()

static bool seg_hdr_get ( FILE *  fp,
struct m0_be_seg_hdr *  out 
)
static

Definition at line 837 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ seghdr()

static int seghdr ( struct scanner *  s,
struct rectype *  r,
char *  buf 
)
static

Definition at line 1622 of file beck.c.

◆ seghdr_check()

static int seghdr_check ( struct scanner *  s,
struct rectype *  r,
char *  buf 
)
static

Definition at line 1644 of file beck.c.

Here is the call graph for this function:

◆ seghdr_ver()

static int seghdr_ver ( struct scanner *  s,
struct rectype *  r,
char *  buf 
)
static

Definition at line 1627 of file beck.c.

Here is the call graph for this function:

◆ sig_handler()

static void sig_handler ( int  num)
static

Definition at line 556 of file beck.c.

Here is the caller graph for this function:

◆ spoil_nr()

static void spoil_nr ( struct m0_be_ut_fmt_group_test *  t,
struct m0_buf *  b 
)
static

Definition at line 301 of file fmt.c.

Here is the caller graph for this function:

◆ stats_print()

static void stats_print ( void  )
static

Definition at line 1022 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test()

static void test ( void  )
static

Definition at line 3204 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_queue()

static void test_queue ( void  )
static

Definition at line 3138 of file beck.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ track_ad_btrees()

void track_ad_btrees ( struct stob_ad_0type_rec *  rec,
bool  print_btree 
)

Definition at line 108 of file main.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ track_cob_btrees()

void track_cob_btrees ( struct m0_cob_domain *  cdom,
bool  print_btree 
)

Definition at line 84 of file main.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ tree_allocator()

static struct m0_be_allocator* tree_allocator ( const struct m0_be_btree *  btree)
static

Definition at line 97 of file btree.c.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ tx2tx_group_recovering_tx()

static struct be_recovering_tx* tx2tx_group_recovering_tx ( struct m0_be_tx *  tx)
static

Definition at line 508 of file tx_group.c.

Here is the caller graph for this function:

◆ tx_group_fom_fini()

static void tx_group_fom_fini ( struct m0_fom *  fom)
static

Definition at line 251 of file tx_group_fom.c.

Here is the call graph for this function:

◆ tx_group_fom_locality()

static size_t tx_group_fom_locality ( const struct m0_fom *  fom)
static

Definition at line 259 of file tx_group_fom.c.

◆ tx_group_fom_tick()

static int tx_group_fom_tick ( struct m0_fom *  fom)
static

Definition at line 149 of file tx_group_fom.c.

Here is the call graph for this function:

◆ txs_allocate()

static int txs_allocate ( struct m0_reqh_service **  service,
const struct m0_reqh_service_type *  stype 
)
static

Allocates and initialises transaction service.

Definition at line 79 of file tx_service.c.

Here is the call graph for this function:

◆ txs_fini()

static void txs_fini ( struct m0_reqh_service *  service)
static

Finalises and deallocates transaction service.

Definition at line 98 of file tx_service.c.

Here is the call graph for this function:

◆ txs_start()

static int txs_start ( struct m0_reqh_service *  service)
static

Definition at line 105 of file tx_service.c.

Here is the call graph for this function:

◆ txs_stop()

static void txs_stop ( struct m0_reqh_service *  service)
static

Definition at line 111 of file tx_service.c.

Here is the call graph for this function:

Variable Documentation

◆ be_group_format_levels

const struct m0_modlev be_group_format_levels[]
static

Definition at line 190 of file tx_group_format.c.

◆ be_log_levels

const struct m0_modlev be_log_levels[]
static

Definition at line 192 of file log.c.

◆ be_log_store_levels

const struct m0_modlev be_log_store_levels[]
static

Definition at line 452 of file log_store.c.

◆ BE_POOL_MAGIC_POISON

const uint64_t BE_POOL_MAGIC_POISON = 0xCCCCCCCCCCCC
static

Definition at line 46 of file pool.c.

◆ be_reg_area_ops

const struct m0_be_regmap_ops* be_reg_area_ops[]
static
Initial value:
= {
[M0_BE_REG_AREA_DATA_COPY] = &be_reg_area_ops_data_copy,
[M0_BE_REG_AREA_DATA_NOCOPY] = &be_reg_area_ops_data_nocopy,
}
be_reg_area_ops_data_nocopy
static const struct m0_be_regmap_ops be_reg_area_ops_data_nocopy
Definition: tx_regmap.c:552
M0_BE_REG_AREA_DATA_NOCOPY
Definition: tx_regmap.h:225
M0_BE_REG_AREA_DATA_COPY
Definition: tx_regmap.h:218
be_reg_area_ops_data_copy
static const struct m0_be_regmap_ops be_reg_area_ops_data_copy
Definition: tx_regmap.c:551

Definition at line 554 of file tx_regmap.c.

◆ be_reg_area_ops_data_copy

static const struct m0_be_regmap_ops be_reg_area_ops_data_copy
static
Initial value:
= {
.rmo_add = be_reg_area_add_copy,
.rmo_del = be_reg_area_del,
.rmo_cpy = be_reg_area_cpy_copy,
.rmo_cut = be_reg_area_cut,
.rmo_split = be_reg_area_split,
}
be_reg_area_cut
static void be_reg_area_cut(void *data, struct m0_be_reg_d *rd, m0_bcount_t cut_at_start, m0_bcount_t cut_at_end)
Definition: tx_regmap.c:712
be_reg_area_split
static void be_reg_area_split(void *data, struct m0_be_reg_d *rd, struct m0_be_reg_d *rd_new)
Definition: tx_regmap.c:720
be_reg_area_add_copy
static void be_reg_area_add_copy(void *data, struct m0_be_reg_d *rd)
Definition: tx_regmap.c:660
be_reg_area_cpy_copy
static void be_reg_area_cpy_copy(void *data, const struct m0_be_reg_d *super, const struct m0_be_reg_d *rd)
Definition: tx_regmap.c:681
be_reg_area_del
static void be_reg_area_del(void *data, const struct m0_be_reg_d *rd)
Definition: tx_regmap.c:676

Definition at line 551 of file tx_regmap.c.

◆ be_reg_area_ops_data_nocopy

static const struct m0_be_regmap_ops be_reg_area_ops_data_nocopy
static
Initial value:
= {
.rmo_add = be_reg_area_add,
.rmo_del = be_reg_area_del,
.rmo_cpy = be_reg_area_cpy,
.rmo_cut = be_reg_area_cut,
.rmo_split = be_reg_area_split,
}
be_reg_area_cut
static void be_reg_area_cut(void *data, struct m0_be_reg_d *rd, m0_bcount_t cut_at_start, m0_bcount_t cut_at_end)
Definition: tx_regmap.c:712
be_reg_area_split
static void be_reg_area_split(void *data, struct m0_be_reg_d *rd, struct m0_be_reg_d *rd_new)
Definition: tx_regmap.c:720
be_reg_area_cpy
static void be_reg_area_cpy(void *data, const struct m0_be_reg_d *super, const struct m0_be_reg_d *rd)
Definition: tx_regmap.c:697
be_reg_area_add
static void be_reg_area_add(void *data, struct m0_be_reg_d *rd)
Definition: tx_regmap.c:671
be_reg_area_del
static void be_reg_area_del(void *data, const struct m0_be_reg_d *rd)
Definition: tx_regmap.c:676

Definition at line 552 of file tx_regmap.c.

◆ be_tx_ast_offset

const ptrdiff_t be_tx_ast_offset[M0_BTS_NR+1]
static
Initial value:
= {
[M0_BTS_GROUPING] = offsetof(struct m0_be_tx, t_ast_grouping),
[M0_BTS_ACTIVE] = offsetof(struct m0_be_tx, t_ast_active),
[M0_BTS_FAILED] = offsetof(struct m0_be_tx, t_ast_failed),
[M0_BTS_LOGGED] = offsetof(struct m0_be_tx, t_ast_logged),
[M0_BTS_PLACED] = offsetof(struct m0_be_tx, t_ast_placed),
[M0_BTS_DONE] = offsetof(struct m0_be_tx, t_ast_done)
}
m0_be_tx::t_ast_grouping
struct m0_sm_ast t_ast_grouping
Definition: tx.h:366
M0_BTS_GROUPING
Definition: tx.h:247
m0_be_tx::t_ast_placed
struct m0_sm_ast t_ast_placed
Definition: tx.h:370
m0_be_tx::t_ast_logged
struct m0_sm_ast t_ast_logged
Definition: tx.h:369
M0_BTS_DONE
Definition: tx.h:269
m0_be_tx::t_ast_done
struct m0_sm_ast t_ast_done
Definition: tx.h:371
M0_BTS_ACTIVE
Definition: tx.h:251
m0_be_tx::t_ast_active
struct m0_sm_ast t_ast_active
Definition: tx.h:367
M0_BTS_LOGGED
Definition: tx.h:259
m0_be_tx::t_ast_failed
struct m0_sm_ast t_ast_failed
Definition: tx.h:368
M0_BTS_PLACED
Definition: tx.h:263
M0_BTS_FAILED
Definition: tx.h:223
offsetof
#define offsetof(typ, memb)
Definition: misc.h:29
m0_be_tx
Definition: tx.h:280

M0_BTS_NR items in array is enough, but sometimes gcc issues the following warning:

$ m0 rebuild
...skip...
CC motr/motr_libmotr_altogether_la-motr_altogether_user.lo
In file included from motr/motr_altogether_user.c:23:
.../be/tx_group.c: In function ‘m0_be_tx_group__tx_state_post’:
.../be/tx.c:84: error: array subscript is above array bounds
.../be/tx.c:84: error: array subscript is above array bounds
Todo:
Find out why M0_BTS_NR + 1 is enough and M0_BTS_NR isn't.

Definition at line 82 of file tx.c.

◆ be_tx_sm_conf

struct m0_sm_conf be_tx_sm_conf
Initial value:
= {
.scf_name = "m0_be_tx::t_sm",
.scf_nr_states = ARRAY_SIZE(be_tx_states),
.scf_state = be_tx_states,
.scf_trans_nr = ARRAY_SIZE(be_tx_sm_trans),
.scf_trans = be_tx_sm_trans
}
be_tx_sm_trans
static struct m0_sm_trans_descr be_tx_sm_trans[]
Definition: tx.c:164
be_tx_states
static struct m0_sm_state_descr be_tx_states[M0_BTS_NR]
Definition: tx.c:113
ARRAY_SIZE
#define ARRAY_SIZE(a)
Definition: misc.h:45

Definition at line 176 of file tx.c.

◆ be_tx_sm_trans

struct m0_sm_trans_descr be_tx_sm_trans[]
static
Initial value:
= {
{ "opening", M0_BTS_PREPARE, M0_BTS_OPENING },
{ "prepare-failed", M0_BTS_PREPARE, M0_BTS_FAILED },
{ "grouping", M0_BTS_OPENING, M0_BTS_GROUPING },
{ "open-failed", M0_BTS_OPENING, M0_BTS_FAILED },
{ "activated", M0_BTS_GROUPING, M0_BTS_ACTIVE },
{ "closed", M0_BTS_ACTIVE, M0_BTS_CLOSED },
{ "logged", M0_BTS_CLOSED, M0_BTS_LOGGED },
{ "placed", M0_BTS_LOGGED, M0_BTS_PLACED },
{ "done", M0_BTS_PLACED, M0_BTS_DONE }
}
M0_BTS_OPENING
Definition: tx.h:243
M0_BTS_GROUPING
Definition: tx.h:247
M0_BTS_DONE
Definition: tx.h:269
M0_BTS_CLOSED
Definition: tx.h:255
M0_BTS_ACTIVE
Definition: tx.h:251
M0_BTS_PREPARE
Definition: tx.h:235
M0_BTS_LOGGED
Definition: tx.h:259
M0_BTS_PLACED
Definition: tx.h:263
M0_BTS_FAILED
Definition: tx.h:223

Definition at line 164 of file tx.c.

◆ be_tx_states

struct m0_sm_state_descr be_tx_states[M0_BTS_NR]
static

Definition at line 113 of file tx.c.

◆ be_ut_gc_tests

struct be_ut_gc_test be_ut_gc_tests[BE_UT_TX_GC_TX_NR]
static

Definition at line 808 of file tx.c.

◆ be_ut_io_sched_scheduler

struct m0_be_io_sched be_ut_io_sched_scheduler
static

Definition at line 112 of file io_sched.c.

◆ be_ut_queue_tests_cfg

struct be_ut_queue_cfg be_ut_queue_tests_cfg[BE_UT_QUEUE_NR]
static
Initial value:
= {
[BE_UT_QUEUE_1_1_1] = BE_UT_QUEUE_TEST( 1, 1, 1, 1),
[BE_UT_QUEUE_2_1_1] = BE_UT_QUEUE_TEST( 2, 1, 1, 10000),
[BE_UT_QUEUE_100_1_1] = BE_UT_QUEUE_TEST(100, 1, 1, 10000),
[BE_UT_QUEUE_100_1_10] = BE_UT_QUEUE_TEST(100, 1, 10, 10000),
[BE_UT_QUEUE_100_10_1] = BE_UT_QUEUE_TEST(100, 10, 1, 10000),
[BE_UT_QUEUE_100_10_10] = BE_UT_QUEUE_TEST(100, 10, 10, 10000),
[BE_UT_QUEUE_10_100_1] = BE_UT_QUEUE_TEST( 10, 100, 1, 10000),
[BE_UT_QUEUE_10_100_5] = BE_UT_QUEUE_TEST( 10, 100, 5, 10000),
[BE_UT_QUEUE_10_1_100] = BE_UT_QUEUE_TEST( 10, 1, 100, 10000),
[BE_UT_QUEUE_10_5_100] = BE_UT_QUEUE_TEST( 10, 5, 100, 10000),
[BE_UT_QUEUE_10_100_100] = BE_UT_QUEUE_TEST( 10, 100, 100, 10000),
}
BE_UT_QUEUE_100_10_10
Definition: queue.c:55
BE_UT_QUEUE_2_1_1
Definition: queue.c:51
BE_UT_QUEUE_100_10_1
Definition: queue.c:54
BE_UT_QUEUE_100_1_10
Definition: queue.c:53
BE_UT_QUEUE_10_1_100
Definition: queue.c:58
BE_UT_QUEUE_10_100_1
Definition: queue.c:56
BE_UT_QUEUE_10_5_100
Definition: queue.c:59
BE_UT_QUEUE_100_1_1
Definition: queue.c:52
BE_UT_QUEUE_1_1_1
Definition: queue.c:50
BE_UT_QUEUE_TEST
#define BE_UT_QUEUE_TEST(q_size_max, producers, consumers, items_nr)
Definition: queue.c:119
BE_UT_QUEUE_10_100_5
Definition: queue.c:57
BE_UT_QUEUE_10_100_100
Definition: queue.c:60

Definition at line 127 of file queue.c.

◆ be_ut_tx_payload_seed

uint64_t be_ut_tx_payload_seed
static

Definition at line 1004 of file tx.c.

◆ beck_builder

struct builder beck_builder
static

Definition at line 520 of file beck.c.

◆ beck_scanner

struct scanner beck_scanner
static

Definition at line 519 of file beck.c.

◆ betool_common_ctx

struct m0_betool_common_ctx betool_common_ctx
static

Definition at line 39 of file common.c.

◆ betool_help

const char* betool_help
static
Initial value:
= ""
"Usage: m0betool [cmd] [path] [size]\n"
"where [cmd] is one from (without quotes):\n"
"- 'st mkfs'\n"
"- 'st run'\n"
"- 'be_recovery_run'\n"
"- 'be_log_resize'\n"
"- 'track_btree'\n"
"- 'print_btree'\n"
"\n"
"Use case for 'st mkfs' and 'st run': run 'st mkfs' once to initialise \n"
"BE data structures, then run 'st run' and kill m0betool process during \n"
"'st run' execution. When 'st run' is called next time BE recovery will \n"
"replay BE log and 'st run' should be able to continue without any issues. \n"
"be_log_resize will create BE log file with custom size. \n"
"This is an ST for BE recovery.\n"
"\n"
"'be_recovery_run' runs BE recovery.\n"
"\n"
"'path' parameter is an optional path to BE domain stob domain location.\n"
"Default BE domain stob domain location is used when this parameter is absent:"
"\n"
"'be_log_resize' create BE log file without mkfs.\n"
"\n"
"'path' and 'size' mandatory arguments for be_log_resize. 'size' in bytes. \n"
"Usage: m0betool be_log_resize <path> <size> \n"
"\n"

Definition at line 54 of file main.c.

◆ betool_st_event_descr

const char* betool_st_event_descr[]
static
Initial value:
= {
"begin",
"tx open",
"fill",
"tx capture",
"tx close&wait",
"end",
}

Definition at line 154 of file st.c.

◆ bnodeops

static const struct recops bnodeops
static
Initial value:
= {
.ro_proc = &bnode,
.ro_check = &bnode_check
}
bnode_check
static int bnode_check(struct scanner *s, struct rectype *r, char *buf)
Definition: beck.c:1351
bnode
static int bnode(struct scanner *s, struct rectype *r, char *buf)
Definition: beck.c:1316

Definition at line 414 of file beck.c.

◆ bt

struct btype bt[]
static
Initial value:
= {
_B(M0_BBT_BALLOC_GROUP_EXTENTS, NULL),
_B(M0_BBT_BALLOC_GROUP_DESC, NULL),
_B(M0_BBT_EMAP_EM_MAPPING, NULL),
_B(M0_BBT_COB_NAMESPACE, NULL),
_B(M0_BBT_EMAP_EM_MAPPING, NULL),
_B(M0_BBT_CAS_CTG, NULL),
_B(M0_BBT_COB_NAMESPACE, NULL),
_B(M0_BBT_EMAP_EM_MAPPING, &emap_proc),
_B(M0_BBT_CAS_CTG, &ctg_proc),
_B(M0_BBT_COB_NAMESPACE, &cob_proc),
_B(M0_BBT_COB_OBJECT_INDEX, NULL),
_B(M0_BBT_COB_FILEATTR_BASIC, NULL),
_B(M0_BBT_COB_FILEATTR_EA, NULL),
_B(M0_BBT_COB_FILEATTR_OMG, NULL),
_B(M0_BBT_CONFDB, NULL),
_B(M0_BBT_UT_KV_OPS, NULL),
[M0_BBT_NR] = {}
}
M0_BBT_BALLOC_GROUP_DESC
Definition: btree.h:120
M0_BBT_COB_NAMESPACE
Definition: btree.h:123
NULL
#define NULL
Definition: misc.h:38
_B
#define _B(t, proc)
Definition: beck.c:457
M0_BBT_COB_OBJECT_INDEX
Definition: btree.h:124
cob_proc
static int cob_proc(struct scanner *s, struct btype *b, struct m0_be_bnode *node, off_t node_offset)
Definition: beck.c:2954
M0_BBT_CONFDB
Definition: btree.h:129
M0_BBT_CAS_CTG
Definition: btree.h:122
ctg_proc
static int ctg_proc(struct scanner *s, struct btype *b, struct m0_be_bnode *node, off_t node_offset)
Definition: beck.c:2579
M0_BBT_EMAP_EM_MAPPING
Definition: btree.h:121
emap_proc
static int emap_proc(struct scanner *s, struct btype *b, struct m0_be_bnode *node, off_t node_offset)
Definition: beck.c:1410
M0_BBT_COB_FILEATTR_BASIC
Definition: btree.h:125
M0_BBT_UT_KV_OPS
Definition: btree.h:130
M0_BBT_COB_FILEATTR_OMG
Definition: btree.h:127
M0_BBT_NR
Definition: btree.h:131
M0_BBT_COB_FILEATTR_EA
Definition: btree.h:126
M0_BBT_BALLOC_GROUP_EXTENTS
Definition: btree.h:119

Definition at line 459 of file beck.c.

◆ btreeops

static const struct recops btreeops
static
Initial value:
= {
.ro_proc = &btree,
.ro_check = &btree_check
}
btree
static int btree(struct scanner *s, struct rectype *r, char *buf)
Definition: beck.c:1270
btree_check
static int btree_check(struct scanner *s, struct rectype *r, char *buf)
Definition: beck.c:1291

Definition at line 413 of file beck.c.

◆ cob_ops

static const struct action_ops cob_ops
static
Initial value:
= {
.o_prep = &cob_prep,
.o_act = &cob_act,
.o_fini = &cob_fini
}
cob_fini
static void cob_fini(struct action *act)
Definition: beck.c:3106
cob_prep
static int cob_prep(struct action *act, struct m0_be_tx_credit *accum)
Definition: beck.c:3015
cob_act
static void cob_act(struct action *act, struct m0_be_tx *tx)
Definition: beck.c:3041

Definition at line 419 of file beck.c.

◆ ctg_ops

static const struct action_ops ctg_ops
static
Initial value:
= {
.o_prep = &ctg_prep,
.o_act = &ctg_act,
.o_fini = &ctg_fini
}
ctg_prep
static int ctg_prep(struct action *act, struct m0_be_tx_credit *accum)
Definition: beck.c:2684
ctg_fini
static void ctg_fini(struct action *act)
Definition: beck.c:2764
ctg_act
static void ctg_act(struct action *act, struct m0_be_tx *tx)
Definition: beck.c:2722

Definition at line 418 of file beck.c.

◆ default_tb_cfg

struct m0_be_tx_bulk_cfg default_tb_cfg
static
Initial value:
= (struct m0_be_tx_bulk_cfg){
.tbc_q_cfg = {
.bqc_q_size_max = 1000,
.bqc_producers_nr_max = 1,
},
.tbc_workers_nr = 0x40,
.tbc_partitions_nr = AO_NR,
.tbc_work_items_per_tx_max = 1,
}
m0_be_tx_bulk_cfg
Definition: tx_bulk.h:64
AO_NR
Definition: beck.c:181

These values provided the maximum builder performance after experiments on hardware.

Definition at line 538 of file beck.c.

◆ disable_directio

bool disable_directio = false
static

Definition at line 527 of file beck.c.

◆ done_ops

static const struct action_ops done_ops
static
Initial value:
= {
.o_prep = &noop_prep,
.o_act = &noop_act,
.o_fini = &noop_fini
}
noop_act
static void noop_act(struct action *act, struct m0_be_tx *tx)
Definition: beck.c:3118
noop_fini
static void noop_fini(struct action *act)
Definition: beck.c:3122
noop_prep
static int noop_prep(struct action *act, struct m0_be_tx_credit *cred)
Definition: beck.c:3113

Definition at line 417 of file beck.c.

◆ dry_run

bool dry_run = false
static

Definition at line 526 of file beck.c.

◆ emap_ops

const struct action_ops emap_ops
static
Initial value:
= {
.o_prep = &emap_prep,
.o_act = &emap_act,
.o_fini = &emap_fini
}
emap_prep
static int emap_prep(struct action *act, struct m0_be_tx_credit *cred)
Definition: beck.c:1480
emap_fini
static void emap_fini(struct action *act)
Definition: beck.c:1603
emap_act
static void emap_act(struct action *act, struct m0_be_tx *tx)
Definition: beck.c:1516

Definition at line 1380 of file beck.c.

◆ g

struct gen g[MAX_GEN] = {}
static

Definition at line 521 of file beck.c.

◆ iobuf

char iobuf[4 *1024 *1024]
static

Definition at line 821 of file beck.c.

◆ levels_be_domain

static const struct m0_modlev levels_be_domain
static
Initial value:
= {
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_INIT),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_0TYPES_REGISTER),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_DESTROY),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_CREATE),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_NORMAL_STOB_DOMAIN_INIT),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_LOG_CONFIGURE),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_MKFS_LOG_CREATE),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_NORMAL_LOG_OPEN),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_PD_INIT),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_NORMAL_SEG0_OPEN),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_NORMAL_0TYPES_VISIT),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_LOG_DISCARD_INIT),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_ENGINE_INIT),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_ENGINE_START),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_MKFS_SEG0_CREATE),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_MKFS_SEG0_STRUCTS_CREATE),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_MKFS_SEG0_0TYPE),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_MKFS_SEGMENTS_CREATE),
BE_DOMAIN_LEVEL(M0_BE_DOMAIN_LEVEL_READY),
}
M0_BE_DOMAIN_LEVEL_NORMAL_LOG_OPEN
Definition: domain.h:162
M0_BE_DOMAIN_LEVEL_PD_INIT
Definition: domain.h:163
M0_BE_DOMAIN_LEVEL_NORMAL_SEG0_OPEN
Definition: domain.h:164
M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_CREATE
Definition: domain.h:158
M0_BE_DOMAIN_LEVEL_ENGINE_INIT
Definition: domain.h:167
M0_BE_DOMAIN_LEVEL_NORMAL_STOB_DOMAIN_INIT
Definition: domain.h:159
BE_DOMAIN_LEVEL
#define BE_DOMAIN_LEVEL(level)
Definition: domain.c:924
M0_BE_DOMAIN_LEVEL_INIT
Definition: domain.h:155
M0_BE_DOMAIN_LEVEL_LOG_CONFIGURE
Definition: domain.h:160
M0_BE_DOMAIN_LEVEL_LOG_DISCARD_INIT
Definition: domain.h:166
M0_BE_DOMAIN_LEVEL_MKFS_SEGMENTS_CREATE
Definition: domain.h:172
M0_BE_DOMAIN_LEVEL_0TYPES_REGISTER
Definition: domain.h:156
M0_BE_DOMAIN_LEVEL_MKFS_SEG0_STRUCTS_CREATE
Definition: domain.h:170
M0_BE_DOMAIN_LEVEL_MKFS_LOG_CREATE
Definition: domain.h:161
M0_BE_DOMAIN_LEVEL_READY
Definition: domain.h:173
M0_BE_DOMAIN_LEVEL_NORMAL_0TYPES_VISIT
Definition: domain.h:165
M0_BE_DOMAIN_LEVEL_MKFS_SEG0_0TYPE
Definition: domain.h:171
M0_BE_DOMAIN_LEVEL_MKFS_STOB_DOMAIN_DESTROY
Definition: domain.h:157
M0_BE_DOMAIN_LEVEL_MKFS_SEG0_CREATE
Definition: domain.h:169
M0_BE_DOMAIN_LEVEL_ENGINE_START
Definition: domain.h:168

Definition at line 663 of file domain.c.

◆ m0_be_0type_seg

const struct m0_be_0type m0_be_0type_seg
static
Initial value:
= {
.b0_name = "M0_BE:SEG",
.b0_init = be_0type_seg_init,
.b0_fini = be_0type_seg_fini,
}
be_0type_seg_fini
static void be_0type_seg_fini(struct m0_be_domain *dom, const char *suffix, const struct m0_buf *data)
Definition: domain.c:332
be_0type_seg_init
static int be_0type_seg_init(struct m0_be_domain *dom, const char *suffix, const struct m0_buf *data)
Definition: domain.c:307

Definition at line 356 of file domain.c.

◆ m0_be_tx_credit_invalid [1/2]

const struct m0_be_tx_credit m0_be_tx_credit_invalid
Initial value:
=
M0_BE_TX_CREDIT(M0_BCOUNT_MAX, M0_BCOUNT_MAX)
M0_BE_TX_CREDIT
#define M0_BE_TX_CREDIT(nr, size)
Definition: tx_credit.h:94

Invalid credit structure used to forcibly fail a transaction.

This is declared here rather than in credit.c so that this symbol exists in the kernel build.

Definition at line 41 of file tx_credit.c.

◆ m0_be_tx_credit_invalid [2/2]

const struct m0_be_tx_credit m0_be_tx_credit_invalid

Invalid credit structure used to forcibly fail a transaction.

This is declared here rather than in credit.c so that this symbol exists in the kernel build.

Definition at line 41 of file tx_credit.c.

◆ m0_be_txs_stype [1/2]

struct m0_reqh_service_type m0_be_txs_stype
Initial value:
= {
.rst_name = "be-tx-service",
.rst_ops = &txs_stype_ops,
.rst_level = M0_BE_TX_SVC_LEVEL,
}
M0_BE_TX_SVC_LEVEL
Definition: reqh_service.h:630
txs_stype_ops
static const struct m0_reqh_service_type_ops txs_stype_ops
Definition: tx_service.c:48

Definition at line 52 of file tx_service.c.

◆ m0_be_txs_stype [2/2]

struct m0_reqh_service_type m0_be_txs_stype

Definition at line 52 of file tx_service.c.

◆ m0_btree_fid_type [1/2]

M0_INTERNAL const struct m0_fid_type m0_btree_fid_type
Initial value:
= {
.ft_id = 'b',
.ft_name = "btree fid",
}

Definition at line 57 of file btree.c.

◆ m0_btree_fid_type [2/2]

M0_EXTERN const struct m0_fid_type m0_btree_fid_type

Btree fid type

Definition at line 154 of file btree.h.

◆ M0_XCA_DOMAIN [1/13]

enum { ... } M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [2/13]

enum { ... } M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [3/13]

struct m0_be_allocator M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [4/13]

struct m0_be_io_part M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [5/13]

enum m0_be_seg_hdr_format_version M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [6/13]

enum m0_be_bnode_format_version M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [7/13]

enum { ... } M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [8/13]

enum m0_be_btree_format_version M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [9/13]

struct m0_fmt_xcode_ctx M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [10/13]

enum m0_be_list_op M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [11/13]

struct m0_be_domain_cfg M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [12/13]

struct m0_be_reg M0_XCA_DOMAIN

◆ M0_XCA_DOMAIN [13/13]

struct m0_be_fmt_decode_cfg M0_XCA_DOMAIN

◆ M0_XCA_ENUM [1/3]

enum m0_avi_be_labels M0_XCA_ENUM

◆ M0_XCA_ENUM [2/3]

enum m0_be_alloc_zone_type M0_XCA_ENUM

◆ M0_XCA_ENUM [3/3]

enum m0_be_btree_type M0_XCA_ENUM

◆ mmap_be_segment

bool mmap_be_segment = false
static

Definition at line 530 of file beck.c.

◆ nv_off_info

struct nv_offset_info nv_off_info
static

Used only in dry-run mode.

Definition at line 523 of file beck.c.

◆ off_info

struct offset_info off_info
static

Definition at line 524 of file beck.c.

◆ offset_file

const char* offset_file = NULL
static

Definition at line 532 of file beck.c.

◆ op_states

struct m0_sm_state_descr op_states[]
static
Initial value:
= {
[M0_BOS_INIT] = {
.sd_flags = M0_SDF_INITIAL,
.sd_name = "M0_BOS_INIT",
.sd_allowed = M0_BITS(M0_BOS_ACTIVE),
},
[M0_BOS_ACTIVE] = {
.sd_flags = 0,
.sd_name = "M0_BOS_ACTIVE",
.sd_allowed = M0_BITS(M0_BOS_DONE),
},
[M0_BOS_DONE] = {
.sd_flags = M0_SDF_TERMINAL,
.sd_name = "M0_BOS_DONE",
.sd_allowed = 0,
},
}
M0_BITS
#define M0_BITS(...)
Definition: misc.h:236
M0_BOS_ACTIVE
Definition: op.h:58
M0_SDF_TERMINAL
Definition: sm.h:471
M0_SDF_INITIAL
Definition: sm.h:450
M0_BOS_DONE
Definition: op.h:59
M0_BOS_INIT
Definition: op.h:57

Definition at line 43 of file op.c.

◆ op_states_conf [1/2]

M0_INTERNAL struct m0_sm_conf op_states_conf
Initial value:
= {
.scf_name = "m0_be_op::bo_sm",
.scf_nr_states = ARRAY_SIZE(op_states),
.scf_state = op_states,
.scf_trans_nr = ARRAY_SIZE(op_trans),
.scf_trans = op_trans
}
op_states
static struct m0_sm_state_descr op_states[]
Definition: op.c:43
op_trans
static struct m0_sm_trans_descr op_trans[]
Definition: op.c:61
ARRAY_SIZE
#define ARRAY_SIZE(a)
Definition: misc.h:45

Definition at line 66 of file op.c.

◆ op_states_conf [2/2]

M0_EXTERN struct m0_sm_conf op_states_conf

Definition at line 774 of file tx.c.

◆ op_trans

struct m0_sm_trans_descr op_trans[]
static
Initial value:
= {
{ "started", M0_BOS_INIT, M0_BOS_ACTIVE },
{ "completed", M0_BOS_ACTIVE, M0_BOS_DONE },
}
M0_BOS_ACTIVE
Definition: op.h:58
M0_BOS_DONE
Definition: op.h:59
M0_BOS_INIT
Definition: op.h:57

Definition at line 61 of file op.c.

◆ resume_scan

bool resume_scan = false
static

Definition at line 529 of file beck.c.

◆ rt

struct rectype rt[]
static
Initial value:
= {
_T(BALLOC_GROUP_DESC, m0_balloc_group_desc, bgd_footer, NULL),
_T(BALLOC, m0_balloc, cb_footer, NULL),
_T(BE_BTREE, m0_be_btree, bb_footer, &btreeops),
_T(BE_BNODE, m0_be_bnode, bt_footer, &bnodeops),
_T(BE_EMAP_KEY, m0_be_emap_key, ek_footer, NULL),
_T(BE_EMAP_REC, m0_be_emap_rec, er_footer, NULL),
_T(BE_EMAP, m0_be_emap, em_footer, NULL),
_T(BE_LIST, m0_be_list, bl_format_footer, NULL),
_T(BE_SEG_HDR, m0_be_seg_hdr, bh_footer, &seghdrops),
_T(CAS_CTG, m0_cas_ctg, cc_foot, NULL),
_T(CAS_STATE, m0_cas_state, cs_footer, NULL),
_T(COB_DOMAIN, m0_cob_domain, cd_footer, NULL),
_T(COB_NSREC, m0_cob_nsrec, cnr_footer, NULL),
_T(EXT, m0_ext, e_footer, NULL),
_T(POOLNODE, m0_poolnode, pn_footer, NULL),
_T(POOLDEV, m0_pooldev, pd_footer, NULL),
_T(POOL_SPARE_USAGE, m0_pool_spare_usage, psu_footer, NULL),
_T(STOB_AD_DOMAIN, m0_stob_ad_domain, sad_footer, NULL),
_T(STOB_AD_0TYPE_REC, stob_ad_0type_rec, sa0_footer, NULL),
[M0_FORMAT_TYPE_NR] = {}
}
er_footer
struct m0_format_footer er_footer
Definition: extmap_internal.h:406
m0_pool_spare_usage
Definition: pool.h:474
NULL
#define NULL
Definition: misc.h:38
m0_cas_ctg
Definition: ctg_store.h:94
cs_footer
struct m0_format_footer cs_footer
Definition: ctg_store.h:133
m0_be_emap
Definition: extmap_internal.h:141
m0_cas_state
Definition: ctg_store.h:154
cb_footer
struct m0_format_footer cb_footer
Definition: balloc.h:644
cd_footer
struct m0_format_footer cd_footer
Definition: cob.h:2382
btreeops
static const struct recops btreeops
Definition: beck.c:413
M0_FORMAT_TYPE_NR
Definition: format.h:115
m0_be_emap_rec
Definition: extmap_internal.h:101
cc_foot
struct m0_format_footer cc_foot
Definition: ctg_store.h:115
m0_be_btree
Definition: btree.h:60
m0_poolnode
Definition: pool.h:390
e_footer
struct m0_format_footer e_footer
Definition: ext.h:98
m0_cob_nsrec
Definition: cob.h:417
m0_stob_ad_domain
Definition: ad.h:111
bb_footer
struct m0_format_footer bb_footer
Definition: btree.h:63
psu_footer
struct m0_format_footer psu_footer
Definition: pool.h:417
m0_be_bnode
Definition: btree_internal.h:49
bnodeops
static const struct recops bnodeops
Definition: beck.c:414
m0_balloc
Definition: balloc.h:221
bl_format_footer
struct m0_format_footer bl_format_footer
Definition: list.h:492
sad_footer
struct m0_format_footer sad_footer
Definition: ad.h:1536
m0_cob_domain
Definition: cob.h:262
bt_footer
struct m0_format_footer bt_footer
Definition: btree_internal.h:597
m0_ext
Definition: ext.h:37
sa0_footer
struct m0_format_footer sa0_footer
Definition: ad_private.h:211
m0_be_emap_key
Definition: extmap_internal.h:60
m0_be_seg_hdr
Definition: seg_internal.h:47
bgd_footer
struct m0_format_footer bgd_footer
Definition: balloc.h:653
m0_pooldev
Definition: pool.h:421
_T
#define _T(name, str, field, ops)
Definition: beck.c:423
stob_ad_0type_rec
Definition: ad_private.h:38
EXT
#define EXT(start, end)
bh_footer
struct m0_format_footer bh_footer
Definition: seg_internal.h:96
ek_footer
struct m0_format_footer ek_footer
Definition: extmap_internal.h:403
m0_be_list
Definition: list.h:76
em_footer
struct m0_format_footer em_footer
Definition: extmap_internal.h:388
cnr_footer
struct m0_format_footer cnr_footer
Definition: cob.h:431
seghdrops
static const struct recops seghdrops
Definition: beck.c:415
m0_balloc_group_desc
Definition: balloc.h:53

Definition at line 428 of file beck.c.

◆ s_seg

struct m0_be_seg s_seg = {}
static

Definition at line 522 of file beck.c.

◆ seghdrops

static const struct recops seghdrops
static
Initial value:
= {
.ro_proc = &seghdr,
.ro_ver = &seghdr_ver,
.ro_check = &seghdr_check,
}
seghdr_check
static int seghdr_check(struct scanner *s, struct rectype *r, char *buf)
Definition: beck.c:1644
seghdr_ver
static int seghdr_ver(struct scanner *s, struct rectype *r, char *buf)
Definition: beck.c:1627
seghdr
static int seghdr(struct scanner *s, struct rectype *r, char *buf)
Definition: beck.c:1622

Definition at line 415 of file beck.c.

◆ signaled

bool signaled = false
static

Definition at line 528 of file beck.c.

◆ test

static void test
Initial value:
= {
{ .t_count = 1 }, { .t_count = 2 }, { .t_count = 3 }, { .t_count = 4 },
{ .t_count = 5 }, { .t_count = 6 }, { .t_count = 7 }, { .t_count = 8 },
}

Definition at line 45 of file thread_pool.c.

◆ tx_group_fom_conf

const struct m0_sm_conf tx_group_fom_conf
static
Initial value:
= {
.scf_name = "m0_be_tx_group_fom",
.scf_nr_states = ARRAY_SIZE(tx_group_fom_states),
.scf_state = tx_group_fom_states,
}
tx_group_fom_states
static struct m0_sm_state_descr tx_group_fom_states[TGS_NR]
Definition: tx_group_fom.c:115
ARRAY_SIZE
#define ARRAY_SIZE(a)
Definition: misc.h:45

Definition at line 143 of file tx_group_fom.c.

◆ tx_group_fom_ops

const struct m0_fom_ops tx_group_fom_ops
static
Initial value:
= {
.fo_fini = tx_group_fom_fini,
.fo_tick = tx_group_fom_tick,
.fo_home_locality = tx_group_fom_locality
}
tx_group_fom_tick
static int tx_group_fom_tick(struct m0_fom *fom)
Definition: tx_group_fom.c:149
tx_group_fom_locality
static size_t tx_group_fom_locality(const struct m0_fom *fom)
Definition: tx_group_fom.c:259
tx_group_fom_fini
static void tx_group_fom_fini(struct m0_fom *fom)
Definition: tx_group_fom.c:251

Definition at line 264 of file tx_group_fom.c.

◆ tx_group_fom_states

struct m0_sm_state_descr tx_group_fom_states[TGS_NR]
static
Initial value:
= {
#define _S(name, flags, allowed)
_S(TGS_INIT, M0_SDF_INITIAL, M0_BITS(TGS_OPEN, TGS_FAILED)),
_S(TGS_FINISH, M0_SDF_TERMINAL, 0),
_S(TGS_FAILED, M0_SDF_FAILURE, M0_BITS(TGS_FINISH)),
_S(TGS_STOPPING, 0, M0_BITS(TGS_FINISH)),
_S(TGS_OPEN, 0, M0_BITS(TGS_PREPARE, TGS_STOPPING)),
_S(TGS_PREPARE, 0, M0_BITS(TGS_LOGGING)),
_S(TGS_LOGGING, 0, M0_BITS(TGS_PLACING, TGS_RECONSTRUCT)),
_S(TGS_RECONSTRUCT, 0, M0_BITS(TGS_TX_OPEN)),
_S(TGS_TX_OPEN, 0, M0_BITS(TGS_TX_CLOSE)),
_S(TGS_TX_CLOSE, 0, M0_BITS(TGS_REAPPLY)),
_S(TGS_REAPPLY, 0, M0_BITS(TGS_PLACING)),
_S(TGS_PLACING, 0, M0_BITS(TGS_PLACED)),
_S(TGS_PLACED, 0, M0_BITS(TGS_STABILIZING)),
_S(TGS_STABILIZING, 0, M0_BITS(TGS_STABLE)),
_S(TGS_STABLE, 0, M0_BITS(TGS_RESET, TGS_TX_GC_WAIT)),
_S(TGS_TX_GC_WAIT, 0, M0_BITS(TGS_RESET)),
_S(TGS_RESET, 0, M0_BITS(TGS_OPEN)),
}
TGS_TX_OPEN
Definition: tx_group_fom.c:95
TGS_LOGGING
Definition: tx_group_fom.c:92
TGS_RECONSTRUCT
Definition: tx_group_fom.c:94
TGS_STOPPING
Definition: tx_group_fom.c:110
M0_BITS
#define M0_BITS(...)
Definition: misc.h:236
TGS_INIT
Definition: tx_group_fom.c:83
TGS_PREPARE
Definition: tx_group_fom.c:91
M0_SDF_FAILURE
Definition: sm.h:462
TGS_FINISH
Definition: tx_group_fom.c:84
TGS_TX_GC_WAIT
Definition: tx_group_fom.c:108
TGS_RESET
Definition: tx_group_fom.c:109
M0_SDF_TERMINAL
Definition: sm.h:471
TGS_PLACED
Definition: tx_group_fom.c:100
TGS_STABILIZING
Definition: tx_group_fom.c:102
TGS_OPEN
Definition: tx_group_fom.c:89
TGS_REAPPLY
Definition: tx_group_fom.c:97
M0_SDF_INITIAL
Definition: sm.h:450
TGS_PLACING
Definition: tx_group_fom.c:99
TGS_FAILED
Definition: tx_group_fom.c:111
TGS_STABLE
Definition: tx_group_fom.c:107
_S
#define _S(name, flags, allowed)
TGS_TX_CLOSE
Definition: tx_group_fom.c:96

Definition at line 115 of file tx_group_fom.c.

◆ tx_group_fom_type

struct m0_fom_type tx_group_fom_type
static

Definition at line 270 of file tx_group_fom.c.

◆ tx_group_fom_type_ops

const struct m0_fom_type_ops tx_group_fom_type_ops
static
Initial value:
= {
.fto_create = NULL
}
NULL
#define NULL
Definition: misc.h:38

Definition at line 272 of file tx_group_fom.c.

◆ txs_ops

const struct m0_reqh_service_ops txs_ops
static
Initial value:
= {
.rso_start = txs_start,
.rso_stop = txs_stop,
.rso_fini = txs_fini
}
txs_stop
static void txs_stop(struct m0_reqh_service *service)
Definition: tx_service.c:111
txs_start
static int txs_start(struct m0_reqh_service *service)
Definition: tx_service.c:105
txs_fini
static void txs_fini(struct m0_reqh_service *service)
Definition: tx_service.c:98

Definition at line 72 of file tx_service.c.

◆ txs_stype_ops

const struct m0_reqh_service_type_ops txs_stype_ops
static
Initial value:
= {
.rsto_service_allocate = txs_allocate
}
txs_allocate
static int txs_allocate(struct m0_reqh_service **out, const struct m0_reqh_service_type *stype)
Definition: tx_service.c:79

Definition at line 48 of file tx_service.c.