static errcode_t create_orphan_file(ocfs2_filesys *fs, uint16_t slot)
{
errcode_t ret;
uint64_t dir, tmp_blkno;
char name[OCFS2_MAX_FILENAME_LEN];
int namelen;
ret = ocfs2_lookup_system_inode(fs, ORPHAN_DIR_SYSTEM_INODE,
slot, &dir);
if (ret)
return ret;
namelen = sprintf(name, "test%ld", random());
ret = ocfs2_lookup(fs, dir, name, namelen, NULL, &tmp_blkno);
if (!ret)
return 0;
else if (ret != OCFS2_ET_FILE_NOT_FOUND)
return ret;
ret = ocfs2_new_inode(fs, &tmp_blkno, S_IFREG | 0755);
if (ret)
return ret;
ret = ocfs2_link(fs, dir, name,
tmp_blkno, OCFS2_FT_REG_FILE);
if (ret)
return ret;
return 0;
}
static errcode_t orphan_dir_check(ocfs2_filesys *fs,
uint16_t new_slots)
{
errcode_t ret = 0;
uint64_t blkno;
int i, has_orphan = 0;
uint16_t max_slots = OCFS2_RAW_SB(fs->fs_super)->s_max_slots;
for (i = new_slots ; i < max_slots; ++i) {
ret = ocfs2_lookup_system_inode(fs, ORPHAN_DIR_SYSTEM_INODE,
i, &blkno);
if (ret) {
verbosef(VL_APP,
"%s while looking up orphan dir for "
"slot %u during orphan dir check\n",
error_message(ret), i);
break;
}
ret = ocfs2_dir_iterate(fs, blkno,
OCFS2_DIRENT_FLAG_EXCLUDE_DOTS, NULL,
orphan_iterate, &has_orphan);
if (has_orphan) {
ret = TUNEFS_ET_ORPHAN_DIR_NOT_EMPTY;
verbosef(VL_APP,
"Entries found in orphan dir for slot %u\n",
i);
break;
}
}
return ret;
}
static errcode_t check_journal_walk(o2fsck_state *ost,
errcode_t (*func)(o2fsck_state *ost,
ocfs2_cached_inode *ci,
struct journal_check_context *jc),
struct journal_check_context *jc)
{
errcode_t ret = 0;
uint64_t blkno;
ocfs2_filesys *fs = ost->ost_fs;
uint16_t i, max_slots = OCFS2_RAW_SB(fs->fs_super)->s_max_slots;
ocfs2_cached_inode *ci = NULL;
for (i = 0; i < max_slots; i++) {
ret = ocfs2_lookup_system_inode(fs, JOURNAL_SYSTEM_INODE, i,
&blkno);
if (ret)
break;
ret = ocfs2_read_cached_inode(fs, blkno, &ci);
if (ret)
break;
jc->jc_this_slot = i;
ret = func(ost, ci, jc);
if (ret)
break;
}
if (ci)
ocfs2_free_cached_inode(fs, ci);
return ret;
}
static errcode_t truncate_orphan_dir(ocfs2_filesys *fs,
uint16_t removed_slot)
{
errcode_t ret;
uint64_t blkno;
char fname[OCFS2_MAX_FILENAME_LEN];
ocfs2_sprintf_system_inode_name(fname, OCFS2_MAX_FILENAME_LEN,
ORPHAN_DIR_SYSTEM_INODE,
removed_slot);
verbosef(VL_APP, "Truncating orphan dir \"%s\"\n", fname);
ret = ocfs2_lookup_system_inode(fs, ORPHAN_DIR_SYSTEM_INODE,
removed_slot, &blkno);
if (!ret) {
ret = ocfs2_truncate(fs, blkno, 0);
if (!ret)
verbosef(VL_APP, "Orphan dir \"%s\" truncated\n",
fname);
else
verbosef(VL_APP,
"%s while truncating orphan dir \"%s\"\n",
error_message(ret), fname);
} else
verbosef(VL_APP,
"%s while looking up orphan dir \"%s\"\n",
error_message(ret), fname);
return ret;
}
static errcode_t create_local_alloc(ocfs2_filesys *fs, uint16_t slot)
{
errcode_t ret;
char *buf = NULL;
struct ocfs2_dinode *di;
struct ocfs2_local_alloc *la;
uint32_t la_size, found;
uint64_t la_off, blkno;
ret = ocfs2_lookup_system_inode(fs, LOCAL_ALLOC_SYSTEM_INODE,
slot, &blkno);
if (ret)
goto bail;
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret)
goto bail;
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret)
goto bail;
di = (struct ocfs2_dinode *)buf;
if (!(di->i_flags & OCFS2_VALID_FL))
goto bail;
if (!(di->i_flags & OCFS2_LOCAL_ALLOC_FL))
goto bail;
if (di->id1.bitmap1.i_total > 0) {
fprintf(stderr, "local alloc#%"PRIu64" file not empty."
"Can't create a new one.\n", blkno);
goto bail;
}
la_size = get_local_alloc_window_bits();
ret = ocfs2_new_clusters(fs, 1, la_size, &la_off, &found);
if (ret)
goto bail;
if(la_size != found)
goto bail;
la = &(di->id2.i_lab);
la->la_bm_off = ocfs2_blocks_to_clusters(fs, la_off);
di->id1.bitmap1.i_total = la_size;
di->id1.bitmap1.i_used = 0;
memset(la->la_bitmap, 0, la->la_size);
ret = ocfs2_write_inode(fs, blkno, buf);
bail:
if(buf)
ocfs2_free(&buf);
return ret;
}
static errcode_t truncate_log_check(ocfs2_filesys *fs,
uint16_t new_slots)
{
errcode_t ret = 0;
uint16_t i;
uint64_t blkno;
char *buf = NULL;
struct ocfs2_dinode *di = NULL;
uint16_t max_slots = OCFS2_RAW_SB(fs->fs_super)->s_max_slots;
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
verbosef(VL_APP,
"%s while allocating inode buffer for "
"truncate log check\n",
error_message(ret));
goto bail;
}
for (i = new_slots; i < max_slots; ++i) {
ret = ocfs2_lookup_system_inode(fs, TRUNCATE_LOG_SYSTEM_INODE,
i, &blkno);
if (ret) {
verbosef(VL_APP,
"%s while looking up truncate log for "
"slot %u during truncate log check\n",
error_message(ret), i);
goto bail;
}
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret) {
verbosef(VL_APP,
"%s while reading inode %"PRIu64" "
"during truncate log check\n",
error_message(ret), blkno);
goto bail;
}
di = (struct ocfs2_dinode *)buf;
if (di->id2.i_dealloc.tl_used > 0) {
ret = TUNEFS_ET_TRUNCATE_LOG_NOT_EMPTY;
verbosef(VL_APP,
"Truncate log for slot %u is not empty\n",
i);
goto bail;
}
}
bail:
if (buf)
ocfs2_free(&buf);
return ret;
}
static errcode_t local_alloc_check(ocfs2_filesys *fs,
uint16_t new_slots)
{
errcode_t ret = 0;
uint16_t i;
uint64_t blkno;
char *buf = NULL;
struct ocfs2_dinode *di = NULL;
uint16_t max_slots = OCFS2_RAW_SB(fs->fs_super)->s_max_slots;
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
verbosef(VL_APP,
"%s while allocating inode buffer for local "
"alloc check\n",
error_message(ret));
goto bail;
}
for (i = new_slots ; i < max_slots; ++i) {
ret = ocfs2_lookup_system_inode(fs, LOCAL_ALLOC_SYSTEM_INODE,
i, &blkno);
if (ret) {
verbosef(VL_APP,
"%s while looking up local alloc for "
"slot %u during local alloc check\n",
error_message(ret), i);
break;
}
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret) {
verbosef(VL_APP,
"%s while reading inode %"PRIu64" "
"during local alloc check\n",
error_message(ret), blkno);
break;
}
di = (struct ocfs2_dinode *)buf;
if (di->id1.bitmap1.i_total > 0) {
ret = TUNEFS_ET_LOCAL_ALLOC_NOT_EMPTY;
verbosef(VL_APP,
"Local alloc for slot %u is not empty\n",
i);
break;
}
}
bail:
if (buf)
ocfs2_free(&buf);
return ret;
}
static errcode_t empty_and_truncate_journal(ocfs2_filesys *fs,
uint16_t removed_slot)
{
errcode_t ret;
uint64_t blkno;
ocfs2_cached_inode *ci = NULL;
char fname[OCFS2_MAX_FILENAME_LEN];
ocfs2_sprintf_system_inode_name(fname, OCFS2_MAX_FILENAME_LEN,
JOURNAL_SYSTEM_INODE,
removed_slot);
verbosef(VL_APP, "Truncating journal \"%s\"\n", fname);
ret = ocfs2_lookup_system_inode(fs, JOURNAL_SYSTEM_INODE,
removed_slot, &blkno);
if (ret) {
verbosef(VL_APP, "%s while looking up journal \"%s\"\n",
error_message(ret), fname);
goto bail;
}
ret = ocfs2_read_cached_inode(fs, blkno, &ci);
if (ret) {
verbosef(VL_APP,
"%s while reading journal inode %"PRIu64"\n",
error_message(ret), blkno);
goto bail;
}
/* we have to empty the journal since it may contains some
* inode blocks which look like valid(except the i_blkno).
* So if this block range is used for future inode alloc
* files, fsck.ocfs2 may raise some error.
*/
ret = empty_journal(fs, ci);
if (ret) {
verbosef(VL_APP, "%s while emptying journal \"%s\"\n",
error_message(ret), fname);
goto bail;
}
ret = ocfs2_truncate(fs, blkno, 0);
if (ret) {
verbosef(VL_APP, "%s while truncating journal \"%s\"\n",
error_message(ret), fname);
goto bail;
}
verbosef(VL_APP, "Journal \"%s\" truncated\n", fname);
bail:
if (ci)
ocfs2_free_cached_inode(fs, ci);
return ret;
}
static errcode_t prep_journal_info(ocfs2_filesys *fs, int slot,
struct journal_info *ji)
{
errcode_t err;
err = ocfs2_malloc_blocks(fs->fs_io, 1, &ji->ji_jsb);
if (err)
com_err(whoami, err, "while allocating space for slot %d's "
"journal superblock", slot);
err = ocfs2_lookup_system_inode(fs, JOURNAL_SYSTEM_INODE,
slot, &ji->ji_ino);
if (err) {
com_err(whoami, err, "while looking up the journal inode for "
"slot %d", slot);
goto out;
}
err = ocfs2_read_cached_inode(fs, ji->ji_ino, &ji->ji_cinode);
if (err) {
com_err(whoami, err, "while reading cached inode %"PRIu64" "
"for slot %d's journal", ji->ji_ino, slot);
goto out;
}
if (!(ji->ji_cinode->ci_inode->id1.journal1.ij_flags &
OCFS2_JOURNAL_DIRTY_FL))
goto out;
err = lookup_journal_block(fs, ji, 0, &ji->ji_jsb_block, 1);
if (err)
goto out;
/* XXX be smarter about reading in the whole super block if it
* spans multiple blocks */
err = ocfs2_read_journal_superblock(fs, ji->ji_jsb_block,
(char *)ji->ji_jsb);
if (err) {
com_err(whoami, err, "while reading block %"PRIu64" as slot "
"%d's journal super block", ji->ji_jsb_block,
ji->ji_slot);
goto out;
}
ji->ji_replay = 1;
verbosef("slot: %d jsb start %u maxlen %u\n", slot,
ji->ji_jsb->s_start, ji->ji_jsb->s_maxlen);
out:
return err;
}
errcode_t handle_slots_system_file(ocfs2_filesys *fs,
int type,
errcode_t (*func)(ocfs2_filesys *fs,
struct ocfs2_dinode *di,
int slot))
{
errcode_t ret;
uint64_t blkno;
int slot, max_slots;
char *buf = NULL;
struct ocfs2_dinode *di;
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret)
goto bail;
di = (struct ocfs2_dinode *)buf;
max_slots = OCFS2_RAW_SB(fs->fs_super)->s_max_slots;
for (slot = 0; slot < max_slots; slot++) {
ret = ocfs2_lookup_system_inode(fs,
type,
slot, &blkno);
if (ret)
goto bail;
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret)
goto bail;
if (func) {
ret = func(fs, di, slot);
if (ret)
goto bail;
}
}
bail:
if (buf)
ocfs2_free(&buf);
return ret;
}
static errcode_t load_global_bitmap(ocfs2_filesys *fs,
ocfs2_cached_inode** inode)
{
errcode_t ret;
uint64_t blkno;
ret = ocfs2_lookup_system_inode(fs, GLOBAL_BITMAP_SYSTEM_INODE,
0, &blkno);
if (ret)
goto bail;
ret = ocfs2_read_cached_inode(fs, blkno, inode);
if (ret)
goto bail;
ret = ocfs2_load_chain_allocator(fs, *inode);
bail:
return ret;
}
static PyObject *
fs_lookup_system_inode (Filesystem *self,
PyObject *args,
PyObject *kwargs)
{
errcode_t ret;
int type, slot_num = OCFS2_INVALID_SLOT;
uint64_t blkno;
static char *kwlist[] = { "type", "slot_num", NULL };
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"i|i:lookup_system_inode", kwlist,
&type, &slot_num))
return NULL;
CHECK_ERROR (ocfs2_lookup_system_inode(self->fs, type, slot_num, &blkno));
return PyLong_FromUnsignedLongLong (blkno);
}
void mess_up_dup_clusters(ocfs2_filesys *fs, enum fsck_type type,
uint64_t blkno)
{
errcode_t err;
char *buf = NULL;
uint64_t inode1_blkno, inode2_blkno;
struct ocfs2_dinode *di1, *di2;
struct ocfs2_extent_list *el1, *el2;
err = ocfs2_malloc_blocks(fs->fs_io, 2, &buf);
if (err)
FSWRK_COM_FATAL(progname, err);
create_file(fs, blkno, &inode1_blkno);
di1 = (struct ocfs2_dinode *)buf;
err = ocfs2_read_inode(fs, inode1_blkno, (char *)di1);
if (err)
FSWRK_COM_FATAL(progname, err);
if (ocfs2_support_inline_data(OCFS2_RAW_SB(fs->fs_super))) {
if (di1->i_dyn_features & OCFS2_INLINE_DATA_FL) {
di1->i_dyn_features &= ~OCFS2_INLINE_DATA_FL;
err = ocfs2_write_inode(fs, inode1_blkno, (char *)di1);
if (err)
FSWRK_COM_FATAL(progname, err);
}
}
if (type != DUP_CLUSTERS_SYSFILE_CLONE) {
create_file(fs, blkno, &inode2_blkno);
di2 = (struct ocfs2_dinode *)(buf + fs->fs_blocksize);
err = ocfs2_read_inode(fs, inode2_blkno, (char *)di2);
if (err)
FSWRK_COM_FATAL(progname, err);
if (ocfs2_support_inline_data(OCFS2_RAW_SB(fs->fs_super))) {
if (di2->i_dyn_features & OCFS2_INLINE_DATA_FL) {
di2->i_dyn_features &= ~OCFS2_INLINE_DATA_FL;
err = ocfs2_write_inode(fs, inode2_blkno,
(char *)di2);
if (err)
FSWRK_COM_FATAL(progname, err);
}
}
err = ocfs2_extend_allocation(fs, inode2_blkno, 1);
if (err)
FSWRK_COM_FATAL(progname, err);
/* Re-read the inode with the allocation */
err = ocfs2_read_inode(fs, inode2_blkno, (char *)di2);
if (err)
FSWRK_COM_FATAL(progname, err);
/* Set i_size to non-zero so that the allocation is valid */
di2->i_size = fs->fs_clustersize;
err = ocfs2_write_inode(fs, inode2_blkno, (char *)di2);
if (err)
FSWRK_COM_FATAL(progname, err);
if (type == DUP_CLUSTERS_CLONE)
fprintf(stdout, "DUP_CLUSTERS_CLONE: "
"Create two inodes #%"PRIu64" and #%"PRIu64
" by allocating same cluster to them.\n",
inode1_blkno, inode2_blkno);
else
fprintf(stdout, "DUP_CLUSTERS_DELETE: "
"Create two inodes #%"PRIu64" and #%"PRIu64
" by allocating same cluster to them.\n",
inode1_blkno, inode2_blkno);
} else {
/* Here use journal file*/
err = ocfs2_lookup_system_inode(fs, JOURNAL_SYSTEM_INODE, 0,
&inode2_blkno);
if (err)
FSWRK_COM_FATAL(progname, err);
di2 = (struct ocfs2_dinode *)(buf + fs->fs_blocksize);
err = ocfs2_read_inode(fs, inode2_blkno, (char *)di2);
if (err)
FSWRK_COM_FATAL(progname, err);
if (di2->id2.i_list.l_tree_depth)
FSWRK_FATAL("Journal inode has non-zero tree "
"depth. fswreck can't use it for "
"DUP_CLUSTERS_SYSFILE_CLONE\n");
fprintf(stdout, "DUP_CLUSTERS_SYSFILE_CLONE: "
"Allocate same cluster to journal file "
"#%"PRIu64" and regular file #%"PRIu64".\n",
inode1_blkno, inode2_blkno);
}
el1 = &(di1->id2.i_list);
el2 = &(di2->id2.i_list);
el1->l_next_free_rec = 1;
el1->l_recs[0] = el2->l_recs[0];
di1->i_size =
ocfs2_clusters_to_bytes(fs, el1->l_recs[0].e_leaf_clusters);
di1->i_clusters = di2->i_clusters;
err = ocfs2_write_inode(fs, inode1_blkno, (char *)di1);
if (err)
FSWRK_COM_FATAL(progname, err);
ocfs2_free(&buf);
}
static errcode_t create_truncate_log(ocfs2_filesys *fs, uint16_t slot)
{
errcode_t ret;
char *buf = NULL;
struct ocfs2_dinode *di;
struct ocfs2_truncate_log *tl;
uint16_t i, used = 10;
uint32_t found, clusters = 10;
uint64_t begin, blkno;
ret = ocfs2_lookup_system_inode(fs, TRUNCATE_LOG_SYSTEM_INODE,
slot, &blkno);
if (ret)
goto bail;
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret)
goto bail;
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret)
goto bail;
di = (struct ocfs2_dinode *)buf;
if (!(di->i_flags & OCFS2_VALID_FL)) {
fprintf(stderr,"not a valid file\n");
goto bail;
}
if (!(di->i_flags & OCFS2_DEALLOC_FL)) {
fprintf(stderr,"not a valid truncate log\n");
goto bail;
}
tl = &di->id2.i_dealloc;
if (le16_to_cpu(tl->tl_used) > 0) {
fprintf(stderr,"truncate log#%"PRIu64" file not empty."
"Can't create a new one.\n", blkno);
goto bail;
}
tl->tl_used = used;
for (i = 0; i < tl->tl_used; i++) {
ret = ocfs2_new_clusters(fs, 1, clusters, &begin, &found);
if (ret)
goto bail;
tl->tl_recs[i].t_start =
ocfs2_blocks_to_clusters(fs, begin);
tl->tl_recs[i].t_clusters = found;
}
ret = ocfs2_write_inode(fs, blkno, buf);
bail:
if(buf)
ocfs2_free(&buf);
return ret;
}
/*
* We only need to replay the journals if the inode's flag is set and s_start
* indicates that there is actually pending data in the journals.
*
* In the simple case of an unclean shutdown we don't want to have to build up
* enough state to be able to truncate the inodes waiting in the orphan dir.
* ocfs2 in the kernel only fixes up the orphan dirs if the journal dirty flag
* is set. So after replaying the journals we clear s_startin the journals to
* stop a second journal replay but leave the dirty bit set so that the kernel
* will truncate the orphaned inodes.
*/
errcode_t o2fsck_should_replay_journals(ocfs2_filesys *fs, int *should,
int *has_dirty)
{
uint16_t i, max_slots;
char *buf = NULL;
uint64_t blkno;
errcode_t ret;
ocfs2_cached_inode *cinode = NULL;
int is_dirty;
uint64_t contig;
journal_superblock_t *jsb;
*should = 0;
max_slots = OCFS2_RAW_SB(fs->fs_super)->s_max_slots;
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(whoami, ret, "while allocating room to read journal "
"blocks");
goto out;
}
jsb = (journal_superblock_t *)buf;
for (i = 0; i < max_slots; i++) {
ret = ocfs2_lookup_system_inode(fs, JOURNAL_SYSTEM_INODE, i,
&blkno);
if (ret) {
com_err(whoami, ret, "while looking up the journal "
"inode for slot %d", i);
goto out;
}
if (cinode) {
ocfs2_free_cached_inode(fs, cinode);
cinode = NULL;
}
ret = ocfs2_read_cached_inode(fs, blkno, &cinode);
if (ret) {
com_err(whoami, ret, "while reading cached inode "
"%"PRIu64" for slot %d's journal", blkno, i);
goto out;
}
is_dirty = cinode->ci_inode->id1.journal1.ij_flags &
OCFS2_JOURNAL_DIRTY_FL;
verbosef("slot %d JOURNAL_DIRTY_FL: %d\n", i, is_dirty);
if (!is_dirty)
continue;
else
*has_dirty = 1;
ret = ocfs2_extent_map_get_blocks(cinode, 0, 1, &blkno,
&contig, NULL);
if (ret) {
com_err(whoami, ret, "while looking up the journal "
"super block in slot %d's journal", i);
goto out;
}
/* XXX be smarter about reading in the whole super block if it
* spans multiple blocks */
ret = ocfs2_read_journal_superblock(fs, blkno, buf);
if (ret) {
com_err(whoami, ret, "while reading the journal "
"super block in slot %d's journal", i);
goto out;
}
if (jsb->s_start)
*should = 1;
}
out:
if (buf)
ocfs2_free(&buf);
if (cinode)
ocfs2_free_cached_inode(fs, cinode);
return ret;
}
static errcode_t relink_system_alloc(ocfs2_filesys *fs,
uint16_t removed_slot,
uint16_t new_slots,
int inode_type)
{
errcode_t ret;
int16_t i;
uint64_t blkno;
struct ocfs2_dinode *di = NULL;
struct ocfs2_chain_list *cl = NULL;
struct relink_ctxt ctxt;
char fname[OCFS2_MAX_FILENAME_LEN];
memset(&ctxt, 0, sizeof(ctxt));
ocfs2_sprintf_system_inode_name(fname, OCFS2_MAX_FILENAME_LEN,
inode_type, removed_slot);
verbosef(VL_APP, "Relinking system allocator \"%s\"\n", fname);
ret = ocfs2_lookup_system_inode(fs, inode_type,
removed_slot, &blkno);
if (ret) {
verbosef(VL_APP, "%s while looking up the allocator\n",
error_message(ret));
goto bail;
}
ret = ocfs2_malloc_block(fs->fs_io, &ctxt.src_inode);
if (ret) {
verbosef(VL_APP,
"%s while allocating the inode buffer\n",
error_message(ret));
goto bail;
}
ret = ocfs2_read_inode(fs, blkno, ctxt.src_inode);
if (ret) {
verbosef(VL_APP,
"%s while reading allocator inode %"PRIu64"\n",
error_message(ret), blkno);
goto bail;
}
di = (struct ocfs2_dinode *)ctxt.src_inode;
if (!(di->i_flags & OCFS2_VALID_FL) ||
!(di->i_flags & OCFS2_BITMAP_FL) ||
!(di->i_flags & OCFS2_CHAIN_FL)) {
verbosef(VL_APP, "Allocator inode %"PRIu64" is corrupt.\n",
blkno);
goto bail;
}
if (di->id1.bitmap1.i_total == 0)
goto bail;
/* Iterate all the groups and modify the group descriptors accordingly. */
ret = ocfs2_malloc_block(fs->fs_io, &ctxt.ex_buf);
if (ret) {
verbosef(VL_APP,
"%s while allocating an extent block buffer\n",
error_message(ret));
goto bail;
}
ret = ocfs2_malloc_block(fs->fs_io, &ctxt.dst_inode);
if (ret) {
verbosef(VL_APP,
"%s while allocating the destination inode buffer\n",
error_message(ret));
goto bail;
}
cl = &di->id2.i_chain;
ctxt.inode_type = inode_type;
/*iterate all the chain record and move them to the new slots. */
for (i = cl->cl_next_free_rec - 1; i >= 0; i--) {
ctxt.new_slot = i % new_slots;
ret = ocfs2_lookup_system_inode(fs, inode_type,
ctxt.new_slot,
&ctxt.dst_blkno);
if (ret) {
verbosef(VL_APP,
"%s while finding the target allocator "
"for slot %d\n",
error_message(ret), ctxt.new_slot);
goto bail;
}
ret = ocfs2_read_inode(fs, ctxt.dst_blkno, ctxt.dst_inode);
if (ret) {
verbosef(VL_APP,
"%s while reading target allocator inode "
"%"PRIu64"\n",
error_message(ret), ctxt.dst_blkno);
goto bail;
}
ctxt.cr = &cl->cl_recs[i];
ret = move_chain_rec(fs, &ctxt);
if (ret) {
verbosef(VL_APP,
"%s while trying to move a chain record "
"to the allocator in slot %d\n",
error_message(ret), ctxt.new_slot);
goto bail;
}
}
/* emtpy the original alloc files. */
di->id1.bitmap1.i_used = 0;
di->id1.bitmap1.i_total = 0;
di->i_clusters = 0;
di->i_size = 0;
cl = &di->id2.i_chain;
cl->cl_next_free_rec = 0;
memset(cl->cl_recs, 0, sizeof(struct ocfs2_chain_rec) * cl->cl_count);
ret = ocfs2_write_inode(fs, blkno, ctxt.src_inode);
if (ret)
verbosef(VL_APP,
"%s while writing out the empty allocator inode\n",
error_message(ret));
bail:
if (ctxt.ex_buf)
ocfs2_free(&ctxt.ex_buf);
if (ctxt.dst_inode)
ocfs2_free(&ctxt.dst_inode);
if (ctxt.src_inode)
ocfs2_free(&ctxt.src_inode);
if (!ret)
verbosef(VL_APP, "Successfully relinked allocator \"%s\"\n",
fname);
return ret;
}
