#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <rvm/rvm.h>
#include <rvm/rvm_statistics.h>
#include <asm/page.h>
#include <fcntl.h>
#include <cthreads.h>

Include dependency graph for rvm_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	chk_vec_t

struct	list_entry_s

struct	free_page_t

struct	rw_lock_t

struct	rw_qentry_t

struct	tree_node_s

union	tree_links_t

struct	tree_pos_t

struct	tree_root_t

struct	nv_buf_t

struct	dev_region_t

struct	mem_region_t

struct	rec_hdr_t

struct	trans_hdr_t

struct	nv_range_t

struct	log_seg_t

struct	log_special_t

struct	rec_end_t

struct	log_wrap_t

struct	device_t

struct	log_status_t

struct	log_dev_status_t

struct	log_buf_t

struct	log_daemon_t

struct	log_t

struct	seg_t

struct	seg_dict_s

struct	region_s

struct	range_t

struct	int_tid_t

struct	rvm_page_entry

Macros
#define	DEBUG 1

#define	getpagesize() PAGE_SIZE

#define	O_BINARY 0

#define	RVM_LOG_VERSION "RVM Log Version 1.4 Oct 17, 1997 "

#define	REALLOC(x, l) (((x) == NULL) ? malloc(l) : realloc((x), (l)))

#define	BCOPY(x, y, n) bcopy((x), (y), (n))

#define	BZERO(x, n) bzero((x), (n))

#define	DO_FOREVER for (;;)

#define	FORWARD rvm_true /* record scan forward */

#define	REVERSE rvm_false /* record scan reverse */

#define	ERR_DATE_SKEW "Current time before last recorded - check kernel date"

#define	TIME_LSS(x, y)

#define	TIME_GTR(x, y)

#define	TIME_LEQ(x, y) (!TIME_GTR((x), (y)))

#define	TIME_GEQ(x, y) (!TIME_LSS((x), (y)))

#define	TIME_EQL(x, y) (((x).tv_sec == (y).tv_sec) && ((x).tv_usec == (y).tv_usec))

#define	TIME_EQL_ZERO(x) (((x).tv_sec == 0 && ((x).tv_usec == 0)))

#define	ZERO_TIME(x)

#define	LENGTH_MASK ((rvm_length_t)(~(sizeof(rvm_length_t) - 1)))

#define	ROUND_TO_LENGTH(len)

#define	CHOP_TO_LENGTH(len) ((rvm_length_t)((rvm_length_t)(len) & LENGTH_MASK))

#define	ALIGNED_LEN(addr, len)

#define	BYTE_SKEW(len) ((rvm_length_t)(len) & ~LENGTH_MASK)

#define	SECTOR_SIZE 512

#define	SECTOR_MASK ((rvm_length_t)(~(SECTOR_SIZE - 1)))

#define	ROUND_TO_SECTOR_SIZE(x) (((rvm_length_t)(x) + SECTOR_SIZE - 1) & SECTOR_MASK)

#define	CHOP_TO_SECTOR_SIZE(x) ((rvm_length_t)(x) & SECTOR_MASK)

#define	SECTOR_INDEX(x) ((x) & (SECTOR_SIZE - 1))

#define	ROUND_OFFSET_TO_SECTOR_SIZE(x) rvm_rnd_offset_to_sector(&(x))

#define	CHOP_OFFSET_TO_SECTOR_SIZE(x)

#define	OFFSET_TO_SECTOR_INDEX(x) (SECTOR_INDEX(RVM_OFFSET_TO_LENGTH((x))))

#define	CHOP_OFFSET_TO_LENGTH_SIZE(x)

#define	ROUND_TO_PAGE_SIZE(x) (((rvm_length_t)(x) + page_size - 1) & page_mask)

#define	CHOP_TO_PAGE_SIZE(x) ((rvm_length_t)(x) & page_mask)

#define	OFFSET_TO_FLOAT(x)

#define	ID_INDEX(id) ((rvm_length_t)(id) - (rvm_length_t)struct_first_id - 1)

#define	INDEX_ID(i) ((struct_id_t)((i) + 1 + (long)struct_first_id))

#define	NUM_CACHE_TYPES ((rvm_length_t)struct_last_cache_id - (rvm_length_t)struct_first_id - 1)

#define	NUM_TYPES ((rvm_length_t)struct_last_id - (rvm_length_t)struct_first_id - 1)

#define	NUM_PRE_ALLOCATED

#define	MAX_ALLOCATED

#define	CACHE_TYPE_SIZES

#define	OTHER_TYPE_SIZES

#define	TYPE_NAMES

#define	LIST_EMPTY(lst) ((lst).list.length == 0)

#define	LIST_NOT_EMPTY(lst) ((lst).list.length != 0)

#define	FOR_ENTRIES_OF(lst, type, ptr)

#define	FOR_REVERSE_ENTRIES_OF(lst, type, ptr)

#define	UNLINK_ENTRIES_OF(lst, type, ptr)

#define	UNLINK_REVERSE_ENTRIES_OF(lst, type, ptr)

#define	RVM_MUTEX struct mutex

#define	RVM_CONDITION struct condition

#define	LOCK_FREE(lck) (mutex_try_lock(&(lck)) ? (mutex_unlock(&(lck)), rvm_true) : rvm_false)

#define	CRITICAL(lck, body)

#define	RW_CRITICAL(rwl, mode, body)

#define	RW_LOCK_FREE(rwl) (((rwl).read_cnt + (rwl).write_cnt) == 0) && ((rwl).lock_mode == f)

#define	TRAVERSE_LEN_INCR 15 /* allocate 15 slots at a time */

#define	FOR_NODES_OF(tree, type, ptr)

#define	FOR_REVERSE_NODES_OF(tree, type, ptr)

#define	FROM_EXISTING_NODE_OF(tree, type, ptr, node, cmp)

#define	UNLINK_NODES_OF(tree, type, ptr)

#define	UNLINK_REVERSE_NODES_OF(tree, type, ptr)

#define	NV_BUF_SIZE(len) (ROUND_TO_LENGTH((len)) + sizeof(nv_buf_t))

#define	RANGE_LEN(range) (ALIGNED_LEN((range)->nv.vmaddr, (range)->nv.length))

#define	RANGE_SIZE(range) ((rvm_length_t)(NV_RANGE_OVERHEAD + RANGE_LEN(range)))

#define	TRANS_SIZE (ROUND_TO_LENGTH((sizeof(trans_hdr_t) + sizeof(rec_end_t))))

#define	NV_RANGE_OVERHEAD (ROUND_TO_LENGTH(sizeof(nv_range_t)))

#define	MIN_NV_RANGE_SIZE (NV_RANGE_OVERHEAD + 64)

#define	MIN_TRANS_SIZE (TRANS_SIZE + MIN_NV_RANGE_SIZE + ROUND_TO_LENGTH(sizeof(log_wrap_t)))

#define	LOG_SPECIAL_SIZE (ROUND_TO_LENGTH(sizeof(log_special_t) - sizeof(list_entry_t)))

#define	LOG_SPECIAL_IOV_MAX 3

#define	MAX_HDR_SIZE (ROUND_TO_LENGTH((sizeof(log_special_t) + MAXPATHLEN)))

#define	NV_LOCAL_MAX (8 * 1024 - ROUND_TO_LENGTH(NV_BUF_SIZE(sizeof(rvm_length_t) + 1)))

#define	LOG_DEV_STATUS_SIZE ROUND_TO_SECTOR_SIZE(sizeof(log_dev_status_t))

#define	RAW_STATUS_OFFSET 16 * SECTOR_SIZE

#define	FILE_STATUS_OFFSET 0

#define	UPDATE_STATUS 100 /* flushes before updating log status area */

#define	RVM_FLUSH_CALL (1)

#define	RVM_FLUSH_COMMIT (2)

#define	RVM_RECOVERY (4)

#define	RVM_TRUNCATE_CALL (010)

#define	RVM_ASYNC_TRUNCATE (020)

#define	RVM_SYNC_TRUNCATE (040)

#define	RVM_TRUNC_FIND_TAIL (0100)

#define	RVM_TRUNC_BUILD_TREE (0200)

#define	RVM_TRUNC_APPLY (0400)

#define	RVM_TRUNC_UPDATE (01000)

#define	RVM_TRUNC_PHASES

#define	SYNCH rvm_true /* synchronization required */

#define	NO_SYNCH rvm_false /* synchronization not required */

#define	SEG_DICT_INDEX(x) ((x) - 1) /* index of segemnt in seg_dict_vec */

#define	RESTORE_FLAG (2 * RVM_COALESCE_TRANS)

#define	FLUSH_FLAG (2 * RESTORE_FLAG)

#define	FIRST_ENTRY_FLAG (2 * FLUSH_FLAG)

#define	LAST_ENTRY_FLAG (2 * FIRST_ENTRY_FLAG)

#define	FLUSH_MARK (2 * LAST_ENTRY_FLAG)

#define	TID(x) ((tid->flags & (x)) != 0)

#define	TRANS_HDR(x) ((trans_hdr->flags & (x)) != 0)

Typedefs
typedef rvm_bool_t	rvm_signal_call_t()

typedef void	rvm_monitor_call_t()

typedef struct list_entry_s	list_entry_t

typedef struct tree_node_s	tree_node_t

typedef long	cmp_func_t(tree_node_t node1, tree_node_t node2)

typedef struct seg_dict_s	seg_dict_t

typedef struct region_s	region_t

typedef struct rvm_page_entry	rvm_page_entry_t

Enumerations
enum	struct_id_t { struct_first_id = 9 , log_id , int_tid_id , tid_rvm_id , range_id , seg_id , region_id , region_rvm_id , options_rvm_id , statistics_rvm_id , mem_region_id , dev_region_id , log_special_id , struct_last_cache_id , log_status_id , log_dev_status_id , log_wrap_id , log_seg_id , seg_dict_id , trans_hdr_id , rec_end_id , nv_range_id , nv_buf_id , free_page_id , rw_qentry_id , tree_root_id , struct_last_id }

enum	rw_lock_mode_t { r = 32 , w , f }

enum	traverse_state_t { lss = 50 , self , gtr , init }

enum	daemon_state_t { rvm_idle = 1000 , init_truncate , truncating , terminate , error }

Functions
rvm_bool_t	rvm_register_page (char *vmaddr, rvm_length_t length)

rvm_bool_t	rvm_unregister_page (char *vmaddr, rvm_length_t length)

void	init_list_header (list_entry_t *whichlist, struct_id_t struct_id)

list_entry_t *	move_list_entry (list_entry_t fromptr, list_entry_t toptr, list_entry_t *cell)

list_entry_t *	alloc_list_entry (struct_id_t id)

void	clear_free_lists (void)

region_t *	make_region (void)

void	free_region (region_t *region)

seg_t *	make_seg (char seg_dev_name, rvm_return_t retval)

void	free_seg (seg_t *seg)

void	free_seg_dict_vec (log_t *log)

log_t *	make_log (char dev_name, rvm_return_t retval)

void	free_log (log_t *log)

char *	make_full_name (char dev_str, char dev_name, rvm_return_t *retval)

log_special_t *	make_log_special (struct_id_t special_id, rvm_length_t length)

void	free_log_special (log_special_t *special)

rvm_return_t	dev_init (device_t dev, char dev_str)

range_t *	make_range (void)

void	free_range (range_t *range)

int_tid_t *	make_tid (rvm_mode_t mode)

void	free_tid (int_tid_t *tid)

mem_region_t *	make_mem_region (void)

void	free_mem_region (mem_region_t *node)

dev_region_t *	make_dev_region (void)

void	free_dev_region (dev_region_t *node)

void	init_log_list (void)

void	enter_log (log_t *log)

rvm_return_t	open_log (char dev_name, log_t log_ptr, char status_buf, rvm_options_t *rvm_options)

rvm_return_t	create_log (log_t *log_ptr, rvm_options_t rvm_options)

rvm_return_t	do_log_options (log_t *log, rvm_options_t rvm_options)

rvm_return_t	close_log (log_t *log)

rvm_return_t	close_all_logs (void)

void	copy_log_stats (log_t *log)

void	clear_log_status (log_t *log)

rvm_return_t	init_log_status (log_t *log)

rvm_return_t	read_log_status (log_t log, char status_buf)

rvm_return_t	write_log_status (log_t log, device_t dev)

rvm_return_t	update_log_tail (log_t log, rec_hdr_t rec_hdr)

void	log_tail_length (log_t log, rvm_offset_t tail_length)

void	log_tail_sngl_w (log_t log, rvm_offset_t tail_length)

long	cur_log_percent (log_t log, rvm_offset_t space_needed)

void	cur_log_length (log_t log, rvm_offset_t length)

rvm_return_t	queue_special (log_t log, log_special_t special)

rvm_return_t	flush_log (log_t log, rvm_length_t count)

rvm_return_t	locate_tail (log_t *log)

rvm_return_t	init_buffer (log_t log, rvm_offset_t offset, rvm_bool_t direction, rvm_bool_t synch)

void	clear_aux_buf (log_t *log)

rvm_return_t	load_aux_buf (log_t log, rvm_offset_t offset, rvm_length_t length, rvm_length_t aux_ptr, rvm_length_t data_len, rvm_bool_t direction, rvm_bool_t synch)

void	reset_hdr_chks (log_t *log)

rvm_bool_t	chk_hdr_currency (log_t log, rec_hdr_t rec_hdr)

rvm_bool_t	chk_hdr_sequence (log_t log, rec_hdr_t rec_hdr, rvm_bool_t direction)

rvm_bool_t	validate_hdr (log_t log, rec_hdr_t rec_hdr, rec_end_t *rec_end, rvm_bool_t direction)

rvm_return_t	validate_rec_reverse (log_t *log, rvm_bool_t synch)

rvm_return_t	scan_forward (log_t *log, rvm_bool_t synch)

rvm_return_t	scan_reverse (log_t *log, rvm_bool_t synch)

rvm_return_t	scan_nv_forward (log_t *log, rvm_bool_t synch)

rvm_return_t	scan_wrap_reverse (log_t *log, rvm_bool_t synch)

rvm_bool_t	initiate_truncation (log_t *log, rvm_length_t threshold)

rvm_return_t	wait_for_truncation (log_t log, struct timeval time_stamp)

rvm_return_t	log_recover (log_t log, rvm_length_t count, rvm_bool_t is_daemon, rvm_length_t flag)

void	log_daemon (void *)

rvm_return_t	alloc_log_buf (log_t *log)

void	free_log_buf (log_t *log)

void	init_map_roots (void)

rvm_return_t	bad_region (rvm_region_t *rvm_region)

char *	page_alloc (rvm_length_t len)

void	page_free (char *vmaddr, rvm_length_t length)

rvm_return_t	close_all_segs (void)

seg_t *	seg_lookup (char dev_name, rvm_return_t retval)

rvm_return_t	define_all_segs (log_t *log)

long	dev_partial_include (rvm_offset_t base1, rvm_offset_t end1, rvm_offset_t base2, rvm_offset_t end2)

long	dev_total_include (rvm_offset_t base1, rvm_offset_t end1, rvm_offset_t base2, rvm_offset_t end2)

long	mem_total_include (tree_node_t tnode1, tree_node_t tnode2)

region_t *	find_whole_range (char *dest, rvm_length_t length, rw_lock_mode_t mode)

rvm_return_t	rvm_map (rvm_region_t rvm_region, rvm_options_t rvm_options)

rvm_return_t	enter_seg_dict (log_t *log, long seg_code)

rvm_return_t	def_seg_dict (log_t log, rec_hdr_t rec_hdr)

long	open_dev (device_t *dev, long flags, long mode)

long	close_dev (device_t *dev)

long	read_dev (device_t dev, rvm_offset_t offset, char *dest, rvm_length_t length)

long	write_dev (device_t dev, rvm_offset_t offset, char *src, rvm_length_t length, rvm_bool_t no_sync)

long	sync_dev (device_t *dev)

long	gather_write_dev (device_t dev, rvm_offset_t offset)

long	set_dev_char (device_t dev, rvm_offset_t dev_length)

void	rw_lock (rw_lock_t *rwl, rw_lock_mode_t mode)

void	rw_unlock (rw_lock_t *rwl, rw_lock_mode_t mode)

void	init_rw_lock (rw_lock_t *rwl)

void	init_tree_root (tree_root_t *root)

tree_node_t *	tree_lookup (tree_root_t tree, tree_node_t node, cmp_func_t *cmp)

rvm_bool_t	tree_insert (tree_root_t tree, tree_node_t node, cmp_func_t *cmp)

rvm_bool_t	tree_delete (tree_root_t tree, tree_node_t node, cmp_func_t *cmp)

tree_node_t *	init_tree_generator (tree_root_t *tree, rvm_bool_t direction, rvm_bool_t unlink)

tree_node_t *	tree_iterate_insert (tree_root_t tree, tree_node_t node, cmp_func_t *cmp)

tree_node_t *	tree_successor (tree_root_t *tree)

tree_node_t *	tree_predecessor (tree_root_t *tree)

rvm_bool_t	bad_init (void)

rvm_return_t	bad_options (rvm_options_t *rvm_options, rvm_bool_t chk_log_dev)

rvm_return_t	bad_statistics (rvm_statistics_t *rvm_statistics)

rvm_return_t	bad_tid (rvm_tid_t *rvm_tid)

rvm_return_t	do_rvm_options (rvm_options_t *rvm_options)

void	make_uname (struct timeval *time)

long	init_unames (void)

struct timeval	add_times (struct timeval x, struct timeval y)

struct timeval	sub_times (struct timeval x, struct timeval y)

long	round_time (struct timeval *x)

void	enter_histogram (long val, rvm_length_t histo, rvm_length_t histo_def, long length)

long	init_utils (void)

rvm_length_t	chk_sum (char *nvaddr, rvm_length_t len)

void	src_aligned_bcopy (char src, char dest, rvm_length_t len)

void	dest_aligned_bcopy (char src, char dest, rvm_length_t len)

rvm_offset_t	rvm_rnd_offset_to_sector (rvm_offset_t *x)

void	rvm_debug (rvm_length_t val)

Variables
tree_root_t	region_tree

rw_lock_t	region_tree_lock

Macro Definition Documentation

◆ ALIGNED_LEN

#define ALIGNED_LEN	(	addr,
		len
	)

Value:

(ROUND_TO_LENGTH((rvm_length_t)(addr) + (rvm_length_t)(len)) - \

CHOP_TO_LENGTH(addr))

rvm_length_t

unsigned long rvm_length_t

Definition: rvm.h:140

ROUND_TO_LENGTH

#define ROUND_TO_LENGTH(len)

Definition: rvm_private.h:129

◆ BCOPY

#define BCOPY	(	x,
		y,
		n
	)	bcopy((x), (y), (n))

◆ BYTE_SKEW

#define BYTE_SKEW ( len ) ((rvm_length_t)(len) & ~LENGTH_MASK)

◆ BZERO

#define BZERO	(	x,
		n
	)	bzero((x), (n))

◆ CACHE_TYPE_SIZES

#define CACHE_TYPE_SIZES

Value:

    sizeof(log_t), \
    sizeof(int_tid_t), \
    sizeof(rvm_tid_t), \
    sizeof(range_t), \
    sizeof(seg_t), \
    sizeof(region_t), \
    sizeof(rvm_region_t), \
    sizeof(rvm_options_t), \
    sizeof(rvm_statistics_t), \
    sizeof(mem_region_t), \
    sizeof(dev_region_t), \
    sizeof(log_special_t)

◆ CHOP_OFFSET_TO_LENGTH_SIZE

#define CHOP_OFFSET_TO_LENGTH_SIZE ( x )

Value:

(RVM_MK_OFFSET(RVM_OFFSET_HIGH_BITS_TO_LENGTH(x), \

CHOP_TO_LENGTH(RVM_OFFSET_TO_LENGTH(x))))

pwdtopdbtool.x

x

Definition: pwdtopdbtool.py:40

RVM_OFFSET_HIGH_BITS_TO_LENGTH

#define RVM_OFFSET_HIGH_BITS_TO_LENGTH(x)

Definition: rvm.h:173

RVM_MK_OFFSET

#define RVM_MK_OFFSET(x, y)

Definition: rvm.h:154

RVM_OFFSET_TO_LENGTH

#define RVM_OFFSET_TO_LENGTH(x)

Definition: rvm.h:167

CHOP_TO_LENGTH

#define CHOP_TO_LENGTH(len)

Definition: rvm_private.h:132

◆ CHOP_OFFSET_TO_SECTOR_SIZE

#define CHOP_OFFSET_TO_SECTOR_SIZE ( x )

Value:

(RVM_MK_OFFSET(RVM_OFFSET_HIGH_BITS_TO_LENGTH(x), \

CHOP_TO_SECTOR_SIZE(RVM_OFFSET_TO_LENGTH(x))))

CHOP_TO_SECTOR_SIZE

#define CHOP_TO_SECTOR_SIZE(x)

Definition: rvm_private.h:142

◆ CHOP_TO_LENGTH

#define CHOP_TO_LENGTH ( len ) ((rvm_length_t)((rvm_length_t)(len) & LENGTH_MASK))

◆ CHOP_TO_PAGE_SIZE

#define CHOP_TO_PAGE_SIZE ( x ) ((rvm_length_t)(x) & page_mask)

◆ CHOP_TO_SECTOR_SIZE

#define CHOP_TO_SECTOR_SIZE ( x ) ((rvm_length_t)(x) & SECTOR_MASK)

◆ CRITICAL

#define CRITICAL	(	lck,
		body
	)

Value:

    do {                      \
        mutex_lock(&(lck));   \
        body;                 \
        mutex_unlock(&(lck)); \
    } while (0)

◆ DEBUG

#define DEBUG 1

◆ DO_FOREVER

#define DO_FOREVER for (;;)

◆ ERR_DATE_SKEW

#define ERR_DATE_SKEW "Current time before last recorded - check kernel date"

◆ FILE_STATUS_OFFSET

#define FILE_STATUS_OFFSET 0

◆ FIRST_ENTRY_FLAG

#define FIRST_ENTRY_FLAG (2 * FLUSH_FLAG)

◆ FLUSH_FLAG

#define FLUSH_FLAG (2 * RESTORE_FLAG)

◆ FLUSH_MARK

#define FLUSH_MARK (2 * LAST_ENTRY_FLAG)

◆ FOR_ENTRIES_OF

#define FOR_ENTRIES_OF	(	lst,
		type,
		ptr
	)

Value:

    /* list iterator, FIFO order */ \
    for ((ptr) = (type *)((lst).nextentry); !((ptr)->links.is_hdr);    \
         (ptr) = (type *)((ptr)->links.nextentry))

◆ FOR_NODES_OF

#define FOR_NODES_OF	(	tree,
		type,
		ptr
	)

Value:

    /* tree iterator, lss -> gtr order */ \
    for ((ptr) = (type *)init_tree_generator(&(tree), FORWARD, rvm_false);  \
         (ptr) != NULL; (ptr) = (type *)tree_successor(&(tree)))

◆ FOR_REVERSE_ENTRIES_OF

#define FOR_REVERSE_ENTRIES_OF	(	lst,
		type,
		ptr
	)

Value:

    /* list iterator, LIFO order */ \
    for ((ptr) = (type *)((lst).preventry); !((ptr)->links.is_hdr);            \
         (ptr) = (type *)((ptr)->links.preventry))

◆ FOR_REVERSE_NODES_OF

#define FOR_REVERSE_NODES_OF	(	tree,
		type,
		ptr
	)

Value:

    /* tree iterator, gtr -> lss order */    \
    for ((ptr) = (type *)init_tree_generator(&(tree), REVERSE, rvm_false); \
         (ptr) != NULL; (ptr) = (type *)tree_predecessor(&(tree)))

◆ FORWARD

#define FORWARD rvm_true /* record scan forward */

◆ FROM_EXISTING_NODE_OF

#define FROM_EXISTING_NODE_OF	(	tree,
		type,
		ptr,
		node,
		cmp
	)

Value:

for ((ptr) = (type *)tree_iterate_insert(&(tree), (node), (cmp)); \

(ptr) != NULL; (ptr) = (type *)tree_successor(&(tree)))

tree_iterate_insert

tree_node_t * tree_iterate_insert(tree_root_t *tree, tree_node_t *node, cmp_func_t *cmp)

Definition: rvm_utils.c:2052

◆ getpagesize

#define getpagesize ( ) PAGE_SIZE

◆ ID_INDEX

#define ID_INDEX ( id ) ((rvm_length_t)(id) - (rvm_length_t)struct_first_id - 1)

◆ INDEX_ID

#define INDEX_ID ( i ) ((struct_id_t)((i) + 1 + (long)struct_first_id))

◆ LAST_ENTRY_FLAG

#define LAST_ENTRY_FLAG (2 * FIRST_ENTRY_FLAG)

◆ LENGTH_MASK

#define LENGTH_MASK ((rvm_length_t)(~(sizeof(rvm_length_t) - 1)))

◆ LIST_EMPTY

#define LIST_EMPTY ( lst ) ((lst).list.length == 0)

◆ LIST_NOT_EMPTY

#define LIST_NOT_EMPTY ( lst ) ((lst).list.length != 0)

◆ LOCK_FREE

#define LOCK_FREE ( lck ) (mutex_try_lock(&(lck)) ? (mutex_unlock(&(lck)), rvm_true) : rvm_false)

◆ LOG_DEV_STATUS_SIZE

#define LOG_DEV_STATUS_SIZE ROUND_TO_SECTOR_SIZE(sizeof(log_dev_status_t))

◆ LOG_SPECIAL_IOV_MAX

#define LOG_SPECIAL_IOV_MAX 3

◆ LOG_SPECIAL_SIZE

#define LOG_SPECIAL_SIZE (ROUND_TO_LENGTH(sizeof(log_special_t) - sizeof(list_entry_t)))

◆ MAX_ALLOCATED

#define MAX_ALLOCATED

Value:

    0,                                  /* log's */ \
    20,                                 /* tid's */ \
    20,                                 /* rvm_tid's */ \
    50,                                 /* range's */ \
    0,                                  /* seg's */ \
    10,                                 /* region's */ \
    0,                                  /* rvm_region's */ \
    0,                                  /* rvm_options */ \
    2,                                  /* rvm_statistics */ \
    10,                                 /* mem_region nodes */ \
    2000,                               /* dev_region nodes */ \
    1                                   /* special log markers */

◆ MAX_HDR_SIZE

#define MAX_HDR_SIZE (ROUND_TO_LENGTH((sizeof(log_special_t) + MAXPATHLEN)))

◆ MIN_NV_RANGE_SIZE

#define MIN_NV_RANGE_SIZE (NV_RANGE_OVERHEAD + 64)

◆ MIN_TRANS_SIZE

#define MIN_TRANS_SIZE (TRANS_SIZE + MIN_NV_RANGE_SIZE + ROUND_TO_LENGTH(sizeof(log_wrap_t)))

◆ NO_SYNCH

#define NO_SYNCH rvm_false /* synchronization not required */

◆ NUM_CACHE_TYPES

#define NUM_CACHE_TYPES ((rvm_length_t)struct_last_cache_id - (rvm_length_t)struct_first_id - 1)

◆ NUM_PRE_ALLOCATED

#define NUM_PRE_ALLOCATED

Value:

    0,                                  /* log's */ \
    20,                                 /* tid's */ \
    20,                                 /* rvm_tid's */ \
    50,                                 /* range's */ \
    0,                                  /* seg's */ \
    10,                                 /* region's */ \
    0,                                  /* rvm_region's */ \
    0,                                  /* rvm_options */ \
    2,                                  /* rvm_statistics */ \
    10,                                 /* mem_region nodes */ \
    1,                                  /* dev_region nodes */ \
    1                                   /* special log markers */

◆ NUM_TYPES

#define NUM_TYPES ((rvm_length_t)struct_last_id - (rvm_length_t)struct_first_id - 1)

◆ NV_BUF_SIZE

#define NV_BUF_SIZE ( len ) (ROUND_TO_LENGTH((len)) + sizeof(nv_buf_t))

◆ NV_LOCAL_MAX

#define NV_LOCAL_MAX (8 * 1024 - ROUND_TO_LENGTH(NV_BUF_SIZE(sizeof(rvm_length_t) + 1)))

◆ NV_RANGE_OVERHEAD

#define NV_RANGE_OVERHEAD (ROUND_TO_LENGTH(sizeof(nv_range_t)))

◆ O_BINARY

#define O_BINARY 0

◆ OFFSET_TO_FLOAT

#define OFFSET_TO_FLOAT ( x )

Value:

((4.294967e+9) * ((float)(RVM_OFFSET_HIGH_BITS_TO_LENGTH(x))) + \

(float)(RVM_OFFSET_TO_LENGTH(x)))

◆ OFFSET_TO_SECTOR_INDEX

#define OFFSET_TO_SECTOR_INDEX ( x ) (SECTOR_INDEX(RVM_OFFSET_TO_LENGTH((x))))

◆ OTHER_TYPE_SIZES

#define OTHER_TYPE_SIZES

Value:

    0, \
    sizeof(log_status_t), \
    sizeof(log_dev_status_t), \
    sizeof(log_wrap_t), \
    sizeof(log_seg_t), \
    sizeof(seg_dict_t), \
    sizeof(trans_hdr_t), \
    sizeof(rec_end_t), \
    sizeof(nv_range_t), \
    sizeof(nv_buf_t), \
    sizeof(free_page_t), \
    sizeof(rw_qentry_t), \
    sizeof(tree_root_t)/*, \
    sizeof(mmapped_list_t)*/

◆ RANGE_LEN

#define RANGE_LEN ( range ) (ALIGNED_LEN((range)->nv.vmaddr, (range)->nv.length))

◆ RANGE_SIZE

#define RANGE_SIZE ( range ) ((rvm_length_t)(NV_RANGE_OVERHEAD + RANGE_LEN(range)))

◆ RAW_STATUS_OFFSET

#define RAW_STATUS_OFFSET 16 * SECTOR_SIZE

◆ REALLOC

#define REALLOC	(	x,
		l
	)	(((x) == NULL) ? malloc(l) : realloc((x), (l)))

◆ RESTORE_FLAG

#define RESTORE_FLAG (2 * RVM_COALESCE_TRANS)

◆ REVERSE

#define REVERSE rvm_false /* record scan reverse */

◆ ROUND_OFFSET_TO_SECTOR_SIZE

#define ROUND_OFFSET_TO_SECTOR_SIZE ( x ) rvm_rnd_offset_to_sector(&(x))

◆ ROUND_TO_LENGTH

#define ROUND_TO_LENGTH ( len )

Value:

(((rvm_length_t)((rvm_length_t)(len) + sizeof(rvm_length_t) - 1)) & \

LENGTH_MASK)

◆ ROUND_TO_PAGE_SIZE

#define ROUND_TO_PAGE_SIZE ( x ) (((rvm_length_t)(x) + page_size - 1) & page_mask)

◆ ROUND_TO_SECTOR_SIZE

#define ROUND_TO_SECTOR_SIZE ( x ) (((rvm_length_t)(x) + SECTOR_SIZE - 1) & SECTOR_MASK)

◆ RVM_ASYNC_TRUNCATE

#define RVM_ASYNC_TRUNCATE (020)

◆ RVM_CONDITION

#define RVM_CONDITION struct condition

◆ RVM_FLUSH_CALL

#define RVM_FLUSH_CALL (1)

◆ RVM_FLUSH_COMMIT

#define RVM_FLUSH_COMMIT (2)

◆ RVM_LOG_VERSION

#define RVM_LOG_VERSION "RVM Log Version 1.4 Oct 17, 1997 "

◆ RVM_MUTEX

#define RVM_MUTEX struct mutex

◆ RVM_RECOVERY

#define RVM_RECOVERY (4)

◆ RVM_SYNC_TRUNCATE

#define RVM_SYNC_TRUNCATE (040)

◆ RVM_TRUNC_APPLY

#define RVM_TRUNC_APPLY (0400)

◆ RVM_TRUNC_BUILD_TREE

#define RVM_TRUNC_BUILD_TREE (0200)

◆ RVM_TRUNC_FIND_TAIL

#define RVM_TRUNC_FIND_TAIL (0100)

◆ RVM_TRUNC_PHASES

#define RVM_TRUNC_PHASES

Value:

(RVM_TRUNC_FIND_TAIL | RVM_TRUNC_BUILD_TREE | RVM_TRUNC_APPLY | \

RVM_TRUNC_UPDATE)

RVM_TRUNC_APPLY

#define RVM_TRUNC_APPLY

Definition: rvm_private.h:868

RVM_TRUNC_FIND_TAIL

#define RVM_TRUNC_FIND_TAIL

Definition: rvm_private.h:864

RVM_TRUNC_BUILD_TREE

#define RVM_TRUNC_BUILD_TREE

Definition: rvm_private.h:866

◆ RVM_TRUNC_UPDATE

#define RVM_TRUNC_UPDATE (01000)

◆ RVM_TRUNCATE_CALL

#define RVM_TRUNCATE_CALL (010)

◆ RW_CRITICAL

#define RW_CRITICAL	(	rwl,
		mode,
		body
	)

Value:

    do {                             \
        rw_lock(&(rwl), (mode));     \
        body;                        \
        rw_unlock(&(rwl), (mode));   \
    } while (0)

◆ RW_LOCK_FREE

#define RW_LOCK_FREE ( rwl ) (((rwl).read_cnt + (rwl).write_cnt) == 0) && ((rwl).lock_mode == f)

◆ SECTOR_INDEX

#define SECTOR_INDEX ( x ) ((x) & (SECTOR_SIZE - 1))

◆ SECTOR_MASK

#define SECTOR_MASK ((rvm_length_t)(~(SECTOR_SIZE - 1)))

◆ SECTOR_SIZE

#define SECTOR_SIZE 512

◆ SEG_DICT_INDEX

#define SEG_DICT_INDEX ( x ) ((x) - 1) /* index of segemnt in seg_dict_vec */

◆ SYNCH

#define SYNCH rvm_true /* synchronization required */

◆ TID

#define TID ( x ) ((tid->flags & (x)) != 0)

◆ TIME_EQL

#define TIME_EQL	(	x,
		y
	)	(((x).tv_sec == (y).tv_sec) && ((x).tv_usec == (y).tv_usec))

◆ TIME_EQL_ZERO

#define TIME_EQL_ZERO ( x ) (((x).tv_sec == 0 && ((x).tv_usec == 0)))

◆ TIME_GEQ

#define TIME_GEQ	(	x,
		y
	)	(!TIME_LSS((x), (y)))

◆ TIME_GTR

#define TIME_GTR	(	x,
		y
	)

Value:

(((x).tv_sec > (y).tv_sec) || \

((((x).tv_sec == (y).tv_sec) && ((x).tv_usec > (y).tv_usec))))

pwdtopdbtool.y

y

Definition: pwdtopdbtool.py:40

◆ TIME_LEQ

#define TIME_LEQ	(	x,
		y
	)	(!TIME_GTR((x), (y)))

◆ TIME_LSS

#define TIME_LSS	(	x,
		y
	)

Value:

(((x).tv_sec < (y).tv_sec) || \

((((x).tv_sec == (y).tv_sec) && ((x).tv_usec < (y).tv_usec))))

◆ TRANS_HDR

#define TRANS_HDR ( x ) ((trans_hdr->flags & (x)) != 0)

◆ TRANS_SIZE

#define TRANS_SIZE (ROUND_TO_LENGTH((sizeof(trans_hdr_t) + sizeof(rec_end_t))))

◆ TRAVERSE_LEN_INCR

#define TRAVERSE_LEN_INCR 15 /* allocate 15 slots at a time */

◆ TYPE_NAMES

#define TYPE_NAMES

Value:

    "log_id", \
    "int_tid_id", \
    "tid_rvm_id", \
    "range_id", \
    "seg_id", \
    "region_id", \
    "region_rvm_id", \
    "options_rvm_id", \
    "statistics_rvm_id", \
    "mem_region_id", \
    "dev_region_id", \
    "log_special_id", \
    "struct_last_cache_id", \
    "log_status_id", \
    "log_dev_status_id", \
    "log_wrap_id", \
    "log_seg_id", \
    "seg_dict_id", \
    "trans_hdr_id", \
    "rec_end_id", \
    "nv_range_id", \
    "nv_buf_id", \
    "free_page_id", \
    "rw_qentry_id", \
    "tree_root_id"

◆ UNLINK_ENTRIES_OF

#define UNLINK_ENTRIES_OF	(	lst,
		type,
		ptr
	)

Value:

    /* list generator, FIFO order */ \
    for ((ptr) = (type *)((lst).nextentry); !((ptr)->links.is_hdr);        \
         (ptr) = (type *)((lst).nextentry))

◆ UNLINK_NODES_OF

#define UNLINK_NODES_OF	(	tree,
		type,
		ptr
	)

Value:

    /* tree iterator, lss -> gtr order */ \
    for ((ptr) = (type *)init_tree_generator(&(tree), FORWARD, rvm_true);      \
         (ptr) != NULL; (ptr) = (type *)tree_successor(&(tree)))

◆ UNLINK_REVERSE_ENTRIES_OF

#define UNLINK_REVERSE_ENTRIES_OF	(	lst,
		type,
		ptr
	)

Value:

    /* list generator, LIFO order */ \
    for ((ptr) = (type *)((lst).preventry); !((ptr)->links.is_hdr);     \
         (ptr) = (type *)((lst).preventry))

◆ UNLINK_REVERSE_NODES_OF

#define UNLINK_REVERSE_NODES_OF	(	tree,
		type,
		ptr
	)

Value:

    /* tree iterator, gtr -> lss order */ \
    for ((ptr) = (type *)init_tree_generator(&(tree), REVERSE, rvm_true);  \
         (ptr) != NULL; (ptr) = (type *)tree_predecessor(&(tree)))

◆ UPDATE_STATUS

#define UPDATE_STATUS 100 /* flushes before updating log status area */

◆ ZERO_TIME

#define ZERO_TIME ( x )

Value:

    do {                 \
        (x).tv_sec  = 0; \
        (x).tv_usec = 0; \
    } while (0)

Typedef Documentation

◆ cmp_func_t

typedef long cmp_func_t(tree_node_t *node1, tree_node_t *node2)

◆ list_entry_t

typedef struct list_entry_s list_entry_t

◆ region_t

typedef struct region_s region_t

◆ rvm_monitor_call_t

typedef void rvm_monitor_call_t()

◆ rvm_page_entry_t

typedef struct rvm_page_entry rvm_page_entry_t

◆ rvm_signal_call_t

typedef rvm_bool_t rvm_signal_call_t()

◆ seg_dict_t

typedef struct seg_dict_s seg_dict_t

◆ tree_node_t

typedef struct tree_node_s tree_node_t

Enumeration Type Documentation

◆ daemon_state_t

enum daemon_state_t

Enumerator
rvm_idle
init_truncate
truncating
terminate
error

◆ rw_lock_mode_t

enum rw_lock_mode_t

Enumerator
r
w
f

◆ struct_id_t

enum struct_id_t

Enumerator
struct_first_id
log_id
int_tid_id
tid_rvm_id
range_id
seg_id
region_id
region_rvm_id
options_rvm_id
statistics_rvm_id
mem_region_id
dev_region_id
log_special_id
struct_last_cache_id
log_status_id
log_dev_status_id
log_wrap_id
log_seg_id
seg_dict_id
trans_hdr_id
rec_end_id
nv_range_id
nv_buf_id
free_page_id
rw_qentry_id
tree_root_id
struct_last_id

◆ traverse_state_t

enum traverse_state_t

Enumerator
lss
self
gtr
init

Function Documentation

◆ add_times()

struct timeval add_times	(	struct timeval *	x,
		struct timeval *	y
	)

◆ alloc_list_entry()

list_entry_t * alloc_list_entry ( struct_id_t id )

◆ alloc_log_buf()

rvm_return_t alloc_log_buf ( log_t * log )

◆ bad_init()

rvm_bool_t bad_init ( void )

◆ bad_options()

rvm_return_t bad_options	(	rvm_options_t *	rvm_options,
		rvm_bool_t	chk_log_dev
	)

◆ bad_region()

rvm_return_t bad_region ( rvm_region_t * rvm_region )

◆ bad_statistics()

rvm_return_t bad_statistics ( rvm_statistics_t * rvm_statistics )

◆ bad_tid()

rvm_return_t bad_tid ( rvm_tid_t * rvm_tid )

◆ chk_hdr_currency()

rvm_bool_t chk_hdr_currency	(	log_t *	log,
		rec_hdr_t *	rec_hdr
	)

◆ chk_hdr_sequence()

rvm_bool_t chk_hdr_sequence	(	log_t *	log,
		rec_hdr_t *	rec_hdr,
		rvm_bool_t	direction
	)

◆ chk_sum()

rvm_length_t chk_sum	(	char *	nvaddr,
		rvm_length_t	len
	)

◆ clear_aux_buf()

void clear_aux_buf ( log_t * log )

◆ clear_free_lists()

void clear_free_lists ( void )

◆ clear_log_status()

void clear_log_status ( log_t * log )

◆ close_all_logs()

rvm_return_t close_all_logs ( void )

◆ close_all_segs()

rvm_return_t close_all_segs ( void )

◆ close_dev()

long close_dev ( device_t * dev )

◆ close_log()

rvm_return_t close_log ( log_t * log )

◆ copy_log_stats()

void copy_log_stats ( log_t * log )

◆ create_log()

rvm_return_t create_log	(	log_t **	log_ptr,
		rvm_options_t *	rvm_options
	)

◆ cur_log_length()

void cur_log_length	(	log_t *	log,
		rvm_offset_t *	length
	)

◆ cur_log_percent()

long cur_log_percent	(	log_t *	log,
		rvm_offset_t *	space_needed
	)

◆ def_seg_dict()

rvm_return_t def_seg_dict	(	log_t *	log,
		rec_hdr_t *	rec_hdr
	)

◆ define_all_segs()

rvm_return_t define_all_segs ( log_t * log )

◆ dest_aligned_bcopy()

void dest_aligned_bcopy	(	char *	src,
		char *	dest,
		rvm_length_t	len
	)

◆ dev_init()

rvm_return_t dev_init	(	device_t *	dev,
		char *	dev_str
	)

◆ dev_partial_include()

long dev_partial_include	(	rvm_offset_t *	base1,
		rvm_offset_t *	end1,
		rvm_offset_t *	base2,
		rvm_offset_t *	end2
	)

◆ dev_total_include()

long dev_total_include	(	rvm_offset_t *	base1,
		rvm_offset_t *	end1,
		rvm_offset_t *	base2,
		rvm_offset_t *	end2
	)

◆ do_log_options()

rvm_return_t do_log_options	(	log_t **	log,
		rvm_options_t *	rvm_options
	)

◆ do_rvm_options()

rvm_return_t do_rvm_options ( rvm_options_t * rvm_options )

◆ enter_histogram()

void enter_histogram	(	long	val,
		rvm_length_t *	histo,
		rvm_length_t *	histo_def,
		long	length
	)

◆ enter_log()

void enter_log ( log_t * log )

◆ enter_seg_dict()

rvm_return_t enter_seg_dict	(	log_t *	log,
		long	seg_code
	)

◆ find_whole_range()

region_t * find_whole_range	(	char *	dest,
		rvm_length_t	length,
		rw_lock_mode_t	mode
	)

◆ flush_log()

rvm_return_t flush_log	(	log_t *	log,
		rvm_length_t *	count
	)

◆ free_dev_region()

void free_dev_region ( dev_region_t * node )

◆ free_log()

void free_log ( log_t * log )

◆ free_log_buf()

void free_log_buf ( log_t * log )

◆ free_log_special()

void free_log_special ( log_special_t * special )

◆ free_mem_region()

void free_mem_region ( mem_region_t * node )

◆ free_range()

void free_range ( range_t * range )

◆ free_region()

void free_region ( region_t * region )

◆ free_seg()

void free_seg ( seg_t * seg )

◆ free_seg_dict_vec()

void free_seg_dict_vec ( log_t * log )

◆ free_tid()

void free_tid ( int_tid_t * tid )

◆ gather_write_dev()

long gather_write_dev	(	device_t *	dev,
		rvm_offset_t *	offset
	)

◆ init_buffer()

rvm_return_t init_buffer	(	log_t *	log,
		rvm_offset_t *	offset,
		rvm_bool_t	direction,
		rvm_bool_t	synch
	)

◆ init_list_header()

void init_list_header	(	list_entry_t *	whichlist,
		struct_id_t	struct_id
	)

◆ init_log_list()

void init_log_list ( void )

◆ init_log_status()

rvm_return_t init_log_status ( log_t * log )

◆ init_map_roots()

void init_map_roots ( void )

◆ init_rw_lock()

void init_rw_lock ( rw_lock_t * rwl )

◆ init_tree_generator()

tree_node_t * init_tree_generator	(	tree_root_t *	tree,
		rvm_bool_t	direction,
		rvm_bool_t	unlink
	)

◆ init_tree_root()

void init_tree_root ( tree_root_t * root )

◆ init_unames()

long init_unames ( void )

◆ init_utils()

long init_utils ( void )

◆ initiate_truncation()

rvm_bool_t initiate_truncation	(	log_t *	log,
		rvm_length_t	threshold
	)

◆ load_aux_buf()

rvm_return_t load_aux_buf	(	log_t *	log,
		rvm_offset_t *	offset,
		rvm_length_t	length,
		rvm_length_t *	aux_ptr,
		rvm_length_t *	data_len,
		rvm_bool_t	direction,
		rvm_bool_t	synch
	)

◆ locate_tail()

rvm_return_t locate_tail ( log_t * log )

◆ log_daemon()

void log_daemon ( void * arg )

◆ log_recover()

rvm_return_t log_recover	(	log_t *	log,
		rvm_length_t *	count,
		rvm_bool_t	is_daemon,
		rvm_length_t	flag
	)

◆ log_tail_length()

void log_tail_length	(	log_t *	log,
		rvm_offset_t *	tail_length
	)

◆ log_tail_sngl_w()

void log_tail_sngl_w	(	log_t *	log,
		rvm_offset_t *	tail_length
	)

◆ make_dev_region()

dev_region_t * make_dev_region ( void )

◆ make_full_name()

char * make_full_name	(	char *	dev_str,
		char *	dev_name,
		rvm_return_t *	retval
	)

◆ make_log()

log_t * make_log	(	char *	dev_name,
		rvm_return_t *	retval
	)

◆ make_log_special()

log_special_t * make_log_special	(	struct_id_t	special_id,
		rvm_length_t	length
	)

◆ make_mem_region()

mem_region_t * make_mem_region ( void )

◆ make_range()

range_t * make_range ( void )

◆ make_region()

region_t * make_region ( void )

◆ make_seg()

seg_t * make_seg	(	char *	seg_dev_name,
		rvm_return_t *	retval
	)

◆ make_tid()

int_tid_t * make_tid ( rvm_mode_t mode )

◆ make_uname()

void make_uname ( struct timeval * time )

◆ mem_total_include()

long mem_total_include	(	tree_node_t *	tnode1,
		tree_node_t *	tnode2
	)

◆ move_list_entry()

list_entry_t * move_list_entry	(	list_entry_t *	fromptr,
		list_entry_t *	toptr,
		list_entry_t *	cell
	)

◆ open_dev()

long open_dev	(	device_t *	dev,
		long	flags,
		long	mode
	)

◆ open_log()

rvm_return_t open_log	(	char *	dev_name,
		log_t **	log_ptr,
		char *	status_buf,
		rvm_options_t *	rvm_options
	)

◆ page_alloc()

char * page_alloc ( rvm_length_t len )

◆ page_free()

void page_free	(	char *	vmaddr,
		rvm_length_t	length
	)

◆ queue_special()

rvm_return_t queue_special	(	log_t *	log,
		log_special_t *	special
	)

◆ read_dev()

long read_dev	(	device_t *	dev,
		rvm_offset_t *	offset,
		char *	dest,
		rvm_length_t	length
	)

◆ read_log_status()

rvm_return_t read_log_status	(	log_t *	log,
		char *	status_buf
	)

◆ reset_hdr_chks()

void reset_hdr_chks ( log_t * log )

◆ round_time()

long round_time ( struct timeval * x )

◆ rvm_debug()

void rvm_debug ( rvm_length_t val )

◆ rvm_map()

rvm_return_t rvm_map	(	rvm_region_t *	rvm_region,
		rvm_options_t *	rvm_options
	)

◆ rvm_register_page()

rvm_bool_t rvm_register_page	(	char *	vmaddr,
		rvm_length_t	length
	)

◆ rvm_rnd_offset_to_sector()

rvm_offset_t rvm_rnd_offset_to_sector ( rvm_offset_t * x )

◆ rvm_unregister_page()

rvm_bool_t rvm_unregister_page	(	char *	vmaddr,
		rvm_length_t	length
	)

◆ rw_lock()

void rw_lock	(	rw_lock_t *	rwl,
		rw_lock_mode_t	mode
	)

◆ rw_unlock()

void rw_unlock	(	rw_lock_t *	rwl,
		rw_lock_mode_t	mode
	)

◆ scan_forward()

rvm_return_t scan_forward	(	log_t *	log,
		rvm_bool_t	synch
	)

◆ scan_nv_forward()

rvm_return_t scan_nv_forward	(	log_t *	log,
		rvm_bool_t	synch
	)

◆ scan_reverse()

rvm_return_t scan_reverse	(	log_t *	log,
		rvm_bool_t	synch
	)

◆ scan_wrap_reverse()

rvm_return_t scan_wrap_reverse	(	log_t *	log,
		rvm_bool_t	synch
	)

◆ seg_lookup()

seg_t * seg_lookup	(	char *	dev_name,
		rvm_return_t *	retval
	)

◆ set_dev_char()

long set_dev_char	(	device_t *	dev,
		rvm_offset_t *	dev_length
	)

◆ src_aligned_bcopy()

void src_aligned_bcopy	(	char *	src,
		char *	dest,
		rvm_length_t	len
	)

◆ sub_times()

struct timeval sub_times	(	struct timeval *	x,
		struct timeval *	y
	)

◆ sync_dev()

long sync_dev ( device_t * dev )

◆ tree_delete()

rvm_bool_t tree_delete	(	tree_root_t *	tree,
		tree_node_t *	node,
		cmp_func_t *	cmp
	)

◆ tree_insert()

rvm_bool_t tree_insert	(	tree_root_t *	tree,
		tree_node_t *	node,
		cmp_func_t *	cmp
	)

◆ tree_iterate_insert()

tree_node_t * tree_iterate_insert	(	tree_root_t *	tree,
		tree_node_t *	node,
		cmp_func_t *	cmp
	)

◆ tree_lookup()

tree_node_t * tree_lookup	(	tree_root_t *	tree,
		tree_node_t *	node,
		cmp_func_t *	cmp
	)

◆ tree_predecessor()

tree_node_t * tree_predecessor ( tree_root_t * tree )

◆ tree_successor()

tree_node_t * tree_successor ( tree_root_t * tree )

◆ update_log_tail()

rvm_return_t update_log_tail	(	log_t *	log,
		rec_hdr_t *	rec_hdr
	)

◆ validate_hdr()

rvm_bool_t validate_hdr	(	log_t *	log,
		rec_hdr_t *	rec_hdr,
		rec_end_t *	rec_end,
		rvm_bool_t	direction
	)

◆ validate_rec_reverse()

rvm_return_t validate_rec_reverse	(	log_t *	log,
		rvm_bool_t	synch
	)

◆ wait_for_truncation()

rvm_return_t wait_for_truncation	(	log_t *	log,
		struct timeval *	time_stamp
	)

◆ write_dev()

long write_dev	(	device_t *	dev,
		rvm_offset_t *	offset,
		char *	src,
		rvm_length_t	length,
		rvm_bool_t	no_sync
	)

◆ write_log_status()

rvm_return_t write_log_status	(	log_t *	log,
		device_t *	dev
	)

Variable Documentation

◆ region_tree

tree_root_t region_tree

extern

◆ region_tree_lock

rw_lock_t region_tree_lock

extern

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ALIGNED_LEN

◆ BCOPY

◆ BYTE_SKEW

◆ BZERO

◆ CACHE_TYPE_SIZES

◆ CHOP_OFFSET_TO_LENGTH_SIZE

◆ CHOP_OFFSET_TO_SECTOR_SIZE

◆ CHOP_TO_LENGTH

◆ CHOP_TO_PAGE_SIZE

◆ CHOP_TO_SECTOR_SIZE

◆ CRITICAL

◆ DEBUG

◆ DO_FOREVER

◆ ERR_DATE_SKEW

◆ FILE_STATUS_OFFSET

◆ FIRST_ENTRY_FLAG

◆ FLUSH_FLAG

◆ FLUSH_MARK

◆ FOR_ENTRIES_OF

◆ FOR_NODES_OF

◆ FOR_REVERSE_ENTRIES_OF

◆ FOR_REVERSE_NODES_OF

◆ FORWARD

◆ FROM_EXISTING_NODE_OF

◆ getpagesize

◆ ID_INDEX

◆ INDEX_ID

◆ LAST_ENTRY_FLAG

◆ LENGTH_MASK

◆ LIST_EMPTY

◆ LIST_NOT_EMPTY

◆ LOCK_FREE

◆ LOG_DEV_STATUS_SIZE

◆ LOG_SPECIAL_IOV_MAX

◆ LOG_SPECIAL_SIZE

◆ MAX_ALLOCATED

◆ MAX_HDR_SIZE

◆ MIN_NV_RANGE_SIZE

◆ MIN_TRANS_SIZE

◆ NO_SYNCH

◆ NUM_CACHE_TYPES

◆ NUM_PRE_ALLOCATED

◆ NUM_TYPES

◆ NV_BUF_SIZE

◆ NV_LOCAL_MAX

◆ NV_RANGE_OVERHEAD

◆ O_BINARY

◆ OFFSET_TO_FLOAT

◆ OFFSET_TO_SECTOR_INDEX

◆ OTHER_TYPE_SIZES

◆ RANGE_LEN

◆ RANGE_SIZE

◆ RAW_STATUS_OFFSET

◆ REALLOC

◆ RESTORE_FLAG

◆ REVERSE

◆ ROUND_OFFSET_TO_SECTOR_SIZE

◆ ROUND_TO_LENGTH

◆ ROUND_TO_PAGE_SIZE

◆ ROUND_TO_SECTOR_SIZE

◆ RVM_ASYNC_TRUNCATE

◆ RVM_CONDITION

◆ RVM_FLUSH_CALL

◆ RVM_FLUSH_COMMIT

◆ RVM_LOG_VERSION

◆ RVM_MUTEX

◆ RVM_RECOVERY

◆ RVM_SYNC_TRUNCATE

◆ RVM_TRUNC_APPLY

◆ RVM_TRUNC_BUILD_TREE

◆ RVM_TRUNC_FIND_TAIL

◆ RVM_TRUNC_PHASES

◆ RVM_TRUNC_UPDATE