[Ocfs2-tools-commits] jlbec commits r317 - in trunk/libocfs2: .
include
svn-commits at oss.oracle.com
svn-commits at oss.oracle.com
Wed Oct 6 17:26:52 CDT 2004
Author: jlbec
Date: 2004-10-06 17:26:51 -0500 (Wed, 06 Oct 2004)
New Revision: 317
Modified:
trunk/libocfs2/cached_inode.c
trunk/libocfs2/extent_map.c
trunk/libocfs2/extents.c
trunk/libocfs2/fileio.c
trunk/libocfs2/include/extent_map.h
trunk/libocfs2/include/ocfs2.h
trunk/libocfs2/inode_scan.c
trunk/libocfs2/ocfs2_err.et.in
trunk/libocfs2/openfs.c
Log:
o Change extent_map code to rbtrees.
o Make ocfs2_clusters_to_blocks() and back part of ocfs2.h
Modified: trunk/libocfs2/cached_inode.c
===================================================================
--- trunk/libocfs2/cached_inode.c 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/cached_inode.c 2004-10-06 22:26:51 UTC (rev 317)
@@ -76,7 +76,7 @@
return OCFS2_ET_INVALID_ARGUMENT;
if (cinode->ci_map)
- ocfs2_free_extent_map(fs, cinode);
+ ocfs2_drop_extent_map(fs, cinode);
if (cinode->ci_inode)
ocfs2_free(&cinode->ci_inode);
Modified: trunk/libocfs2/extent_map.c
===================================================================
--- trunk/libocfs2/extent_map.c 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/extent_map.c 2004-10-06 22:26:51 UTC (rev 317)
@@ -34,61 +34,339 @@
#include "extent_map.h"
-/* FIXME: Use rbtrees. Add lookup */
-
struct extent_map_context {
ocfs2_cached_inode *cinode;
errcode_t errcode;
};
-errcode_t ocfs2_extent_map_add(ocfs2_cached_inode *cinode,
- ocfs2_extent_rec *rec)
+/*
+ * Find an entry in the tree that intersects the region passed in.
+ * Note that this will find straddled intervals, it is up to the
+ * callers to enforce any boundary conditions.
+ *
+ * The rb_node garbage lets insertion share the search. Trivial
+ * callers pass NULL.
+ */
+static ocfs2_extent_map_entry *
+ocfs2_extent_map_lookup(ocfs2_extent_map *em,
+ uint32_t cpos, uint32_t clusters,
+ struct rb_node ***ret_p,
+ struct rb_node **ret_parent)
{
+ struct rb_node **p = &em->em_extents.rb_node;
+ struct rb_node *parent = NULL;
+ ocfs2_extent_map_entry *ent = NULL;
+
+ while (*p)
+ {
+ parent = *p;
+ ent = rb_entry(parent, ocfs2_extent_map_entry, e_node);
+ if ((cpos + clusters) <= ent->e_rec.e_cpos) {
+ p = &(*p)->rb_left;
+ ent = NULL;
+ } else if (cpos >= (ent->e_rec.e_cpos +
+ ent->e_rec.e_clusters)) {
+ p = &(*p)->rb_right;
+ ent = NULL;
+ } else
+ break;
+ }
+
+ if (ret_p != NULL)
+ *ret_p = p;
+ if (ret_parent != NULL)
+ *ret_parent = parent;
+ return ent;
+}
+
+static errcode_t ocfs2_extent_map_insert_entry(ocfs2_extent_map *em,
+ ocfs2_extent_map_entry *ent)
+{
+ struct rb_node **p, *parent;
+ ocfs2_extent_map_entry *old_ent;
+
+ old_ent = ocfs2_extent_map_lookup(em, ent->e_rec.e_cpos,
+ ent->e_rec.e_clusters,
+ &p, &parent);
+ if (old_ent)
+ return OCFS2_ET_INVALID_EXTENT_LOOKUP;
+
+ rb_link_node(&ent->e_node, parent, p);
+ rb_insert_color(&ent->e_node, &em->em_extents);
+
+ return 0;
+}
+
+errcode_t ocfs2_extent_map_insert(ocfs2_extent_map *em,
+ ocfs2_extent_rec *rec,
+ int tree_depth)
+{
errcode_t ret;
- ocfs2_extent_map *em;
- struct list_head *next, *prev;
- ocfs2_extent_map_entry *ent, *tmp;
+ ocfs2_extent_map_entry *old_ent, *new_ent;
+ ocfs2_extent_map_entry *left_ent = NULL, *right_ent = NULL;
+
+ /* FIXME: should we cache i_clusters instead of cinode? */
+ if ((rec->e_cpos + rec->e_clusters) >
+ em->em_cinode->ci_inode->i_clusters)
+ return OCFS2_ET_INVALID_EXTENT_LOOKUP;
+
+ ret = ocfs2_malloc0(sizeof(struct _ocfs2_extent_map_entry),
+ &new_ent);
+ if (ret)
+ return ret;
+
+ new_ent->e_rec = *rec;
+ new_ent->e_tree_depth = tree_depth;
+ ret = ocfs2_extent_map_insert_entry(em, new_ent);
+ if (!ret)
+ return 0;
+
+ ret = OCFS2_ET_INTERNAL_FAILURE;
+ old_ent = ocfs2_extent_map_lookup(em, rec->e_cpos,
+ rec->e_clusters, NULL, NULL);
+
+ if (!old_ent)
+ goto out_free;
+
+ ret = OCFS2_ET_INVALID_EXTENT_LOOKUP;
+ if (old_ent->e_tree_depth < tree_depth)
+ goto out_free;
+ if (old_ent->e_tree_depth == tree_depth) {
+ if (!memcmp(rec, &old_ent->e_rec,
+ sizeof(ocfs2_extent_rec)))
+ ret = 0; /* Same entry, just skip */
+ goto out_free;
+ }
+
+ /*
+ * We do it in this order specifically so that malloc failures
+ * do not leave an inconsistent tree.
+ */
+ if (rec->e_cpos > old_ent->e_rec.e_cpos) {
+ ret = ocfs2_malloc0(sizeof(struct _ocfs2_extent_map_entry),
+ &left_ent);
+ if (ret)
+ goto out_free;
+ *left_ent = *old_ent;
+ left_ent->e_rec.e_clusters =
+ rec->e_cpos - left_ent->e_rec.e_cpos;
+ }
+ if ((old_ent->e_rec.e_cpos +
+ old_ent->e_rec.e_clusters) >
+ (rec->e_cpos + rec->e_clusters)) {
+ ret = ocfs2_malloc0(sizeof(struct _ocfs2_extent_map_entry),
+ &right_ent);
+ if (ret)
+ goto out_free;
+ *right_ent = *old_ent;
+ right_ent->e_rec.e_cpos =
+ rec->e_cpos + rec->e_clusters;
+ right_ent->e_rec.e_clusters =
+ (old_ent->e_rec.e_cpos +
+ old_ent->e_rec.e_clusters) -
+ right_ent->e_rec.e_cpos;
+ }
+
+ rb_erase(&old_ent->e_node, &em->em_extents);
+
+ if (left_ent) {
+ ret = ocfs2_extent_map_insert_entry(em,
+ left_ent);
+ if (ret)
+ goto out_free;
+ }
+
+ ret = ocfs2_extent_map_insert_entry(em, new_ent);
+ if (ret)
+ goto out_free;
+
+ if (right_ent) {
+ ret = ocfs2_extent_map_insert_entry(em,
+ right_ent);
+ if (ret)
+ goto out_free;
+ }
+
+ ocfs2_free(&old_ent);
+
+ return 0;
+
+out_free:
+ if (left_ent)
+ ocfs2_free(&left_ent);
+ if (right_ent)
+ ocfs2_free(&right_ent);
+ ocfs2_free(&new_ent);
+
+ return ret;
+}
+
+
+/*
+ * Look up the record containing this cluster offset. This record is
+ * part of the extent map. Do not free it. Any changes you make to
+ * it will reflect in the extent map. So, if your last extent
+ * is (cpos = 10, clusters = 10) and you truncate the file by 5
+ * clusters, you want to do:
+ *
+ * ret = ocfs2_extent_map_get_rec(em, orig_size - 5, &rec);
+ * rec->e_clusters -= 5;
+ */
+errcode_t ocfs2_extent_map_get_rec(ocfs2_extent_map *em,
+ uint32_t cpos,
+ ocfs2_extent_rec **rec)
+{
+ ocfs2_extent_map_entry *ent;
+
+ *rec = NULL;
+
+ ent = ocfs2_extent_map_lookup(em, cpos, 1, NULL, NULL);
- if (!cinode || !cinode->ci_map)
- return OCFS2_ET_INVALID_ARGUMENT;
+ if (ent)
+ *rec = &ent->e_rec;
- if (rec->e_cpos >= cinode->ci_inode->i_clusters)
- return OCFS2_ET_INVALID_ARGUMENT;
+ return 0;
+}
- em = cinode->ci_map;
+errcode_t ocfs2_extent_map_get_clusters(ocfs2_extent_map *em,
+ uint32_t v_cpos, int count,
+ uint32_t *p_cpos,
+ int *ret_count)
+{
+ uint32_t coff, ccount;
+ ocfs2_extent_map_entry *ent;
+ ocfs2_filesys *fs = em->em_cinode->ci_fs;
- next = prev = &em->em_extents;
- list_for_each(next, &em->em_extents) {
- tmp = list_entry(next, ocfs2_extent_map_entry, e_list);
- if (rec->e_cpos >=
- (tmp->e_rec.e_cpos + tmp->e_rec.e_clusters)) {
- prev = next;
- continue;
- }
+ *p_cpos = ccount = 0;
- if (!memcmp(rec, &tmp->e_rec,
- sizeof(ocfs2_extent_map_entry)))
- return 0;
+ if ((v_cpos + count) >= em->em_cinode->ci_inode->i_clusters)
+ return OCFS2_ET_INVALID_EXTENT_LOOKUP;
- if ((rec->e_cpos + rec->e_clusters) <=
- tmp->e_rec.e_cpos)
- break;
+ ent = ocfs2_extent_map_lookup(em, v_cpos, count, NULL, NULL);
+ if (ent) {
+ /* We should never find ourselves straddling an interval */
+ if ((ent->e_rec.e_cpos > v_cpos) ||
+ ((v_cpos + count) >
+ (ent->e_rec.e_cpos + ent->e_rec.e_clusters)))
+ return OCFS2_ET_INVALID_EXTENT_LOOKUP;
- return OCFS2_ET_CORRUPT_EXTENT_BLOCK;
+ coff = v_cpos - ent->e_rec.e_cpos;
+ *p_cpos = ocfs2_blocks_to_clusters(fs,
+ ent->e_rec.e_blkno) +
+ coff;
+
+ if (ret_count)
+ *ret_count = ent->e_rec.e_clusters - coff;
+
+ return 0;
}
- ret = ocfs2_malloc0(sizeof(ocfs2_extent_map_entry), &ent);
+
+ return OCFS2_ET_EXTENT_NOT_FOUND;
+}
+
+errcode_t ocfs2_extent_map_get_blocks(ocfs2_extent_map *em,
+ uint64_t v_blkno, int count,
+ uint64_t *p_blkno, int *ret_count)
+{
+ uint64_t boff;
+ uint32_t cpos, clusters;
+ ocfs2_filesys *fs = em->em_cinode->ci_fs;
+ int bpc = ocfs2_clusters_to_blocks(fs, 1);
+ ocfs2_extent_map_entry *ent;
+ ocfs2_extent_rec *rec;
+
+ *p_blkno = 0;
+
+ cpos = ocfs2_blocks_to_clusters(fs, v_blkno);
+ clusters = ocfs2_blocks_to_clusters(fs,
+ (uint64_t)count + bpc - 1);
+ if ((cpos + clusters) >= em->em_cinode->ci_inode->i_clusters)
+ return OCFS2_ET_INVALID_EXTENT_LOOKUP;
+
+ ent = ocfs2_extent_map_lookup(em, cpos, clusters, NULL, NULL);
+ if (ent)
+ {
+ rec = &ent->e_rec;
+
+ /* We should never find ourselves straddling an interval */
+ if ((rec->e_cpos > cpos) ||
+ ((cpos + clusters) >
+ (rec->e_cpos + rec->e_clusters)))
+ return OCFS2_ET_INVALID_EXTENT_LOOKUP;
+
+ boff = ocfs2_clusters_to_blocks(fs, cpos - rec->e_cpos);
+ boff += (v_blkno % bpc);
+ *p_blkno = rec->e_blkno + boff;
+
+ if (ret_count) {
+ *ret_count = ocfs2_clusters_to_blocks(fs,
+ rec->e_clusters) - boff;
+ }
+
+ return 0;
+ }
+
+ return OCFS2_ET_EXTENT_NOT_FOUND;
+}
+
+errcode_t ocfs2_extent_map_new(ocfs2_filesys *fs,
+ ocfs2_cached_inode *cinode,
+ ocfs2_extent_map **ret_em)
+{
+ errcode_t ret;
+ ocfs2_extent_map *em;
+
+ ret = ocfs2_malloc0(sizeof(struct _ocfs2_extent_map), &em);
if (ret)
return ret;
- ent->e_rec.e_cpos = rec->e_cpos;
- ent->e_rec.e_clusters = rec->e_clusters;
- ent->e_rec.e_blkno = rec->e_blkno;
- list_add(&ent->e_list, prev);
+ em->em_cinode = cinode;
+ em->em_extents = RB_ROOT;
+ *ret_em = em;
+
return 0;
}
+/*
+ * Truncate all entries past new_clusters.
+ * If you want to also clip the last extent by some number of clusters,
+ * you need to call ocfs2_extent_map_get_rec() and modify the rec
+ * you are returned.
+ */
+errcode_t ocfs2_extent_map_trunc(ocfs2_extent_map *em,
+ uint32_t new_clusters)
+{
+ errcode_t ret = 0;
+ struct rb_node *node, *next;
+ ocfs2_extent_map_entry *ent;
+
+ node = rb_last(&em->em_extents);
+ while (node)
+ {
+ next = rb_prev(node);
+
+ ent = rb_entry(node, ocfs2_extent_map_entry, e_node);
+ if (ent->e_rec.e_cpos < new_clusters)
+ break;
+
+ rb_erase(&ent->e_node, &em->em_extents);
+ ocfs2_free(&ent);
+
+ node = next;
+ }
+
+ return ret;
+}
+
+void ocfs2_extent_map_free(ocfs2_extent_map *em)
+{
+ ocfs2_extent_map_trunc(em, 0);
+ ocfs2_free(&em);
+}
+
+
static int extent_map_func(ocfs2_filesys *fs,
ocfs2_extent_rec *rec,
int tree_depth,
@@ -101,7 +379,8 @@
int iret = 0;
struct extent_map_context *ctxt = priv_data;
- ret = ocfs2_extent_map_add(ctxt->cinode, rec);
+ ret = ocfs2_extent_map_insert(ctxt->cinode->ci_map, rec,
+ tree_depth);
if (ret) {
ctxt->errcode = ret;
iret |= OCFS2_EXTENT_ABORT;
@@ -119,22 +398,15 @@
if (!cinode)
return OCFS2_ET_INVALID_ARGUMENT;
- ret = ocfs2_malloc0(sizeof(ocfs2_extent_map), &cinode->ci_map);
+ ret = ocfs2_extent_map_new(fs, cinode, &cinode->ci_map);
if (ret)
return ret;
- INIT_LIST_HEAD(&cinode->ci_map->em_extents);
- cinode->ci_map->em_cinode = cinode;
-
ctxt.cinode = cinode;
ctxt.errcode = 0;
- ret = ocfs2_extent_iterate(fs,
- cinode->ci_blkno,
- OCFS2_EXTENT_FLAG_DATA_ONLY,
- NULL,
- extent_map_func,
- &ctxt);
+ ret = ocfs2_extent_iterate(fs, cinode->ci_blkno, 0, NULL,
+ extent_map_func, &ctxt);
if (ret)
goto cleanup;
@@ -146,43 +418,12 @@
return 0;
cleanup:
- ocfs2_free_extent_map(fs, cinode);
+ ocfs2_drop_extent_map(fs, cinode);
return ret;
}
-errcode_t ocfs2_extent_map_clear(ocfs2_cached_inode *cinode,
- uint32_t cpos, uint32_t clusters)
-{
- ocfs2_extent_map *em;
- struct list_head *pos, *next;
- ocfs2_extent_map_entry *ent;
-
- if (!cinode || !cinode->ci_map)
- return OCFS2_ET_INVALID_ARGUMENT;
-
- em = cinode->ci_map;
-
- for (pos = em->em_extents.next, next = pos->next;
- pos != &em->em_extents;
- pos = next, next = pos->next) {
- ent = list_entry(pos, ocfs2_extent_map_entry, e_list);
-
- if ((ent->e_rec.e_cpos + ent->e_rec.e_clusters) <=
- cpos)
- continue;
-
- if ((cpos + clusters) <= (ent->e_rec.e_cpos))
- continue;
-
- list_del(pos);
- ocfs2_free(&ent);
- }
-
- return 0;
-}
-
-errcode_t ocfs2_free_extent_map(ocfs2_filesys *fs,
+errcode_t ocfs2_drop_extent_map(ocfs2_filesys *fs,
ocfs2_cached_inode *cinode)
{
ocfs2_extent_map *em;
@@ -191,10 +432,9 @@
return OCFS2_ET_INVALID_ARGUMENT;
em = cinode->ci_map;
+ ocfs2_extent_map_free(em);
+ cinode->ci_map = NULL;
- ocfs2_extent_map_clear(cinode, 0, cinode->ci_inode->i_clusters);
- ocfs2_free(&cinode->ci_map);
-
return 0;
}
@@ -224,7 +464,7 @@
ocfs2_cached_inode *cinode)
{
ocfs2_extent_map *em;
- struct list_head *pos;
+ struct rb_node *node;
uint32_t ccount;
ocfs2_extent_map_entry *ent;
@@ -233,9 +473,10 @@
fprintf(stdout, "EXTENTS:\n");
ccount = 0;
- list_for_each(pos, &em->em_extents) {
- ent = list_entry(pos, ocfs2_extent_map_entry, e_list);
+ for (node = rb_first(&em->em_extents); node; node = rb_next(node)) {
+ ent = rb_entry(node, ocfs2_extent_map_entry, e_node);
+
fprintf(stdout, "(%08"PRIu32", %08"PRIu32", %08"PRIu64") |"
" + %08"PRIu32" = %08"PRIu32" / %08"PRIu32"\n",
ent->e_rec.e_cpos, ent->e_rec.e_clusters,
Modified: trunk/libocfs2/extents.c
===================================================================
--- trunk/libocfs2/extents.c 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/extents.c 2004-10-06 22:26:51 UTC (rev 317)
@@ -344,12 +344,9 @@
struct block_context *ctxt = priv_data;
uint64_t blkno, bcount, bend;
int iret = 0;
- int c_to_b_bits =
- (OCFS2_RAW_SB(fs->fs_super)->s_clustersize_bits -
- OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits);
- bcount = (uint64_t)ccount << c_to_b_bits;
- bend = bcount + ((uint64_t)rec->e_clusters << c_to_b_bits);
+ bcount = ocfs2_clusters_to_blocks(fs, ccount);
+ bend = bcount + ocfs2_clusters_to_blocks(fs, rec->e_clusters);
for (blkno = rec->e_blkno; bcount < bend; blkno++, bcount++) {
if (((bcount * fs->fs_blocksize) >= ctxt->inode->i_size) &&
Modified: trunk/libocfs2/fileio.c
===================================================================
--- trunk/libocfs2/fileio.c 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/fileio.c 2004-10-06 22:26:51 UTC (rev 317)
@@ -71,9 +71,6 @@
errcode_t retval;
char *inode_buf;
ocfs2_dinode *di;
- int c_to_b_bits =
- OCFS2_RAW_SB(fs->fs_super)->s_clustersize_bits -
- OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits;
/* So the caller can see nothing was read */
*len = 0;
@@ -95,7 +92,7 @@
goto out_free;
retval = ocfs2_malloc_blocks(fs->fs_io,
- di->i_clusters << c_to_b_bits,
+ ocfs2_clusters_to_blocks(fs, di->i_clusters),
buf);
if (retval)
goto out_free;
Modified: trunk/libocfs2/include/extent_map.h
===================================================================
--- trunk/libocfs2/include/extent_map.h 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/include/extent_map.h 2004-10-06 22:26:51 UTC (rev 317)
@@ -27,17 +27,18 @@
#ifndef _EXTENT_MAP_H
#define _EXTENT_MAP_H
-#include "kernel-list.h"
+#include "kernel-rbtree.h"
typedef struct _ocfs2_extent_map_entry ocfs2_extent_map_entry;
struct _ocfs2_extent_map {
ocfs2_cached_inode *em_cinode;
- struct list_head em_extents;
+ struct rb_root em_extents;
};
struct _ocfs2_extent_map_entry {
- struct list_head e_list;
+ struct rb_node e_node;
+ int e_tree_depth;
ocfs2_extent_rec e_rec;
};
Modified: trunk/libocfs2/include/ocfs2.h
===================================================================
--- trunk/libocfs2/include/ocfs2.h 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/include/ocfs2.h 2004-10-06 22:26:51 UTC (rev 317)
@@ -246,14 +246,30 @@
errcode_t ocfs2_free_cached_inode(ocfs2_filesys *fs,
ocfs2_cached_inode *cinode);
+errcode_t ocfs2_extent_map_new(ocfs2_filesys *fs,
+ ocfs2_cached_inode *cinode,
+ ocfs2_extent_map **ret_em);
+void ocfs2_extent_map_free(ocfs2_extent_map *em);
+errcode_t ocfs2_extent_map_insert(ocfs2_extent_map *em,
+ ocfs2_extent_rec *rec,
+ int tree_depth);
+errcode_t ocfs2_extent_map_trunc(ocfs2_extent_map *em,
+ uint32_t new_clusters);
+errcode_t ocfs2_extent_map_get_rec(ocfs2_extent_map *em,
+ uint32_t cpos,
+ ocfs2_extent_rec **rec);
+errcode_t ocfs2_extent_map_get_clusters(ocfs2_extent_map *em,
+ uint32_t v_cpos, int count,
+ uint32_t *p_cpos,
+ int *ret_count);
+errcode_t ocfs2_extent_map_get_blocks(ocfs2_extent_map *em,
+ uint64_t v_blkno, int count,
+ uint64_t *p_blkno,
+ int *ret_count);
errcode_t ocfs2_load_extent_map(ocfs2_filesys *fs,
ocfs2_cached_inode *cinode);
-errcode_t ocfs2_free_extent_map(ocfs2_filesys *fs,
+errcode_t ocfs2_drop_extent_map(ocfs2_filesys *fs,
ocfs2_cached_inode *cinode);
-errcode_t ocfs2_extent_map_add(ocfs2_cached_inode *cinode,
- ocfs2_extent_rec *rec);
-errcode_t ocfs2_extent_map_clear(ocfs2_cached_inode *cinode,
- uint32_t cpos, uint32_t clusters);
errcode_t ocfs2_create_journal_superblock(ocfs2_filesys *fs,
uint32_t size, int flags,
@@ -380,4 +396,25 @@
void *priv_data),
void *priv_data);
+static inline uint64_t ocfs2_clusters_to_blocks(ocfs2_filesys *fs,
+ uint32_t clusters)
+{
+ int c_to_b_bits =
+ OCFS2_RAW_SB(fs->fs_super)->s_clustersize_bits -
+ OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits;
+
+ return (uint64_t)clusters << c_to_b_bits;
+}
+
+static inline uint32_t ocfs2_blocks_to_clusters(ocfs2_filesys *fs,
+ uint64_t blocks)
+{
+ int b_to_c_bits =
+ OCFS2_RAW_SB(fs->fs_super)->s_clustersize_bits -
+ OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits;
+
+ return (uint32_t)(blocks >> b_to_c_bits);
+}
+
+
#endif /* _FILESYS_H */
Modified: trunk/libocfs2/inode_scan.c
===================================================================
--- trunk/libocfs2/inode_scan.c 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/inode_scan.c 2004-10-06 22:26:51 UTC (rev 317)
@@ -56,7 +56,6 @@
int blocks_in_buffer;
unsigned int blocks_left;
uint64_t bpos;
- int c_to_b_bits;
};
@@ -268,9 +267,6 @@
return ret;
scan->fs = fs;
- scan->c_to_b_bits =
- OCFS2_RAW_SB(fs->fs_super)->s_clustersize_bits -
- OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits;
/* One inode alloc per node, one global inode alloc */
scan->num_inode_alloc =
@@ -288,7 +284,9 @@
((8 * fs->fs_blocksize) +
(fs->fs_clustersize - 1)) /
fs->fs_clustersize;
- scan->buffer_blocks <<= scan->c_to_b_bits;
+ scan->buffer_blocks =
+ ocfs2_clusters_to_blocks(fs,
+ scan->buffer_blocks);
}
ret = ocfs2_malloc(sizeof(char) * scan->buffer_blocks *
Modified: trunk/libocfs2/ocfs2_err.et.in
===================================================================
--- trunk/libocfs2/ocfs2_err.et.in 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/ocfs2_err.et.in 2004-10-06 22:26:51 UTC (rev 317)
@@ -95,4 +95,10 @@
ec OCFS2_ET_CORRUPT_CHAIN,
"Chain allocator is corrupt"
+ec OCFS2_ET_INVALID_EXTENT_LOOKUP,
+ "Invalid range passed to extent map lookup"
+
+ec OCFS2_ET_EXTENT_NOT_FOUND,
+ "No mapping exists for the given extent range"
+
end
Modified: trunk/libocfs2/openfs.c
===================================================================
--- trunk/libocfs2/openfs.c 2004-10-06 18:29:32 UTC (rev 316)
+++ trunk/libocfs2/openfs.c 2004-10-06 22:26:51 UTC (rev 317)
@@ -78,9 +78,6 @@
errcode_t ret;
char *buf;
ocfs2_dinode *inode;
- int c_to_b_bits =
- OCFS2_RAW_SB(fs->fs_super)->s_clustersize_bits -
- OCFS2_RAW_SB(fs->fs_super)->s_blocksize_bits;
ret = ocfs2_lookup_system_inode(fs, GLOBAL_BITMAP_SYSTEM_INODE,
0, &fs->fs_bm_blkno);
@@ -98,7 +95,7 @@
inode = (ocfs2_dinode *)buf;
fs->fs_clusters = inode->id1.bitmap1.i_total;
- fs->fs_blocks = (uint64_t)fs->fs_clusters << c_to_b_bits;
+ fs->fs_blocks = ocfs2_clusters_to_blocks(fs, fs->fs_clusters);
out_free:
ocfs2_free(&buf);
More information about the Ocfs2-tools-commits
mailing list