int sd_indexcommit(sdindex *i, sr *r, sdid *id, ssqf *qf, uint64_t offset)
{
int size = ss_bufused(&i->v);
int size_extension = 0;
int extensions = 0;
if (qf) {
extensions = SD_INDEXEXT_AMQF;
size_extension += sizeof(sdindexamqf);
size_extension += qf->qf_table_size;
}
int rc = ss_bufensure(&i->i, r->a, size + size_extension);
if (ssunlikely(rc == -1))
return sr_oom(r->e);
memcpy(i->i.p, i->v.s, size);
ss_bufadvance(&i->i, size);
if (qf) {
sdindexamqf *qh = (sdindexamqf*)(i->i.p);
qh->q = qf->qf_qbits;
qh->r = qf->qf_rbits;
qh->entries = qf->qf_entries;
qh->size = qf->qf_table_size;
ss_bufadvance(&i->i, sizeof(sdindexamqf));
memcpy(i->i.p, qf->qf_table, qf->qf_table_size);
ss_bufadvance(&i->i, qf->qf_table_size);
}
ss_buffree(&i->v, r->a);
i->h = sd_indexheader(i);
i->h->offset = offset;
i->h->id = *id;
i->h->extension = size_extension;
i->h->extensions = extensions;
i->h->crc = ss_crcs(r->crc, i->h, sizeof(sdindexheader), 0);
return 0;
}
int sd_indexcommit(sdindex *i, sr *r, sdid *id, ssqf *qf,
uint32_t align,
uint64_t offset)
{
int size = ss_bufused(&i->v);
int size_extension = 0;
int extensions = 0;
if (qf) {
extensions = SD_INDEXEXT_AMQF;
size_extension += sizeof(sdindexamqf);
size_extension += qf->qf_table_size;
}
/* calculate index align for direct_io */
int size_meta = size + size_extension + sizeof(sdindexheader);
int size_align = 0;
if (align) {
size_align += align - ((offset + size_meta + ss_bufused(&i->i)) % align);
size_meta += size_align;
}
int rc = ss_bufensure(&i->i, r->a, size_meta);
if (ssunlikely(rc == -1))
return sr_oom(r->e);
/* min/max pairs */
memcpy(i->i.p, i->v.s, size);
ss_bufadvance(&i->i, size);
/* extension */
if (qf) {
sdindexamqf *qh = (sdindexamqf*)(i->i.p);
qh->q = qf->qf_qbits;
qh->r = qf->qf_rbits;
qh->entries = qf->qf_entries;
qh->size = qf->qf_table_size;
ss_bufadvance(&i->i, sizeof(sdindexamqf));
memcpy(i->i.p, qf->qf_table, qf->qf_table_size);
ss_bufadvance(&i->i, qf->qf_table_size);
}
ss_buffree(&i->v, r->a);
sdindexheader *h = &i->build;
/* align */
if (size_align) {
h->align = size_align;
memset(i->i.p, 0, size_align);
ss_bufadvance(&i->i, size_align);
}
/* header */
h->offset = offset;
h->id = *id;
h->extension = size_extension;
h->extensions = extensions;
h->crc = ss_crcs(r->crc, h, sizeof(sdindexheader), 0);
memcpy(i->i.p, &i->build, sizeof(sdindexheader));
ss_bufadvance(&i->i, sizeof(sdindexheader));
i->h = sd_indexheader(i);
return 0;
}
static int
sl_iternext_of(sliter *i, slv *next, int validate)
{
if (next == NULL)
return 0;
char *eof = (char*)i->map.p + i->map.size;
char *start = (char*)next;
/* eof */
if (ssunlikely(start == eof)) {
if (i->count != i->pos) {
sr_malfunction(i->r->e, "corrupted log file '%s': transaction is incomplete",
i->log->file);
sl_iterseterror(i);
return -1;
}
i->v = NULL;
i->next = NULL;
return 0;
}
char *end = start + next->size;
if (ssunlikely((start > eof || (end > eof)))) {
sr_malfunction(i->r->e, "corrupted log file '%s': bad record size",
i->log->file);
sl_iterseterror(i);
return -1;
}
if (validate && i->validate)
{
uint32_t crc = 0;
if (! (next->flags & SVBEGIN)) {
crc = ss_crcp(i->r->crc, start + sizeof(slv), next->size, 0);
}
crc = ss_crcs(i->r->crc, start, sizeof(slv), crc);
if (ssunlikely(crc != next->crc)) {
sr_malfunction(i->r->e, "corrupted log file '%s': bad record crc",
i->log->file);
sl_iterseterror(i);
return -1;
}
}
i->pos++;
if (i->pos > i->count) {
/* next transaction */
i->v = NULL;
i->pos = 0;
i->count = 0;
i->next = next;
return 0;
}
i->v = next;
sv_init(&i->current, &sl_vif, i->v, NULL);
return 1;
}
int sd_buildend(sdbuild *b, sr *r)
{
/* update sizes */
sdbuildref *ref = sd_buildref(b);
ref->msize = ss_bufused(&b->m) - ref->m;
ref->vsize = ss_bufused(&b->v) - ref->v;
ref->ksize = ss_bufused(&b->k) - ref->k;
ref->csize = 0;
/* calculate data crc (non-compressed) */
sdpageheader *h = sd_buildheader(b);
uint32_t crc = 0;
if (sslikely(b->crc)) {
crc = ss_crcp(r->crc, b->m.s + ref->m, ref->msize, 0);
crc = ss_crcp(r->crc, b->v.s + ref->v, ref->vsize, crc);
crc = ss_crcp(r->crc, b->k.s + ref->k, ref->ksize, crc);
}
h->crcdata = crc;
/* compression */
if (b->compress) {
int rc = sd_buildcompress(b, r);
if (ssunlikely(rc == -1))
return -1;
ref->csize = ss_bufused(&b->c) - ref->c;
}
/* update page header */
int total = ref->msize + ref->vsize + ref->ksize;
h->sizekeys = ref->ksize;
h->sizeorigin = total - sizeof(sdpageheader);
h->size = h->sizeorigin;
if (b->compress)
h->size = ref->csize - sizeof(sdpageheader);
else
h->size = h->sizeorigin;
h->crc = ss_crcs(r->crc, h, sizeof(sdpageheader), 0);
if (b->compress)
memcpy(b->c.s + ref->c, h, sizeof(sdpageheader));
return 0;
}
