/*
* Reblock a record's data. Both the B-Tree element and record pointers
* to the data must be adjusted.
*/
static int
hammer_reblock_data(struct hammer_ioc_reblock *reblock,
hammer_cursor_t cursor, hammer_btree_elm_t elm)
{
hammer_buffer_t data_buffer = NULL;
hammer_off_t odata_offset;
hammer_off_t ndata_offset;
int error;
void *ndata;
error = hammer_btree_extract_data(cursor);
if (error)
return (error);
ndata = hammer_alloc_data(cursor->trans, elm->leaf.data_len,
elm->leaf.base.rec_type,
&ndata_offset, &data_buffer,
0, &error);
if (error)
goto done;
hammer_io_notmeta(data_buffer);
/*
* Move the data. Note that we must invalidate any cached
* data buffer in the cursor before calling blockmap_free.
* The blockmap_free may free up the entire big-block and
* will not be able to invalidate it if the cursor is holding
* a data buffer cached in that big-block.
*/
hammer_modify_buffer_noundo(cursor->trans, data_buffer);
bcopy(cursor->data, ndata, elm->leaf.data_len);
hammer_modify_buffer_done(data_buffer);
hammer_cursor_invalidate_cache(cursor);
hammer_blockmap_free(cursor->trans,
elm->leaf.data_offset, elm->leaf.data_len);
hammer_modify_node(cursor->trans, cursor->node,
&elm->leaf.data_offset, sizeof(hammer_off_t));
odata_offset = elm->leaf.data_offset;
elm->leaf.data_offset = ndata_offset;
hammer_modify_node_done(cursor->node);
if (hammer_debug_general & 0x4000) {
hdkprintf("%08x %016jx -> %016jx\n",
(elm ? elm->base.localization : -1),
(intmax_t)odata_offset,
(intmax_t)ndata_offset);
}
done:
if (data_buffer)
hammer_rel_buffer(data_buffer, 0);
return (error);
}
/*
* Reblock a record's data. Both the B-Tree element and record pointers
* to the data must be adjusted.
*/
static int
hammer_reblock_data(struct hammer_ioc_reblock *reblock,
hammer_cursor_t cursor, hammer_btree_elm_t elm)
{
struct hammer_buffer *data_buffer = NULL;
hammer_off_t ndata_offset;
int error;
void *ndata;
error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_DATA |
HAMMER_CURSOR_GET_LEAF);
if (error)
return (error);
ndata = hammer_alloc_data(cursor->trans, elm->leaf.data_len,
elm->leaf.base.rec_type,
&ndata_offset, &data_buffer,
0, &error);
if (error)
goto done;
hammer_io_notmeta(data_buffer);
/*
* Move the data. Note that we must invalidate any cached
* data buffer in the cursor before calling blockmap_free.
* The blockmap_free may free up the entire big-block and
* will not be able to invalidate it if the cursor is holding
* a data buffer cached in that big-block.
*/
hammer_modify_buffer_noundo(cursor->trans, data_buffer);
bcopy(cursor->data, ndata, elm->leaf.data_len);
hammer_modify_buffer_done(data_buffer);
hammer_cursor_invalidate_cache(cursor);
hammer_blockmap_free(cursor->trans,
elm->leaf.data_offset, elm->leaf.data_len);
hammer_modify_node(cursor->trans, cursor->node,
&elm->leaf.data_offset, sizeof(hammer_off_t));
elm->leaf.data_offset = ndata_offset;
hammer_modify_node_done(cursor->node);
done:
if (data_buffer)
hammer_rel_buffer(data_buffer, 0);
return (error);
}
/*
* Write out a new record.
*/
static
int
hammer_mirror_write(hammer_cursor_t cursor,
struct hammer_ioc_mrecord_rec *mrec,
char *udata)
{
hammer_transaction_t trans;
hammer_buffer_t data_buffer;
hammer_off_t ndata_offset;
hammer_tid_t high_tid;
void *ndata;
int error;
int doprop;
trans = cursor->trans;
data_buffer = NULL;
/*
* Get the sync lock so the whole mess is atomic
*/
hammer_sync_lock_sh(trans);
/*
* Allocate and adjust data
*/
if (mrec->leaf.data_len && mrec->leaf.data_offset) {
ndata = hammer_alloc_data(trans, mrec->leaf.data_len,
mrec->leaf.base.rec_type,
&ndata_offset, &data_buffer,
0, &error);
if (ndata == NULL)
return(error);
mrec->leaf.data_offset = ndata_offset;
hammer_modify_buffer_noundo(trans, data_buffer);
error = copyin(udata, ndata, mrec->leaf.data_len);
if (error == 0) {
if (hammer_crc_test_leaf(ndata, &mrec->leaf) == 0) {
hdkprintf("CRC DATA @ %016llx/%d MISMATCH ON PIPE\n",
(long long)ndata_offset,
mrec->leaf.data_len);
error = EINVAL;
} else {
error = hammer_mirror_localize_data(
ndata, &mrec->leaf);
}
}
hammer_modify_buffer_done(data_buffer);
} else {
mrec->leaf.data_offset = 0;
error = 0;
ndata = NULL;
}
if (error)
goto failed;
/*
* Do the insertion. This can fail with a EDEADLK or EALREADY
*/
cursor->flags |= HAMMER_CURSOR_INSERT;
error = hammer_btree_lookup(cursor);
if (error != ENOENT) {
if (error == 0)
error = EALREADY;
goto failed;
}
error = hammer_btree_insert(cursor, &mrec->leaf, &doprop);
/*
* Cursor is left on the current element, we want to skip it now.
*/
cursor->flags |= HAMMER_CURSOR_ATEDISK;
cursor->flags &= ~HAMMER_CURSOR_INSERT;
/*
* Track a count of active inodes.
*/
if (error == 0 &&
mrec->leaf.base.rec_type == HAMMER_RECTYPE_INODE &&
mrec->leaf.base.delete_tid == 0) {
hammer_modify_volume_field(trans,
trans->rootvol,
vol0_stat_inodes);
++trans->hmp->rootvol->ondisk->vol0_stat_inodes;
hammer_modify_volume_done(trans->rootvol);
}
/*
* vol0_next_tid must track the highest TID stored in the filesystem.
* We do not need to generate undo for this update.
*/
high_tid = mrec->leaf.base.create_tid;
if (high_tid < mrec->leaf.base.delete_tid)
high_tid = mrec->leaf.base.delete_tid;
if (trans->rootvol->ondisk->vol0_next_tid < high_tid) {
hammer_modify_volume_noundo(trans, trans->rootvol);
trans->rootvol->ondisk->vol0_next_tid = high_tid;
hammer_modify_volume_done(trans->rootvol);
}
/*
* WARNING! cursor's leaf pointer may have changed after
* do_propagation returns.
*/
if (error == 0 && doprop)
hammer_btree_do_propagation(cursor, NULL, &mrec->leaf);
failed:
/*
* Cleanup
*/
if (error && mrec->leaf.data_offset) {
hammer_blockmap_free(cursor->trans,
mrec->leaf.data_offset,
mrec->leaf.data_len);
}
hammer_sync_unlock(trans);
if (data_buffer)
hammer_rel_buffer(data_buffer, 0);
return(error);
}
/*
* Generate UNDO record(s) for the block of data at the specified zone1
* or zone2 offset.
*
* The recovery code will execute UNDOs in reverse order, allowing overlaps.
* All the UNDOs are executed together so if we already laid one down we
* do not have to lay another one down for the same range.
*
* For HAMMER version 4+ UNDO a 512 byte boundary is enforced and a PAD
* will be laid down for any unused space. UNDO FIFO media structures
* will implement the hdr_seq field (it used to be reserved01), and
* both flush and recovery mechanics will be very different.
*
* WARNING! See also hammer_generate_redo() in hammer_redo.c
*/
int
hammer_generate_undo(hammer_transaction_t trans,
hammer_off_t zone_off, void *base, int len)
{
hammer_mount_t hmp;
hammer_volume_t root_volume;
hammer_blockmap_t undomap;
hammer_buffer_t buffer = NULL;
hammer_fifo_undo_t undo;
hammer_fifo_tail_t tail;
hammer_off_t next_offset;
int error;
int bytes;
int n;
hmp = trans->hmp;
/*
* A SYNC record may be required before we can lay down a general
* UNDO. This ensures that the nominal recovery span contains
* at least one SYNC record telling the recovery code how far
* out-of-span it must go to run the REDOs.
*/
if ((hmp->flags & HAMMER_MOUNT_REDO_SYNC) == 0 &&
hmp->version >= HAMMER_VOL_VERSION_FOUR) {
hammer_generate_redo_sync(trans);
}
/*
* Enter the offset into our undo history. If there is an existing
* undo we do not have to generate a new one.
*/
if (hammer_enter_undo_history(hmp, zone_off, len) == EALREADY)
return(0);
root_volume = trans->rootvol;
undomap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
/* no undo recursion */
hammer_modify_volume_noundo(NULL, root_volume);
hammer_lock_ex(&hmp->undo_lock);
/* undo had better not roll over (loose test) */
if (hammer_undo_space(trans) < len + HAMMER_BUFSIZE*3)
panic("hammer: insufficient undo FIFO space!");
/*
* Loop until the undo for the entire range has been laid down.
*/
while (len) {
/*
* Fetch the layout offset in the UNDO FIFO, wrap it as
* necessary.
*/
if (undomap->next_offset == undomap->alloc_offset) {
undomap->next_offset =
HAMMER_ZONE_ENCODE(HAMMER_ZONE_UNDO_INDEX, 0);
}
next_offset = undomap->next_offset;
/*
* This is a tail-chasing FIFO, when we hit the start of a new
* buffer we don't have to read it in.
*/
if ((next_offset & HAMMER_BUFMASK) == 0) {
undo = hammer_bnew(hmp, next_offset, &error, &buffer);
hammer_format_undo(undo, hmp->undo_seqno ^ 0x40000000);
} else {
undo = hammer_bread(hmp, next_offset, &error, &buffer);
}
if (error)
break;
/* no undo recursion */
hammer_modify_buffer_noundo(NULL, buffer);
/*
* Calculate how big a media structure fits up to the next
* alignment point and how large a data payload we can
* accomodate.
*
* If n calculates to 0 or negative there is no room for
* anything but a PAD.
*/
bytes = HAMMER_UNDO_ALIGN -
((int)next_offset & HAMMER_UNDO_MASK);
n = bytes -
(int)sizeof(struct hammer_fifo_undo) -
(int)sizeof(struct hammer_fifo_tail);
/*
* If available space is insufficient for any payload
* we have to lay down a PAD.
*
* The minimum PAD is 8 bytes and the head and tail will
* overlap each other in that case. PADs do not have
* sequence numbers or CRCs.
*
* A PAD may not start on a boundary. That is, every
* 512-byte block in the UNDO/REDO FIFO must begin with
* a record containing a sequence number.
*/
if (n <= 0) {
KKASSERT(bytes >= sizeof(struct hammer_fifo_tail));
KKASSERT(((int)next_offset & HAMMER_UNDO_MASK) != 0);
tail = (void *)((char *)undo + bytes - sizeof(*tail));
if ((void *)undo != (void *)tail) {
tail->tail_signature = HAMMER_TAIL_SIGNATURE;
tail->tail_type = HAMMER_HEAD_TYPE_PAD;
tail->tail_size = bytes;
}
undo->head.hdr_signature = HAMMER_HEAD_SIGNATURE;
undo->head.hdr_type = HAMMER_HEAD_TYPE_PAD;
undo->head.hdr_size = bytes;
/* NO CRC OR SEQ NO */
undomap->next_offset += bytes;
hammer_modify_buffer_done(buffer);
hammer_stats_undo += bytes;
continue;
}
/*
* Calculate the actual payload and recalculate the size
* of the media structure as necessary.
*/
if (n > len) {
n = len;
bytes = ((n + HAMMER_HEAD_ALIGN_MASK) &
~HAMMER_HEAD_ALIGN_MASK) +
(int)sizeof(struct hammer_fifo_undo) +
(int)sizeof(struct hammer_fifo_tail);
}
if (hammer_debug_general & 0x0080) {
kprintf("undo %016llx %d %d\n",
(long long)next_offset, bytes, n);
}
undo->head.hdr_signature = HAMMER_HEAD_SIGNATURE;
undo->head.hdr_type = HAMMER_HEAD_TYPE_UNDO;
undo->head.hdr_size = bytes;
undo->head.hdr_seq = hmp->undo_seqno++;
undo->head.hdr_crc = 0;
undo->undo_offset = zone_off;
undo->undo_data_bytes = n;
bcopy(base, undo + 1, n);
tail = (void *)((char *)undo + bytes - sizeof(*tail));
tail->tail_signature = HAMMER_TAIL_SIGNATURE;
tail->tail_type = HAMMER_HEAD_TYPE_UNDO;
tail->tail_size = bytes;
KKASSERT(bytes >= sizeof(undo->head));
undo->head.hdr_crc = crc32(undo, HAMMER_FIFO_HEAD_CRCOFF) ^
crc32(&undo->head + 1, bytes - sizeof(undo->head));
undomap->next_offset += bytes;
hammer_stats_undo += bytes;
/*
* Before we finish off the buffer we have to deal with any
* junk between the end of the media structure we just laid
* down and the UNDO alignment boundary. We do this by laying
* down a dummy PAD. Even though we will probably overwrite
* it almost immediately we have to do this so recovery runs
* can iterate the UNDO space without having to depend on
* the indices in the volume header.
*
* This dummy PAD will be overwritten on the next undo so
* we do not adjust undomap->next_offset.
*/
bytes = HAMMER_UNDO_ALIGN -
((int)undomap->next_offset & HAMMER_UNDO_MASK);
if (bytes != HAMMER_UNDO_ALIGN) {
KKASSERT(bytes >= sizeof(struct hammer_fifo_tail));
undo = (void *)(tail + 1);
tail = (void *)((char *)undo + bytes - sizeof(*tail));
if ((void *)undo != (void *)tail) {
tail->tail_signature = HAMMER_TAIL_SIGNATURE;
tail->tail_type = HAMMER_HEAD_TYPE_PAD;
tail->tail_size = bytes;
}
undo->head.hdr_signature = HAMMER_HEAD_SIGNATURE;
undo->head.hdr_type = HAMMER_HEAD_TYPE_PAD;
undo->head.hdr_size = bytes;
/* NO CRC OR SEQ NO */
}
hammer_modify_buffer_done(buffer);
/*
* Adjust for loop
*/
len -= n;
base = (char *)base + n;
zone_off += n;
}
hammer_modify_volume_done(root_volume);
hammer_unlock(&hmp->undo_lock);
if (buffer)
hammer_rel_buffer(buffer, 0);
return(error);
}
/*
* HAMMER version 4+ conversion support.
*
* Convert a HAMMER version < 4 UNDO FIFO area to a 4+ UNDO FIFO area.
* The 4+ UNDO FIFO area is backwards compatible. The conversion is
* needed to initialize the sequence space and place headers on the
* new 512-byte undo boundary.
*/
int
hammer_upgrade_undo_4(hammer_transaction_t trans)
{
hammer_mount_t hmp;
hammer_volume_t root_volume;
hammer_blockmap_t undomap;
hammer_buffer_t buffer = NULL;
hammer_fifo_head_t head;
hammer_fifo_tail_t tail;
hammer_off_t next_offset;
u_int32_t seqno;
int error;
int bytes;
hmp = trans->hmp;
root_volume = trans->rootvol;
/* no undo recursion */
hammer_lock_ex(&hmp->undo_lock);
hammer_modify_volume_noundo(NULL, root_volume);
/*
* Adjust the in-core undomap and the on-disk undomap.
*/
next_offset = HAMMER_ZONE_ENCODE(HAMMER_ZONE_UNDO_INDEX, 0);
undomap = &hmp->blockmap[HAMMER_ZONE_UNDO_INDEX];
undomap->next_offset = next_offset;
undomap->first_offset = next_offset;
undomap = &root_volume->ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];
undomap->next_offset = next_offset;
undomap->first_offset = next_offset;
/*
* Loop over the entire UNDO space creating DUMMY entries. Sequence
* numbers are assigned.
*/
seqno = 0;
bytes = HAMMER_UNDO_ALIGN;
while (next_offset != undomap->alloc_offset) {
head = hammer_bnew(hmp, next_offset, &error, &buffer);
if (error)
break;
hammer_modify_buffer_noundo(NULL, buffer);
tail = (void *)((char *)head + bytes - sizeof(*tail));
head->hdr_signature = HAMMER_HEAD_SIGNATURE;
head->hdr_type = HAMMER_HEAD_TYPE_DUMMY;
head->hdr_size = bytes;
head->hdr_seq = seqno;
head->hdr_crc = 0;
tail = (void *)((char *)head + bytes - sizeof(*tail));
tail->tail_signature = HAMMER_TAIL_SIGNATURE;
tail->tail_type = HAMMER_HEAD_TYPE_DUMMY;
tail->tail_size = bytes;
head->hdr_crc = crc32(head, HAMMER_FIFO_HEAD_CRCOFF) ^
crc32(head + 1, bytes - sizeof(*head));
hammer_modify_buffer_done(buffer);
hammer_stats_undo += bytes;
next_offset += HAMMER_UNDO_ALIGN;
++seqno;
}
/*
* The sequence number will be the next sequence number to lay down.
*/
hmp->undo_seqno = seqno;
kprintf("version upgrade seqno start %08x\n", seqno);
hammer_modify_volume_done(root_volume);
hammer_unlock(&hmp->undo_lock);
if (buffer)
hammer_rel_buffer(buffer, 0);
return (error);
}
