name string | code string | asm string | file string |
|---|---|---|---|
filemgr_destroy_file | fdb_status filemgr_destroy_file(char *filename,
struct filemgr_config *config,
struct hash *destroy_file_set)
{
struct filemgr *file = NULL;
struct hash to_destroy_files;
struct hash *destroy_set = (destroy_file_set ? destroy_file_set :
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdx, %rbx
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
leaq -0x60(%rbp), %r13
testq %rdx, %rdx
cmovneq %rdx, %r13
je 0x17ca9
leaq -0x260(%rbp), %r12
movq %r14, -0xf0(%r12)
movq %rbx, %rdi
movq %r... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
filemgr_set_cancel_compaction | void filemgr_set_cancel_compaction(struct filemgr *file, bool cancel)
{
spin_lock(&file->lock);
if (cancel) {
file->fflags |= FILEMGR_CANCEL_COMPACTION;
} else {
file->fflags &= ~FILEMGR_CANCEL_COMPACTION;
}
spin_unlock(&file->lock);
} | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x1a0(%rdi), %r15
movq %r15, %rdi
callq 0x3310
movb 0xc(%r14), %al
andb $-0x41, %al
shlb $0x6, %bl
orb %al, %bl
movb %bl, 0xc(%r14)
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x30b0
| /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
filemgr_actual_stale_regions | struct stale_regions filemgr_actual_stale_regions(struct filemgr *file,
bid_t offset,
size_t length)
{
uint8_t *buf = alca(uint8_t, file->blocksize);
size_t remaining = length;
size_t real_blocksize = file->b... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x10(%rsi), %eax
movq %rsp, %rcx
movq %rax, -0x30(%rbp)
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x60(%rbp)
movq %rcx, %rsp
movq 0x... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
filemgr_dirty_update_remove_node(filemgr*, filemgr_dirty_update_node*) | static void _filemgr_dirty_update_remove_node(struct filemgr *file,
struct filemgr_dirty_update_node *node)
{
struct avl_node *a;
struct filemgr_dirty_update_block *block;
if (!node) {
return;
}
// free all dirty blocks belonging to this node
... | testq %rdi, %rdi
je 0x186b8
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x61d0
testq %rax, %rax
je 0x186a5
movq %rax, %r15
movq %r15, %rdi
callq 0x61f4
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x66ab
movq 0x18(%r15), %rdi
callq 0x3430
m... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
filemgr_dirty_update_get_latest | struct filemgr_dirty_update_node *filemgr_dirty_update_get_latest(struct filemgr *file)
{
struct filemgr_dirty_update_node *node = NULL;
// find the first immutable node from the end
spin_lock(&file->dirty_update_lock);
node = file->latest_dirty_update;
if (node) {
atomic_incr_uint32_t(&no... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2d0(%rdi), %rbx
movq %rbx, %rdi
callq 0x3310
movq 0x2c8(%r14), %r14
testq %r14, %r14
je 0x1876a
lock
incl 0x24(%r14)
movq %rbx, %rdi
callq 0x30b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
filemgr_write_dirty | fdb_status filemgr_write_dirty(struct filemgr *file, bid_t bid, void *buf,
struct filemgr_dirty_update_node *node,
err_log_callback *log_callback)
{
struct avl_node *a;
struct filemgr_dirty_update_block *block, query;
query.bid = bid;
a = av... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10(%rsp), %rsi
movq %r12, 0x20(%rsi)
addq $0x38, %r15
leaq 0xc7f(%rip), %rdx # 0x197e6
movq %r15, %rdi
callq 0x625e
movq %rax, %r13
testq %rax, %rax
jne 0x18bd3
movl $0x1,... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
filemgr_read_dirty | fdb_status filemgr_read_dirty(struct filemgr *file, bid_t bid, void *buf,
struct filemgr_dirty_update_node *node_reader,
struct filemgr_dirty_update_node *node_writer,
err_log_callback *log_callback,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
testq %r8, %r8
je 0x18c33
movq %rsp, %rsi
movq %r12, 0x20(%rsi)
addq $0x38, %r8
leaq 0xbc0(%rip), %rdx # 0x197e6
movq %r8, %rdi
callq 0x625e
testq %rax, %rax
jne 0... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
kvs_stat_cmp(avl_node*, avl_node*, void*) | static int _kvs_stat_cmp(struct avl_node *a, struct avl_node *b, void *aux)
{
struct kvs_node *aa, *bb;
aa = _get_entry(a, struct kvs_node, avl_id);
bb = _get_entry(b, struct kvs_node, avl_id);
if (aa->id < bb->id) {
return -1;
} else if (aa->id > bb->id) {
return 1;
} else {
... | movq -0xb0(%rdi), %rax
xorl %ecx, %ecx
cmpq -0xb0(%rsi), %rax
seta %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovael %ecx, %eax
retq
| /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
fdb_kvs_get_seqnum | fdb_seqnum_t _fdb_kvs_get_seqnum(struct kvs_header *kv_header,
fdb_kvs_id_t id)
{
fdb_seqnum_t seqnum;
struct kvs_node query, *node;
struct avl_node *a;
spin_lock(&kv_header->lock);
query.id = id;
a = avl_search(kv_header->idx_id, &query.avl_id, _kvs_stat_cmp);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x3310
leaq 0xb8(%rsp), %rsi
movq %r14, -0xb0(%rsi)
movq 0x20(%r15), %rdi
leaq -0x218(%rip), %rdx # 0x18d76
callq 0x625e
testq %rax, %rax
je 0x18fa1
movq -0xa8(%rax), %r14
jmp 0x18fa4
xorl ... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
kvs_ops_stat_get_kv_header | int _kvs_ops_stat_get_kv_header(struct kvs_header *kv_header,
fdb_kvs_id_t kv_id,
struct kvs_ops_stat *stat)
{
int ret = 0;
struct avl_node *a;
struct kvs_node query, *node;
query.id = kv_id;
a = avl_search(kv_header->idx_id, &query.av... | pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
leaq 0xb8(%rsp), %rax
movq %rsi, -0xb0(%rax)
movq 0x20(%rdi), %rdi
leaq -0x446(%rip), %rdx # 0x18d76
movq %rax, %rsi
callq 0x625e
testq %rax, %rax
je 0x19207
movq -0x88(%rax), %rcx
movq %rcx, (%rbx)
movq -0x80(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq -0x78(%rax), %rcx
movq ... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
kvs_ops_stat_get | int _kvs_ops_stat_get(struct filemgr *file,
fdb_kvs_id_t kv_id,
struct kvs_ops_stat *stat)
{
int ret = 0;
if (kv_id == 0) {
spin_lock(&file->lock);
*stat = file->header.op_stat;
spin_unlock(&file->lock);
} else {
struct kvs_header ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x19250
movq %rsi, %r12
movq 0x170(%r15), %r15
leaq 0x38(%r15), %rbx
movq %rbx, %rdi
callq 0x3310
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x19197
movl %eax, %ebp
jmp 0x192a7
leaq 0x1a0(%r15), %rbx
mo... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
filemgr_get_ops_stats | struct kvs_ops_stat *filemgr_get_ops_stats(struct filemgr *file,
struct kvs_info *kvs)
{
struct kvs_ops_stat *stat = NULL;
if (!kvs || (kvs && kvs->id == 0)) {
return &file->header.op_stat;
} else {
struct kvs_header *kv_header = file->kv_header;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x19328
movq %rsi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x19328
movq 0x170(%rbx), %rbx
leaq 0x38(%rbx), %r15
movq %r15, %rdi
callq 0x3310
movq 0x8(%r14), %rax
leaq 0xb8(%rsp), %rsi
movq %rax, -0xb0(%rsi)
movq 0x20(%rbx), %rdi
leaq -0x593(%rip... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
fhandle_idx_cmp(avl_node*, avl_node*, void*) | INLINE int _fhandle_idx_cmp(struct avl_node *a, struct avl_node *b, void *aux)
{
uint64_t aaa, bbb;
struct filemgr_fhandle_idx_node *aa, *bb;
aa = _get_entry(a, struct filemgr_fhandle_idx_node, avl);
bb = _get_entry(b, struct filemgr_fhandle_idx_node, avl);
aaa = (uint64_t)aa->fhandle;
bbb = (ui... | movq -0x8(%rdi), %rcx
movq -0x8(%rsi), %rax
movq %rax, %rdx
xorq %rcx, %rdx
movq %rdx, %rsi
shrq $0x3f, %rsi
leal -0x1(%rsi), %edi
xorl %r8d, %r8d
subq %rax, %rcx
setne %r8b
shrq $0x20, %rcx
orl %r8d, %ecx
andl %edi, %ecx
shrq $0x20, %rdx
movl $0x80000000, %edi # imm = 0x80000000
andl %edi, %edx
orl %esi, %edx
sh... | /ForestDB-KVStore[P]forestdb/src/filemgr.cc |
fdb_readkey_wrap | size_t _fdb_readkey_wrap(void *handle, uint64_t offset, void *buf)
{
fdb_status fs;
keylen_t keylen;
struct docio_handle *dhandle = (struct docio_handle*)handle;
offset = _endian_decode(offset);
fs = docio_read_doc_key(dhandle, offset, &keylen, buf);
if (fs == FDB_RESULT_SUCCESS) {
retu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
bswapq %r14
leaq 0xe(%rsp), %rdx
movq %r14, %rsi
callq 0x1207d
testl %eax, %eax
je 0x1997a
movl %eax, %r10d
movq (%rbx), %r12
movl 0x10(%rbx), %r13d
subq $0x8, %rsp
leaq 0x272d1(%rip), %r11 # 0x40... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_fetch_header | void fdb_fetch_header(uint64_t version,
void *header_buf,
bid_t *trie_root_bid,
bid_t *seq_root_bid,
bid_t *stale_root_bid,
uint64_t *ndocs,
uint64_t *ndeletes,
uint6... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq 0xa8(%rsp), %rax
movq %rax, (%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
mov... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_snapshot_open | LIBFDB_API
fdb_status fdb_snapshot_open(fdb_kvs_handle *handle_in,
fdb_kvs_handle **ptr_handle, fdb_seqnum_t seqnum)
{
#ifdef _MEMPOOL
mempool_init();
#endif
if (!handle_in || !ptr_handle) {
return FDB_RESULT_INVALID_HANDLE;
}
fdb_config config = handle_in->config;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
testq %rdi, %rdi
sete %al
movq %rsi, 0x28(%rsp)
testq %rsi, %rsi
sete %cl
movl $0xffffffe2, %r13d # imm = 0xFFFFFFE2
orb %al, %cl
jne 0x1baea
movq %rdx, %rbp
movq %rdi, %r14
leaq 0x70(%rdi), %rsi
leaq 0x80(... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_sync_db_header | void fdb_sync_db_header(fdb_kvs_handle *handle)
{
uint64_t cur_revnum = filemgr_get_header_revnum(handle->file);
if (handle->cur_header_revnum != cur_revnum) {
void *header_buf = NULL;
size_t header_len;
bid_t hdr_bid;
filemgr_header_revnum_t revnum;
header_buf = filemgr... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x14fbb
movq 0x180(%rbx), %rcx
cmpq %rax, %rcx
jne 0x1bcef
movq 0x28(%rbx), %rax
cmpq %rbx, (%rax)
jne 0x1be99
movq 0x48(%rbx), %rdi
callq 0x14fe8
movq %rax, 0x1b0(%rbx)
jmp 0x1be99
movq 0x48(%rbx), %rdi
... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_reset(_fdb_kvs_handle*, _fdb_kvs_handle*) | static fdb_status _fdb_reset(fdb_kvs_handle *handle, fdb_kvs_handle *handle_in)
{
struct filemgr_config fconfig;
struct btreeblk_handle *new_bhandle;
struct docio_handle *new_dhandle;
struct hbtrie *new_trie = NULL;
struct btree *new_seqtree = NULL, *old_seqtree;
struct btree *new_staletree = NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x2598a
xorl %eax, %eax
xchgb %al, 0x1d0(%r14)
movq 0x1c0(%r15), %rdi
callq 0x3180
leaq 0x1(%rax), %rdi
callq 0x34b0
movq %rax, 0x1c0(%r14)
movl $0xfffffff8, %ebx # imm = 0xFFFFFFF8
testq %rax,... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_rollback_all | LIBFDB_API
fdb_status fdb_rollback_all(fdb_file_handle *fhandle,
fdb_snapshot_marker_t marker)
{
#ifdef _MEMPOOL
mempool_init();
#endif
fdb_config config;
fdb_kvs_handle *super_handle;
fdb_kvs_handle rhandle;
fdb_kvs_handle *handle = &rhandle;
struct filemgr *file;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rsp)
movq $0x0, 0x1d8(%rsp)
testq %rdi, %rdi
je 0x1cfdc
movq %rsi, %rbp
movq %rdi, %r12
movq (%rdi), %rbx
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x1cf4a
movq %r12, %rdi... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_doc_free | LIBFDB_API
fdb_status fdb_doc_free(fdb_doc *doc)
{
if (doc) {
free(doc->key);
free(doc->meta);
free(doc->body);
free(doc);
}
return FDB_RESULT_SUCCESS;
} | testq %rdi, %rdi
je 0x1d7ce
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x3430
movq 0x38(%rbx), %rdi
callq 0x3430
movq 0x40(%rbx), %rdi
callq 0x3430
movq %rbx, %rdi
callq 0x3430
popq %rbx
xorl %eax, %eax
retq
| /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_sync_dirty_root(_fdb_kvs_handle*) | static void _fdb_sync_dirty_root(fdb_kvs_handle *handle)
{
if (handle->config.do_not_search_wal) {
return;
}
bid_t dirty_idtree_root = BLK_NOT_FOUND;
bid_t dirty_seqtree_root = BLK_NOT_FOUND;
if (handle->shandle) {
// skip snapshot
return;
}
struct filemgr_dirty_up... | pushq %rbx
cmpb $0x0, 0x15b(%rdi)
jne 0x1db65
movq %rdi, %rbx
cmpq $0x0, 0x1a8(%rdi)
je 0x1db67
popq %rbx
retq
movq 0x48(%rbx), %rdi
callq 0x18743
movq 0x58(%rbx), %rdi
movq %rax, 0x68(%rdi)
testq %rax, %rax
je 0x1db65
movq 0x28(%rax), %rcx
movq 0x30(%rax), %r9
cmpq $-0x1, %rcx
je 0x1db93
movq 0x30(%rbx), %rax
movq %rc... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_traverse_index | LIBFDB_API
fdb_status fdb_traverse_index(fdb_kvs_handle *handle,
const void *key,
size_t keylen,
fdb_index_traversal_callback cb,
void* ctx)
{
uint64_t offset;
struct docio_object _doc;
hb... | testq %rdi, %rdi
je 0x1e29b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r15
movq %rdi, %rbx
movl $0xffffffec, %ecx # imm = 0xFFFFFFEC
cmpb $0x1, 0x15b(%rdi)
jne 0x1e2a7
testq %r15, %r15
je 0x1e2a2
movb $0x1, %cl
xorl %eax, %eax
lock
cmpxchgb %cl, ... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_get_metaonly | LIBFDB_API
fdb_status fdb_get_metaonly(fdb_kvs_handle *handle, fdb_doc *doc)
{
uint64_t offset;
struct docio_object _doc;
struct docio_handle *dhandle;
struct filemgr *wal_file = NULL;
fdb_status wr;
hbtrie_result hr = HBTRIE_RESULT_FAIL;
fdb_txn *txn;
struct _fdb_key_cmp_info cmp_info;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movl $0x0, -0x60(%rbp)
movups %xmm0, -0x58(%rbp)
movups %xmm0, -0x48(%rbp)
testq %rdi, %rdi
je 0x1e3df
movq %rsi, %r14
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testq %rs... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
equal_docs(fdb_doc_struct*, docio_object*) | static uint8_t equal_docs(fdb_doc *doc, struct docio_object *_doc) {
uint8_t rv = 1;
// Compare a seq num if seq tree is enabled.
if (doc->seqnum != SEQNUM_NOT_USED) {
if (doc->seqnum != _doc->seqnum) {
free(_doc->key);
free(_doc->meta);
free(_doc->body);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %rax
cmpq $-0x1, %rax
je 0x1efc6
movb $0x1, %bpl
cmpq 0x20(%rbx), %rax
jne 0x1f002
jmp 0x1f031
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x1efe5
movq 0x18(%rbx), %r15
movq (%r14), %rdx
movq %r15, %rsi
callq 0x33e0
te... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_set | LIBFDB_API
fdb_status fdb_set(fdb_kvs_handle *handle, fdb_doc *doc)
{
if (!handle) {
return FDB_RESULT_INVALID_HANDLE;
}
uint64_t offset;
struct docio_object _doc;
struct filemgr *file;
struct docio_handle *dhandle;
struct timeval tv;
bool txn_enabled = false;
bool sub_handl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
testq %rdi, %rdi
je 0x1f388
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqa %xmm0, -0x90(%rbp)
movl $0x0, -0x80(%rbp)
movdqu %xmm0, -0x78(%rbp)
movdqu %xmm0, -0x68(%rbp)
testb $0x2, 0x94(%rdi)
jne 0x1f390
movq %rsi, %r14
movl $0... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_commit | LIBFDB_API
fdb_status fdb_commit(fdb_file_handle *fhandle, fdb_commit_opt_t opt)
{
if (!fhandle) {
return FDB_RESULT_INVALID_HANDLE;
}
return _fdb_commit( fhandle->root,
opt,
!( fhandle->root->config.durability_opt &
FDB_DRB_A... | testq %rdi, %rdi
je 0x1fca0
movq (%rdi), %rdi
xorl %edx, %edx
testb $0x2, 0x91(%rdi)
sete %dl
movzbl %sil, %esi
jmp 0x1c9a1
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
retq
| /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_bottom_up_index_build_get(void*, void**, unsigned long*, void**, void*) | void _fdb_bottom_up_index_build_get(void* cur_entry,
void** key_out,
size_t* keylen_out,
void** value_out,
void* aux)
{
struct bottom_up_build_entry* entry =
_get_e... | movq 0x10(%rdi), %rax
movq %rax, (%rsi)
movq 0x18(%rdi), %rax
movq %rax, (%rdx)
movq 0x20(%rdi), %rax
bswapq %rax
movq %fs:0x0, %rdx
leaq -0x30(%rdx), %rdx
movq %rax, %fs:-0x30
movq %rdx, (%rcx)
retq
| /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_bottom_up_index_build_get_seq(void*, void**, unsigned long*, void**, void*) | void _fdb_bottom_up_index_build_get_seq(void* cur_entry,
void** key_out,
size_t* keylen_out,
void** value_out,
void* aux)
{
struct bottom_up_build_entry* en... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpb $0x0, %fs:-0x10
je 0x1fdf0
movq 0x18(%r13), %rax
cmpq $0x0, 0x18(%rax)
je 0x1fd8a
movzwl 0x70(%rax), %r13d
leaq 0x8(%r13), %rsi
movq %fs:-0x20, %rax
subq %fs:-0x28, %rax
cmpq %rax, ... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_compact_file(_fdb_kvs_handle*, filemgr*, btreeblk_handle*, docio_handle*, hbtrie*, hbtrie*, btree*, btree*, unsigned long, bool, fdb_compact_opt_struct const*) | fdb_status _fdb_compact_file(fdb_kvs_handle *handle,
struct filemgr *new_file,
struct btreeblk_handle *new_bhandle,
struct docio_handle *new_dhandle,
struct hbtrie *new_trie,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6b8, %rsp # imm = 0x6B8
movq %r9, 0x38(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, %r12
movq %rdx, 0x28(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq $-0x1, 0x60(%rsp)
movq 0x48(%rdi), %rdi
callq 0x14fe8
movq %rax, %r15
movq %r14, %rdi
movq %ra... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_cleanup_compact_err(_fdb_kvs_handle*, filemgr*, bool, bool, btreeblk_handle*, docio_handle*, hbtrie*, hbtrie*, btree*, btree*) | static void _fdb_cleanup_compact_err(fdb_kvs_handle *handle,
struct filemgr *new_file,
bool cleanup_cache,
bool got_lock,
struct btreeblk_handle *new_bhandle,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, %rbp
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r12
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq %rsi, %rdi... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_compact_move_delta(_fdb_kvs_handle*, filemgr*, hbtrie*, btree*, btree*, btree*, docio_handle*, btreeblk_handle*, unsigned long, unsigned long, bool, bool, bool, bool, unsigned long*) | static fdb_status _fdb_compact_move_delta(fdb_kvs_handle *handle,
struct filemgr *new_file,
struct hbtrie *new_trie,
struct btree *new_idtree,
struct bt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %r9, -0x30(%rbp)
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, -0x70(%rbp)
movq %rdi, %r13
movq 0x48(%rdi), %rax
movl 0x10(%rax), %ecx
movq %rcx, -0x78(%rbp)
movq 0x110(%rax), %r... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_compact(_fdb_file_handle*, char const*, unsigned long, bool, fdb_encryption_key const*, fdb_compact_opt_struct const*) | static fdb_status _fdb_compact(fdb_file_handle *fhandle,
const char *new_filename,
fdb_snapshot_marker_t marker,
bool clone_docs,
const fdb_encryption_key *new_encryption_key,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movl $0xffffffe2, %r13d # imm = 0xFFFFFFE2
testq %rdi, %rdi
je 0x2393a
movq %rdi, %r15
movq (%rdi), %r14
testq %r14, %r14
je 0x2393a
movl %ecx, %ebp
movb $0x1, %cl
xorl %eax, %eax
lock
cmpxchgb %cl, 0x1d0(%... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_set_daemon_compaction_interval | LIBFDB_API
fdb_status fdb_set_daemon_compaction_interval(fdb_file_handle *fhandle,
size_t interval)
{
if (!fhandle || !fhandle->root) {
return FDB_RESULT_INVALID_HANDLE;
}
fdb_kvs_handle *handle = fhandle->root;
if (handle->config.compaction_mode =... | movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testq %rdi, %rdi
je 0x23bb9
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x23bb9
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
cmpb $0x1, 0x9e(%rcx)
jne 0x23bb9
movq 0x48(%rcx), %rdi
jmp 0x1028a
retq
| /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_close_root | fdb_status _fdb_close_root(fdb_kvs_handle *handle)
{
fdb_status fs;
if (!handle) {
return FDB_RESULT_SUCCESS;
}
if (handle->kvs) {
if (handle->kvs->type == KVS_SUB) {
return fdb_kvs_close(handle);
} else if (handle->kvs->type == KVS_ROOT) {
// close all s... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x23d07
movq %rdi, %r14
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x23ca1
movzbl (%rax), %eax
testl %eax, %eax
je 0x23c95
cmpl $0x1, %eax
jne 0x23ca1
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3131b
movq %r14, %rdi
callq 0x31277
testl %... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_estimate_space_used | LIBFDB_API
size_t fdb_estimate_space_used(fdb_file_handle *fhandle)
{
size_t ret = 0;
size_t datasize;
size_t nlivenodes;
fdb_kvs_handle *handle = NULL;
struct filemgr *file;
if (!fhandle) {
return 0;
}
handle = fhandle->root;
fdb_check_file_reopen(handle, NULL);
fdb_s... | testq %rdi, %rdi
je 0x23ef2
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1baff
movq %rbx, %rdi
callq 0x1bca8
movq 0x48(%rbx), %r14
movq %r14, %rdi
movl $0x3, %esi
callq 0x190b1
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x190b1
movl 0x74(%rbx), %r14d
imulq %rax, ... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_get_file_info | LIBFDB_API
fdb_status fdb_get_file_info(fdb_file_handle *fhandle, fdb_file_info *info)
{
uint64_t ndocs, ndeletes;
fdb_kvs_handle *handle;
if (!fhandle) {
return FDB_RESULT_INVALID_HANDLE;
}
if (!info) {
return FDB_RESULT_INVALID_ARGS;
}
handle = fhandle->root;
fdb_che... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x24255
movq %rsi, %rbx
testq %rsi, %rsi
je 0x24260
movq %rdi, %r15
movq (%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1baff
movq %r14, %rdi
callq 0x1bca8
cmpb $0x1, 0x9e(%r14)
jne 0x2426b
leaq 0x1c0(%r14), %rax
jmp 0x2426f
movl $0xffffff... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_get_all_snap_markers | LIBFDB_API
fdb_status fdb_get_all_snap_markers(fdb_file_handle *fhandle,
fdb_snapshot_info_t **markers_out,
uint64_t *num_markers)
{
fdb_kvs_handle *handle;
bid_t hdr_bid;
size_t header_len;
uint8_t header_buf[FDB_BLOCKSIZE];
bi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10f8, %rsp # imm = 0x10F8
movq $-0x1, %rax
movq %rax, 0x78(%rsp)
movq %rax, 0x70(%rsp)
movq %rax, 0x68(%rsp)
testq %rdi, %rdi
je 0x246d8
movq %rdx, %rbx
movq %rsi, %r14
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
movl $0xfffffff... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_cancel_compaction | LIBFDB_API
fdb_status fdb_cancel_compaction(fdb_file_handle *fhandle)
{
if (!fhandle) {
return FDB_RESULT_INVALID_HANDLE;
}
fdb_kvs_handle *super_handle = fhandle->root;
filemgr_mutex_lock(super_handle->file);
filemgr_set_cancel_compaction(super_handle->file, true);
// TODO: Find a be... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2487f
movq (%rdi), %r14
movq 0x48(%r14), %rdi
callq 0x181da
movq 0x48(%r14), %rdi
movl $0x1, %esi
callq 0x180a3
movl $0x2710, 0x4(%rsp) # imm = 0x2710
movq 0x48(%r14), %rax
movb 0x108(%rax), %al
cmpb $0x1, %al
jne 0x24867
leaq 0x4(%rsp), %rbx
movq 0x48(%r14), ... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_set_block_reusing_params | LIBFDB_API
fdb_status fdb_set_block_reusing_params(fdb_file_handle *fhandle,
size_t block_reusing_threshold,
size_t num_keeping_headers)
{
if (!fhandle || !fhandle->root) {
return FDB_RESULT_INVALID_HANDLE;
}
filemgr *fi... | movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testq %rdi, %rdi
je 0x248bc
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x248bc
movq 0x48(%rcx), %rax
movq 0x110(%rax), %rcx
movq %rsi, 0x48(%rcx)
movq 0x110(%rax), %rax
movq %rdx, 0x50(%rax)
xorl %eax, %eax
retq
| /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_kvs_handle::operator=(_fdb_kvs_handle const&) | _fdb_kvs_handle& operator=(const _fdb_kvs_handle& kv_handle) {
kvs_config = kv_handle.kvs_config;
kvs = kv_handle.kvs;
op_stats = kv_handle.op_stats;
fhandle = kv_handle.fhandle;
trie = kv_handle.trie;
staletree = kv_handle.staletree;
if (kv_handle.kvs) {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
movups 0x28(%rsi), %xmm0
movups %xmm0, 0x28(%rdi)
movq 0x38(%rsi), %rax
movq %rax, 0x38(%rdi)
movq 0x40(%rsi), %rax
mov... | /ForestDB-KVStore[P]forestdb/src/internal_types.h |
cmp_uint64_t_endian_safe(void*, void*, void*) | INLINE int _cmp_uint64_t_endian_safe(void *key1, void *key2, void *aux)
{
(void) aux;
uint64_t a,b;
a = *(uint64_t*)key1;
b = *(uint64_t*)key2;
a = _endian_decode(a);
b = _endian_decode(b);
return _CMP_U64(a, b);
} | movq (%rdi), %rdi
movq (%rsi), %rsi
movq %rdi, %rcx
bswapq %rcx
movq %rsi, %rax
bswapq %rax
movq %rax, %rdx
xorq %rcx, %rdx
movq %rdx, %r8
shrq $0x3f, %r8
leal -0x1(%r8), %r9d
subq %rax, %rcx
shrq $0x20, %rcx
xorl %r10d, %r10d
cmpq %rsi, %rdi
setne %r10b
orl %r10d, %ecx
andl %r9d, %ecx
shrq $0x20, %rdx
movl $0x80000000... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_recover_compaction(_fdb_kvs_handle*, char const*) | INLINE fdb_status _fdb_recover_compaction(fdb_kvs_handle *handle,
const char *new_filename)
{
fdb_kvs_handle new_db;
fdb_config config = handle->config;
struct filemgr *new_file;
// As partially compacted file may contain various errors,
// we temporarily d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x70(%rdi), %rsi
leaq 0x210(%rsp), %r15
movl $0xf8, %edx
movq %r15, %rdi
callq 0x3300
leaq 0x18(%rsp), %r12
movl $0x1f0, %edx # imm = 0x1F0
movq %r12, %rdi
xorl %e... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_wal_flush_seq_purge(void*, avl_tree*, avl_tree*) | INLINE void _fdb_wal_flush_seq_purge(void *dbhandle,
struct avl_tree *stale_seqnum_list,
struct avl_tree *kvs_delta_stats)
{
fdb_seqnum_t _seqnum;
int64_t nlivenodes;
int64_t ndeltanodes;
int64_t delta;
uint8_t kvid_seqnum[siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x61d0
testq %rax, %rax
je 0x264f0
movq %rax, %r13
leaq -0x10(%r13), %rbp
movq %r13, %rdi
callq 0x61f4
movq %rax, %r12
movq 0x58(%r15), %rax
movq 0x8(%rax),... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_wal_flush_kvs_delta_stats(filemgr*, avl_tree*) | INLINE void _fdb_wal_flush_kvs_delta_stats(struct filemgr *file,
struct avl_tree *kvs_delta_stats)
{
struct avl_node *node;
struct wal_kvs_delta_stat *delta_stat;
node = avl_first(kvs_delta_stats);
while (node) {
delta_stat = _get_entry(node, struct wal... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x61d0
testq %rax, %rax
je 0x265b6
movq %rax, %r15
leaq -0x30(%r15), %r13
movq %r15, %rdi
callq 0x61f4
movq %rax, %r12
movq -0x30(%r15), %rsi
movq -0x10(%r15), %rcx
movq %r14, %rdi
movl $0x3, %edx
callq 0x18d92
... | /ForestDB-KVStore[P]forestdb/src/forestdb.cc |
fdb_cmp_uint64_t(void const*, void const*) | INLINE uint64_t deref64(const void *ptr)
{
#ifdef _ALIGN_MEM_ACCESS
// 8-byte align check (rightmost 3 bits must be '000')
// Not sure whether 8-byte integer should be aligned in
// 8-byte boundary or just 4-byte boundary.
if ( (size_t)ptr & 0x7 ) {
uint64_t value;
memcpy(&value, ptr, si... | movq (%rdi), %rcx
movq (%rsi), %rax
movq %rax, %rdx
xorq %rcx, %rdx
movq %rdx, %rsi
shrq $0x3f, %rsi
leal -0x1(%rsi), %edi
xorl %r8d, %r8d
subq %rax, %rcx
setne %r8b
shrq $0x20, %rcx
orl %r8d, %ecx
andl %edi, %ecx
shrq $0x20, %rdx
movl $0x80000000, %edi # imm = 0x80000000
andl %edi, %edx
orl %esi, %edx
shrq $0x20... | /ForestDB-KVStore[P]forestdb/src/btree_kv.h |
hash_scan | void *hash_scan(struct hash *hash, hash_check_func *check_func, void *ctx)
{
size_t i;
void *ret = NULL;
#ifdef _HASH_TREE
struct avl_node *node;
#else
struct list_elem *e;
#endif
struct hash_elem *h;
for (i=0;i<hash->nbuckets;++i){
#ifdef _HASH_TREE
node = avl_first(hash->buckets + i... | cmpq $0x0, (%rdi)
je 0x27635
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rbp, %rdi
shlq $0x4, %rdi
addq 0x8(%r15), %rdi
callq 0x61d0
movq %rax, %r12
testq %r12, %r12
je 0x2761c
movq %r12, %rdi
callq 0x61f4
movq %rax, ... | /ForestDB-KVStore[P]forestdb/src/hash.cc |
hash_remove | struct hash_elem * hash_remove(struct hash *hash, struct hash_elem *e)
{
int bucket = hash->hash_func(hash, e);
struct hash_elem *hash_elem;
IFDEF_LOCK( spin_lock(hash->locks + bucket) );
#ifdef _HASH_TREE
struct avl_node *node;
node = avl_search(hash->buckets + bucket, &e->avl, _hash_cmp_wrap);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq *0x10(%rdi)
movslq %eax, %r14
shlq $0x4, %r14
movq 0x8(%rbx), %rdi
addq %r14, %rdi
leaq 0x28(%rip), %rdx # 0x27683
movq %r15, %rsi
callq 0x625e
movq %rax, %r15
testq %rax, %rax
je 0x2767a
addq 0x8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
c... | /ForestDB-KVStore[P]forestdb/src/hash.cc |
hash_free_active | void hash_free_active(struct hash *hash, hash_free_func *free_func)
{
size_t i;
#ifdef _HASH_TREE
struct avl_node *node;
#else
struct list_elem *e, *e_next;
#endif
struct hash_elem *h;
for (i=0;i<hash->nbuckets;++i){
#ifdef _HASH_TREE
node = avl_first(hash->buckets + i);
while(nod... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x276f7
movq %rsi, %r14
xorl %r13d, %r13d
movq %r13, %rbp
shlq $0x4, %rbp
movq 0x8(%rbx), %rdi
addq %rbp, %rdi
callq 0x61d0
testq %rax, %rax
je 0x276ef
movq %rax, %r15
movq %r15, %rdi
callq 0x61f4
movq %rax... | /ForestDB-KVStore[P]forestdb/src/hash.cc |
hbtrie_reform_key | int _hbtrie_reform_key(struct hbtrie *trie, void *rawkey,
int rawkeylen, void *outkey)
{
int outkeylen;
int nchunk;
int i;
uint8_t rsize;
size_t csize = trie->chunksize;
nchunk = _get_nchunk_raw(trie, rawkey, rawkeylen);
outkeylen = nchunk * csize;
if (nchunk > 2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ecx
movzbl (%rdi), %r14d
leal (%rcx,%r14), %eax
decl %eax
cltd
idivl %r14d
movl %eax, %r15d
leal 0x1(%r15), %r12d
leal -0x2(%r12), %eax
mulb %r14b
xorl %edx, %edx
cmpl $0x2, %r15d
movzbl %al, %eax
cmovll %edx, %eax
movl %ecx, %ebp
subb %... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_iterator_init | hbtrie_result hbtrie_iterator_init(struct hbtrie *trie,
struct hbtrie_iterator *it,
void *initial_key,
size_t keylen)
{
it->trie = *trie;
// MUST NOT affect the original trie due to sharing the same memory ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movl $0xe, %ecx
movq %rsi, %rdi
movq %r14, %rsi
rep movsq (%rsi), %es:(%rdi)
movzbl (%rbx), %r15d
movq %r15, %rdi
callq 0x34b0
movq %rax, 0x68(%rbx)
movq %rax, %rdi
movl $0xff, %... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_last | hbtrie_result hbtrie_last(struct hbtrie_iterator *it)
{
struct hbtrie_iterator temp;
temp = *it;
hbtrie_iterator_free(it);
it->trie = temp.trie;
// MUST NOT affect the original trie due to sharing the same memory segment
it->trie.last_map_chunk = (void *)malloc(it->trie.chunksize);
memset(... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x98, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3300
movq %rbx, %rdi
callq 0x27b2d
movl $0xe, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep movsq (%rsi), %es:(%rdi)
movzbl (%rbx), %r14d
movq %r14, %rdi
callq 0x34b0
movq %rax, 0x68(%rbx)
movq %r... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_prev | hbtrie_result hbtrie_prev(struct hbtrie_iterator *it,
void *key_buf,
size_t *keylen,
void *value_buf)
{
hbtrie_result hr;
if (HBTRIE_ITR_IS_REV(it) && HBTRIE_ITR_IS_FAILED(it)) {
return HBTRIE_RESULT_FAIL;
}
struct l... | movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movb 0x90(%rdi), %sil
notb %sil
movl $0x3, %eax
testb $0x3, %sil
je 0x27c86
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rax
leaq -0x70(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
callq 0x27c87
movb 0x90(%rbx), %cl
movl %ecx, %edx
orb $0x3, %dl
andb $-0x8, %cl
orb $0x5,... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_next | hbtrie_result hbtrie_next(struct hbtrie_iterator *it,
void *key_buf,
size_t *keylen,
void *value_buf)
{
hbtrie_result hr;
if (HBTRIE_ITR_IS_FWD(it) && HBTRIE_ITR_IS_FAILED(it)) {
return HBTRIE_RESULT_FAIL;
}
struct l... | movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movb 0x90(%rdi), %sil
andb $0x3, %sil
movl $0x3, %eax
cmpb $0x2, %sil
je 0x284e4
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rax
leaq -0x70(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
xorl %r9d, %r9d
callq 0x284e5
movb 0x90(%rbx), %cl
movl %ecx, %edx
andb $-0x4, %dl
or... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_next(hbtrie_iterator*, btreeit_item*, void*, unsigned long*, void*, unsigned char) | static hbtrie_result _hbtrie_next(struct hbtrie_iterator *it,
struct btreeit_item *item,
void *key_buf,
size_t *keylen,
void *value_buf,
uint8_t flag)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, %r13d
movq %r8, -0x80(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movzbl (%rdi), %eax
movq %rsp, %r15
addl $0xf, %eax
andl $-0x10, %eax
subq %rax, %r15
movq %r15, %rsp
mo... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_next_partial | hbtrie_result hbtrie_next_partial(struct hbtrie_iterator *it,
void *key_buf,
size_t *keylen,
void *value_buf)
{
hbtrie_result hr;
if (HBTRIE_ITR_IS_FWD(it) && HBTRIE_ITR_IS_FAILED(it)) {
return HBTRIE_... | movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movb 0x90(%rdi), %sil
andb $0x3, %sil
movl $0x3, %eax
cmpb $0x2, %sil
je 0x28f17
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rax
leaq -0x70(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
movl $0x2, %r9d
callq 0x284e5
movb 0x90(%rbx), %cl
movl %ecx, %edx
andb $-0x4, %dl
or... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_find(hbtrie*, void*, int, void*, list*, unsigned char) | static hbtrie_result _hbtrie_find(struct hbtrie *trie, void *key, int keylen,
void *valuebuf, struct list *btreelist, uint8_t flag)
{
int nchunk;
int rawkeylen;
int prevchunkno, curchunkno, cpt_node = 0;
struct btree *btree = NULL;
struct btree btree_static;
btr... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, -0x4c(%rbp)
movq %r8, %r12
movq %rcx, -0x58(%rbp)
movq %rsi, %r13
movq %rdi, %rbx
movzbl (%rdi), %ecx
movq %rsp, %rsi
leal 0xf(%rcx), %eax
andl $-0x10, %eax
subq %rax, %rsi
movq %rsi, -0xc0(%rbp)
movq %rsi, %rs... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_btree_cascaded_update(hbtrie*, list*, void*, int) | static void _hbtrie_btree_cascaded_update(struct hbtrie *trie,
struct list *btreelist,
void *key,
int free_opt)
{
bid_t bid_new, _bid;
struct btreelist_item *btreeitem, *btreeitem_child;... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x29f2a
movq (%rax), %rcx
testq %rcx, %rcx
je 0x29f4a
movq %rdx, %r15
leaq 0x8(%rsp), %r12
movq %rcx, %r13
movq -0x40(%rax), %rax
cmpq %rax, -0x8(%rcx)
je 0x29f1c
bswapq %rax
... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
hbtrie_remove(hbtrie*, void*, int, unsigned char) | INLINE hbtrie_result _hbtrie_remove(struct hbtrie *trie,
void *rawkey, int rawkeylen,
uint8_t flag)
{
int nchunk = _get_nchunk_raw(trie, rawkey, rawkeylen);
int keylen;
uint8_t *key = alca(uint8_t, nchunk * trie->chunksize);
uint8_t... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r14d
movl %edx, %r8d
movq %rdi, %r12
movzbl (%rdi), %ecx
leal (%r8,%rcx), %eax
decl %eax
cltd
idivl %ecx
movslq %eax, %r15
incq %r15
movq %r15, %rax
imulq %rcx, %rax
addq $0xf, %rax
andq $-0x10, %rax
movq %rsp... | /ForestDB-KVStore[P]forestdb/src/hbtrie.cc |
fdb_iterator_close | LIBFDB_API
fdb_status fdb_iterator_close(fdb_iterator *iterator)
{
if (!iterator || !iterator->handle) {
return FDB_RESULT_INVALID_HANDLE;
}
LATENCY_STAT_START();
if (iterator->hbtrie_iterator) {
hbtrie_iterator_free(iterator->hbtrie_iterator);
free(iterator->hbtrie_iterator);
... | movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testq %rdi, %rdi
je 0x2c827
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c826
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2c765
callq 0x27b2d
movq 0x8(%rbx), %rdi
callq 0x3430
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2c77c
callq 0xb766
movq 0x10(%rbx), %rdi
callq ... | /ForestDB-KVStore[P]forestdb/src/iterator.cc |
fdb_iterator_seek(_fdb_iterator*, void const*, unsigned long, unsigned char, bool) | static fdb_status _fdb_iterator_seek(fdb_iterator *iterator,
const void *seek_key,
const size_t seek_keylen,
const fdb_iterator_seek_opt_t seek_pref,
bool seek_min_max)
{
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
movl $0xffffffe2, %edi # imm = 0xFFFFFFE2
testq %rbx, %rbx
je 0x2d3f6
movl %r8d, %r13d
movq %rdx, %r8
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x2d3f6
movq %rsi, %r12
movzwl 0x... | /ForestDB-KVStore[P]forestdb/src/iterator.cc |
fdb_iterator_prev | LIBFDB_API
fdb_status fdb_iterator_prev(fdb_iterator *iterator)
{
if (!iterator || !iterator->handle) {
return FDB_RESULT_INVALID_HANDLE;
}
fdb_status result = FDB_RESULT_SUCCESS;
LATENCY_STAT_START();
if (!atomic_cas_uint8_t(&iterator->handle->handle_busy, 0, 1)) {
return FDB_RESU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
testq %rdi, %rdi
je 0x2dee2
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x2dee2
movb $0x1, %dl
xorl %eax, %eax
lock
cmpxchgb %dl, 0x1d0(%rcx)
movl $0xfff... | /ForestDB-KVStore[P]forestdb/src/iterator.cc |
fdb_key_cmp(_fdb_iterator*, void*, unsigned long, void*, unsigned long) | static int _fdb_key_cmp(fdb_iterator *iterator, void *key1, size_t keylen1,
void *key2, size_t keylen2) {
int cmp;
if (iterator->handle->kvs_config.custom_cmp) {
// custom compare function for variable length key
if (iterator->handle->kvs) {
// multi KV instan... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq (%rdi), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x2e2aa
cmpq $0x0, 0x18(%rcx)
je 0x2e2cb
movq %rdi, %r13
movq %r14, (%rsp)
movzwl 0x70(%rcx), %ebp
leaq 0x8(%rsp), ... | /ForestDB-KVStore[P]forestdb/src/iterator.cc |
fdb_iterator_seek_to_max | LIBFDB_API
fdb_status fdb_iterator_seek_to_max(fdb_iterator *iterator)
{
if (!iterator || !iterator->handle) {
return FDB_RESULT_INVALID_HANDLE;
}
fdb_status ret;
LATENCY_STAT_START();
if (!iterator->hbtrie_iterator) {
ret = _fdb_iterator_seek_to_max_seq(iterator);
} else {
... | testq %rdi, %rdi
je 0x2e4b5
cmpq $0x0, (%rdi)
je 0x2e4b5
cmpq $0x0, 0x8(%rdi)
je 0x2e316
jmp 0x2dfef
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
retq
| /ForestDB-KVStore[P]forestdb/src/iterator.cc |
fdb_file_handle_close_all | void fdb_file_handle_close_all(fdb_file_handle *fhandle)
{
struct list_elem *e;
struct kvs_opened_node *node;
spin_lock(&fhandle->lock);
e = list_begin(fhandle->handles);
while (e) {
node = _get_entry(e, struct kvs_opened_node, le);
e = list_next(e);
_fdb_close(node->handle)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x3310
movq 0x8(%r14), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x2eb36
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rdi
movq 0x8(%r15), %r12
callq 0x1d2c3
movq -0x8(%r15), %rdi
callq 0x3430
movq %r14, %rdi
c... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_file_handle_parse_cmp_func | void fdb_file_handle_parse_cmp_func(fdb_file_handle *fhandle,
size_t n_func,
char **kvs_names,
fdb_custom_cmp_variable *functions,
void **user_params)
{
uint64_t i;
str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
testq %rsi, %rsi
sete %al
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
sete %dl
orb %al, %dl
testq %rcx, %rcx
sete %al
orb %dl, %al
jne 0x2ec26
movq %r8, %rbx
movq %rsi, %r12
movq %rcx, %r15
movl $0x1, %edi
movl $0x10, %es... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_file_handle_clone_cmp_func_list | void fdb_file_handle_clone_cmp_func_list(fdb_file_handle *fhandle,
struct list *cmp_func_list)
{
struct list_elem *e;
struct cmp_func_node *src, *dst;
if (fhandle->cmp_func_list || /* already exist */
!cmp_func_list) {
return;
}
fhandle->cmp... | testq %rsi, %rsi
je 0x2ecda
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x2ecd5
movq %rsi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x3270
movq %rax, 0x10(%rbx)
movq (%r14), %r15
testq %r15, %r15
je 0x2ecd5
movl $0x1, %edi
movl $0x28, %esi
callq 0x3270
movq %rax, %r14
movq -0x18(%r15),... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_file_handle_add_cmp_func | void fdb_file_handle_add_cmp_func(fdb_file_handle* fhandle,
char* kvs_name,
fdb_custom_cmp_variable cmp_func,
void* cmp_func_user_param)
{
struct cmp_func_node *node;
// create list if not exist
if (!fhand... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq 0x10(%rdi), %r15
testq %r15, %r15
jne 0x2ed11
movq %rdi, %r13
movl $0x1, %edi
movl $0x10, %esi
callq 0x3270
movq %rax, %r15
movq %rax, 0x10(%r13)
movl $0x1, %edi
movl $0x28, %esi
callq 0x327... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_cmp_check | fdb_status fdb_kvs_cmp_check(fdb_kvs_handle *handle)
{
int ori_flag;
fdb_file_handle *fhandle = handle->fhandle;
fdb_custom_cmp_variable ori_custom_cmp;
void* ori_custom_param;
struct filemgr *file = handle->file;
struct cmp_func_node *cmp_node;
struct kvs_node *kvs_node, query;
struct l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x48(%rdi), %rbp
movq 0x170(%rbp), %rdi
addq $0x38, %rdi
callq 0x3310
movq 0x170(%rbp), %rax
movb 0x28(%rax), %cl
movb %cl, 0xf(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), ... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_get_name | char* _fdb_kvs_get_name(fdb_kvs_handle *handle, struct filemgr *file)
{
struct kvs_node *node, query;
struct avl_node *a;
if (handle->kvs == NULL) {
// single KV instance mode
return NULL;
}
query.id = handle->kvs->id;
if (query.id == 0) { // default KV instance
return ... | movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x2f345
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2f358
movq %rsi, %rbx
movq 0x170(%rsi), %rdi
addq $0x38, %rdi
callq 0x3310
movq 0x170(%rbx), %rax
movq 0x20(%rax), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x1c0(%rip), %rdx ... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_find_cmp_name(_fdb_kvs_handle*, char*, int (**)(void*, unsigned long, void*, unsigned long, void*), void**) | void fdb_kvs_find_cmp_name(fdb_kvs_handle *handle,
char *kvs_name,
fdb_custom_cmp_variable* cmp_func_out,
void** user_param_out)
{
fdb_file_handle *fhandle;
struct list_elem *e;
struct cmp_func_node *cmp_node;
fhandle = ha... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2f3d3
movq (%rax), %r13
testq %r13, %r13
je 0x2f3d3
movq %rsi, %r15
leaq 0xdedc(%rip), %r12 # 0x3d26f
testq %r15, %r15
je 0x2f3b5
movq %r15, %rdi
movq %r12, %rsi
... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_find_cmp_chunk | void fdb_kvs_find_cmp_chunk(void *chunk,
void *aux,
hbtrie_cmp_func** cmp_func_out,
void** user_param_out)
{
fdb_kvs_id_t kv_id;
struct hbtrie *trie = (struct hbtrie *)aux;
struct btreeblk_handle *bhandle;
struct filemgr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x10(%rsi), %rcx
movq 0x38(%rcx), %r12
movq 0x170(%r12), %rcx
cmpb $0x0, 0x28(%rcx)
je 0x2f4a7
movq %rdi, %rax
movzbl (%rsi), %edi
movq %rsp, %r15
movq %rax, %rsi
movq %r15, %rdx
callq 0x19358
movq (%r15), %rax
testq %rax,... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_header_reset_all_stats | void fdb_kvs_header_reset_all_stats(struct filemgr *file)
{
struct avl_node *a;
struct kvs_node *node;
struct kvs_header *kv_header = file->kv_header;
spin_lock(&kv_header->lock);
a = avl_first(kv_header->idx_id);
while (a) {
node = _get_entry(a, struct kvs_node, avl_id);
a = av... | pushq %r14
pushq %rbx
pushq %rax
movq 0x170(%rdi), %r14
leaq 0x38(%r14), %rbx
movq %rbx, %rdi
callq 0x3310
movq 0x20(%r14), %rdi
callq 0x61d0
testq %rax, %rax
je 0x2f7b2
movq %rax, %r14
movq %r14, %rdi
callq 0x61f4
xorps %xmm0, %xmm0
movups %xmm0, -0x50(%r14)
movups %xmm0, -0x40(%r14)
movups %xmm0, -0x30(%r14)
movq $0x... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_header_copy | void fdb_kvs_header_copy(fdb_kvs_handle *handle,
struct filemgr *new_file,
struct docio_handle *new_dhandle,
uint64_t *new_file_kv_info_offset,
bool create_new)
{
struct avl_node *a, *aa;
struct kvs_node *node_ol... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
testl %r8d, %r8d
je 0x2f876
movq %rcx, %r12
movq %rdx, %r13
movq %rsp, %r15
movq %r15, %rdi
callq 0x2f6a4
movq (%r15), %r15
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rsi
movq 0x1a0(%rbx), %rdx... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_header_read | void fdb_kvs_header_read(struct kvs_header *kv_header,
struct docio_handle *dhandle,
uint64_t kv_info_offset,
uint64_t version,
bool only_seq_nums)
{
int64_t offset;
struct docio_object doc;
memset(&doc, 0, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq $0x0, 0x30(%rdx)
movq %rsi, %rdi
movq %rbx, %rsi
movl $0x... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_header_import | void _fdb_kvs_header_import(struct kvs_header *kv_header,
void *data, size_t len, uint64_t version,
bool only_seq_nums)
{
uint64_t i, offset = 0;
uint16_t name_len, _name_len;
uint64_t n_kv, _n_kv, kv_id, _kv_id, flags, _flags;
uint64_t _nlivenodes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0x4(%rsp)
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %r13
movq 0x8(%rsi), %r15
bswapq %r15
addq $0x38, %rdi
movq %rdi, 0x20(%rsp)
callq 0x3310
movq %r12, 0x18(%rsp)
movq %r15, (%r12)... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_get_snap_info | fdb_status _fdb_kvs_get_snap_info(void *data, uint64_t version,
fdb_snapshot_info_t *snap_info)
{
int i, offset = 0, sizeof_skipped_segments;
uint16_t name_len, _name_len;
int64_t n_kv, _n_kv;
bool is_deltasize;
fdb_seqnum_t _seqnum;
// Version control
if (!... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x36d18
movq (%rbx), %r13
bswapq %r13
movq %r13, %rbp
incq %rbp
je 0x300aa
movl %eax, %r12d
movq %rbp, %rdi
shlq $0x4, %rdi
callq 0x34b0
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x30096
mo... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_get_kvs_seqnum | LIBFDB_API
fdb_status fdb_get_kvs_seqnum(fdb_kvs_handle *handle, fdb_seqnum_t *seqnum)
{
if (!handle) {
return FDB_RESULT_INVALID_HANDLE;
}
if (!seqnum) {
return FDB_RESULT_INVALID_ARGS;
}
if (!atomic_cas_uint8_t(&handle->handle_busy, 0, 1)) {
return FDB_RESULT_HANDLE_BUSY;... | testq %rdi, %rdi
je 0x303f5
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rsi, %rsi
je 0x303fc
movq %rdi, %rbx
movb $0x1, %cl
xorl %eax, %eax
lock
cmpxchgb %cl, 0x1d0(%rdi)
movl $0xffffffd9, %ecx # imm = 0xFFFFFFD9
jne 0x3045c
cmpq $0x0, 0x1a8(%rbx)
je 0x30403
movq 0x1b8(%rbx), %rax
movq %rax, (%r14)
jm... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_set_seqnum | void fdb_kvs_set_seqnum(struct filemgr *file,
fdb_kvs_id_t id,
fdb_seqnum_t seqnum)
{
struct kvs_header *kv_header = file->kv_header;
struct kvs_node query, *node;
struct avl_node *a;
if (id == 0) {
// default KV instance
filemgr_set... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
je 0x304cf
movq %rsi, %r14
movq 0x170(%rdi), %r12
leaq 0x38(%r12), %r15
movq %r15, %rdi
callq 0x3310
leaq 0xc0(%rsp), %rsi
movq %r14, -0xb0(%rsi)
movq 0x20(%r12), %rdi
leaq -0xfcd(%rip), %rdx # 0x2f4df
callq 0x625e
movq %... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_open | LIBFDB_API
fdb_status fdb_kvs_open(fdb_file_handle *fhandle,
fdb_kvs_handle **ptr_handle,
const char *kvs_name,
fdb_kvs_config *kvs_config)
{
fdb_kvs_handle *handle;
fdb_config config;
fdb_status fs;
fdb_kvs_handle *root_handle;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
testq %rdi, %rdi
je 0x3114b
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0x3114b
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
leaq 0x70(%r15), %rsi
lea... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_close | fdb_status _fdb_kvs_close(fdb_kvs_handle *handle)
{
fdb_kvs_handle *root_handle = handle->fhandle->root;
fdb_status fs;
if (handle->node) {
spin_lock(&root_handle->fhandle->lock);
list_remove(root_handle->fhandle->handles, &handle->node->le);
spin_unlock(&root_handle->fhandle->lock)... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x1d8(%rdi)
je 0x31268
movq 0x28(%rbx), %rax
movq (%rax), %r14
movq 0x28(%r14), %rdi
addq $0x20, %rdi
callq 0x3310
movq 0x28(%r14), %rax
movq 0x8(%rax), %rdi
movq 0x1d8(%rbx), %rsi
addq $0x8, %rsi
callq 0x326c0
movq 0x28(%r14), %rdi
addq $0x20, %rdi
callq 0x30... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
fdb_kvs_close_all | fdb_status fdb_kvs_close_all(fdb_kvs_handle *root_handle)
{
fdb_status fs;
struct list_elem *e;
struct kvs_opened_node *node;
spin_lock(&root_handle->fhandle->lock);
e = list_begin(root_handle->fhandle->handles);
while (e) {
node = _get_entry(e, struct kvs_opened_node, le);
e = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
addq $0x20, %rdi
callq 0x3310
movq 0x28(%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x312fd
movq 0x28(%rbx), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x326c0
movq %rax, %r15
movq -0x8(%r14), %r... | /ForestDB-KVStore[P]forestdb/src/kv_instance.cc |
list_remove_reverse | struct list_elem *list_remove_reverse(struct list *list, struct list_elem *e)
{
IFDEF_LOCK( spin_lock(&list->lock); );
if (e) {
// if not NULL
if (e->next) e->next->prev = e->prev;
if (e->prev) e->prev->next = e->next;
if (list->head == e) list->head = e->next;
if (list-... | testq %rsi, %rsi
je 0x3272b
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x3270f
movq %rax, (%rcx)
testq %rax, %rax
je 0x32718
movq %rcx, 0x8(%rax)
cmpq %rsi, (%rdi)
jne 0x32724
movq 0x8(%rsi), %rcx
movq %rcx, (%rdi)
cmpq %rsi, 0x8(%rdi)
je 0x3272e
retq
xorl %eax, %eax
retq
movq %rax, 0x8(%rdi)
retq
| /ForestDB-KVStore[P]forestdb/src/list.cc |
printISOTime(char*, unsigned long) | void printISOTime(char* buffer, size_t buffer_len) {
struct tm* tm_now;
time_t rawtime;
time(&rawtime);
tm_now = localtime(&rawtime);
// 2017-06-22T10:00:00
size_t time_len = strftime(buffer, buffer_len,
"%Y-%m-%dT%H:%M:%S", tm_now);
// Add milliseconds
t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3370
movq %r14, %rdi
callq 0x32c0
movq %rax, %r14
leaq 0xfbd3(%rip), %rdx # 0x4239b
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rcx
callq 0x32f0
movq %rax, %r15
leaq 0x18(%rsp)... | /ForestDB-KVStore[P]forestdb/src/log_message.cc |
fdb_gather_stale_blocks(_fdb_kvs_handle*, unsigned long, unsigned long, unsigned long, unsigned long, list_elem*, bool) | void fdb_gather_stale_blocks(fdb_kvs_handle *handle,
filemgr_header_revnum_t revnum,
bid_t prev_hdr,
uint64_t kv_info_offset,
fdb_seqnum_t seqnum,
struct list_elem *e_last,
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
cmpq $0x0, 0x280(%rdi)
je 0x33043
movq %rdx, %r12
movq %r14, -0x50(%rbp)
movb 0x10(%rbp), %al
movb %al, -0x29(%rbp)
movq %rsi, %r15
leaq -0xe8(%rbp), %rdx
xorl %esi, %esi
movq %r9, -0... | /ForestDB-KVStore[P]forestdb/src/staleblock.cc |
insert_n_merge(avl_tree*, unsigned long, unsigned int) | static void _insert_n_merge(struct avl_tree *tree,
uint64_t item_pos,
uint32_t item_len)
{
struct stale_data query, *item;
struct avl_node *avl;
// retrieve the tree first
query.pos = item_pos;
avl = avl_search(tree, &query.avl, _reusable_offs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %rsi
movq %r15, -0x10(%rsi)
leaq 0xfb(%rip), %rdx # 0x339b6
callq 0x625e
testq %rax, %rax
je 0x338d6
movq %rax, %r14
addq $-0x10, %r14
cmpl %ebp, -0x8(%rax)
jae 0x33901
movl %e... | /ForestDB-KVStore[P]forestdb/src/staleblock.cc |
sb_bmp_fetch_doc | fdb_status sb_bmp_fetch_doc(fdb_kvs_handle *handle)
{
// == read bitmap from system docs ==
size_t i;
uint64_t num_docs;
int64_t r_offset;
char doc_key[64];
struct superblock *sb = handle->file->sb;
struct sb_rsv_bmp *rsv = NULL;
// skip if previous bitmap exists OR
// there is no b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x48(%rdi), %rax
movq 0x198(%rax), %r13
movq 0x20(%r13), %rax
xorl %ebp, %ebp
testq %rax, %rax
jne 0x33ee3
movq 0x18(%r13), %rax
testq %rax, %rax
je 0x33ee3
movq %rdi, %r14
leaq 0xc0(%r13), %rbx
movq %rbx, %rdi
callq 0x3310
movq 0x2... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_sync_circular | fdb_status sb_sync_circular(fdb_kvs_handle *handle)
{
uint64_t sb_revnum;
fdb_status fs;
sb_revnum = atomic_get_uint64_t(&handle->file->sb->revnum);
fs = sb_write(handle->file,
sb_revnum % handle->file->sb->config->num_sb,
&handle->log_callback);
return fs;
} | movq 0x48(%rdi), %rax
movq 0x198(%rax), %rax
movq 0x8(%rax), %rax
movq 0x48(%rdi), %rcx
movq 0x198(%rcx), %rdx
movq (%rdx), %rdx
movzbl (%rdx), %esi
xorl %edx, %edx
divq %rsi
leaq 0x168(%rdi), %rax
movq %rcx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
jmp 0x34325
| /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_write | fdb_status sb_write(struct filemgr *file, size_t sb_no,
err_log_callback * log_callback)
{
int r;
int real_blocksize = file->blocksize;
int blocksize = file->blocksize - BLK_MARKER_SIZE;
void* buf_aligned = nullptr;
malloc_align(buf_aligned, FDB_SECTOR_SIZE, file->blocksize);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movl 0x10(%rdi), %r12d
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x200, %esi # imm = 0x200
movq %r14, %rdi
movq %r12, %rdx
callq 0x31e0
testl %eax, %... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_check_block_reusing | sb_decision_t sb_check_block_reusing(fdb_kvs_handle *handle)
{
// start block reusing when
// 1) if blocks are not reused yet in this file:
// when file size becomes larger than the threshold
// 2) otherwise:
// when # free blocks decreases under the threshold
uint64_t live_datasize;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x48(%rdi), %rax
movq 0x198(%rax), %r15
xorl %ebx, %ebx
testq %r15, %r15
je 0x348af
movb 0x108(%rax), %al
testb %al, %al
jne 0x348af
movq %rdi, %r14
movq 0x48(%rdi), %rax
movq 0x110(%rax), %rcx
movq 0x48(%rcx), %r12
leaq -0x64(%r12), %rcx
cmpq $-0x63, %rcx
jb ... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_reserve_next_reusable_blocks | bool sb_reserve_next_reusable_blocks(fdb_kvs_handle *handle)
{
size_t i;
uint64_t num_blocks, bmp_size_byte;
stale_header_info sheader;
reusable_block_list blist;
struct superblock *sb = handle->file->sb;
struct sb_rsv_bmp *rsv = NULL;
if (sb->rsv_bmp) {
// next bitmap already recla... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x48(%rdi), %rax
movq 0x198(%rax), %r14
cmpq $0x0, 0x88(%r14)
je 0x3504a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
callq 0x322a5
cmpq $-0x1, %rd... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_return_reusable_blocks | void sb_return_reusable_blocks(fdb_kvs_handle *handle)
{
uint64_t node_id;
bid_t cur;
struct superblock *sb = handle->file->sb;
struct sb_rsv_bmp *rsv;
struct avl_node *a;
struct bmp_idx_node *item, query;
if (!sb) {
// we don't need to do this.
return;
}
// re-inse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq 0x48(%rdi), %rax
movq 0x198(%rax), %rbx
testq %rbx, %rbx
je 0x35407
movq 0x18(%rbx), %r15
movq 0x90(%rbx), %r13
cmpq %r15, %r13
jae 0x3529d
leaq 0x50(%rbx), %r14
leaq 0x1d731(%rip), %r12 # 0x528f0
movq 0x20... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_bmp_mask_init | void sb_bmp_mask_init()
{
// preset masks to speed up bitmap set/clear operations
size_t i, pos, len;
for (i=0; i<8; ++i) {
bmp_basic_mask[i] = 0x1 << (7-i);
}
for (pos=0; pos<8; ++pos) {
for (len=0; len<9; ++len) {
bmp_2d_mask[pos][len] = 0x0;
if (len != 0 &&... | movabsq $0x102040810204080, %rax # imm = 0x102040810204080
movq %rax, 0x1d4a9(%rip) # 0x528f0
xorl %eax, %eax
leaq 0x1d4b0(%rip), %rcx # 0x52900
leaq 0x1d499(%rip), %rdx # 0x528f0
leaq (%rax,%rax,8), %rsi
addq %rcx, %rsi
xorl %edi, %edi
movb $0x0, (%rdi,%rsi)
testq %rdi, %rdi
setne %r8b
leaq (%rdi,%rax), %r... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_free(superblock*) | static void _sb_free(struct superblock *sb)
{
if (sb->rsv_bmp) {
atomic_store_uint32_t(&sb->rsv_bmp->status, SB_RSV_VOID);
_free_bmp_idx(&sb->rsv_bmp->bmp_idx);
_rsv_free(sb->rsv_bmp);
free(sb->rsv_bmp);
}
_free_bmp_idx(&sb->bmp_idx);
free(sb->bmp);
free(sb->bmp_prev... | pushq %rbx
movq %rdi, %rbx
movq 0x88(%rdi), %rax
testq %rax, %rax
je 0x366ec
xorl %ecx, %ecx
xchgl %ecx, 0x60(%rax)
movq 0x88(%rbx), %rdi
addq $0x18, %rdi
callq 0x34a70
movq 0x88(%rbx), %rdi
callq 0x35416
movq 0x88(%rbx), %rdi
callq 0x3430
leaq 0x50(%rbx), %rdi
callq 0x34a70
movq 0x20(%rbx), %rdi
callq 0x3430
movq 0x48... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
sb_init | fdb_status sb_init(struct filemgr *file, struct sb_config sconfig,
err_log_callback * log_callback)
{
size_t i;
bid_t sb_bid;
fdb_status fs;
// exit if superblock already exists.
if (file->sb) {
return FDB_RESULT_SUCCESS;
}
// no data should be written in the file... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
cmpq $0x0, 0x198(%rdi)
jne 0x367ad
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movl $0xffffffd2, %ebp # imm = 0xFFFFFFD2
testq %rax, %rax
je 0x367b8
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movl %esi, %r... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
bmp_idx_cmp(avl_node*, avl_node*, void*) | INLINE int _bmp_idx_cmp(struct avl_node *a, struct avl_node *b, void *aux)
{
struct bmp_idx_node *aa, *bb;
aa = _get_entry(a, struct bmp_idx_node, avl);
bb = _get_entry(b, struct bmp_idx_node, avl);
#ifdef __BIT_CMP
return _CMP_U64(aa->id, bb->id);
#else
if (aa->id < bb->id) {
return -1;
... | movq -0x8(%rdi), %rcx
movq -0x8(%rsi), %rax
movq %rax, %rdx
xorq %rcx, %rdx
movq %rdx, %rsi
shrq $0x3f, %rsi
leal -0x1(%rsi), %edi
xorl %r8d, %r8d
subq %rax, %rcx
setne %r8b
shrq $0x20, %rcx
orl %r8d, %ecx
andl %edi, %ecx
shrq $0x20, %rdx
movl $0x80000000, %edi # imm = 0x80000000
andl %edi, %edx
orl %esi, %edx
sh... | /ForestDB-KVStore[P]forestdb/src/superblock.cc |
wal_init | fdb_status wal_init(struct filemgr *file, int nbucket)
{
size_t num_shards;
atomic_init_uint8_t(&file->wal->isPopulated, 0);
file->wal->flag = WAL_FLAG_INITIALIZED;
atomic_init_uint32_t(&file->wal->size, 0);
atomic_init_uint32_t(&file->wal->num_flushable, 0);
atomic_init_uint64_t(&file->wal->dat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rax
xorl %ecx, %ecx
xchgb %cl, 0x1(%rax)
movq 0x48(%rdi), %rax
movb $0x1, (%rax)
xorl %ecx, %ecx
xchgl %ecx, 0x4(%rax)
movq 0x48(%rdi), %rax
xorl %ecx, %ecx
xchgl %ecx, 0x8(%rax)
movq 0x48(%rdi), %rax
xorl %ec... | /ForestDB-KVStore[P]forestdb/src/wal.cc |
wal_snapshot_open | fdb_status wal_snapshot_open(struct filemgr *file,
fdb_txn *txn,
fdb_kvs_id_t kv_id,
fdb_seqnum_t seqnum,
_fdb_key_cmp_info *key_cmp_info,
struct snap_handle **shandle)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq 0x48(%rdi), %r15
leaq 0x60(%r15), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3310
leaq 0x18(%rsp), %rsi
movq $0x0, 0x20(%rsi)
leaq 0x1(%r14),... | /ForestDB-KVStore[P]forestdb/src/wal.cc |
wal_release_flushed_items | fdb_status wal_release_flushed_items(struct filemgr *file,
union wal_flush_items *flush_items)
{
struct wal_item *item;
size_t shard_num;
_wal_snap_mark_flushed(file->wal); // Read-write barrier: items are in trie
if (_wal_are_items_sorted(flush_items)) {
s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %r12
leaq 0x60(%r12), %r15
movq %r15, %rdi
callq 0x3310
addq $0x50, %r12
movq %r12, %rdi
callq 0x61d0
testq %rax, %rax
je 0x3809c
movb $0x1, 0x32(%rax)
movq %rax, %rdi
callq 0x61f4
jmp 0x38089
movq %r15, %rdi
callq 0... | /ForestDB-KVStore[P]forestdb/src/wal.cc |
wal_flush(filemgr*, void*, fdb_status (*)(void*, wal_item*, avl_tree*, avl_tree*), unsigned long (*)(void*, wal_item*), void (*)(void*, avl_tree*, avl_tree*), void (*)(filemgr*, avl_tree*), wal_flush_items*, bool) | static fdb_status _wal_flush(struct filemgr *file,
void *dbhandle,
wal_flush_func *flush_func,
wal_get_old_offset_func *get_old_offset,
wal_flush_seq_purge_func *seq_purge_func,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, 0x58(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r12
movq 0xc0(%rsp), %rbp
movq 0x48(%rdi), %rax
movq 0x48(%rax), %rax
movq %rax, 0x40(%rsp)
callq 0x16776
movl %eax, %ebx
testb %... | /ForestDB-KVStore[P]forestdb/src/wal.cc |
wal_snapshot_clone | fdb_status wal_snapshot_clone(struct snap_handle *shandle_in,
struct snap_handle **shandle_out,
fdb_seqnum_t seqnum)
{
if (seqnum == FDB_SNAPSHOT_INMEM ||
shandle_in->seqnum == seqnum) {
atomic_incr_uint16_t(&shandle_in->ref_cnt_kvs);
... | cmpq $-0x1, %rdx
je 0x38724
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rdx, 0x40(%rdi)
jne 0x3872e
lock incw 0x30(%rdi)
movq %rdi, (%rsi)
xorl %eax, %eax
retq
| /ForestDB-KVStore[P]forestdb/src/wal.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.