int si_nodeopen(sinode *n, sr *r, sischeme *scheme, sspath *path,
sdsnapshotnode *sn)
{
int rc = ss_fileopen(&n->file, path->path);
if (ssunlikely(rc == -1)) {
sr_malfunction(r->e, "db file '%s' open error: %s",
ss_pathof(&n->file.path),
strerror(errno));
return -1;
}
rc = ss_fileseek(&n->file, n->file.size);
if (ssunlikely(rc == -1)) {
sr_malfunction(r->e, "db file '%s' seek error: %s",
ss_pathof(&n->file.path),
strerror(errno));
goto error;
}
int in_memory = 0;
if (scheme->storage == SI_SIN_MEMORY)
in_memory = 1;
rc = si_noderecover(n, r, sn, in_memory);
if (ssunlikely(rc == -1))
goto error;
if (scheme->mmap) {
rc = si_nodemap(n, r);
if (ssunlikely(rc == -1))
goto error;
}
return 0;
error:
si_nodeclose(n, r, 0);
return -1;
}
int si_nodeopen(sinode *n, sr *r, sischeme *scheme, sspath *path)
{
int rc = ss_fileopen(&n->file, path->path);
if (ssunlikely(rc == -1)) {
sr_malfunction(r->e, "db file '%s' open error: %s",
ss_pathof(&n->file.path),
strerror(errno));
return -1;
}
rc = ss_fileseek(&n->file, n->file.size);
if (ssunlikely(rc == -1)) {
sr_malfunction(r->e, "db file '%s' seek error: %s",
ss_pathof(&n->file.path),
strerror(errno));
goto error;
}
rc = si_noderecover(n, r, scheme->in_memory);
if (ssunlikely(rc == -1))
goto error;
if (scheme->mmap) {
rc = si_nodemap(n, r);
if (ssunlikely(rc == -1))
goto error;
}
return 0;
error:
si_nodeclose(n, r);
return -1;
}
int si_nodecreate(sinode *n, sr *r, sischeme *scheme, sdid *id,
sdindex *i,
sdbuild *build)
{
si_branchset(&n->self, i);
sspath path;
ss_pathAB(&path, scheme->path, id->parent, id->id, ".db.incomplete");
int rc = ss_filenew(&n->file, path.path);
if (ssunlikely(rc == -1)) {
sr_malfunction(r->e, "db file '%s' create error: %s",
path.path, strerror(errno));
return -1;
}
rc = sd_commit(build, r, &n->self.index, &n->file);
if (ssunlikely(rc == -1))
return -1;
if (scheme->mmap) {
rc = si_nodemap(n, r);
if (ssunlikely(rc == -1))
return -1;
}
n->branch = &n->self;
n->branch_count++;
return 0;
}
sinode *si_bootstrap(si *i, uint64_t parent)
{
sr *r = i->r;
/* create node */
sinode *n = si_nodenew(r);
if (ssunlikely(n == NULL))
return NULL;
sdid id = {
.parent = parent,
.flags = 0,
.id = sr_seq(r->seq, SR_NSNNEXT)
};
int rc;
rc = si_nodecreate(n, r, i->scheme, &id);
if (ssunlikely(rc == -1))
goto e0;
n->branch = &n->self;
n->branch_count++;
/* in-memory mode support */
ssblob *blob = NULL;
if (i->scheme->storage == SI_SIN_MEMORY) {
blob = &n->self.copy;
rc = ss_blobensure(blob, 4096);
if (ssunlikely(rc == -1))
goto e0;
n->in_memory = 1;
}
/* create index with one empty page */
sdindex index;
sd_indexinit(&index);
rc = sd_indexbegin(&index, r);
if (ssunlikely(rc == -1))
goto e0;
ssqf f, *qf = NULL;
ss_qfinit(&f);
sdbuild build;
sd_buildinit(&build);
rc = sd_buildbegin(&build, r,
i->scheme->node_page_checksum,
i->scheme->compression_key,
i->scheme->compression,
i->scheme->compression_if);
if (ssunlikely(rc == -1))
goto e1;
sd_buildend(&build, r);
rc = sd_indexadd(&index, r, &build, sizeof(sdseal));
if (ssunlikely(rc == -1))
goto e1;
/* write seal */
uint64_t seal = n->file.size;
rc = sd_writeseal(r, &n->file, blob);
if (ssunlikely(rc == -1))
goto e1;
/* write page */
rc = sd_writepage(r, &n->file, blob, &build);
if (ssunlikely(rc == -1))
goto e1;
/* amqf */
if (i->scheme->amqf) {
rc = ss_qfensure(&f, r->a, 0);
if (ssunlikely(rc == -1))
goto e1;
qf = &f;
}
rc = sd_indexcommit(&index, r, &id, qf, n->file.size);
if (ssunlikely(rc == -1))
goto e1;
ss_qffree(&f, r->a);
/* write index */
rc = sd_writeindex(r, &n->file, blob, &index);
if (ssunlikely(rc == -1))
goto e1;
/* close seal */
rc = sd_seal(r, &n->file, blob, &index, seal);
if (ssunlikely(rc == -1))
goto e1;
if (blob) {
rc = ss_blobfit(blob);
if (ssunlikely(rc == -1))
goto e1;
}
if (i->scheme->mmap) {
rc = si_nodemap(n, r);
if (ssunlikely(rc == -1))
goto e1;
}
si_branchset(&n->self, &index);
sd_buildcommit(&build, r);
sd_buildfree(&build, r);
return n;
e1:
ss_qffree(&f, r->a);
sd_indexfree(&index, r);
sd_buildfree(&build, r);
e0:
si_nodefree(n, r, 0);
return NULL;
}
static inline int
si_deploy(si *i, sr *r, int create_directory)
{
/* create directory */
int rc;
if (sslikely(create_directory)) {
rc = ss_vfsmkdir(r->vfs, i->scheme->path, 0755);
if (ssunlikely(rc == -1)) {
sr_malfunction(r->e, "directory '%s' create error: %s",
i->scheme->path, strerror(errno));
return -1;
}
}
/* create scheme file */
rc = si_schemedeploy(i->scheme, r);
if (ssunlikely(rc == -1)) {
sr_malfunction_set(r->e);
return -1;
}
/* create initial node */
sinode *n = si_bootstrap(i, 0);
if (ssunlikely(n == NULL))
return -1;
SS_INJECTION(r->i, SS_INJECTION_SI_RECOVER_0,
si_nodefree(n, r, 0);
sr_malfunction(r->e, "%s", "error injection");
return -1);
rc = si_nodecomplete(n, r, i->scheme);
if (ssunlikely(rc == -1)) {
si_nodefree(n, r, 1);
return -1;
}
si_insert(i, n);
si_plannerupdate(&i->p, SI_COMPACT|SI_BRANCH|SI_TEMP, n);
i->size = si_nodesize(n);
return 1;
}
static inline int
si_split(si *index, sdc *c, ssbuf *result,
sinode *parent,
ssiter *i,
uint64_t size_node,
uint64_t size_stream,
uint32_t stream,
uint64_t vlsn)
{
sr *r = &index->r;
uint32_t timestamp = ss_timestamp();
int rc;
sdmergeconf mergeconf = {
.stream = stream,
.size_stream = size_stream,
.size_node = size_node,
.size_page = index->scheme.compaction.node_page_size,
.checksum = index->scheme.compaction.node_page_checksum,
.expire = index->scheme.expire,
.timestamp = timestamp,
.compression = index->scheme.compression,
.compression_if = index->scheme.compression_if,
.direct_io = index->scheme.direct_io,
.direct_io_page_size = index->scheme.direct_io_page_size,
.vlsn = vlsn
};
sinode *n = NULL;
sdmerge merge;
rc = sd_mergeinit(&merge, r, i, &c->build, &c->build_index,
&c->upsert, &mergeconf);
if (ssunlikely(rc == -1))
return -1;
while ((rc = sd_merge(&merge)) > 0)
{
/* create new node */
uint64_t id = sr_seq(index->r.seq, SR_NSNNEXT);
n = si_nodenew(r, id, parent->id);
if (ssunlikely(n == NULL))
goto error;
rc = si_nodecreate(n, r, &index->scheme);
if (ssunlikely(rc == -1))
goto error;
/* write pages */
uint64_t offset;
offset = sd_iosize(&c->io, &n->file);
while ((rc = sd_mergepage(&merge, offset)) == 1) {
rc = sd_writepage(r, &n->file, &c->io, merge.build);
if (ssunlikely(rc == -1))
goto error;
offset = sd_iosize(&c->io, &n->file);
}
if (ssunlikely(rc == -1))
goto error;
offset = sd_iosize(&c->io, &n->file);
rc = sd_mergeend(&merge, offset);
if (ssunlikely(rc == -1))
goto error;
/* write index */
rc = sd_writeindex(r, &n->file, &c->io, &merge.index);
if (ssunlikely(rc == -1))
goto error;
/* mmap mode */
if (index->scheme.mmap) {
rc = si_nodemap(n, r);
if (ssunlikely(rc == -1))
goto error;
}
/* add node to the list */
rc = ss_bufadd(result, index->r.a, &n, sizeof(sinode*));
if (ssunlikely(rc == -1)) {
sr_oom_malfunction(index->r.e);
goto error;
}
n->index = merge.index;
}
if (ssunlikely(rc == -1))
goto error;
return 0;
error:
if (n)
si_nodefree(n, r, 0);
sd_mergefree(&merge);
si_splitfree(result, r);
return -1;
}
static int
si_merge(si *index, sdc *c, sinode *node,
uint64_t vlsn,
ssiter *stream,
uint64_t size_stream,
uint32_t n_stream)
{
sr *r = &index->r;
ssbuf *result = &c->a;
ssiter i;
/* begin compaction.
*
* Split merge stream into a number of
* a new nodes.
*/
int rc;
rc = si_split(index, c, result,
node, stream,
index->scheme.compaction.node_size,
size_stream,
n_stream,
vlsn);
if (ssunlikely(rc == -1))
return -1;
SS_INJECTION(r->i, SS_INJECTION_SI_COMPACTION_0,
si_splitfree(result, r);
sr_malfunction(r->e, "%s", "error injection");
return -1);
/* mask removal of a single node as a
* single node update */
int count = ss_bufused(result) / sizeof(sinode*);
int count_index;
si_lock(index);
count_index = index->n;
si_unlock(index);
sinode *n;
if (ssunlikely(count == 0 && count_index == 1))
{
n = si_bootstrap(index, node->id);
if (ssunlikely(n == NULL))
return -1;
rc = ss_bufadd(result, r->a, &n, sizeof(sinode*));
if (ssunlikely(rc == -1)) {
sr_oom_malfunction(r->e);
si_nodefree(n, r, 1);
return -1;
}
count++;
}
/* commit compaction changes */
si_lock(index);
svindex *j = si_nodeindex(node);
si_plannerremove(&index->p, node);
si_nodesplit(node);
switch (count) {
case 0: /* delete */
si_remove(index, node);
si_redistribute_index(index, r, c, node);
break;
case 1: /* self update */
n = *(sinode**)result->s;
n->i0 = *j;
n->used = j->used;
si_nodelock(n);
si_replace(index, node, n);
si_plannerupdate(&index->p, n);
break;
default: /* split */
rc = si_redistribute(index, r, c, node, result);
if (ssunlikely(rc == -1)) {
si_unlock(index);
si_splitfree(result, r);
return -1;
}
ss_iterinit(ss_bufiterref, &i);
ss_iteropen(ss_bufiterref, &i, result, sizeof(sinode*));
n = ss_iterof(ss_bufiterref, &i);
n->used = n->i0.used;
si_nodelock(n);
si_replace(index, node, n);
si_plannerupdate(&index->p, n);
for (ss_iternext(ss_bufiterref, &i); ss_iterhas(ss_bufiterref, &i);
ss_iternext(ss_bufiterref, &i)) {
n = ss_iterof(ss_bufiterref, &i);
n->used = n->i0.used;
si_nodelock(n);
si_insert(index, n);
si_plannerupdate(&index->p, n);
}
break;
}
sv_indexinit(j);
si_unlock(index);
/* compaction completion */
/* seal nodes */
ss_iterinit(ss_bufiterref, &i);
ss_iteropen(ss_bufiterref, &i, result, sizeof(sinode*));
while (ss_iterhas(ss_bufiterref, &i))
{
n = ss_iterof(ss_bufiterref, &i);
if (index->scheme.sync) {
rc = ss_filesync(&n->file);
if (ssunlikely(rc == -1)) {
sr_malfunction(r->e, "db file '%s' sync error: %s",
ss_pathof(&n->file.path),
strerror(errno));
return -1;
}
}
rc = si_noderename_seal(n, r, &index->scheme);
if (ssunlikely(rc == -1)) {
si_nodefree(node, r, 0);
return -1;
}
SS_INJECTION(r->i, SS_INJECTION_SI_COMPACTION_3,
si_nodefree(node, r, 0);
sr_malfunction(r->e, "%s", "error injection");
return -1);
ss_iternext(ss_bufiterref, &i);
}
SS_INJECTION(r->i, SS_INJECTION_SI_COMPACTION_1,
si_nodefree(node, r, 0);
sr_malfunction(r->e, "%s", "error injection");
return -1);
/* gc node */
uint16_t refs = si_noderefof(node);
if (sslikely(refs == 0)) {
rc = si_nodefree(node, r, 1);
if (ssunlikely(rc == -1))
return -1;
} else {
/* node concurrently being read, schedule for
* delayed removal */
si_nodegc(node, r, &index->scheme);
si_lock(index);
ss_listappend(&index->gc, &node->gc);
index->gc_count++;
si_unlock(index);
}
SS_INJECTION(r->i, SS_INJECTION_SI_COMPACTION_2,
sr_malfunction(r->e, "%s", "error injection");
return -1);
/* complete new nodes */
ss_iterinit(ss_bufiterref, &i);
ss_iteropen(ss_bufiterref, &i, result, sizeof(sinode*));
while (ss_iterhas(ss_bufiterref, &i))
{
n = ss_iterof(ss_bufiterref, &i);
rc = si_noderename_complete(n, r, &index->scheme);
if (ssunlikely(rc == -1))
return -1;
SS_INJECTION(r->i, SS_INJECTION_SI_COMPACTION_4,
sr_malfunction(r->e, "%s", "error injection");
return -1);
ss_iternext(ss_bufiterref, &i);
}
/* unlock */
si_lock(index);
ss_iterinit(ss_bufiterref, &i);
ss_iteropen(ss_bufiterref, &i, result, sizeof(sinode*));
while (ss_iterhas(ss_bufiterref, &i))
{
n = ss_iterof(ss_bufiterref, &i);
si_nodeunlock(n);
ss_iternext(ss_bufiterref, &i);
}
si_unlock(index);
return 0;
}