/**
* Write multiple logical sectors at an offset.
* Logical block size is 512 bytes.
*
* @fd file descriptor of the target storage device.
* @offset_lb storage offset [logical block].
* @sect_ary input sector data array.
* @idx_lb start offset in sect_ary [logical block].
* @n_lb number of sectors to write [logical block].
*
* RETURN:
* true in success, or false.
*/
bool sector_array_pwrite_lb(
int fd, u64 offset_lb,
const struct sector_data_array *sect_ary,
unsigned int idx_lb, unsigned int n_lb)
{
const unsigned int pbs = sect_ary->sector_size;
unsigned int w_lb = 0;
ASSERT(fd > 0);
ASSERT_SECTOR_DATA_ARRAY(sect_ary);
ASSERT(n_lb > 0);
while (w_lb < n_lb) {
unsigned int idx = addr_pb(pbs, idx_lb + w_lb);
unsigned int off_lb = off_in_pb(pbs, idx_lb + w_lb);
unsigned int tmp_lb =
get_min_value(n_lb_in_pb(pbs) - off_lb, n_lb - w_lb);
if (!sector_write_lb(
fd, offset_lb + w_lb,
sect_ary->array[idx],
off_lb, tmp_lb)) {
return false;
}
w_lb += tmp_lb;
}
ASSERT(w_lb == n_lb);
return true;
}
/**
* Clear log and detect resize of log device.
*
* @wdev walb dev.
* @ctl ioctl data.
* RETURN:
* 0 in success, or -EFAULT.
*/
static int ioctl_wdev_clear_log(struct walb_dev *wdev, struct walb_ctl *ctl)
{
u64 new_ldev_size, old_ldev_size;
u8 new_uuid[UUID_SIZE], old_uuid[UUID_SIZE];
unsigned int pbs = wdev->physical_bs;
bool is_grown = false;
struct walb_super_sector *super;
u64 lsid0_off;
struct lsid_set lsids;
u64 old_ring_buffer_size;
u32 new_salt;
ASSERT(ctl->command == WALB_IOCTL_CLEAR_LOG);
LOGn("WALB_IOCTL_CLEAR_LOG.\n");
/* Freeze iocore and checkpointing. */
iocore_freeze(wdev);
stop_checkpointing(&wdev->cpd);
/* Get old/new log device size. */
old_ldev_size = wdev->ldev_size;
new_ldev_size = wdev->ldev->bd_part->nr_sects;
if (old_ldev_size > new_ldev_size) {
LOGe("Log device shrink not supported.\n");
goto error0;
}
/* Backup variables. */
old_ring_buffer_size = wdev->ring_buffer_size;
backup_lsid_set(wdev, &lsids);
/* Initialize lsid(s). */
spin_lock(&wdev->lsid_lock);
wdev->lsids.latest = 0;
wdev->lsids.flush = 0;
wdev->lsids.completed = 0;
wdev->lsids.permanent = 0;
wdev->lsids.written = 0;
wdev->lsids.prev_written = 0;
wdev->lsids.oldest = 0;
spin_unlock(&wdev->lsid_lock);
/* Grow the walblog device. */
if (old_ldev_size < new_ldev_size) {
LOGn("Detect log device size change.\n");
/* Grow the disk. */
is_grown = true;
if (!resize_disk(wdev->log_gd, new_ldev_size)) {
LOGe("grow disk failed.\n");
iocore_set_readonly(wdev);
goto error1;
}
LOGn("Grown log device size from %"PRIu64" to %"PRIu64".\n",
old_ldev_size, new_ldev_size);
wdev->ldev_size = new_ldev_size;
/* Recalculate ring buffer size. */
wdev->ring_buffer_size =
addr_pb(pbs, new_ldev_size)
- get_ring_buffer_offset(pbs);
}
/* Generate new uuid and salt. */
get_random_bytes(new_uuid, 16);
get_random_bytes(&new_salt, sizeof(new_salt));
wdev->log_checksum_salt = new_salt;
/* Update superblock image. */
spin_lock(&wdev->lsuper0_lock);
super = get_super_sector(wdev->lsuper0);
memcpy(old_uuid, super->uuid, UUID_SIZE);
memcpy(super->uuid, new_uuid, UUID_SIZE);
super->ring_buffer_size = wdev->ring_buffer_size;
super->log_checksum_salt = new_salt;
/* super->metadata_size; */
lsid0_off = get_offset_of_lsid_2(super, 0);
spin_unlock(&wdev->lsuper0_lock);
/* Sync super sector. */
if (!walb_sync_super_block(wdev)) {
LOGe("sync superblock failed.\n");
iocore_set_readonly(wdev);
goto error2;
}
/* Invalidate first logpack */
if (!invalidate_lsid(wdev, 0)) {
LOGe("invalidate lsid 0 failed.\n");
iocore_set_readonly(wdev);
goto error2;
}
/* Clear log overflow. */
iocore_clear_log_overflow(wdev);
/* Melt iocore and checkpointing. */
start_checkpointing(&wdev->cpd);
iocore_melt(wdev);
return 0;
error2:
restore_lsid_set(wdev, &lsids);
wdev->ring_buffer_size = old_ring_buffer_size;
#if 0
wdev->ldev_size = old_ldev_size;
if (!resize_disk(wdev->log_gd, old_ldev_size)) {
LOGe("resize_disk to shrink failed.\n");
}
#endif
error1:
start_checkpointing(&wdev->cpd);
iocore_melt(wdev);
error0:
return -EFAULT;
}