static int set_journal_block64_run(struct tunefs_operation *op,
ocfs2_filesys *fs, int flags)
{
errcode_t err;
int rc = 0;
ocfs2_fs_options mask, options;
struct ocfs2_super_block *super = OCFS2_RAW_SB(fs->fs_super);
memset(&mask, 0, sizeof(ocfs2_fs_options));
memset(&options, 0, sizeof(ocfs2_fs_options));
mask.opt_incompat |= JBD2_FEATURE_INCOMPAT_64BIT;
options.opt_incompat |= JBD2_FEATURE_INCOMPAT_64BIT;
if (!tools_interact("Enable block64 journal feature on device \"%s\"? ",
fs->fs_devname))
goto out;
tunefs_block_signals();
super->s_feature_compat |= OCFS2_FEATURE_COMPAT_JBD2_SB;
err = ocfs2_write_super(fs);
if (!err)
err = tunefs_set_journal_size(fs, 0, mask, options);
tunefs_unblock_signals();
if (err) {
rc = 1;
tcom_err(err,
"; unable to enable block64 journal feature on "
"device \"%s\"", fs->fs_devname);
}
out:
return rc;
}
static int enable_backup_super(ocfs2_filesys *fs, int flags)
{
errcode_t err = 0;
struct ocfs2_super_block *super = OCFS2_RAW_SB(fs->fs_super);
struct tools_progress *prog;
if (OCFS2_HAS_COMPAT_FEATURE(super,
OCFS2_FEATURE_COMPAT_BACKUP_SB)) {
verbosef(VL_APP,
"Backup superblock feature is already enabled; "
"nothing to enable\n");
goto out;
}
if (!tools_interact("Enable the backup superblock feature on "
"device \"%s\"? ",
fs->fs_devname))
goto out;
prog = tools_progress_start("Enable backup-super", "backup-super",
2);
if (!prog) {
err = TUNEFS_ET_NO_MEMORY;
tcom_err(err, "while initializing the progress display");
goto out;
}
tunefs_block_signals();
err = check_backup_offsets(fs);
tools_progress_step(prog, 1);
if (!err)
err = fill_backup_supers(fs);
if (!err) {
super->s_feature_compat |= OCFS2_FEATURE_COMPAT_BACKUP_SB;
err = ocfs2_write_super(fs);
if (err)
tcom_err(err, "while writing out the superblock\n");
}
tunefs_unblock_signals();
tools_progress_step(prog, 1);
tools_progress_stop(prog);
if (err)
errorf("Unable to enable the backup superblock feature on "
"device \"%s\"\n",
fs->fs_devname);
out:
return err;
}
static int disable_grpquota(ocfs2_filesys *fs, int flags)
{
errcode_t ret;
struct ocfs2_super_block *super = OCFS2_RAW_SB(fs->fs_super);
struct tools_progress *prog = NULL;
if (!OCFS2_HAS_RO_COMPAT_FEATURE(super,
OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)) {
verbosef(VL_APP, "Group quotas are already disabled; "
"nothing to disable\n");
return 0;
}
if (!tools_interact("Disable group quota feature on device "
"\"%s\"? ",
fs->fs_devname))
return 0;
prog = tools_progress_start("Disabling user quota", "nousrquota", 2);
if (!prog) {
ret = TUNEFS_ET_NO_MEMORY;
tcom_err(ret, "while initializing progress display");
return ret;
}
tunefs_block_signals();
ret = remove_quota_files(fs, GRPQUOTA, prog);
if (ret) {
tcom_err(ret, "while removing group quota files");
goto bail;
}
OCFS2_CLEAR_RO_COMPAT_FEATURE(super,
OCFS2_FEATURE_RO_COMPAT_GRPQUOTA);
ret = ocfs2_write_super(fs);
tools_progress_step(prog, 1);
bail:
tools_progress_stop(prog);
tunefs_unblock_signals();
return ret;
}
static errcode_t cloned_volume(ocfs2_filesys *fs, const char *new_label)
{
errcode_t err;
struct tools_progress *prog;
if (!tools_interact_critical(
"Updating the UUID and label on cloned volume \"%s\".\n"
"DANGER: THIS WILL MODIFY THE UUID WITHOUT ACCESSING THE "
"CLUSTER SOFTWARE. YOU MUST BE ABSOLUTELY SURE THAT NO "
"OTHER NODE IS USING THIS FILESYSTEM BEFORE MODIFYING "
"ITS UUID.\n"
"Update the UUID and label? ",
fs->fs_devname))
return 0;
prog = tools_progress_start("Cloning volume", "cloning", 3);
if (!prog) {
err = TUNEFS_ET_NO_MEMORY;
tcom_err(err, "while initializing the progress display");
goto out;
}
update_volume_uuid(fs);
tools_progress_step(prog, 1);
update_volume_label(fs, new_label);
tools_progress_step(prog, 1);
tunefs_block_signals();
err = ocfs2_write_super(fs);
tunefs_unblock_signals();
tools_progress_step(prog, 1);
tools_progress_stop(prog);
out:
return err;
}
static errcode_t write_out_superblock(o2fsck_state *ost)
{
struct ocfs2_dinode *di = ost->ost_fs->fs_super;
struct ocfs2_super_block *sb = OCFS2_RAW_SB(di);
if (sb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_RESIZE_INPROG)
sb->s_feature_incompat &= ~OCFS2_FEATURE_INCOMPAT_RESIZE_INPROG;
if (sb->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_TUNEFS_INPROG) {
sb->s_feature_incompat &=
~OCFS2_FEATURE_INCOMPAT_TUNEFS_INPROG;
sb->s_tunefs_flag = 0;
}
if (ost->ost_num_clusters)
di->i_clusters = ost->ost_num_clusters;
sb->s_errors = ost->ost_saw_error;
sb->s_lastcheck = time(NULL);
sb->s_mnt_count = 0;
return ocfs2_write_super(ost->ost_fs);
}
static errcode_t remove_quota_files(ocfs2_filesys *fs, int type,
struct tools_progress *prog)
{
struct remove_quota_files_ctxt ctxt = {
.fs = fs,
.type = type,
.err = 0,
};
ocfs2_dir_iterate(fs, fs->fs_sysdir_blkno,
OCFS2_DIRENT_FLAG_EXCLUDE_DOTS, NULL,
remove_quota_files_iterate, &ctxt);
tools_progress_step(prog, 1);
return ctxt.err;
}
static int enable_usrquota(ocfs2_filesys *fs, int flags)
{
struct ocfs2_super_block *super = OCFS2_RAW_SB(fs->fs_super);
errcode_t ret;
struct tools_progress *prog = NULL;
if (OCFS2_HAS_RO_COMPAT_FEATURE(super,
OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) {
verbosef(VL_APP, "User quotas are already enabled; "
"nothing to enable\n");
return 0;
}
if (!tools_interact("Enable user quota feature on device "
"\"%s\"? ",
fs->fs_devname))
return 0;
prog = tools_progress_start("Enabling user quota", "usrquota", 6);
if (!prog) {
ret = TUNEFS_ET_NO_MEMORY;
tcom_err(ret, "while initializing progress display");
return ret;
}
tunefs_block_signals();
ret = create_quota_files(fs, USRQUOTA, prog);
if (ret) {
tcom_err(ret, "while creating user quota files");
goto bail;
}
OCFS2_SET_RO_COMPAT_FEATURE(super,
OCFS2_FEATURE_RO_COMPAT_USRQUOTA);
ret = ocfs2_write_super(fs);
tools_progress_step(prog, 1);
bail:
tunefs_unblock_signals();
tools_progress_stop(prog);
return ret;
}
static int disable_usrquota(ocfs2_filesys *fs, int flags)
{
errcode_t ret;
struct ocfs2_super_block *super = OCFS2_RAW_SB(fs->fs_super);
struct tools_progress *prog = NULL;
if (!OCFS2_HAS_RO_COMPAT_FEATURE(super,
OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) {
verbosef(VL_APP, "User quotas are already disabled; "
"nothing to disable\n");
return 0;
}
if (!tools_interact("Disable user quota feature on device "
"\"%s\"? ",
fs->fs_devname))
return 0;
prog = tools_progress_start("Disabling user quota", "nousrquota", 2);
if (!prog) {
ret = TUNEFS_ET_NO_MEMORY;
tcom_err(ret, "while initializing progress display");
return ret;
}
tunefs_block_signals();
ret = remove_quota_files(fs, USRQUOTA, prog);
if (ret) {
tcom_err(ret, "while removing user quota files");
goto bail;
}
OCFS2_CLEAR_RO_COMPAT_FEATURE(super,
OCFS2_FEATURE_RO_COMPAT_USRQUOTA);
ret = ocfs2_write_super(fs);
tools_progress_step(prog, 1);
bail:
tunefs_unblock_signals();
tools_progress_stop(prog);
return ret;
}
static errcode_t update_slot_count(ocfs2_filesys *fs, int num_slots)
{
errcode_t ret = 0;
int orig_slots = OCFS2_RAW_SB(fs->fs_super)->s_max_slots;
if (num_slots == orig_slots) {
verbosef(VL_APP,
"Device \"%s\" already has %d node slots; "
"nothing to do\n",
fs->fs_devname, num_slots);
goto out;
}
if (!tools_interact("Change the number of node slots on device "
"\"%s\" from %d to %d? ",
fs->fs_devname, orig_slots, num_slots))
goto out;
tunefs_block_signals();
if (num_slots > orig_slots)
ret = add_slots(fs, num_slots);
else
ret = remove_slots(fs, num_slots);
if (ret)
goto out_unblock;
OCFS2_RAW_SB(fs->fs_super)->s_max_slots = num_slots;
if (num_slots > orig_slots) {
/* Grow the new journals to match the first slot */
verbosef(VL_APP,
"Allocating space for the new journals\n");
ret = tunefs_set_journal_size(fs, 0);
if (!ret)
verbosef(VL_APP, "Journal space allocated\n");
else {
verbosef(VL_APP,
"%s while trying to size the new journals\n",
error_message(ret));
goto out_unblock;
}
}
ret = ocfs2_format_slot_map(fs);
if (ret)
goto out_unblock;
if (num_slots < orig_slots) {
ret = tunefs_clear_in_progress(fs,
OCFS2_TUNEFS_INPROG_REMOVE_SLOT);
if (ret)
goto out_unblock;
}
ret = ocfs2_write_super(fs);
out_unblock:
tunefs_unblock_signals();
out:
return ret;
}
