lgcosta/reiserfsprogs
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dac518d099bbd0b3b4feb58351cc41d89683e40d
reiserfsprogs/utils/fsck/uobjectid.c
T

396 lines
8.6 KiB
C
Raw Blame History

/*
* Copyright 1996-2004 by Hans Reiser, licensing governed by
* reiserfsprogs/README
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "fsck.h"
#include "misc/malloc.h"
/* when --check fsck builds a map of objectids of files it finds in the tree
when --rebuild-tree - fsck builds map of objectids it inserts into tree */
#define ALLOC_SIZE 1024
#define MAX_ID (~(__u32)0)
/* 2 bytes for the counter */
#define BM_SIZE (ALLOC_SIZE - sizeof(__u16))
#define BM_INTERVAL (BM_SIZE * 8)
#define INDEX_COUNT (MAX_ID / BM_INTERVAL)
#define id_map_interval(map, id) (map->index + (id / BM_INTERVAL))
#define id_map_local_count(interval) (interval + BM_SIZE)
/*
typedef struct sb_id_map {
__u32 * m_begin;
__u32 m_size, m_used_slot_count;
} sb_id_map_t;
*/
id_map_t *id_map_init() {
id_map_t *map;
__u32 i;
map = misc_getmem(sizeof(id_map_t));
map->index = misc_malloc(INDEX_COUNT * sizeof(void *));
for (i = 0; i < INDEX_COUNT; i++) {
if (map->index[i] != (void *)0)
map->index[i] = (void *)0;
}
id_map_mark(map, 0);
id_map_mark(map, 1);
/* id == 0 should not be there, just for convinient usage */
map->count--;
return map;
}
void id_map_free(id_map_t *map) {
__u32 i;
for (i = 0; i < INDEX_COUNT; i++) {
if (map->index[i] != (void *)0 && map->index[i] != (void *)1)
misc_freemem(map->index[i]);
}
misc_freemem(map->index);
misc_freemem(map);
}
int id_map_test(id_map_t *map, __u32 id) {
void **interval = id_map_interval(map, id);
if (*interval == (void *)0)
return 0;
if (*interval == (void *)1)
return 1;
return misc_test_bit(id % BM_INTERVAL, *interval);
}
int id_map_mark(id_map_t *map, __u32 id) {
void **interval = id_map_interval(map, id);
if (*interval == (void *)0)
*interval = misc_getmem(ALLOC_SIZE);
if (*interval == (void *)1)
return 1;
if (misc_test_bit(id % BM_INTERVAL, *interval))
return 1;
misc_set_bit(id % BM_INTERVAL, *interval);
(*(__u16 *)id_map_local_count(*interval))++;
map->count++;
if ((*(__u16 *)id_map_local_count(*interval)) == BM_INTERVAL) {
/* Dealloc fully used bitmap */
misc_freemem(*interval);
*interval = (void *)1;
}
if (map->last_used < (id / BM_INTERVAL))
map->last_used = id / BM_INTERVAL;
return 0;
}
/* call this for proper_id_map only!! */
__u32 id_map_alloc(id_map_t *map) {
__u32 i, zero_count;
__u32 id = 0, first = ~(__u32)0;
for (i = 0, zero_count = 0; zero_count < 10 && i < INDEX_COUNT - 1; i++) {
if (map->index[i] == (void *)0) {
if (zero_count == 0)
first = i;
zero_count++;
} else if (map->index[i] != (void *)1)
break;
}
if (map->index[i] != (void *)1 && map->index[i] != (void *)0) {
id = misc_find_first_zero_bit(map->index[i], BM_INTERVAL);
if (id >= BM_INTERVAL)
misc_die ("Id is out of interval size, interval looks corrupted.");
id += i * BM_INTERVAL;
} else if (first != ~(__u32)0) {
id = first * BM_INTERVAL;
if (id == 0)
id = 2;
} else
misc_die ("%s: No more free objectid is available.", __FUNCTION__);
id_map_mark(map, id);
return id;
}
/* this could be used if some more sofisticated flushing will be needed. */
/*
static void sb_id_map_pack(sb_id_map_t *map) {
map->m_begin[1] = map->m_begin[map->m_used_slot_count - 1];
memset(map->m_begin + 2, 0, map->m_used_slot_count - 2);
map->m_used_slot_count = 2;
}*/
static __u32 id_map_next_bound(id_map_t *map, __u32 start) {
__u32 index = start / BM_INTERVAL;
__u32 offset = 0;
int look_for;
if (map->index[index] == (void *)0)
look_for = 1;
else if (map->index[index] == (void *)1)
look_for = 0;
else {
offset = start % BM_INTERVAL;
look_for = !misc_test_bit(offset, map->index[index]);
offset++;
}
start_again:
if (look_for) {
while (index < INDEX_COUNT && map->index[index] == (void *)0) {
index++;
}
if (index == INDEX_COUNT)
return 0;
if (map->index[index] == (void *)1)
return index * BM_INTERVAL;
offset = misc_find_next_set_bit(map->index[index],
BM_INTERVAL, offset);
if (offset >= BM_INTERVAL) {
offset = 0;
index++;
goto start_again;
}
} else {
while (index < INDEX_COUNT && map->index[index] == (void *)1)
index++;
if (index == INDEX_COUNT)
return 0;
if (map->index[index] == (void *)0)
return index * BM_INTERVAL;
offset = misc_find_next_zero_bit(map->index[index],
BM_INTERVAL, offset);
if (offset >= BM_INTERVAL) {
offset = 0;
index++;
goto start_again;
}
}
return index * BM_INTERVAL + offset;
}
void id_map_flush(struct id_map * map, reiserfs_filsys_t * fs) {
int size, max, i;
__u32 id, prev_id;
__u32 * sb_objectid_map;
size = reiserfs_super_size (fs->fs_ondisk_sb);
sb_objectid_map = (__u32 *)((char *)(fs->fs_ondisk_sb) + size);
max = ((fs->fs_blocksize - size) >> 3 << 1);
reiserfs_sb_set_mapmax (fs->fs_ondisk_sb, max);
id = 1;
sb_objectid_map[0] = cpu_to_le32(0);
for (i = 1; i < max - 1; i++) {
id = id_map_next_bound(map, id);
sb_objectid_map[i] = cpu_to_le32(id);
if (id == 0) {
if (i % 2) {
misc_die ("%s: Used interval is not closed "
"on flushing.", __FUNCTION__);
}
break;
}
}
if (map->index[map->last_used] == (void *)0) {
misc_die ("Object id map looks corrupted - last "
"used interval cannot be zeroed.");
}
i++;
if (i == max) {
if (id == 0) {
misc_die ("Objectid interval does not contain "
"any set bit what is expected.");
}
if (map->index[map->last_used] == (void *)1) {
prev_id = BM_INTERVAL - 1;
} else {
prev_id = ~(__u32)0;
if (id < map->last_used * BM_INTERVAL)
id = 0;
else
id %= BM_INTERVAL;
if (misc_test_bit(id, map->index[map->last_used]))
prev_id = id;
while ((id = misc_find_next_set_bit(map->index[map->last_used],
BM_INTERVAL, (id + 1))) != BM_INTERVAL)
{
prev_id = id;
}
if (prev_id == ~(__u32)0) {
misc_die ("Objectid interval does not contain "
"any set bit what is expected.");
}
prev_id++;
}
sb_objectid_map[max - 1] =
cpu_to_le32(prev_id + map->last_used * BM_INTERVAL);
} else {
i--;
memset(sb_objectid_map + i, 0, (max - i) * sizeof (__u32));
}
reiserfs_sb_set_mapcur (fs->fs_ondisk_sb, i);
}
void fetch_objectid_map (struct id_map * map,
reiserfs_filsys_t * fs)
{
__u32 i, j, sb_size;
__u32 * sb_objectid_map;
sb_size = reiserfs_super_size (fs->fs_ondisk_sb);
sb_objectid_map = (__u32 *)((char *)(fs->fs_ondisk_sb) + sb_size);
if (map == NULL)
misc_die ("Not map given");
for (i = 0; i < reiserfs_sb_get_mapcur(fs->fs_ondisk_sb); i+=2) {
for (j = sb_objectid_map[i]; j < sb_objectid_map[i + 1]; j++) {
id_map_mark(map, j);
if (j == 0)
map->count--;
}
}
}
#define OBJMAP_START_MAGIC 375331
#define OBJMAP_END_MAGIC 7700472
void reiserfs_objectid_map_save (FILE * fp, struct id_map * id_map) {
__u32 v, count;
v = OBJMAP_START_MAGIC;
fwrite (&v, 4, 1, fp);
v = 0;
count = 0;
/* Write 0. */
fwrite (&v, 4, 1, fp);
count++;
while ((v = id_map_next_bound(id_map, v))) {
fwrite (&v, 4, 1, fp);
count++;
}
fwrite (&count, 4, 1, fp);
v = OBJMAP_END_MAGIC;
fwrite (&v, 4, 1, fp);
}
struct id_map * reiserfs_objectid_map_load (FILE * fp) {
__u32 v, count, i, prev, next;
struct id_map * id_map;
int skip, odd;
id_map = id_map_init();
fread (&v, 4, 1, fp);
if (v != OBJMAP_START_MAGIC) {
reiserfs_warning (stderr, "reiserfs_objectid_map_load: no "
"objectid map begin magic found");
goto error;
}
count = 0;
skip = 0;
odd = 0;
prev = 0;
while (1) {
if (skip) {
skip = 0;
v = next;
} else if (fread(&v, 4, 1, fp) != 1) {
reiserfs_warning (stderr, "%s: failed to read the given",
__FUNCTION__);
goto error;
}
if (v == count) {
/* Check if the magic goes after. */
if (fread(&next, 4, 1, fp) != 1) {
reiserfs_warning (stderr, "%s: failed to read the given",
__FUNCTION__);
goto error;
}
if (next != OBJMAP_END_MAGIC)
skip = 1;
else break;
}
if (odd) {
for (i = prev; i < v; i++) {
id_map_mark(id_map, i);
if (i == 0)
id_map->count--;
}
}
prev = v;
odd = odd ? 0 : 1;
count++;
}
return id_map;
error:
fflush (stderr);
id_map_free(id_map);
return NULL;
}
Reference in new issue View Git Blame Copy Permalink