/*
* Remove a volume.
*/
int
hammer_ioc_volume_del(hammer_transaction_t trans, hammer_inode_t ip,
struct hammer_ioc_volume *ioc)
{
struct hammer_mount *hmp = trans->hmp;
struct mount *mp = hmp->mp;
struct hammer_volume_ondisk *ondisk;
struct bigblock_stat stat;
hammer_volume_t volume;
int vol_no;
int error = 0;
if (mp->mnt_flag & MNT_RDONLY) {
hmkprintf(hmp, "Cannot del volume from read-only HAMMER filesystem\n");
return (EINVAL);
}
if (hammer_lock_ex_try(&hmp->volume_lock) != 0) {
hmkprintf(hmp, "Another volume operation is in progress!\n");
return (EAGAIN);
}
/*
* find volume by volname
*/
volume = NULL;
HAMMER_VOLUME_NUMBER_FOREACH(hmp, vol_no) {
volume = hammer_get_volume(hmp, vol_no, &error);
KKASSERT(volume != NULL && error == 0);
if (strcmp(volume->vol_name, ioc->device_name) == 0) {
break;
}
hammer_rel_volume(volume, 0);
volume = NULL;
}
int
hammer_ioc_volume_add(hammer_transaction_t trans, hammer_inode_t ip,
struct hammer_ioc_volume *ioc)
{
hammer_mount_t hmp = trans->hmp;
struct mount *mp = hmp->mp;
struct hammer_volume_ondisk ondisk;
hammer_volume_t volume;
int64_t total_bigblocks, empty_bigblocks;
int free_vol_no = 0;
int error;
if (mp->mnt_flag & MNT_RDONLY) {
hmkprintf(hmp, "Cannot add volume to read-only HAMMER filesystem\n");
return (EINVAL);
}
if (hammer_lock_ex_try(&hmp->volume_lock) != 0) {
hmkprintf(hmp, "Another volume operation is in progress!\n");
return (EAGAIN);
}
if (hmp->nvolumes >= HAMMER_MAX_VOLUMES) {
hammer_unlock(&hmp->volume_lock);
hmkprintf(hmp, "Max number of HAMMER volumes exceeded\n");
return (EINVAL);
}
/*
* Find an unused volume number.
*/
while (free_vol_no < HAMMER_MAX_VOLUMES &&
hammer_volume_number_test(hmp, free_vol_no)) {
++free_vol_no;
}
if (free_vol_no >= HAMMER_MAX_VOLUMES) {
hmkprintf(hmp, "Max number of HAMMER volumes exceeded\n");
error = EINVAL;
goto end;
}
error = hammer_format_volume_header(hmp, ioc, &ondisk, free_vol_no);
if (error)
goto end;
error = hammer_install_volume(hmp, ioc->device_name, NULL, &ondisk);
if (error)
goto end;
hammer_sync_lock_sh(trans);
hammer_lock_ex(&hmp->blkmap_lock);
volume = hammer_get_volume(hmp, free_vol_no, &error);
KKASSERT(volume != NULL && error == 0);
error = hammer_format_freemap(trans, volume);
KKASSERT(error == 0);
error = hammer_count_bigblocks(hmp, volume,
&total_bigblocks, &empty_bigblocks);
KKASSERT(error == 0);
KKASSERT(total_bigblocks == empty_bigblocks);
hammer_rel_volume(volume, 0);
++hmp->nvolumes;
error = hammer_update_volumes_header(trans,
total_bigblocks, empty_bigblocks);
KKASSERT(error == 0);
hammer_unlock(&hmp->blkmap_lock);
hammer_sync_unlock(trans);
KKASSERT(error == 0);
end:
hammer_unlock(&hmp->volume_lock);
if (error)
hmkprintf(hmp, "An error occurred: %d\n", error);
return (error);
}
int
hammer_ioc_volume_add(hammer_transaction_t trans, hammer_inode_t ip,
struct hammer_ioc_volume *ioc)
{
struct hammer_mount *hmp = trans->hmp;
struct mount *mp = hmp->mp;
hammer_volume_t volume;
int error;
if (mp->mnt_flag & MNT_RDONLY) {
kprintf("Cannot add volume to read-only HAMMER filesystem\n");
return (EINVAL);
}
if (hmp->nvolumes + 1 >= HAMMER_MAX_VOLUMES) {
kprintf("Max number of HAMMER volumes exceeded\n");
return (EINVAL);
}
if (hammer_lock_ex_try(&hmp->volume_lock) != 0) {
kprintf("Another volume operation is in progress!\n");
return (EAGAIN);
}
/*
* Find an unused volume number.
*/
int free_vol_no = 0;
while (free_vol_no < HAMMER_MAX_VOLUMES &&
RB_LOOKUP(hammer_vol_rb_tree, &hmp->rb_vols_root, free_vol_no)) {
++free_vol_no;
}
if (free_vol_no >= HAMMER_MAX_VOLUMES) {
kprintf("Max number of HAMMER volumes exceeded\n");
hammer_unlock(&hmp->volume_lock);
return (EINVAL);
}
struct vnode *devvp = NULL;
error = hammer_setup_device(&devvp, ioc->device_name, 0);
if (error)
goto end;
KKASSERT(devvp);
error = hammer_format_volume_header(
hmp,
devvp,
hmp->rootvol->ondisk->vol_name,
free_vol_no,
hmp->nvolumes+1,
ioc->vol_size,
ioc->boot_area_size,
ioc->mem_area_size);
hammer_close_device(&devvp, 0);
if (error)
goto end;
error = hammer_install_volume(hmp, ioc->device_name, NULL);
if (error)
goto end;
hammer_sync_lock_sh(trans);
hammer_lock_ex(&hmp->blkmap_lock);
++hmp->nvolumes;
/*
* Set each volumes new value of the vol_count field.
*/
for (int vol_no = 0; vol_no < HAMMER_MAX_VOLUMES; ++vol_no) {
volume = hammer_get_volume(hmp, vol_no, &error);
if (volume == NULL && error == ENOENT) {
/*
* Skip unused volume numbers
*/
error = 0;
continue;
}
KKASSERT(volume != NULL && error == 0);
hammer_modify_volume_field(trans, volume, vol_count);
volume->ondisk->vol_count = hmp->nvolumes;
hammer_modify_volume_done(volume);
/*
* Only changes to the header of the root volume
* are automatically flushed to disk. For all
* other volumes that we modify we do it here.
*
* No interlock is needed, volume buffers are not
* messed with by bioops.
*/
if (volume != trans->rootvol && volume->io.modified) {
hammer_crc_set_volume(volume->ondisk);
hammer_io_flush(&volume->io, 0);
}
hammer_rel_volume(volume, 0);
}
volume = hammer_get_volume(hmp, free_vol_no, &error);
KKASSERT(volume != NULL && error == 0);
struct bigblock_stat stat;
error = hammer_format_freemap(trans, volume, &stat);
KKASSERT(error == 0);
/*
* Increase the total number of bigblocks and update stat/vstat totals.
*/
hammer_modify_volume_field(trans, trans->rootvol,
vol0_stat_bigblocks);
trans->rootvol->ondisk->vol0_stat_bigblocks += stat.total_bigblocks;
hammer_modify_volume_done(trans->rootvol);
/*
* Bigblock count changed so recompute the total number of blocks.
*/
mp->mnt_stat.f_blocks = trans->rootvol->ondisk->vol0_stat_bigblocks *
(HAMMER_LARGEBLOCK_SIZE / HAMMER_BUFSIZE);
mp->mnt_vstat.f_blocks = trans->rootvol->ondisk->vol0_stat_bigblocks *
(HAMMER_LARGEBLOCK_SIZE / HAMMER_BUFSIZE);
/*
* Increase the number of free bigblocks
* (including the copy in hmp)
*/
hammer_modify_volume_field(trans, trans->rootvol,
vol0_stat_freebigblocks);
trans->rootvol->ondisk->vol0_stat_freebigblocks += stat.total_free_bigblocks;
hmp->copy_stat_freebigblocks =
trans->rootvol->ondisk->vol0_stat_freebigblocks;
hammer_modify_volume_done(trans->rootvol);
hammer_rel_volume(volume, 0);
hammer_unlock(&hmp->blkmap_lock);
hammer_sync_unlock(trans);
KKASSERT(error == 0);
end:
hammer_unlock(&hmp->volume_lock);
if (error)
kprintf("An error occurred: %d\n", error);
return (error);
}
/*
* Remove a volume.
*/
int
hammer_ioc_volume_del(hammer_transaction_t trans, hammer_inode_t ip,
struct hammer_ioc_volume *ioc)
{
struct hammer_mount *hmp = trans->hmp;
struct mount *mp = hmp->mp;
hammer_volume_t volume;
int error = 0;
if (mp->mnt_flag & MNT_RDONLY) {
kprintf("Cannot del volume from read-only HAMMER filesystem\n");
return (EINVAL);
}
if (hammer_lock_ex_try(&hmp->volume_lock) != 0) {
kprintf("Another volume operation is in progress!\n");
return (EAGAIN);
}
volume = NULL;
/*
* find volume by volname
*/
for (int vol_no = 0; vol_no < HAMMER_MAX_VOLUMES; ++vol_no) {
volume = hammer_get_volume(hmp, vol_no, &error);
if (volume == NULL && error == ENOENT) {
/*
* Skip unused volume numbers
*/
error = 0;
continue;
}
KKASSERT(volume != NULL && error == 0);
if (strcmp(volume->vol_name, ioc->device_name) == 0) {
break;
}
hammer_rel_volume(volume, 0);
volume = NULL;
}
if (volume == NULL) {
kprintf("Couldn't find volume\n");
error = EINVAL;
goto end;
}
if (volume == trans->rootvol) {
kprintf("Cannot remove root-volume\n");
hammer_rel_volume(volume, 0);
error = EINVAL;
goto end;
}
/*
*
*/
hmp->volume_to_remove = volume->vol_no;
struct hammer_ioc_reblock reblock;
bzero(&reblock, sizeof(reblock));
reblock.key_beg.localization = HAMMER_MIN_LOCALIZATION;
reblock.key_beg.obj_id = HAMMER_MIN_OBJID;
reblock.key_end.localization = HAMMER_MAX_LOCALIZATION;
reblock.key_end.obj_id = HAMMER_MAX_OBJID;
reblock.head.flags = HAMMER_IOC_DO_FLAGS;
reblock.free_level = 0;
error = hammer_ioc_reblock(trans, ip, &reblock);
if (reblock.head.flags & HAMMER_IOC_HEAD_INTR) {
error = EINTR;
}
if (error) {
if (error == EINTR) {
kprintf("reblock was interrupted\n");
} else {
kprintf("reblock failed: %d\n", error);
}
hmp->volume_to_remove = -1;
hammer_rel_volume(volume, 0);
goto end;
}
/*
* Sync filesystem
*/
int count = 0;
while (hammer_flusher_haswork(hmp)) {
hammer_flusher_sync(hmp);
++count;
if (count >= 5) {
if (count == 5)
kprintf("HAMMER: flushing.");
else
kprintf(".");
tsleep(&count, 0, "hmrufl", hz);
}
if (count == 30) {
kprintf("giving up");
break;
}
}
kprintf("\n");
hammer_sync_lock_sh(trans);
hammer_lock_ex(&hmp->blkmap_lock);
/*
* We use stat later to update rootvol's bigblock stats
*/
struct bigblock_stat stat;
error = hammer_free_freemap(trans, volume, &stat);
if (error) {
kprintf("Failed to free volume. Volume not empty!\n");
hmp->volume_to_remove = -1;
hammer_rel_volume(volume, 0);
hammer_unlock(&hmp->blkmap_lock);
hammer_sync_unlock(trans);
goto end;
}
hmp->volume_to_remove = -1;
hammer_rel_volume(volume, 0);
/*
* Unload buffers
*/
RB_SCAN(hammer_buf_rb_tree, &hmp->rb_bufs_root, NULL,
hammer_unload_buffer, volume);
error = hammer_unload_volume(volume, NULL);
if (error == -1) {
kprintf("Failed to unload volume\n");
hammer_unlock(&hmp->blkmap_lock);
hammer_sync_unlock(trans);
goto end;
}
volume = NULL;
--hmp->nvolumes;
/*
* Set each volume's new value of the vol_count field.
*/
for (int vol_no = 0; vol_no < HAMMER_MAX_VOLUMES; ++vol_no) {
volume = hammer_get_volume(hmp, vol_no, &error);
if (volume == NULL && error == ENOENT) {
/*
* Skip unused volume numbers
*/
error = 0;
continue;
}
KKASSERT(volume != NULL && error == 0);
hammer_modify_volume_field(trans, volume, vol_count);
volume->ondisk->vol_count = hmp->nvolumes;
hammer_modify_volume_done(volume);
/*
* Only changes to the header of the root volume
* are automatically flushed to disk. For all
* other volumes that we modify we do it here.
*
* No interlock is needed, volume buffers are not
* messed with by bioops.
*/
if (volume != trans->rootvol && volume->io.modified) {
hammer_crc_set_volume(volume->ondisk);
hammer_io_flush(&volume->io, 0);
}
hammer_rel_volume(volume, 0);
}
/*
* Update the total number of bigblocks
*/
hammer_modify_volume_field(trans, trans->rootvol,
vol0_stat_bigblocks);
trans->rootvol->ondisk->vol0_stat_bigblocks -= stat.total_bigblocks;
hammer_modify_volume_done(trans->rootvol);
/*
* Update the number of free bigblocks
* (including the copy in hmp)
*/
hammer_modify_volume_field(trans, trans->rootvol,
vol0_stat_freebigblocks);
trans->rootvol->ondisk->vol0_stat_freebigblocks -= stat.total_free_bigblocks;
hmp->copy_stat_freebigblocks =
trans->rootvol->ondisk->vol0_stat_freebigblocks;
hammer_modify_volume_done(trans->rootvol);
/*
* Bigblock count changed so recompute the total number of blocks.
*/
mp->mnt_stat.f_blocks = trans->rootvol->ondisk->vol0_stat_bigblocks *
(HAMMER_LARGEBLOCK_SIZE / HAMMER_BUFSIZE);
mp->mnt_vstat.f_blocks = trans->rootvol->ondisk->vol0_stat_bigblocks *
(HAMMER_LARGEBLOCK_SIZE / HAMMER_BUFSIZE);
hammer_unlock(&hmp->blkmap_lock);
hammer_sync_unlock(trans);
/*
* Erase the volume header of the removed device.
*
* This is to not accidentally mount the volume again.
*/
struct vnode *devvp = NULL;
error = hammer_setup_device(&devvp, ioc->device_name, 0);
if (error) {
kprintf("Failed to open device: %s\n", ioc->device_name);
goto end;
}
KKASSERT(devvp);
error = hammer_clear_volume_header(devvp);
if (error) {
kprintf("Failed to clear volume header of device: %s\n",
ioc->device_name);
goto end;
}
hammer_close_device(&devvp, 0);
KKASSERT(error == 0);
end:
hammer_unlock(&hmp->volume_lock);
return (error);
}
