[Ocfs2-tools-devel] [PATCH 39/50] fsck.ocfs2: Check refcount of clusters.v3
Tao Ma
tao.ma at oracle.com
Wed Feb 3 00:29:13 PST 2010
Hi Joel,
I have refactored this patch. The huge function is split
into several small ones. And I also remove some unused parameters.
Enjoy it. I will re-send the whole series once this get your
ack.
As we have added refcounted clusters into rb-tree,
now we can rebuild the refcount tree according to
these result.
Signed-off-by: Tao Ma <tao.ma at oracle.com>
---
fsck.ocfs2/fsck.ocfs2.checks.8.in | 12 +
fsck.ocfs2/include/refcount.h | 1 +
fsck.ocfs2/pass1.c | 3 +
fsck.ocfs2/refcount.c | 587 +++++++++++++++++++++++++++++++++++++
include/ocfs2/ocfs2.h | 6 +
libocfs2/refcount.c | 12 +-
6 files changed, 615 insertions(+), 6 deletions(-)
diff --git a/fsck.ocfs2/fsck.ocfs2.checks.8.in b/fsck.ocfs2/fsck.ocfs2.checks.8.in
index e134ac8..af5eecc 100644
--- a/fsck.ocfs2/fsck.ocfs2.checks.8.in
+++ b/fsck.ocfs2/fsck.ocfs2.checks.8.in
@@ -657,6 +657,18 @@ refering an invalid refcount block.
Answering yes remove this refcount block and clear refcount flag from this file.
+.SS "REFCOUNT_REC_REDUNDANT"
+Refcount record is used to store the refcount for physical clusters. Some
+refcount record is found to have no physical clusters corresponding to it.
+
+Answering yes remove the refcount record.
+
+.SS "REFCOUNT_COUNT_INVALID"
+Refcount record is used to store the refcount for physical clusters. A record
+record is found whichs claims the wrong refcount for some physical clusters.
+
+Answering yes update the corresponding refcount record.
+
\" pass1b.c
.SS "DUP_CLUSTERS_SYSFILE_CLONE"
diff --git a/fsck.ocfs2/include/refcount.h b/fsck.ocfs2/include/refcount.h
index 4e4f901..40cb5b5 100644
--- a/fsck.ocfs2/include/refcount.h
+++ b/fsck.ocfs2/include/refcount.h
@@ -28,5 +28,6 @@ errcode_t o2fsck_mark_clusters_refcounted(o2fsck_state *ost,
uint64_t p_cpos,
uint32_t clusters,
uint32_t v_cpos);
+errcode_t o2fsck_check_mark_refcounted_clusters(o2fsck_state *ost);
#endif /* __O2FSCK_REFCOUNT_H__ */
diff --git a/fsck.ocfs2/pass1.c b/fsck.ocfs2/pass1.c
index e605aca..c90f699 100644
--- a/fsck.ocfs2/pass1.c
+++ b/fsck.ocfs2/pass1.c
@@ -1436,6 +1436,9 @@ errcode_t o2fsck_pass1(o2fsck_state *ost)
mark_local_allocs(ost);
mark_truncate_logs(ost);
+ ret = o2fsck_check_mark_refcounted_clusters(ost);
+ if (ret)
+ com_err(whoami, ret, "while checking refcounted clusters");
write_cluster_alloc(ost);
write_inode_alloc(ost);
diff --git a/fsck.ocfs2/refcount.c b/fsck.ocfs2/refcount.c
index 78b1610..5ec57c3 100644
--- a/fsck.ocfs2/refcount.c
+++ b/fsck.ocfs2/refcount.c
@@ -57,6 +57,10 @@ struct refcount_tree {
struct list_head files_list;
int files_count;
int is_valid;
+ char *root_buf;
+ char *leaf_buf;
+ /* the cluster offset we have checked against this tree. */
+ uint64_t p_cend;
};
static errcode_t check_rb(o2fsck_state *ost, uint64_t blkno,
@@ -483,3 +487,586 @@ add_clusters:
refcount_extent_insert(file, extent);
return 0;
}
+
+/*
+ * Given a refcount tree, find the lowest p_cpos of all
+ * the files sharing the tree.
+ */
+static int get_refcounted_extent(struct refcount_tree *tree,
+ uint64_t *p_cpos,
+ uint32_t *p_clusters,
+ uint32_t *p_refcount)
+{
+ struct refcount_extent *extent;
+ struct refcount_file *file;
+ struct list_head *p, *next;
+ struct rb_node *node;
+ uint64_t cpos = UINT64_MAX;
+ uint32_t clusters = 0, refcount = 0;
+ int found = 0;
+
+ list_for_each_safe(p, next, &tree->files_list) {
+ file = list_entry(p, struct refcount_file, list);
+ node = rb_first(&file->ref_extents);
+
+ /*
+ * If the file has no extent, go to next file.
+ * XXX: We can improve it here by removing the empty file.
+ */
+ if (!node)
+ continue;
+
+ found = 1;
+
+ extent = rb_entry(node, struct refcount_extent, ext_node);
+ if (extent->p_cpos < cpos) {
+ /* We meet with a new start. */
+ clusters = cpos - extent->p_cpos < extent->clusters ?
+ cpos - extent->p_cpos : extent->clusters;
+ cpos = extent->p_cpos;
+ refcount = 1;
+ } else if (extent->p_cpos == cpos) {
+ clusters = clusters < extent->clusters ?
+ clusters : extent->clusters;
+ refcount++;
+ } else if (extent->p_cpos < cpos + clusters) {
+ /*
+ * extent->p_cpos > cpos, change clusters accordingly.
+ */
+ clusters = extent->p_cpos - cpos;
+ }
+ }
+
+ if (!found)
+ return 0;
+
+ *p_cpos = cpos;
+ *p_clusters = clusters;
+ *p_refcount = refcount;
+
+ return 1;
+}
+
+/*
+ * Remove pair(cpos, clusters) from the all the files sharing the tree.
+ * The pair is actually got by get_refcounted_extent.
+ */
+static void remove_refcounted_extent(struct refcount_tree *tree,
+ uint64_t cpos,
+ uint32_t clusters)
+{
+ struct refcount_extent *extent;
+ struct refcount_file *file;
+ struct list_head *p, *next;
+ struct rb_node *node;
+
+ /* Remove the tuple from the refcounted file. */
+ list_for_each_safe(p, next, &tree->files_list) {
+ file = list_entry(p, struct refcount_file, list);
+ node = rb_first(&file->ref_extents);
+
+ /* If the file has no extent, go to next file. */
+ if (!node)
+ continue;
+
+ extent = rb_entry(node, struct refcount_extent, ext_node);
+ assert(extent->p_cpos >= cpos);
+
+ if (cpos + clusters <= extent->p_cpos)
+ continue;
+
+ assert(extent->p_cpos + extent->clusters >= cpos + clusters);
+
+ if (cpos + clusters == extent->p_cpos + extent->clusters) {
+ rb_erase(&extent->ext_node, &file->ref_extents);
+ ocfs2_free(&extent);
+ } else {
+ extent->clusters =
+ (extent->p_cpos + extent->clusters) -
+ (cpos + clusters);
+ extent->p_cpos = cpos + clusters;
+ }
+ }
+}
+
+/*
+ * Check all the files sharing the tree and if there is a file contains
+ * the (p_cpos, len) with refcounted flag, we clear it.
+ * Note:
+ * This function is only called when checking a continuous clusters.
+ * The pair (p_cpos, len) is a part of the original tuple we get from
+ * get_refcounted_extent, so it can't be in 2 different refcount_extent.
+ */
+static errcode_t o2fsck_clear_refcount(o2fsck_state *ost,
+ struct refcount_tree *tree,
+ uint64_t p_cpos,
+ uint32_t len)
+{
+ errcode_t ret = 0;
+ struct refcount_extent *extent;
+ struct refcount_file *file;
+ struct list_head *p, *next;
+ struct rb_node **node;
+ uint32_t v_start;
+
+ list_for_each_safe(p, next, &tree->files_list) {
+ file = list_entry(p, struct refcount_file, list);
+ node = &file->ref_extents.rb_node;
+
+ /* If the file has no extent, go to next file. */
+ if (!*node)
+ continue;
+
+ while (*node) {
+ extent = rb_entry(*node,
+ struct refcount_extent, ext_node);
+ if (extent->p_cpos > p_cpos + len)
+ node = &(*node)->rb_left;
+ else if (extent->p_cpos + extent->clusters <= p_cpos)
+ node = &(*node)->rb_right;
+ else
+ break;
+ }
+
+ if (node &&
+ (extent->p_cpos <= p_cpos &&
+ extent->p_cpos + extent->clusters >= p_cpos + len)) {
+ v_start = p_cpos - extent->p_cpos + extent->v_cpos;
+ ret = ocfs2_change_refcount_flag(ost->ost_fs,
+ file->i_blkno,
+ v_start, len,
+ p_cpos, 0,
+ OCFS2_EXT_REFCOUNTED);
+ if (ret) {
+ com_err(whoami, ret,
+ "while clearing refcount flag at "
+ "%u in file %"PRIu64,
+ v_start, file->i_blkno);
+ goto out;
+ }
+ }
+ }
+
+out:
+ return ret;
+}
+
+/*
+ * o2fsck_refcount_punch_hole and o2fsck_change_refcount are just wrappers
+ * for the corresponding libocfs2 functions with one addition: re-read
+ * root refcount block since we may have changed the tree during the operation.
+ */
+static errcode_t o2fsck_refcount_punch_hole(o2fsck_state *ost,
+ struct refcount_tree *tree,
+ uint64_t p_cpos, uint32_t len)
+{
+ errcode_t ret;
+
+ ret = ocfs2_refcount_punch_hole(ost->ost_fs, tree->rf_blkno,
+ p_cpos, len);
+ if (ret) {
+ com_err(whoami, ret, "while punching hole in "
+ "(%"PRIu64", %u) in refcount tree %"PRIu64,
+ p_cpos, len, tree->rf_blkno);
+ goto out;
+ }
+
+ /* re-read the root blkno since we may have changed it somehow. */
+ ret = ocfs2_read_refcount_block(ost->ost_fs,
+ tree->rf_blkno, tree->root_buf);
+
+out:
+ return ret;
+}
+
+static errcode_t o2fsck_change_refcount(o2fsck_state *ost,
+ struct refcount_tree *tree,
+ uint64_t p_cpos, uint32_t len,
+ uint32_t refcount)
+{
+ errcode_t ret;
+
+ ret = ocfs2_change_refcount(ost->ost_fs, tree->rf_blkno,
+ p_cpos, len, refcount);
+ if (ret) {
+ com_err(whoami, ret, "while changing refcount in "
+ "(%"PRIu64", %u) in refcount tree %"PRIu64" to %u",
+ p_cpos, len, tree->rf_blkno, refcount);
+ goto out;
+ }
+
+ /* re-read the root blkno since we may have changed it somehow. */
+ ret = ocfs2_read_refcount_block(ost->ost_fs,
+ tree->rf_blkno, tree->root_buf);
+
+out:
+ return ret;
+
+}
+
+/*
+ * Given [cpos, end), remove all the refcount records in this range from
+ * the refcount tree.
+ */
+static errcode_t o2fsck_remove_refcount_range(o2fsck_state *ost,
+ struct refcount_tree *tree,
+ uint64_t cpos,
+ uint64_t end)
+{
+ errcode_t ret = 0;
+ int index;
+ unsigned int len;
+ struct ocfs2_refcount_rec rec;
+ uint64_t range = end - cpos;
+
+ while (range) {
+ len = range > UINT_MAX ? UINT_MAX : range;
+
+ ret = ocfs2_get_refcount_rec(ost->ost_fs, tree->root_buf,
+ cpos, len, &rec,
+ &index, tree->leaf_buf);
+ if (ret) {
+ com_err(whoami, ret, "while getting refcount rec at "
+ "%"PRIu64" in tree %"PRIu64,
+ cpos, tree->rf_blkno);
+ goto out;
+ }
+
+ if (!rec.r_refcount) {
+ cpos += rec.r_clusters;
+ range -= rec.r_clusters;
+ continue;
+ }
+
+ /*
+ * In case we found some refcount rec, just ask for
+ * punching hole for the whole range (cpos, len), and
+ * o2fsck_refcount_punch_hole will handle the complex
+ * issue for us.
+ */
+ if (prompt(ost, PY, PR_REFCOUNT_REC_REDUNDANT,
+ "refcount records among clusters (%"PRIu64
+ ", %u) are found with no physical clusters "
+ "corresponding to them. Remove them?", cpos, len)) {
+ ret = o2fsck_refcount_punch_hole(ost, tree, cpos, len);
+ if (ret) {
+ com_err(whoami, ret, "while punching "
+ "hole in (%"PRIu64", %u) in refcount "
+ "tree %"PRIu64, cpos, len,
+ tree->rf_blkno);
+ goto out;
+ }
+ }
+ cpos += len;
+ range -= len;
+ }
+
+out:
+ return ret;
+}
+
+/*
+ * Given tuple(p_cpos, clusters, refcount), check whether the refcount
+ * tree has the corresponding refcount record. If not, add/update them.
+ * If the user don't allow us to change the refcount tree, add them to
+ * to duplicate_clusters and let it handle them.
+ */
+static errcode_t o2fsck_check_clusters_in_refcount(o2fsck_state *ost,
+ struct refcount_tree *tree,
+ uint64_t p_cpos,
+ uint32_t clusters,
+ uint32_t refcount)
+{
+ errcode_t ret = 0;
+ uint32_t rec_len;
+ int index;
+ struct ocfs2_refcount_rec rec;
+
+ if (!clusters)
+ return 0;
+
+ /*
+ * the previous check ended at tree->p_cend, and now we get
+ * p_cpos, so any refcount record between p_cend and p_cpos
+ * should be considered as redundant.
+ */
+ ret = o2fsck_remove_refcount_range(ost, tree, tree->p_cend,
+ p_cpos);
+ if (ret) {
+ com_err(whoami, ret, "while removing refcount rec from "
+ "%"PRIu64" to %"PRIu64" in tree %"PRIu64,
+ tree->p_cend, p_cpos, tree->rf_blkno);
+ goto out;
+ }
+
+ tree->p_cend = p_cpos + clusters;
+again:
+ ret = ocfs2_get_refcount_rec(ost->ost_fs, tree->root_buf,
+ p_cpos, clusters, &rec,
+ &index, tree->leaf_buf);
+ if (ret) {
+ com_err(whoami, ret, "while getting refcount rec at "
+ "%"PRIu64" in tree %"PRIu64,
+ p_cpos, tree->rf_blkno);
+ goto out;
+ }
+
+ /*
+ * Actually ocfs2_get_refcount_rec will fake some refcount record
+ * in case it can't find p_cpos in the refcount tree. So we really
+ * shouldn't meet with a case rec->r_cpos > p_cpos.
+ */
+ assert(rec.r_cpos <= p_cpos);
+
+ rec_len = ocfs2_min(p_cpos + clusters,
+ (uint64_t)rec.r_cpos + rec.r_clusters) - p_cpos;
+ if (rec.r_refcount != refcount) {
+ if (prompt(ost, PY, PR_REFCOUNT_COUNT_INVALID,
+ "clusters %"PRIu64 " with len %u have %u refcount "
+ "while there are %u files point to them. "
+ "Correct the refcount value?",
+ p_cpos, rec_len, rec.r_refcount, refcount)) {
+ ret = o2fsck_change_refcount(ost, tree,
+ p_cpos, rec_len, refcount);
+ if (ret) {
+ com_err(whoami, ret, "while updating refcount "
+ "%u at %"PRIu64" len %u in tree "
+ "%"PRIu64, refcount, p_cpos,
+ rec_len, tree->rf_blkno);
+ goto out;
+ }
+ } else {
+ /*
+ * XXX:
+ * Do we need to ask user for adding them to dup?
+ *
+ * Call o2fsck_mark_clusters_allocated will add them
+ * them to duplicate_clusters automatically.
+ */
+ o2fsck_mark_clusters_allocated(ost, p_cpos, rec_len);
+ ret = o2fsck_refcount_punch_hole(ost, tree,
+ p_cpos, rec_len);
+ if (ret) {
+ com_err(whoami, ret, "while punching "
+ "hole at %"PRIu64"in refcount "
+ "tree %"PRIu64, p_cpos,
+ tree->rf_blkno);
+ goto out;
+ }
+
+ ret = o2fsck_clear_refcount(ost, tree, p_cpos, rec_len);
+ if (ret) {
+ com_err(whoami, ret,
+ "while clearing refcount for "
+ "cluster %"PRIu64" len %u in %"PRIu64,
+ p_cpos, rec_len, tree->rf_blkno);
+ goto out;
+ }
+ }
+ }
+
+ /* we have finished checking (p_cpos, clusters). */
+ if (p_cpos + clusters <= rec.r_cpos + rec.r_clusters)
+ goto out;
+
+ /*
+ * now we have finished checking current refcount_rec,
+ * p_cpos + clusters > rec.r_cpos + rec.r_clusters,
+ * need to read next refcount_rec.
+ */
+ clusters += p_cpos;
+ p_cpos = rec.r_cpos + rec.r_clusters;
+ clusters -= p_cpos;
+ goto again;
+
+out:
+ return ret;
+}
+
+static errcode_t o2fsck_check_refcount_clusters(o2fsck_state *ost,
+ struct refcount_tree *tree,
+ uint64_t start,
+ uint32_t len,
+ uint32_t refcount)
+{
+ int val;
+ errcode_t ret = 0;
+ uint64_t p_cend;
+ uint32_t clusters;
+
+ o2fsck_mark_clusters_allocated(ost, start, len);
+
+ while (len) {
+ if (ost->ost_duplicate_clusters) {
+ /*
+ * Check whether the clusters can be found in
+ * duplicated cluster list.
+ */
+ p_cend = start;
+ clusters = len;
+ while (clusters) {
+ ocfs2_bitmap_test(
+ ost->ost_duplicate_clusters,
+ p_cend, &val);
+ if (val)
+ break;
+
+ clusters--;
+ p_cend++;
+ }
+ } else
+ p_cend = start + len;
+
+ /*
+ * p_cend points to the end cluster we will check in this loop.
+ *
+ * If there is a cluster which is already setted by other
+ * owner(find in duplicate_clusters), p_end now points to it.
+ *
+ * So we check the refcounted clusters [start, p_cend) and then
+ * punch a hole in refcount tree at p_cend in case.
+ */
+ clusters = p_cend - start;
+
+ ret = o2fsck_check_clusters_in_refcount(ost,
+ tree,
+ start,
+ clusters,
+ refcount);
+ if (ret) {
+ com_err(whoami, ret, "while checking "
+ "refcounted clusters");
+ goto out;
+ }
+
+ if (len > clusters) {
+ /*
+ * We haven't finished our check and the reason
+ * is that p_cend is setted in dup_clusters, so
+ * punch a hole, clear the refcount flag for
+ * p_cend and continue our check.
+ */
+ ret = o2fsck_refcount_punch_hole(ost, tree,
+ p_cend, 1);
+ if (ret) {
+ com_err(whoami, ret, "while punching "
+ "hole at %"PRIu64"in refcount "
+ "tree %"PRIu64, p_cend,
+ tree->rf_blkno);
+ goto out;
+ }
+ ret = o2fsck_clear_refcount(ost, tree,
+ p_cend, 1);
+ if (ret) {
+ com_err(whoami, ret,
+ "while clearing refcount for "
+ "cluster %"PRIu64" in %"PRIu64,
+ p_cend, tree->rf_blkno);
+ goto out;
+ }
+ /* start check from next cluster. */
+ p_cend++;
+ }
+
+ len = start + len - p_cend;
+ start = p_cend;
+ }
+
+out:
+ return ret;
+}
+
+/*
+ * Given a refcount tree, check the refcounted clusters and their refcount.
+ */
+static errcode_t o2fsck_check_refcount(o2fsck_state *ost,
+ struct refcount_tree *tree)
+{
+ errcode_t ret;
+ uint64_t p_cpos = 0;
+ uint32_t clusters = 0, refcount = 0;
+
+ ret = ocfs2_malloc_block(ost->ost_fs->fs_io, &tree->root_buf);
+ if (ret) {
+ com_err(whoami, ret, "while allocating a block-sized buffer "
+ "for a refcount block");
+ goto out;
+ }
+
+ ret = ocfs2_malloc_block(ost->ost_fs->fs_io, &tree->leaf_buf);
+ if (ret) {
+ com_err(whoami, ret, "while allocating a block-sized buffer "
+ "for a refcount block");
+ goto out;
+ }
+
+ ret = ocfs2_read_refcount_block(ost->ost_fs,
+ tree->rf_blkno, tree->root_buf);
+ if (ret) {
+ com_err(whoami, ret, "while reading root refcount block at"
+ " %"PRIu64, tree->rf_blkno);
+ goto out;
+ }
+
+ while (get_refcounted_extent(tree, &p_cpos,
+ &clusters, &refcount)) {
+ ret = o2fsck_check_refcount_clusters(ost, tree, p_cpos,
+ clusters, refcount);
+ if (ret) {
+ com_err(whoami, ret, "while checking refcount clusters "
+ "(%"PRIu64", %u, %u) in tree %"PRIu64,
+ p_cpos, clusters, refcount, tree->rf_blkno);
+ goto out;
+ }
+ remove_refcounted_extent(tree, p_cpos, clusters);
+ }
+
+ /*
+ * Remove all the refcount rec passed p_cpos + clusters from the tree
+ * since there is no corresponding refcounted clusters.
+ */
+ ret = o2fsck_remove_refcount_range(ost, tree, p_cpos + clusters,
+ tree->rf_end);
+ if (ret)
+ com_err(whoami, ret, "while deleting redundant refcount rec");
+out:
+ if (tree->root_buf)
+ ocfs2_free(&tree->root_buf);
+ if (tree->leaf_buf)
+ ocfs2_free(&tree->leaf_buf);
+ return ret;
+}
+
+errcode_t o2fsck_check_mark_refcounted_clusters(o2fsck_state *ost)
+{
+ errcode_t ret = 0;
+ struct refcount_tree *tree;
+ struct rb_node *node;
+ struct list_head *p, *next;
+ struct refcount_file *file;
+
+ if (!ocfs2_refcount_tree(OCFS2_RAW_SB(ost->ost_fs->fs_super)))
+ return 0;
+
+ while ((node = rb_first(&ost->ost_refcount_trees)) != NULL) {
+ tree = rb_entry(node, struct refcount_tree, ref_node);
+
+ if (tree->is_valid) {
+ ret = o2fsck_check_refcount(ost, tree);
+ if (ret)
+ goto out;
+ }
+
+ list_for_each_safe(p, next, &tree->files_list) {
+ file = list_entry(p, struct refcount_file, list);
+ node = rb_first(&file->ref_extents);
+ assert(!node);
+ list_del(&file->list);
+ ocfs2_free(&file);
+ }
+ rb_erase(&tree->ref_node, &ost->ost_refcount_trees);
+ ocfs2_free(&tree);
+ }
+out:
+ return ret;
+}
diff --git a/include/ocfs2/ocfs2.h b/include/ocfs2/ocfs2.h
index 2f24edd..65e10e7 100644
--- a/include/ocfs2/ocfs2.h
+++ b/include/ocfs2/ocfs2.h
@@ -439,6 +439,12 @@ errcode_t ocfs2_refcount_punch_hole(ocfs2_filesys *fs, uint64_t rf_blkno,
errcode_t ocfs2_change_refcount(ocfs2_filesys *fs, uint64_t rf_blkno,
uint64_t p_start, uint32_t len,
uint32_t refcount);
+int ocfs2_get_refcount_rec(ocfs2_filesys *fs,
+ char *ref_root_buf,
+ uint64_t cpos, unsigned int len,
+ struct ocfs2_refcount_rec *ret_rec,
+ int *index,
+ char *ret_buf);
errcode_t ocfs2_swap_dir_entries_from_cpu(void *buf, uint64_t bytes);
errcode_t ocfs2_swap_dir_entries_to_cpu(void *buf, uint64_t bytes);
void ocfs2_swap_dir_trailer(struct ocfs2_dir_block_trailer *trailer);
diff --git a/libocfs2/refcount.c b/libocfs2/refcount.c
index d8fe16e..58afe32 100644
--- a/libocfs2/refcount.c
+++ b/libocfs2/refcount.c
@@ -280,12 +280,12 @@ out:
* and end at a small value between cpos+len and start of the next record.
* This fake record has r_refcount = 0.
*/
-static int ocfs2_get_refcount_rec(ocfs2_filesys *fs,
- char *ref_root_buf,
- uint64_t cpos, unsigned int len,
- struct ocfs2_refcount_rec *ret_rec,
- int *index,
- char *ret_buf)
+int ocfs2_get_refcount_rec(ocfs2_filesys *fs,
+ char *ref_root_buf,
+ uint64_t cpos, unsigned int len,
+ struct ocfs2_refcount_rec *ret_rec,
+ int *index,
+ char *ret_buf)
{
int ret = 0, i, found;
uint32_t low_cpos;
--
1.5.4.4
More information about the Ocfs2-tools-devel
mailing list