int journal_trans_commit(journal_t *journal)
{
if (journal == NULL) {
return KNOT_EINVAL;
}
if ((journal->bflags & JOURNAL_TRANS) == 0) {
return KNOT_ENOENT;
}
/* Mark affected nodes as commited. */
int ret = KNOT_EOK;
size_t i = journal->tmark;
for(; i != journal->qtail; i = (i + 1) % journal->max_nodes) {
journal->nodes[i].flags &= (~JOURNAL_TRANS);
ret = journal_update(journal, journal->nodes + i);
if (ret != KNOT_EOK) {
dbg_journal("journal: failed to clear TRANS flag from "
"node %zu\n", i);
return ret;
}
}
/* Clear in-transaction flags. */
journal->tmark = 0;
journal->bflags &= (~JOURNAL_TRANS);
return KNOT_EOK;
}
int journal_trans_rollback(journal_t *journal)
{
if (journal == NULL) {
return KNOT_EINVAL;
}
if ((journal->bflags & JOURNAL_TRANS) == 0) {
return KNOT_ENOENT;
}
/* Preempt last (failed) node. */
journal_node_t *t_end = journal->nodes + journal->qtail;
dbg_journal("journal: rollback transaction id=<%hu,%hu> (@%u, l=%u)\n",
journal->tmark, journal->qtail, t_end->pos, t_end->len);
journal->free.pos = t_end->pos;
journal->free.len = t_end->len;
/* Best effort free. */
t_end->flags = JOURNAL_FREE;
(void) journal_update(journal, t_end);
/* Write back free segment state. */
int seek_ret = lseek(journal->fd, JOURNAL_HSIZE, SEEK_SET);
if (seek_ret < 0 || !sfwrite(&journal->free, sizeof(journal_node_t), journal->fd)) {
return KNOT_ERROR;
}
/* Clear in-transaction flags. */
journal->tmark = 0;
journal->bflags &= (~JOURNAL_TRANS);
return KNOT_EOK;
}
int journal_write_out(journal_t *journal, journal_node_t *n)
{
/* Mark node as valid and write back. */
uint16_t jnext = n->next;
size_t size = n->len;
const size_t node_len = sizeof(journal_node_t);
n->flags = JOURNAL_VALID | journal->bflags;
n->next = 0;
journal_update(journal, n);
/* Handle free segment on node rotation. */
if (journal->qtail > jnext && journal->fslimit == FSLIMIT_INF) {
/* Trim free space. */
journal->fsize -= journal->free.len;
dbg_journal_verb("journal: * trimmed filesize to %zu\n",
journal->fsize);
/* Rewind free segment. */
journal_node_t *n = journal->nodes + jnext;
journal->free.pos = n->pos;
journal->free.len = 0;
} else {
/* Mark used space. */
journal->free.pos += size;
journal->free.len -= size;
}
dbg_journal("journal: finishing node=%u id=%llu flags=0x%x, "
"data=<%u, %u> free=<%u, %u>\n",
journal->qtail, (unsigned long long)n->id,
n->flags, n->pos, n->pos + n->len,
journal->free.pos,
journal->free.pos + journal->free.len);
/* Write back free segment state. */
int seek_ret = lseek(journal->fd, JOURNAL_HSIZE, SEEK_SET);
if (seek_ret < 0 || !sfwrite(&journal->free, node_len, journal->fd)) {
/* Node is marked valid and failed to shrink free space,
* node will be overwritten on the next write. Return error.
*/
dbg_journal("journal: failed to write back "
"free segment descriptor\n");
return KNOT_ERROR;
}
/* Node write successful. */
journal->qtail = jnext;
/* Write back queue state, not essential as it may be recovered.
* qhead - lowest valid node identifier (least recent)
* qtail - highest valid node identifier (most recently used)
*/
uint16_t qstate[2] = {journal->qhead, journal->qtail};
seek_ret = lseek(journal->fd, JOURNAL_HSIZE - 2 * sizeof(uint16_t), SEEK_SET);
if (seek_ret < 0 || !sfwrite(qstate, 2 * sizeof(uint16_t), journal->fd)) {
dbg_journal("journal: failed to write back queue state\n");
return KNOT_ERROR;
}
return KNOT_EOK;
}
int journal_write_in(journal_t *j, journal_node_t **rn, uint64_t id, size_t len)
{
const size_t node_len = sizeof(journal_node_t);
*rn = NULL;
/* Find next free node. */
uint16_t jnext = (j->qtail + 1) % j->max_nodes;
dbg_journal("journal: will write id=%llu, node=%u, size=%zu, fsize=%zu\n",
(unsigned long long)id, j->qtail, len, j->fsize);
/* Calculate remaining bytes to reach file size limit. */
size_t fs_remaining = j->fslimit - j->fsize;
int seek_ret = 0;
/* Increase free segment if on the end of file. */
journal_node_t *n = j->nodes + j->qtail;
if (j->free.pos + j->free.len == j->fsize) {
dbg_journal_verb("journal: * is last node\n");
/* Grow journal file until the size limit. */
if(j->free.len < len && len <= fs_remaining) {
size_t diff = len - j->free.len;
dbg_journal("journal: * growing by +%zu, pos=%u, "
"new fsize=%zu\n",
diff, j->free.pos,
j->fsize + diff);
j->fsize += diff; /* Appending increases file size. */
j->free.len += diff;
}
/* Rewind if resize is needed, but the limit is reached. */
if(j->free.len < len && len > fs_remaining) {
journal_node_t *head = j->nodes + j->qhead;
j->fsize = j->free.pos;
j->free.pos = head->pos;
j->free.len = 0;
dbg_journal_verb("journal: * fslimit reached, "
"rewinding to %u\n",
head->pos);
dbg_journal_verb("journal: * file size trimmed to %zu\n",
j->fsize);
}
}
/* Evict occupied nodes if necessary. */
while (j->free.len < len ||
j->nodes[jnext].flags > JOURNAL_FREE) {
/* Evict least recent node if not empty. */
journal_node_t *head = j->nodes + j->qhead;
/* Check if it has been synced to disk. */
if (head->flags & JOURNAL_DIRTY) {
return KNOT_EAGAIN;
}
/* Write back evicted node. */
head->flags = JOURNAL_FREE;
seek_ret = lseek(j->fd, JOURNAL_HSIZE + (j->qhead + 1) * node_len, SEEK_SET);
if (seek_ret < 0 || !sfwrite(head, node_len, j->fd)) {
return KNOT_ERROR;
}
dbg_journal("journal: * evicted node=%u, growing by +%u\n",
j->qhead, head->len);
/* Write back query state. */
j->qhead = (j->qhead + 1) % j->max_nodes;
uint16_t qstate[2] = {j->qhead, j->qtail};
seek_ret = lseek(j->fd, JOURNAL_HSIZE - 2 * sizeof(uint16_t), SEEK_SET);
if (seek_ret < 0 || !sfwrite(qstate, 2 * sizeof(uint16_t), j->fd)) {
return KNOT_ERROR;
}
/* Increase free segment. */
j->free.len += head->len;
}
/* Invalidate node and write back. */
n->id = id;
n->pos = j->free.pos;
n->len = len;
n->flags = JOURNAL_FREE;
n->next = jnext;
journal_update(j, n);
*rn = n;
return KNOT_EOK;
}
