[Ocfs2-tools-commits] taoma commits r1322 - in
branches/sparse-files: debugfs.ocfs2 extras fsck.ocfs2
fswreck libocfs2 libocfs2/include mkfs.ocfs2 sizetest
svn-commits at oss.oracle.com
svn-commits at oss.oracle.com
Tue Mar 20 23:37:35 PDT 2007
Author: taoma
Date: 2007-03-20 23:37:23 -0700 (Tue, 20 Mar 2007)
New Revision: 1322
Modified:
branches/sparse-files/debugfs.ocfs2/commands.c
branches/sparse-files/debugfs.ocfs2/dump.c
branches/sparse-files/debugfs.ocfs2/find_block_inode.c
branches/sparse-files/extras/find_dup_extents.c
branches/sparse-files/fsck.ocfs2/extent.c
branches/sparse-files/fswreck/extent.c
branches/sparse-files/fswreck/symlink.c
branches/sparse-files/libocfs2/extend_file.c
branches/sparse-files/libocfs2/extent_map.c
branches/sparse-files/libocfs2/extents.c
branches/sparse-files/libocfs2/heartbeat.c
branches/sparse-files/libocfs2/include/ocfs2.h
branches/sparse-files/libocfs2/include/ocfs2_fs.h
branches/sparse-files/libocfs2/truncate.c
branches/sparse-files/mkfs.ocfs2/mkfs.c
branches/sparse-files/sizetest/sizes.txt
branches/sparse-files/sizetest/sizetest.c
Log:
Change e_clusters of extent_rec to e_int_clusters and e_leaf_clusters.
This time no use of e_flags is added, so 'unwritten extent' isn't supported yet.
Modified: branches/sparse-files/debugfs.ocfs2/commands.c
===================================================================
--- branches/sparse-files/debugfs.ocfs2/commands.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/debugfs.ocfs2/commands.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -426,21 +426,22 @@
errcode_t ret = 0;
char *buf = NULL;
int i;
- uint32_t clstoff;
+ uint32_t clstoff, clusters;
uint32_t tmp;
clstoff = ocfs2_blocks_to_clusters(fs, blkoff);
for (i = 0; i < el->l_next_free_rec; ++i) {
rec = &(el->l_recs[i]);
+ clusters = ocfs2_rec_clusters(el->l_tree_depth, rec);
/* For a sparse file, we may find an empty record.
* Just skip it.
*/
- if (!rec->e_clusters)
+ if (clusters)
continue;
- if (clstoff >= (rec->e_cpos + rec->e_clusters))
+ if (clstoff >= (rec->e_cpos + clusters))
continue;
if (!el->l_tree_depth) {
@@ -493,18 +494,20 @@
errcode_t ret = 0;
char *buf = NULL;
int i;
+ uint32_t clusters;
dump_extent_list (out, el);
for (i = 0; i < el->l_next_free_rec; ++i) {
rec = &(el->l_recs[i]);
+ clusters = ocfs2_rec_clusters(el->l_tree_depth, rec);
/* In a unsuccessful insertion, we may shift a tree
* add a new branch for it and do no insertion. So we
* may meet a extent block which have
- * rec->e_clusters == 0, this should only be happen
+ * clusters == 0, this should only be happen
* in the last extent rec. */
- if (!rec->e_clusters && i == el->l_next_free_rec - 1)
+ if (!clusters && i == el->l_next_free_rec - 1)
break;
if (el->l_tree_depth) {
Modified: branches/sparse-files/debugfs.ocfs2/dump.c
===================================================================
--- branches/sparse-files/debugfs.ocfs2/dump.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/debugfs.ocfs2/dump.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -290,6 +290,7 @@
{
struct ocfs2_extent_rec *rec;
int i;
+ uint32_t clusters;
fprintf(out, "\tTree Depth: %u Count: %u Next Free Rec: %u\n",
ext->l_tree_depth, ext->l_count, ext->l_next_free_rec);
@@ -301,13 +302,14 @@
for (i = 0; i < ext->l_next_free_rec; ++i) {
rec = &(ext->l_recs[i]);
+ clusters = ocfs2_rec_clusters(ext->l_tree_depth, rec);
/* For a sparse file, we may find an empty record.
* Just skip it.
*/
- if (!rec->e_clusters)
+ if (!clusters)
continue;
fprintf(out, "\t%-2d %-11u %-12u %"PRIu64"\n",
- i, rec->e_cpos, rec->e_clusters, rec->e_blkno);
+ i, rec->e_cpos, clusters, rec->e_blkno);
}
bail:
Modified: branches/sparse-files/debugfs.ocfs2/find_block_inode.c
===================================================================
--- branches/sparse-files/debugfs.ocfs2/find_block_inode.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/debugfs.ocfs2/find_block_inode.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -49,6 +49,7 @@
int i;
int j;
uint64_t numblks;
+ uint32_t clusters;
if (*found >= count)
return 0;
@@ -63,11 +64,12 @@
for (i = 0; i < el->l_next_free_rec; ++i) {
rec = &(el->l_recs[i]);
+ clusters = ocfs2_rec_clusters(el->l_tree_depth, rec);
/* For a sparse file, we may find an empty record.
* Just skip it.
*/
- if (!rec->e_clusters)
+ if (!clusters)
continue;
if (el->l_tree_depth) {
@@ -98,7 +100,7 @@
if (ba[j].status != STATUS_UNKNOWN)
continue;
- numblks = ocfs2_clusters_to_blocks(fs, rec->e_clusters);
+ numblks = ocfs2_clusters_to_blocks(fs, clusters);
if (ba[j].blkno >= rec->e_blkno &&
ba[j].blkno < rec->e_blkno + numblks) {
Modified: branches/sparse-files/extras/find_dup_extents.c
===================================================================
--- branches/sparse-files/extras/find_dup_extents.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/extras/find_dup_extents.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -68,7 +68,7 @@
OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits;
cluster = (uint32_t)(rec->e_blkno >> b_to_c_bits);
- for (i = 0; i < rec->e_clusters; i++) {
+ for (i = 0; i < ocfs2_rec_clusters(tree_depth, rec); i++) {
ret = ocfs2_bitmap_set(we->extent_map,
cluster + i,
&oldval);
@@ -112,7 +112,7 @@
OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits;
cluster = (uint32_t)(rec->e_blkno >> b_to_c_bits);
- for (i = 0; i < rec->e_clusters; i++) {
+ for (i = 0; i < ocfs2_rec_clusters(tree_depth, rec); i++) {
ret = ocfs2_bitmap_test(we->dup_map,
cluster + i,
&oldval);
Modified: branches/sparse-files/fsck.ocfs2/extent.c
===================================================================
--- branches/sparse-files/fsck.ocfs2/extent.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/fsck.ocfs2/extent.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -155,10 +155,11 @@
{
errcode_t ret = 0;
uint64_t first_block;
- uint32_t last_cluster;
+ uint32_t last_cluster, clusters;
+ clusters = ocfs2_rec_clusters(el->l_tree_depth, er);
verbosef("cpos %u clusters %u blkno %"PRIu64"\n", er->e_cpos,
- er->e_clusters, er->e_blkno);
+ clusters, er->e_blkno);
if (ocfs2_block_out_of_range(ost->ost_fs, er->e_blkno))
goto out;
@@ -204,7 +205,7 @@
/* imagine blkno 0, 1 er_clusters. last_cluster is 1 and
* fs_clusters is 1, which is ok.. */
last_cluster = ocfs2_blocks_to_clusters(ost->ost_fs, er->e_blkno) +
- er->e_clusters;
+ clusters;
if (last_cluster > ost->ost_fs->fs_clusters &&
prompt(ost, PY, PR_EXTENT_CLUSTERS_OVERRUN,
@@ -214,7 +215,8 @@
"clusters to fit it in the volume?", er->e_cpos,
di->i_blkno, last_cluster - ost->ost_fs->fs_clusters)) {
- er->e_clusters -= last_cluster - ost->ost_fs->fs_clusters;
+ clusters -= last_cluster - ost->ost_fs->fs_clusters;
+ ocfs2_set_rec_clusters(el->l_tree_depth, er, clusters);
*changed = 1;
}
@@ -236,6 +238,7 @@
struct ocfs2_extent_rec *er;
uint64_t max_size;
uint16_t i;
+ uint32_t clusters;
size_t cpy;
verbosef("depth %u count %u next_free %u\n", el->l_tree_depth,
@@ -286,11 +289,12 @@
for (i = 0; i < max_recs; i++) {
er = &el->l_recs[i];
+ clusters = ocfs2_rec_clusters(el->l_tree_depth, er);
/* For a sparse file, we may find an empty record
* in the left most record. Just skip it.
*/
- if (el->l_tree_depth && !i && !er->e_clusters)
+ if (el->l_tree_depth && !i && !clusters)
continue;
/* returns immediately if blkno is out of range.
@@ -334,11 +338,11 @@
/* mark the data clusters as used */
o2fsck_mark_clusters_allocated(ost,
ocfs2_blocks_to_clusters(ost->ost_fs, er->e_blkno),
- er->e_clusters);
+ clusters);
- ei->ei_clusters += er->e_clusters;
+ ei->ei_clusters += clusters;
- max_size = (er->e_cpos + er->e_clusters) <<
+ max_size = (er->e_cpos + clusters) <<
OCFS2_RAW_SB(ost->ost_fs->fs_super)->s_clustersize_bits;
if (max_size > ei->ei_max_size)
ei->ei_max_size = max_size;
Modified: branches/sparse-files/fswreck/extent.c
===================================================================
--- branches/sparse-files/fswreck/extent.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/fswreck/extent.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -311,14 +311,14 @@
blkno, oldno, er->e_blkno);
break;
case EXTENT_CLUSTERS_OVERRUN:
- oldno = er->e_clusters;
- er->e_clusters = fs->fs_clusters + 1;
+ oldno = er->e_leaf_clusters;
+ er->e_leaf_clusters = fs->fs_clusters + 1;
er->e_blkno = ocfs2_clusters_to_blocks(fs,
fs->fs_clusters - 1);
fprintf(stdout, "EXTENT_CLUSTERS_OVERRUN: "
"Corrupt inode#%"PRIu64", "
"change cluster from %"PRIu64 " to %d\n",
- blkno, oldno, er->e_clusters);
+ blkno, oldno, er->e_leaf_clusters);
break;
case EXTENT_BLKNO_RANGE:
er->e_blkno = 1;
Modified: branches/sparse-files/fswreck/symlink.c
===================================================================
--- branches/sparse-files/fswreck/symlink.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/fswreck/symlink.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -214,9 +214,9 @@
er = el->l_recs;
fprintf(stdout, "LINK_BLOCKS: "
"Corrupt inode#%"PRIu64","
- "change e_clusters from %u to %u\n",
- blkno, er->e_clusters, (er->e_clusters + 1));
- er->e_clusters += 1;
+ "change e_leaf_clusters from %u to %u\n",
+ blkno, er->e_leaf_clusters, (er->e_leaf_clusters + 1));
+ er->e_leaf_clusters += 1;
break;
default:
FSWRK_FATAL("Invalid type[%d]\n", type);
Modified: branches/sparse-files/libocfs2/extend_file.c
===================================================================
--- branches/sparse-files/libocfs2/extend_file.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/libocfs2/extend_file.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -266,14 +266,21 @@
struct ocfs2_extent_rec *ext,
uint64_t blkno)
{
- return blkno == (ext->e_blkno +
- ocfs2_clusters_to_blocks(fs, ext->e_clusters));
+ uint64_t blk_end = ext->e_blkno;
+
+ blk_end += ocfs2_clusters_to_blocks(fs, ext->e_leaf_clusters);
+
+ return blkno == blk_end;
}
static inline int ocfs2_extents_adjacent(struct ocfs2_extent_rec *left,
struct ocfs2_extent_rec *right)
{
- return (left->e_cpos + left->e_clusters == right->e_cpos);
+ uint32_t left_range;
+
+ left_range = left->e_cpos + left->e_leaf_clusters;
+
+ return (left_range == right->e_cpos);
}
static enum ocfs2_contig_type
@@ -329,9 +336,11 @@
*/
static inline uint32_t ocfs2_sum_rightmost_rec(struct ocfs2_extent_list *el)
{
- int i = el->l_next_free_rec - 1;
+ uint16_t i = el->l_next_free_rec - 1;
- return el->l_recs[i].e_cpos + el->l_recs[i].e_clusters;
+ return el->l_recs[i].e_cpos +
+ ocfs2_rec_clusters(el->l_tree_depth, &el->l_recs[i]);
+
}
/*
@@ -421,13 +430,15 @@
eb->h_next_leaf_blk = 0;
eb_el->l_tree_depth = i;
eb_el->l_next_free_rec = 1;
+ memset(eb_el->l_recs, 0,
+ sizeof(struct ocfs2_extent_rec) * eb_el->l_count);
/*
* This actually counts as an empty extent as
* c_clusters == 0
*/
eb_el->l_recs[0].e_cpos = new_cpos;
eb_el->l_recs[0].e_blkno = next_blkno;
- eb_el->l_recs[0].e_clusters = 0;
+ eb_el->l_recs[0].e_int_clusters = 0;
if (!eb_el->l_tree_depth)
new_last_eb_blk = eb->h_blkno;
@@ -440,7 +451,7 @@
i = el->l_next_free_rec;
el->l_recs[i].e_blkno = next_blkno;
el->l_recs[i].e_cpos = new_cpos;
- el->l_recs[i].e_clusters = 0;
+ el->l_recs[i].e_int_clusters = 0;
el->l_next_free_rec++;
/* fe needs a new last extent block pointer, as does the
@@ -571,9 +582,13 @@
return ret;
}
+/*
+ * This is only valid for leaf nodes, which are the only ones that can
+ * have empty extents anyway.
+ */
static inline int ocfs2_is_empty_extent(struct ocfs2_extent_rec *rec)
{
- return !rec->e_clusters;
+ return !rec->e_leaf_clusters;
}
/*
@@ -749,7 +764,7 @@
* tree, this should just wind up returning the
* rightmost record.
*/
- range = rec->e_cpos + rec->e_clusters;
+ range = rec->e_cpos + rec->e_int_clusters;
if (cpos >= rec->e_cpos && cpos < range)
break;
}
@@ -883,21 +898,21 @@
*/
left_clusters = right_child_el->l_recs[0].e_cpos;
left_clusters -= left_rec->e_cpos;
- left_rec->e_clusters = left_clusters;
+ left_rec->e_int_clusters = left_clusters;
/*
* Calculate the rightmost cluster count boundary before
- * moving cpos - we will need to adjust e_clusters after
+ * moving cpos - we will need to adjust clusters after
* updating e_cpos to keep the same highest cluster count.
*/
right_end = right_rec->e_cpos;
- right_end += right_rec->e_clusters;
+ right_end += right_rec->e_int_clusters;
right_rec->e_cpos = left_rec->e_cpos;
right_rec->e_cpos += left_clusters;
right_end -= right_rec->e_cpos;
- right_rec->e_clusters = right_end;
+ right_rec->e_int_clusters = right_end;
}
/*
@@ -1121,7 +1136,9 @@
}
*cpos = el->l_recs[j - 1].e_cpos;
- *cpos = *cpos + el->l_recs[j - 1].e_clusters - 1;
+ *cpos = *cpos + ocfs2_rec_clusters(el,
+ &el->l_recs[j - 1]);
+ *cpos = *cpos - 1;
goto out;
}
}
@@ -1290,7 +1307,6 @@
struct ocfs2_extent_block *eb;
struct ocfs2_extent_list *el;
uint32_t new_clusters;
- int i;
el = &ctxt->di->id2.i_list;
if (el->l_next_free_rec != el->l_count)
@@ -1321,12 +1337,7 @@
sizeof(struct ocfs2_extent_rec) * el->l_count);
el->l_recs[0].e_cpos = 0;
el->l_recs[0].e_blkno = blkno;
- el->l_recs[0].e_clusters = new_clusters;
- for(i = 1; i < el->l_next_free_rec; i++) {
- el->l_recs[i].e_cpos = 0;
- el->l_recs[i].e_clusters = 0;
- el->l_recs[i].e_blkno = 0;
- }
+ el->l_recs[0].e_int_clusters = new_clusters;
el->l_next_free_rec = 1;
if (el->l_tree_depth == 1)
@@ -1395,7 +1406,7 @@
i = el->l_next_free_rec - 1;
rec = &el->l_recs[i];
- if (cpos >= (rec->e_cpos + rec->e_clusters))
+ if (cpos >= (rec->e_cpos + rec->e_leaf_clusters))
goto set_tail_append;
return;
@@ -1547,7 +1558,7 @@
rec->e_blkno = insert_rec->e_blkno;
rec->e_cpos = insert_rec->e_cpos;
}
- rec->e_clusters += insert_rec->e_clusters;
+ rec->e_leaf_clusters += insert_rec->e_leaf_clusters;
return;
}
@@ -1568,7 +1579,7 @@
if (insert->ins_appending == APPEND_TAIL) {
i = el->l_next_free_rec - 1;
rec = &el->l_recs[i];
- range = rec->e_cpos + rec->e_clusters;
+ range = rec->e_cpos + rec->e_leaf_clusters;
assert(insert_rec->e_cpos >= range);
i++;
@@ -1595,6 +1606,7 @@
{
int ret, i, next_free;
struct ocfs2_extent_list *el;
+ struct ocfs2_extent_rec *rec;
el = path_root_el(path);
i = 0;
@@ -1605,10 +1617,10 @@
goto out;
}
- el->l_recs[next_free - 1].e_clusters = insert_rec->e_cpos;
- el->l_recs[next_free - 1].e_clusters += insert_rec->e_clusters;
- el->l_recs[next_free - 1].e_clusters -=
- el->l_recs[next_free - 1].e_cpos;
+ rec = &el->l_recs[next_free - 1];
+ rec->e_int_clusters = insert_rec->e_cpos;
+ rec->e_int_clusters += insert_rec->e_leaf_clusters;
+ rec->e_int_clusters -= rec->e_cpos;
if (++i >= path->p_tree_depth)
break;
@@ -1734,7 +1746,7 @@
goto out;
out_update_clusters:
- di->i_clusters += insert_rec->e_clusters;
+ di->i_clusters += insert_rec->e_leaf_clusters;
ret = 0;
out:
@@ -1767,9 +1779,10 @@
if (ret)
goto bail;
+ memset(&ctxt.rec, 0, sizeof(struct ocfs2_extent_rec));
ctxt.rec.e_cpos = cpos;
ctxt.rec.e_blkno = c_blkno;
- ctxt.rec.e_clusters = clusters;
+ ctxt.rec.e_leaf_clusters = clusters;
ret = ocfs2_figure_insert_type(&ctxt,&last_eb, &insert);
if (ret)
Modified: branches/sparse-files/libocfs2/extent_map.c
===================================================================
--- branches/sparse-files/libocfs2/extent_map.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/libocfs2/extent_map.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -497,7 +497,7 @@
rec = &el->l_recs[i];
rec_start = rec->e_cpos;
- rec_end = rec_start + rec->e_clusters;
+ rec_end = rec_start + ocfs2_rec_clusters(el->l_tree_depth,rec);
if (v_cluster >= rec_start && v_cluster < rec_end) {
ret = i;
@@ -549,8 +549,9 @@
if (!rec->e_blkno) {
fprintf(stderr, "Inode %"PRIu64" has bad extent "
- "record (%u, %u, 0)", di->i_blkno,
- rec->e_cpos, rec->e_clusters);
+ "record (%u, %u, 0)", di->i_blkno,
+ rec->e_cpos,
+ ocfs2_rec_clusters(el->l_tree_depth, rec));
ret = OCFS2_ET_BAD_BLKNO;
goto out;
}
@@ -561,7 +562,8 @@
*p_cluster = *p_cluster + coff;
if (num_clusters)
- *num_clusters = rec->e_clusters - coff;
+ *num_clusters = ocfs2_rec_clusters(el->l_tree_depth,
+ rec) - coff;
}
out:
Modified: branches/sparse-files/libocfs2/extents.c
===================================================================
--- branches/sparse-files/libocfs2/extents.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/libocfs2/extents.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -49,7 +49,10 @@
struct ocfs2_extent_rec *rec = &el->l_recs[i];
rec->e_cpos = bswap_32(rec->e_cpos);
- rec->e_clusters = bswap_32(rec->e_clusters);
+ if (el->l_tree_depth)
+ rec->e_int_clusters = bswap_32(rec->e_int_clusters);
+ else
+ rec->e_leaf_clusters = bswap_16(rec->e_leaf_clusters);
rec->e_blkno = bswap_64(rec->e_blkno);
}
}
@@ -248,7 +251,7 @@
iret |= update_eb_rec(ctxt, &before,
&el->l_recs[i]);
- if (el->l_recs[i].e_clusters &&
+ if (el->l_recs[i].e_int_clusters &&
(el->l_recs[i].e_cpos >= ctxt->last_eb_cpos)) {
/*
* Only set last_eb_blkno if current extent
@@ -264,7 +267,7 @@
/* For a sparse file, we may find an empty record
* in the left most record. Just skip it.
*/
- if (!i && !el->l_recs[i].e_clusters)
+ if (!i && !el->l_recs[i].e_leaf_clusters)
continue;
iret |= (*ctxt->func)(ctxt->fs, &el->l_recs[i],
el->l_tree_depth,
@@ -273,7 +276,8 @@
if (iret & OCFS2_EXTENT_CHANGED)
iret |= update_leaf_rec(ctxt, &before,
&el->l_recs[i]);
- ctxt->ccount += el->l_recs[i].e_clusters;
+ ctxt->ccount += ocfs2_rec_clusters(el->l_tree_depth,
+ &el->l_recs[i]);
}
if (iret & (OCFS2_EXTENT_ABORT | OCFS2_EXTENT_ERROR))
break;
@@ -281,7 +285,8 @@
if (iret & OCFS2_EXTENT_CHANGED) {
for (i = 0; i < el->l_count; i++) {
- if (el->l_recs[i].e_clusters)
+ if (ocfs2_rec_clusters(el->l_tree_depth,
+ &el->l_recs[i]))
continue;
el->l_next_free_rec = i;
break;
@@ -514,7 +519,8 @@
int iret = 0;
bcount = ocfs2_clusters_to_blocks(fs, rec->e_cpos);
- bend = bcount + ocfs2_clusters_to_blocks(fs, rec->e_clusters);
+ bend = bcount + ocfs2_clusters_to_blocks(fs,
+ ocfs2_rec_clusters(tree_depth, rec));
for (blkno = rec->e_blkno; bcount < bend; blkno++, bcount++) {
if (((bcount * fs->fs_blocksize) >= ctxt->inode->i_size) &&
@@ -632,12 +638,14 @@
fprintf(stdout, " ");
fprintf(stdout, "(%08"PRIu32", %08"PRIu32", %08"PRIu64") |"
" + %08"PRIu32" = %08"PRIu32" / %08"PRIu32"\n",
- rec->e_cpos, rec->e_clusters,
- rec->e_blkno, ccount, ccount + rec->e_clusters,
+ rec->e_cpos, ocfs2_rec_clustes(tree_depth, rec),
+ rec->e_blkno, ccount,
+ ccount + ocfs2_rec_clusters(tree_depth, rec),
wi->di->i_clusters);
if (!tree_depth &&
- ((ccount + rec->e_clusters) == wi->di->i_clusters))
+ ((ccount + ocfs2_rec_clusters(tree_depth, rec)) ==
+ wi->di->i_clusters))
fprintf(stdout, "TOTAL: %u\n", wi->di->i_clusters);
return 0;
Modified: branches/sparse-files/libocfs2/heartbeat.c
===================================================================
--- branches/sparse-files/libocfs2/heartbeat.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/libocfs2/heartbeat.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -89,7 +89,7 @@
goto leave;
}
- blocks = rec->e_clusters << cluster_bits;
+ blocks = ocfs2_rec_clusters(0, rec) << cluster_bits;
blocks >>= block_bits;
if (blocks > O2NM_MAX_NODES)
Modified: branches/sparse-files/libocfs2/include/ocfs2.h
===================================================================
--- branches/sparse-files/libocfs2/include/ocfs2.h 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/libocfs2/include/ocfs2.h 2007-03-21 06:37:23 UTC (rev 1322)
@@ -727,6 +727,35 @@
}
/*
+ * Helper function to look at the # of clusters in an extent record.
+ */
+static inline uint32_t ocfs2_rec_clusters(uint16_t tree_depth,
+ struct ocfs2_extent_rec *rec)
+{
+ /*
+ * Cluster count in extent records is slightly different
+ * between interior nodes and leaf nodes. This is to support
+ * unwritten extents which need a flags field in leaf node
+ * records, thus shrinking the available space for a clusters
+ * field.
+ */
+ if (tree_depth)
+ return rec->e_int_clusters;
+ else
+ return rec->e_leaf_clusters;
+}
+
+static inline void ocfs2_set_rec_clusters(uint16_t tree_depth,
+ struct ocfs2_extent_rec *rec,
+ uint32_t clusters)
+{
+ if (tree_depth)
+ rec->e_int_clusters = clusters;
+ else
+ rec->e_leaf_clusters = clusters;
+}
+
+/*
* shamelessly lifted from the kernel
*
* min()/max() macros that also do
Modified: branches/sparse-files/libocfs2/include/ocfs2_fs.h
===================================================================
--- branches/sparse-files/libocfs2/include/ocfs2_fs.h 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/libocfs2/include/ocfs2_fs.h 2007-03-21 06:37:23 UTC (rev 1322)
@@ -286,7 +286,15 @@
*/
struct ocfs2_extent_rec {
/*00*/ __le32 e_cpos; /* Offset into the file, in clusters */
- __le32 e_clusters; /* Clusters covered by this extent */
+ union {
+ __le32 e_int_clusters; /* Clusters covered by all children */
+ struct {
+ __le16 e_leaf_clusters; /* Clusters covered by this
+ extent */
+ __u8 e_reserved1;
+ __u8 e_flags; /* Extent flags */
+ };
+ };
__le64 e_blkno; /* Physical disk offset, in blocks */
/*10*/
};
Modified: branches/sparse-files/libocfs2/truncate.c
===================================================================
--- branches/sparse-files/libocfs2/truncate.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/libocfs2/truncate.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -41,18 +41,19 @@
uint64_t ref_blkno, int ref_recno,
void *priv_data)
{
- uint32_t len, new_i_clusters = *(uint32_t *)priv_data;
+ uint32_t len, rec_clusters, new_i_clusters = *(uint32_t *)priv_data;
uint64_t start = 0;
errcode_t ret;
- if ((rec->e_cpos + rec->e_clusters) <= new_i_clusters)
+ if ((rec->e_cpos + ocfs2_rec_clusters(tree_depth, rec)) <=
+ new_i_clusters)
return 0;
if (rec->e_cpos >= new_i_clusters) {
/* the rec is entirely outside the new size, free it */
if (!tree_depth) {
start = rec->e_blkno;
- len = rec->e_clusters;
+ len = ocfs2_rec_clusters(tree_depth, rec);
} else {
/* here we meet with a full empty extent block, delete
* it. The extent list it contains should already be
@@ -63,17 +64,22 @@
goto bail;
}
- rec->e_blkno = 0;
- rec->e_clusters = 0;
- rec->e_cpos = 0;
+ memset(rec, 0, sizeof(struct ocfs2_extent_rec));
} else {
/* we're truncating into the middle of the rec */
- len = rec->e_cpos + rec->e_clusters;
+ len = rec->e_cpos +
+ ocfs2_rec_clusters(tree_depth, rec);
len -= new_i_clusters;
- rec->e_clusters = new_i_clusters - rec->e_cpos;
- if (!tree_depth)
+ if (!tree_depth) {
+ ocfs2_set_rec_clusters(tree_depth, rec,
+ new_i_clusters - rec->e_cpos);
start = rec->e_blkno +
- ocfs2_clusters_to_blocks(fs, rec->e_clusters);
+ ocfs2_clusters_to_blocks(fs,
+ ocfs2_rec_clusters(tree_depth,
+ rec));
+ } else
+ ocfs2_set_rec_clusters(tree_depth, rec,
+ new_i_clusters - rec->e_cpos);
}
if (start) {
Modified: branches/sparse-files/mkfs.ocfs2/mkfs.c
===================================================================
--- branches/sparse-files/mkfs.ocfs2/mkfs.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/mkfs.ocfs2/mkfs.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -1899,7 +1899,7 @@
if (rec->extent_len) {
di->id2.i_list.l_next_free_rec = 1;
di->id2.i_list.l_recs[0].e_cpos = 0;
- di->id2.i_list.l_recs[0].e_clusters = clusters;
+ ocfs2_set_rec_clusters(0, &di->id2.i_list.l_recs[0], clusters);
di->id2.i_list.l_recs[0].e_blkno =
rec->extent_off >> s->blocksize_bits;
}
Modified: branches/sparse-files/sizetest/sizes.txt
===================================================================
--- branches/sparse-files/sizetest/sizes.txt 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/sizetest/sizes.txt 2007-03-21 06:37:23 UTC (rev 1322)
@@ -1,6 +1,6 @@
[off] ocfs2_extent_rec [size]
0x000 e_cpos +0x04
-0x004 e_clusters +0x04
+0x004 e_int_clusters +0x04
0x008 e_blkno +0x08
Total 0x010
Modified: branches/sparse-files/sizetest/sizetest.c
===================================================================
--- branches/sparse-files/sizetest/sizetest.c 2007-03-21 05:03:57 UTC (rev 1321)
+++ branches/sparse-files/sizetest/sizetest.c 2007-03-21 06:37:23 UTC (rev 1322)
@@ -49,7 +49,7 @@
START_TYPE(ocfs2_extent_rec);
SHOW_OFFSET(struct ocfs2_extent_rec, e_cpos);
- SHOW_OFFSET(struct ocfs2_extent_rec, e_clusters);
+ SHOW_OFFSET(struct ocfs2_extent_rec, e_int_clusters);
SHOW_OFFSET(struct ocfs2_extent_rec, e_blkno);
END_TYPE(struct ocfs2_extent_rec);
More information about the Ocfs2-tools-commits
mailing list