static inline int
si_noderecover_snapshot(sinode *n, sr *r, sdsnapshotnode *sn)
{
char *p = (char*)sn + sizeof(sdsnapshotnode);
uint32_t i = 0;
int first = 1;
int rc;
while (i < sn->branch_count) {
sdindexheader *h = (sdindexheader*)p;
sibranch *b;
if (first) {
b = &n->self;
} else {
b = si_branchnew(r);
if (ssunlikely(b == NULL))
return -1;
}
sdindex index;
sd_indexinit(&index);
rc = sd_indexcopy(&index, r, h);
if (ssunlikely(rc == -1))
return -1;
si_branchset(b, &index);
b->next = n->branch;
n->branch = b;
n->branch_count++;
first = 0;
p += sd_indexsize_ext(h);
i++;
}
return 0;
}
static inline int
si_noderecover(sinode *n, sr *r, sdsnapshotnode *sn, int in_memory)
{
/* fast recover from snapshot file */
if (sn) {
n->temperature_reads = sn->temperature_reads;
if (! in_memory)
return si_noderecover_snapshot(n, r, sn);
}
/* recover branches */
ssiter i;
ss_iterinit(sd_recover, &i);
ss_iteropen(sd_recover, &i, r, &n->file);
int first = 1;
int rc;
while (ss_iteratorhas(&i))
{
sdindexheader *h = ss_iteratorof(&i);
sibranch *b;
if (first) {
b = &n->self;
} else {
b = si_branchnew(r);
if (ssunlikely(b == NULL))
goto error;
}
sdindex index;
sd_indexinit(&index);
rc = sd_indexcopy(&index, r, h);
if (ssunlikely(rc == -1))
goto error;
si_branchset(b, &index);
if (in_memory) {
rc = si_branchload(b, r, &n->file);
if (ssunlikely(rc == -1))
goto error;
}
b->next = n->branch;
n->branch = b;
n->branch_count++;
first = 0;
ss_iteratornext(&i);
}
rc = sd_recover_complete(&i);
if (ssunlikely(rc == -1))
goto error;
ss_iteratorclose(&i);
n->in_memory = in_memory;
return 0;
error:
ss_iteratorclose(&i);
return -1;
}
static inline int
si_noderecover(sinode *n, sr *r, int in_memory)
{
/* recover branches */
ssiter i;
ss_iterinit(sd_recover, &i);
ss_iteropen(sd_recover, &i, r, &n->file);
int first = 1;
int rc;
while (ss_iteratorhas(&i))
{
sdindexheader *h = ss_iteratorof(&i);
sibranch *b;
if (first) {
b = &n->self;
} else {
b = si_branchnew(r);
if (ssunlikely(b == NULL))
goto error;
}
sdindex index;
sd_indexinit(&index);
rc = sd_indexcopy(&index, r, h);
if (ssunlikely(rc == -1))
goto error;
si_branchset(b, &index);
if (in_memory) {
char *start = (char*)h - h->total - sizeof(sdseal);
char *end = start + sizeof(sdseal) + h->total +
sizeof(sdindexheader) + h->size +
h->extension;
int branch_size = end - start;
rc = ss_blobensure(&b->copy, branch_size);
if (ssunlikely(rc == -1)) {
sr_oom_malfunction(r->e);
goto error;
}
memcpy(b->copy.p, start, branch_size);
}
b->next = n->branch;
n->branch = b;
n->branch_count++;
first = 0;
ss_iteratornext(&i);
}
rc = sd_recover_complete(&i);
if (ssunlikely(rc == -1))
goto error;
ss_iteratorclose(&i);
return 0;
error:
ss_iteratorclose(&i);
return -1;
}
static inline int
si_noderecover(sinode *n, sr *r)
{
/* recover branches */
ssiter i;
ss_iterinit(sd_recover, &i);
ss_iteropen(sd_recover, &i, r, &n->file);
int first = 1;
int rc;
while (ss_iteratorhas(&i))
{
sdindexheader *h = ss_iteratorof(&i);
sibranch *b;
if (first) {
b = &n->self;
} else {
b = si_branchnew(r);
if (ssunlikely(b == NULL))
goto error;
}
sdindex index;
sd_indexinit(&index);
rc = sd_indexcopy(&index, r, h);
if (ssunlikely(rc == -1))
goto error;
si_branchset(b, &index);
b->next = n->branch;
n->branch = b;
n->branch_count++;
first = 0;
ss_iteratornext(&i);
}
rc = sd_recover_complete(&i);
if (ssunlikely(rc == -1))
goto error;
ss_iteratorclose(&i);
return 0;
error:
ss_iteratorclose(&i);
return -1;
}