blob: 9c03ba4fd8584eea42c9cf7567537fedef095631 [file] [log] [blame]
/*
* Copyright 2000-2004 by Hans Reiser, licensing governed by
* reiserfsprogs/README
*/
#define _GNU_SOURCE
#include "includes.h"
#include <linux/kdev_t.h>
#include <time.h>
struct key root_dir_key = {0, 0, {{0, 0},}};
struct key parent_root_dir_key = {0, 0, {{0, 0},}};
struct key lost_found_dir_key = {0, 0, {{0, 0}, }};
struct key badblock_key = {BADBLOCK_DIRID, BADBLOCK_OBJID, {{0, 0},}};
__u16 root_dir_format = 0;
__u16 lost_found_dir_format = 0;
static void make_const_keys (void)
{
set_key_dirid (&root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
set_key_objectid (&root_dir_key, REISERFS_ROOT_OBJECTID);
set_key_dirid (&parent_root_dir_key, 0);
set_key_objectid (&parent_root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
}
/* reiserfs needs at least: enough blocks for journal, 64 k at the beginning,
one block for super block, bitmap block and root block. Note that first
bitmap block must point to all of them */
int is_block_count_correct (unsigned long journal_offset, unsigned int block_size,
unsigned long block_count, unsigned long journal_size)
{
unsigned long blocks;
/* RESERVED, MD RAID SBs, super block, bitmap, root, journal size with journal header */
blocks = journal_offset + journal_size;
/* we have a limit: skipped area, super block, journal and root block
all have to be addressed by one first bitmap */
if (blocks > block_size * 8)
return 0;
if (blocks > block_count)
return 0;
return 1;
}
/* read super block. fixme: only 4k blocks, pre-journaled format
is refused. Journal and bitmap are to be opened separately.
skip_check is set to 1 if checks of openned SB should be omitted.*/
reiserfs_filsys_t * reiserfs_open (char * filename, int flags,
int *error, void * vp, int check)
{
reiserfs_filsys_t * fs;
struct buffer_head * bh;
struct reiserfs_super_block * sb;
int fd;
unsigned int i;
/* convert root dir key and parent root dir key to little endian format */
make_const_keys ();
if (error)
*error = 0;
fd = open (filename, flags
#if defined(O_LARGEFILE)
| O_LARGEFILE
#endif
);
if (fd == -1) {
if (error)
*error = errno;
return 0;
}
fs = getmem (sizeof (*fs));
fs->fs_dev = fd;
fs->fs_vp = vp;
asprintf (&fs->fs_file_name, "%s", filename);
/* reiserfs super block is either in 16-th or in 2-nd 4k block of the
device */
for (i = 2; i < 17; i += 14) {
bh = bread (fd, i, 4096);
if (!bh) {
reiserfs_warning (stderr, "reiserfs_open: bread failed reading block %d\n", i);
} else {
sb = (struct reiserfs_super_block *)bh->b_data;
if (is_any_reiserfs_magic_string(sb))
goto found;
/* reiserfs signature is not found at the i-th 4k block */
brelse (bh);
}
}
reiserfs_warning(stderr,
"\nreiserfs_open: the reiserfs superblock cannot be found on %s.\n", filename);
freemem (fs);
close (fd);
fs = NULL;
return fs;
found:
if (!is_blocksize_correct(get_sb_block_size(sb))) {
reiserfs_warning(stderr, "reiserfs_open: a superblock with wrong parameters "
"was found in the block (%d).\n", i);
freemem (fs);
close (fd);
brelse(bh);
return NULL;
}
if (check) {
/* A few checks of found super block. */
struct buffer_head *tmp_bh;
tmp_bh = bread (fd, get_sb_block_count(sb) - 1, get_sb_block_size(sb));
if (!tmp_bh) {
reiserfs_warning (stderr, "\n%s: Your partition is not big enough to contain the \n"
"filesystem of (%lu) blocks as was specified in the found super block.\n",
__FUNCTION__, get_sb_block_count(sb) - 1);
freemem (fs);
close (fd);
brelse(bh);
return NULL;
}
brelse(tmp_bh);
}
fs->fs_blocksize = get_sb_block_size (sb);
/* check block size on the filesystem */
if (fs->fs_blocksize != 4096) {
i = bh->b_blocknr * 4096 / fs->fs_blocksize;
brelse (bh);
bh = bread (fd, i, fs->fs_blocksize);
if (!bh) {
reiserfs_warning (stderr, "reiserfs_open: bread failed reading block %d, size %d\n",
i, fs->fs_blocksize);
freemem (fs);
return 0;
}
sb = (struct reiserfs_super_block *)bh->b_data;
}
fs->fs_hash_function = code2func (get_sb_hash_code (sb));
fs->fs_super_bh = bh;
fs->fs_ondisk_sb = sb;
fs->fs_flags = flags; /* O_RDONLY or O_RDWR */
fs->fs_format = get_reiserfs_format (sb);
/*reiserfs_read_bitmap_blocks(fs);*/
if (flags & O_RDWR)
fs->fs_dirt = 1;
else
fs->fs_dirt = 0;
return fs;
}
/* creates buffer for super block and fills it up with fields which are
constant for given size and version of a filesystem */
reiserfs_filsys_t * reiserfs_create (char * filename,
int version,
unsigned long block_count,
int block_size,
int default_journal,
int new_format)
{
reiserfs_filsys_t * fs;
unsigned int bmap_nr = reiserfs_bmap_nr(block_count, block_size);;
time_t now;
/* convert root dir key and parent root dir key to little endian format */
make_const_keys ();
if (count_blocks (filename, block_size) < block_count) {
reiserfs_warning (stderr, "reiserfs_create: no enough blocks on device\n");
return 0;
}
if (!is_block_count_correct (REISERFS_DISK_OFFSET_IN_BYTES / block_size,
block_size, block_count, 0))
{
reiserfs_warning (stderr, "reiserfs_create: can not create that small "
"(%u blocks) filesystem\n", block_count);
return 0;
}
fs = getmem (sizeof (*fs));
if (!fs) {
reiserfs_warning (stderr, "reiserfs_create: getmem failed\n");
return 0;
}
fs->fs_dev = open (filename, O_RDWR | O_EXCL
#if defined(O_LARGEFILE)
| O_LARGEFILE
#endif
);
if (fs->fs_dev == -1) {
reiserfs_warning (stderr, "reiserfs_create: could not open %s: %s\n",
filename, strerror(errno));
freemem (fs);
return 0;
}
fs->fs_blocksize = block_size;
asprintf (&fs->fs_file_name, "%s", filename);
fs->fs_format = version;
if (new_format)
fs->fs_super_bh = getblk (fs->fs_dev,
REISERFS_DISK_OFFSET_IN_BYTES / block_size, block_size);
else
fs->fs_super_bh = getblk (fs->fs_dev,
REISERFS_OLD_DISK_OFFSET_IN_BYTES / block_size, block_size);
if (!fs->fs_super_bh) {
reiserfs_warning (stderr, "reiserfs_create: getblk failed\n");
return 0;
}
mark_buffer_uptodate (fs->fs_super_bh, 1);
fs->fs_ondisk_sb = (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
memset (fs->fs_ondisk_sb, 0, block_size);
/* fill super block fields which are constant for given version and block count */
set_sb_block_count (fs->fs_ondisk_sb, block_count);
/* sb_free_blocks */
/* sb_root_block */
/* sb_journal_1st_block */
/* sb_journal_dev */
/* sb_orig_journal_size */
/* sb_joural_magic */
/* sb_journal magic_F */
/* sb_mount_id */
/* sb_not_used0 */
/* sb_generation_number */
set_sb_block_size (fs->fs_ondisk_sb, block_size);
switch (version) {
case REISERFS_FORMAT_3_5:
set_sb_oid_maxsize (fs->fs_ondisk_sb,
(block_size - SB_SIZE_V1) / sizeof(__u32) / 2 * 2);
/* sb_oid_cursize */
/* sb_state */
memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_3_5_SUPER_MAGIC_STRING,
strlen (REISERFS_3_5_SUPER_MAGIC_STRING));
break;
case REISERFS_FORMAT_3_6:
set_sb_oid_maxsize (fs->fs_ondisk_sb,
(block_size - SB_SIZE) / sizeof(__u32) / 2 * 2);
/* sb_oid_cursize */
/* sb_state */
memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_3_6_SUPER_MAGIC_STRING,
strlen (REISERFS_3_6_SUPER_MAGIC_STRING));
break;
}
if (!default_journal)
memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_JR_SUPER_MAGIC_STRING,
strlen (REISERFS_JR_SUPER_MAGIC_STRING));
/* sb_fsck_state */
/* sb_hash_function_code */
/* sb_tree_height */
set_sb_bmap_nr (fs->fs_ondisk_sb,
reiserfs_bmap_over(bmap_nr) ? 0 : bmap_nr);
set_sb_version (fs->fs_ondisk_sb, version);
set_sb_v2_lastcheck(fs->fs_ondisk_sb, time(&now));
set_sb_v2_check_interval(fs->fs_ondisk_sb, DEFAULT_CHECK_INTERVAL);
set_sb_v2_mnt_count(fs->fs_ondisk_sb, 1);
set_sb_v2_max_mnt_count(fs->fs_ondisk_sb, DEFAULT_MAX_MNT_COUNT);
/* sb_not_used1 */
mark_buffer_dirty (fs->fs_super_bh);
fs->fs_dirt = 1;
return fs;
}
int no_reiserfs_found (reiserfs_filsys_t * fs)
{
return (fs == NULL || fs->fs_blocksize == 0) ? 1 : 0;
}
int new_format (reiserfs_filsys_t * fs)
{
return fs->fs_super_bh->b_blocknr != 2;
}
int spread_bitmaps (reiserfs_filsys_t * fs)
{
return fs->fs_super_bh->b_blocknr != 2;
}
/* 0 means: do not guarantee that fs is consistent */
int reiserfs_is_fs_consistent (reiserfs_filsys_t * fs)
{
if (get_sb_umount_state (fs->fs_ondisk_sb) == FS_CLEANLY_UMOUNTED &&
get_sb_fs_state (fs->fs_ondisk_sb) == FS_CONSISTENT)
return 1;
return 0;
}
/* flush bitmap, brelse super block, flush all dirty buffers, close and open
again the device, read super block */
static void reiserfs_only_reopen (reiserfs_filsys_t * fs, int flag)
{
unsigned long super_block;
/* reiserfs_flush_to_ondisk_bitmap (fs->fs_bitmap2, fs);*/
super_block = fs->fs_super_bh->b_blocknr;
brelse (fs->fs_super_bh);
flush_buffers (fs->fs_dev);
invalidate_buffers (fs->fs_dev);
if (close (fs->fs_dev))
die ("reiserfs_reopen: closed failed: %s", strerror(errno));
fs->fs_dev = open (fs->fs_file_name, flag
#if defined(O_LARGEFILE)
| O_LARGEFILE
#endif
);
if (fs->fs_dev == -1)
die ("reiserfs_reopen: could not reopen device: %s", strerror(errno));
fs->fs_super_bh = bread (fs->fs_dev, super_block, fs->fs_blocksize);
if (!fs->fs_super_bh)
die ("reiserfs_reopen: reading super block failed");
fs->fs_ondisk_sb = (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
fs->fs_flags = flag; /* O_RDONLY or O_RDWR */
if (flag & O_RDWR)
fs->fs_dirt = 1;
else
fs->fs_dirt = 0;
}
void reiserfs_reopen (reiserfs_filsys_t * fs, int flag)
{
reiserfs_only_reopen (fs, flag);
reiserfs_reopen_journal (fs, flag);
}
int is_opened_rw (reiserfs_filsys_t * fs)
{
if ((fs->fs_flags) & O_RDWR)
return 1;
return 0;
}
/* flush all changes made on a filesystem */
void reiserfs_flush (reiserfs_filsys_t * fs)
{
if (fs->fs_dirt) {
reiserfs_flush_journal (fs);
flush_buffers (fs->fs_dev);
}
fs->fs_dirt = 0;
}
/* free all memory involved into manipulating with filesystem */
void reiserfs_free (reiserfs_filsys_t * fs)
{
reiserfs_free_journal (fs);
reiserfs_free_ondisk_bitmap (fs);
/* release super block and memory used by filesystem handler */
brelse (fs->fs_super_bh);
fs->fs_super_bh = 0;
free_buffers ();
free (fs->fs_file_name);
fs->fs_file_name = 0;
freemem (fs);
}
/* this closes everything: journal. bitmap and the fs itself */
void reiserfs_close (reiserfs_filsys_t * fs)
{
reiserfs_close_journal (fs);
reiserfs_close_ondisk_bitmap (fs);
reiserfs_flush (fs);
reiserfs_free (fs);
fsync(fs->fs_dev);
}
int reiserfs_new_blocknrs (reiserfs_filsys_t * fs,
unsigned long * free_blocknrs,
unsigned long start,
int amount_needed)
{
if (fs->block_allocator)
return fs->block_allocator (fs, free_blocknrs, start, amount_needed);
die ("block allocator is not defined\n");
return 0;
}
int reiserfs_free_block (reiserfs_filsys_t * fs, unsigned long block)
{
if (fs->block_deallocator)
return fs->block_deallocator (fs, block);
die ("block deallocator is not defined\n");
return 0;
}
static int reiserfs_search_by_key_x (reiserfs_filsys_t * fs, struct key * key,
struct path * path, int key_length)
{
struct buffer_head * bh;
unsigned long block;
struct path_element * curr;
int retval;
block = get_sb_root_block (fs->fs_ondisk_sb);
if (not_data_block(fs, block))
return IO_ERROR;
path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
while (1) {
curr = PATH_OFFSET_PELEMENT (path, ++ path->path_length);
bh = curr->pe_buffer = bread (fs->fs_dev, block, fs->fs_blocksize);
if (bh == 0) {
path->path_length --;
pathrelse (path);
return ITEM_NOT_FOUND;
}
retval = reiserfs_bin_search (key, B_N_PKEY (bh, 0), B_NR_ITEMS (bh),
is_leaf_node (bh) ? IH_SIZE : KEY_SIZE,
&curr->pe_position,
key_length == 4 ?
comp_keys : comp_keys_3);
if (retval == POSITION_FOUND) {
/* key found, return if this is leaf level */
if (is_leaf_node (bh)) {
path->pos_in_item = 0;
return ITEM_FOUND;
}
curr->pe_position ++;
} else {
/* key not found in the node */
if (is_leaf_node (bh))
return ITEM_NOT_FOUND;
}
block = get_dc_child_blocknr (B_N_CHILD (bh, curr->pe_position));
if (not_data_block(fs, block))
return IO_ERROR;
}
printf ("search_by_key: you can not get here\n");
return ITEM_NOT_FOUND;
}
int reiserfs_search_by_key_3 (reiserfs_filsys_t * fs, struct key * key,
struct path * path)
{
return reiserfs_search_by_key_x (fs, key, path, 3);
}
int reiserfs_search_by_key_4 (reiserfs_filsys_t * fs, struct key * key,
struct path * path)
{
return reiserfs_search_by_key_x (fs, key, path, 4);
}
/* key is key of byte in the regular file. This searches in tree
through items and in the found item as well */
int usearch_by_position (reiserfs_filsys_t * s, struct key * key,
int version, struct path * path)
{
struct buffer_head * bh;
struct item_head * ih;
struct key * next_key;
if (reiserfs_search_by_key_3 (s, key, path) == ITEM_FOUND) {
ih = get_ih (path);
if (!is_direct_ih (ih) && !is_indirect_ih (ih))
return DIRECTORY_FOUND;
path->pos_in_item = 0;
return POSITION_FOUND;
}
bh = get_bh (path);
ih = get_ih (path);
if (PATH_LAST_POSITION (path) == 0) {
/* previous item does not exist, that means we are in leftmost leaf of
* the tree */
if (!not_of_one_file (&ih->ih_key, key)) {
if (!is_direct_ih (ih) && !is_indirect_ih (ih))
return DIRECTORY_FOUND;
return POSITION_NOT_FOUND;
}
return FILE_NOT_FOUND;
}
/* take previous item */
PATH_LAST_POSITION (path) --;
ih --;
if (not_of_one_file (&ih->ih_key, key) || is_stat_data_ih(ih)) {
/* previous item belongs to another object or is a stat data, check
* next item */
PATH_LAST_POSITION (path) ++;
if (PATH_LAST_POSITION (path) < B_NR_ITEMS (bh))
/* next key is in the same node */
next_key = B_N_PKEY (bh, PATH_LAST_POSITION (path));
else
next_key = uget_rkey (path);
if (next_key == 0 || not_of_one_file (next_key, key)) {
/* there is no any part of such file in the tree */
path->pos_in_item = 0;
return FILE_NOT_FOUND;
}
if (is_direntry_key (next_key)) {
reiserfs_warning (stderr, "usearch_by_position: looking for %k found a directory with the same key\n",
next_key);
return DIRECTORY_FOUND;
}
/* next item is the part of this file */
path->pos_in_item = 0;
return POSITION_NOT_FOUND;
}
if (is_direntry_ih (ih)) {
return DIRECTORY_FOUND;
}
if (is_stat_data_ih(ih)) {
PATH_LAST_POSITION (path) ++;
return FILE_NOT_FOUND;
}
/* previous item is part of desired file */
if (I_K_KEY_IN_ITEM (ih, key, bh->b_size)) {
path->pos_in_item = get_offset (key) - get_offset (&ih->ih_key);
if (is_indirect_ih (ih) )
path->pos_in_item /= bh->b_size;
return POSITION_FOUND;
}
path->pos_in_item = is_indirect_ih (ih) ? I_UNFM_NUM (ih) : get_ih_item_len (ih);
return POSITION_NOT_FOUND;
}
static int comp_dir_entries (const void * p1, const void * p2)
{
__u32 off1, off2;
off1 = d32_get((__u32 *)p1, 0);
off2 = *(__u32 *)p2;
if (off1 < off2)
return -1;
if (off1 > off2)
return 1;
return 0;
}
struct key * uget_lkey (struct path * path)
{
int pos, offset = path->path_length;
struct buffer_head * bh;
if (offset < FIRST_PATH_ELEMENT_OFFSET)
die ("uget_lkey: illegal offset in the path (%d)", offset);
/* While not higher in path than first element. */
while (offset-- > FIRST_PATH_ELEMENT_OFFSET) {
if (! buffer_uptodate (PATH_OFFSET_PBUFFER (path, offset)) )
die ("uget_lkey: parent is not uptodate");
/* Parent at the path is not in the tree now. */
if (! B_IS_IN_TREE (bh = PATH_OFFSET_PBUFFER (path, offset)))
die ("uget_lkey: buffer on the path is not in tree");
/* Check whether position in the parent is correct. */
if ((pos = PATH_OFFSET_POSITION (path, offset)) > B_NR_ITEMS (bh))
die ("uget_lkey: invalid position (%d) in the path", pos);
/* Check whether parent at the path really points to the child. */
if (get_dc_child_blocknr (B_N_CHILD (bh, pos)) != PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr)
die ("uget_lkey: invalid block number (%d). Must be %ld",
get_dc_child_blocknr (B_N_CHILD (bh, pos)), PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr);
/* Return delimiting key if position in the parent is not equal to zero. */
if (pos)
return B_N_PDELIM_KEY(bh, pos - 1);
}
/* there is no left delimiting key */
return 0;
}
struct key * uget_rkey (struct path * path)
{
int pos, offset = path->path_length;
struct buffer_head * bh;
if (offset < FIRST_PATH_ELEMENT_OFFSET)
die ("uget_rkey: illegal offset in the path (%d)", offset);
while (offset-- > FIRST_PATH_ELEMENT_OFFSET) {
if (! buffer_uptodate (PATH_OFFSET_PBUFFER (path, offset)))
die ("uget_rkey: parent is not uptodate");
/* Parent at the path is not in the tree now. */
if (! B_IS_IN_TREE (bh = PATH_OFFSET_PBUFFER (path, offset)))
die ("uget_rkey: buffer on the path is not in tree");
/* Check whether position in the parrent is correct. */
if ((pos = PATH_OFFSET_POSITION (path, offset)) > B_NR_ITEMS (bh))
die ("uget_rkey: invalid position (%d) in the path", pos);
/* Check whether parent at the path really points to the child. */
if (get_dc_child_blocknr (B_N_CHILD (bh, pos)) != PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr)
die ("uget_rkey: invalid block number (%d). Must be %ld",
get_dc_child_blocknr (B_N_CHILD (bh, pos)), PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr);
/* Return delimiting key if position in the parent is not the last one. */
if (pos != B_NR_ITEMS (bh))
return B_N_PDELIM_KEY (bh, pos);
}
/* there is no right delimiting key */
return 0;
}
struct key * reiserfs_next_key (struct path * path) {
if (get_item_pos (path) < B_NR_ITEMS (get_bh (path)) - 1)
return B_N_PKEY (get_bh (path), get_item_pos (path) + 1);
return uget_rkey (path);
}
/* NOTE: this only should be used to look for keys who exists */
int reiserfs_search_by_entry_key (reiserfs_filsys_t * fs, struct key * key,
struct path * path)
{
struct buffer_head * bh;
int item_pos;
struct item_head * ih;
struct key tmpkey;
__u32 offset;
if (reiserfs_search_by_key_4 (fs, key, path) == ITEM_FOUND) {
path->pos_in_item = 0;
return POSITION_FOUND;
}
bh = get_bh (path);
item_pos = get_item_pos (path);
ih = get_ih (path);
if (item_pos == 0) {
/* key is less than the smallest key in the tree */
if (not_of_one_file (&(ih->ih_key), key))
/* there are no items of that directory */
return DIRECTORY_NOT_FOUND;
if (!is_direntry_ih (ih)) {
reiserfs_panic ("reiserfs_search_by_entry_key: found item "
"is not of directory type %H", ih);
}
/* key we looked for should be here */
path->pos_in_item = 0;
return POSITION_NOT_FOUND;
}
/* take previous item */
item_pos --;
ih --;
PATH_LAST_POSITION (path) --;
if (not_of_one_file (&(ih->ih_key), key) || !is_direntry_ih (ih)) {
/* previous item belongs to another object or is stat data, check next
item */
item_pos ++;
PATH_LAST_POSITION (path) ++;
if (item_pos < B_NR_ITEMS (bh)) {
/* next item is in the same node */
ih ++;
if (not_of_one_file (&(ih->ih_key), key)) {
/* there are no items of that directory */
path->pos_in_item = 0;
return DIRECTORY_NOT_FOUND;
}
if (!is_direntry_ih (ih))
reiserfs_panic ("_search_by_entry_key: %k is not a directory",
key);
} else {
/* next item is in right neighboring node */
struct key * next_key = uget_rkey (path);
if (next_key == 0 || not_of_one_file (next_key, key)) {
/* there are no items of that directory */
path->pos_in_item = 0;
return DIRECTORY_NOT_FOUND;
}
if (!is_direntry_key (next_key))
reiserfs_panic ("_search_by_entry_key: %k is not a directory",
key);
/* we got right delimiting key - search for it - the entry will be
pasted in position 0 */
copy_key (&tmpkey, next_key);
pathrelse (path);
if (reiserfs_search_by_key_4 (fs, &tmpkey, path) != ITEM_FOUND || PATH_LAST_POSITION (path) != 0)
reiserfs_panic ("_search_by_entry_key: item corresponding to delimiting key %k not found",
&tmpkey);
}
/* next item is the part of this directory */
path->pos_in_item = 0;
return POSITION_NOT_FOUND;
}
/* previous item is part of desired directory */
offset = get_key_offset_v1 (key);
if (reiserfs_bin_search (&offset, B_I_DEH (bh, ih), get_ih_entry_count (ih),
DEH_SIZE, &(path->pos_in_item), comp_dir_entries) == POSITION_FOUND)
return POSITION_FOUND;
return POSITION_NOT_FOUND;
}
void init_tb_struct (struct tree_balance * tb, reiserfs_filsys_t * fs,
struct path * path, int size)
{
memset (tb, '\0', sizeof(struct tree_balance));
tb->tb_fs = fs;
tb->tb_path = path;
PATH_OFFSET_PBUFFER(path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
PATH_OFFSET_POSITION(path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
tb->insert_size[0] = size;
}
int reiserfs_remove_entry (reiserfs_filsys_t * fs, struct key * key)
{
struct path path;
struct tree_balance tb;
struct item_head * ih;
struct reiserfs_de_head * deh;
if (reiserfs_search_by_entry_key (fs, key, &path) != POSITION_FOUND) {
pathrelse (&path);
return 1;
}
ih = get_ih (&path);
if (get_ih_entry_count (ih) == 1) {
init_tb_struct (&tb, fs, &path, -(IH_SIZE + get_ih_item_len (ih)));
if (fix_nodes (M_DELETE, &tb, 0) != CARRY_ON) {
unfix_nodes (&tb);
return 1;
}
do_balance (&tb, 0, 0, M_DELETE, 0);
return 0;
}
deh = B_I_DEH (get_bh (&path), ih) + path.pos_in_item;
init_tb_struct (&tb, fs, &path, -(DEH_SIZE + entry_length (ih, deh, path.pos_in_item)));
if (fix_nodes (M_CUT, &tb, 0) != CARRY_ON) {
unfix_nodes (&tb);
return 1;
}
do_balance (&tb, 0, 0, M_CUT, 0);
return 0;
}
void reiserfs_paste_into_item (reiserfs_filsys_t * fs, struct path * path,
const void * body, int size)
{
struct tree_balance tb;
init_tb_struct (&tb, fs, path, size);
if (fix_nodes (M_PASTE, &tb, 0/*ih*/) != CARRY_ON)
reiserfs_panic ("reiserfs_paste_into_item: fix_nodes failed");
do_balance (&tb, 0, body, M_PASTE, 0/*zero num*/);
}
void reiserfs_insert_item (reiserfs_filsys_t * fs, struct path * path,
struct item_head * ih, const void * body)
{
struct tree_balance tb;
init_tb_struct (&tb, fs, path, IH_SIZE + get_ih_item_len(ih));
if (fix_nodes (M_INSERT, &tb, ih) != CARRY_ON)
die ("reiserfs_insert_item: fix_nodes failed");
do_balance (&tb, ih, body, M_INSERT, 0/*zero num*/);
}
/*===========================================================================*/
__u32 hash_value (hashf_t func, char * name, int namelen)
{
__u32 res;
res = func (name, namelen);
res = GET_HASH_VALUE(res);
if (res == 0)
res = 128;
return res;
}
/* if name is found in a directory - return 1 and set path to the name,
otherwise return 0 and pathrelse path */
int reiserfs_locate_entry (reiserfs_filsys_t * fs, struct key * dir, char * name,
struct path * path)
{
struct key entry_key;
struct item_head * ih;
struct reiserfs_de_head * deh;
int i, retval;
struct key * rdkey;
set_key_dirid (&entry_key, get_key_dirid (dir));
set_key_objectid (&entry_key, get_key_objectid (dir));
set_key_offset_v1 (&entry_key, 0);
set_key_uniqueness (&entry_key, DIRENTRY_UNIQUENESS);
if (reiserfs_search_by_entry_key (fs, &entry_key, path) == DIRECTORY_NOT_FOUND) {
pathrelse (path);
return 0;
}
do {
ih = get_ih (path);
deh = B_I_DEH (get_bh (path), ih) + path->pos_in_item;
for (i = path->pos_in_item; i < get_ih_entry_count (ih); i ++, deh ++) {
/* the name in directory has the same hash as the given name */
if ((name_in_entry_length (ih, deh, i) == (int)strlen (name)) &&
!memcmp (name_in_entry (deh, i), name, strlen (name))) {
path->pos_in_item = i;
return 1;
}
}
rdkey = uget_rkey (path);
if (!rdkey || not_of_one_file (rdkey, dir)) {
pathrelse (path);
return 0;
}
if (!is_direntry_key (rdkey))
reiserfs_panic ("reiserfs_locate_entry: can not find name in broken directory yet");
/* first name of that item may be a name we are looking for */
entry_key = *rdkey;
pathrelse (path);
retval = reiserfs_search_by_entry_key (fs, &entry_key, path);
if (retval != POSITION_FOUND)
reiserfs_panic ("reiserfs_locate_entry: wrong delimiting key in the tree");
} while (1);
return 0;
}
/* returns 0 if name is not found in a directory and 1 if name is
found. Stores key found in the entry in 'key'. Returns minimal not used
generation counter in 'min_gen_counter'. dies if found object is not a
directory. */
int reiserfs_find_entry (reiserfs_filsys_t * fs, struct key * dir, char * name,
unsigned int * min_gen_counter, struct key * key)
{
struct key entry_key;
int retval;
int i;
INITIALIZE_PATH (path);
struct item_head * ih;
struct reiserfs_de_head * deh;
struct key * rdkey;
__u32 hash;
set_key_dirid (&entry_key, get_key_dirid (dir));
set_key_objectid (&entry_key, get_key_objectid (dir));
if (!strcmp (name, "."))
hash = DOT_OFFSET;
else if (!strcmp (name, ".."))
hash = DOT_DOT_OFFSET;
else
hash = hash_value (reiserfs_hash (fs), name, strlen (name));
set_key_offset_v1 (&entry_key, hash);
set_key_uniqueness (&entry_key, DIRENTRY_UNIQUENESS);
*min_gen_counter = 0;
if (reiserfs_search_by_entry_key (fs, &entry_key, &path) == DIRECTORY_NOT_FOUND) {
pathrelse (&path);
return 0;
}
do {
ih = get_ih (&path);
deh = B_I_DEH (get_bh (&path), ih) + path.pos_in_item;
for (i = path.pos_in_item; i < get_ih_entry_count (ih); i ++, deh ++) {
if (GET_HASH_VALUE (get_deh_offset (deh)) != GET_HASH_VALUE (hash)) {
/* all entries having the same hash were scanned */
pathrelse (&path);
return 0;
}
if (GET_GENERATION_NUMBER (get_deh_offset (deh)) == *min_gen_counter)
(*min_gen_counter) ++;
if ((name_in_entry_length (ih, deh, i) == (int)strlen (name)) &&
(!memcmp (name_in_entry (deh, i), name, strlen (name)))) {
/* entry found in the directory */
if (key) {
memset (key, 0, sizeof (struct key));
set_key_dirid (key, get_deh_dirid (deh));
set_key_objectid (key, get_deh_objectid (deh));
}
pathrelse (&path);
return 1;//get_deh_objectid (deh) ? get_deh_objectid (deh) : 1;
}
}
rdkey = uget_rkey (&path);
if (!rdkey || not_of_one_file (rdkey, dir)) {
pathrelse (&path);
return 0;
}
if (!is_direntry_key (rdkey))
reiserfs_panic ("reiserfs_find_entry: can not find name in broken directory yet");
/* next item is the item of the directory we are looking name in */
if (GET_HASH_VALUE (get_offset (rdkey)) != hash) {
/* but there is no names with given hash */
pathrelse (&path);
return 0;
}
/* first name of that item may be a name we are looking for */
entry_key = *rdkey;
pathrelse (&path);
retval = reiserfs_search_by_entry_key (fs, &entry_key, &path);
if (retval != POSITION_FOUND)
reiserfs_panic ("reiserfs_find_entry: wrong delimiting key in the tree");
} while (1);
return 0;
}
/* compose directory entry: dir entry head and name itself */
char * make_entry (char * entry, char * name, struct key * key, __u32 offset)
{
struct reiserfs_de_head * deh;
__u16 state;
if (!entry)
entry = getmem (DEH_SIZE + ROUND_UP (strlen (name)));
memset (entry, 0, DEH_SIZE + ROUND_UP (strlen (name)));
deh = (struct reiserfs_de_head *)entry;
set_deh_location (deh, 0);
set_deh_offset (deh, offset);
state = (1 << DEH_Visible2);
set_deh_state (deh, state);
/* key of object entry will point to */
set_deh_dirid (deh, get_key_dirid (key));
set_deh_objectid (deh, get_key_objectid (key));
memcpy ((char *)(deh + 1), name, strlen (name));
return entry;
}
/* add new name into a directory. If it exists in a directory - do
nothing */
int reiserfs_add_entry (reiserfs_filsys_t * fs, struct key * dir, char * name, int name_len,
struct key * key, __u16 fsck_need)
{
struct item_head entry_ih = {{0,}, };
char * entry;
int retval;
INITIALIZE_PATH(path);
unsigned int gen_counter;
int item_len;
__u32 hash;
if (reiserfs_find_entry (fs, dir, name, &gen_counter, 0))
/* entry is in the directory already or directory was not found */
return 0;
/* compose entry key to look for its place in the tree */
set_key_dirid (&(entry_ih.ih_key), get_key_dirid (dir));
set_key_objectid (&(entry_ih.ih_key), get_key_objectid (dir));
if (!strcmp (name, "."))
hash = DOT_OFFSET;
else if (!strcmp (name, ".."))
hash = DOT_DOT_OFFSET;
else
hash = hash_value (reiserfs_hash (fs), name, strlen (name)) + gen_counter;
set_key_offset_v1 (&(entry_ih.ih_key), hash);
set_key_uniqueness (&(entry_ih.ih_key), DIRENTRY_UNIQUENESS);
set_ih_key_format (&entry_ih, KEY_FORMAT_1);
set_ih_entry_count (&entry_ih, 1);
item_len = DEH_SIZE + name_len;
/*
if (get_reiserfs_format (fs->fs_ondisk_sb) == REISERFS_FORMAT_3_5)
item_len = DEH_SIZE + strlen (name);
else if (get_reiserfs_format (fs->fs_ondisk_sb) == REISERFS_FORMAT_3_6)
item_len = DEH_SIZE + ROUND_UP (strlen (name));
else
reiserfs_panic ("unknown fs format");
*/
set_ih_item_len (&entry_ih, item_len);
/* fsck may need to insert item which was not reached yet */
set_ih_flags (&entry_ih, fsck_need);
entry = make_entry (0, name, key, get_offset (&(entry_ih.ih_key)));
retval = reiserfs_search_by_entry_key (fs, &(entry_ih.ih_key), &path);
switch (retval) {
case POSITION_NOT_FOUND:
reiserfs_paste_into_item (fs, &path, entry, item_len);
break;
case DIRECTORY_NOT_FOUND:
set_deh_location ((struct reiserfs_de_head *)entry, DEH_SIZE);
reiserfs_insert_item (fs, &path, &entry_ih, entry);
break;
default:
reiserfs_panic ("reiserfs_add_entry: looking for %k (inserting name \"%s\") "
"search_by_entry_key returned %d",
&(entry_ih.ih_key), name, retval);
}
freemem (entry);
return item_len;
}
void copy_key (void * to, void * from)
{
memcpy (to, from, KEY_SIZE);
}
void copy_short_key (void * to, void * from)
{
memcpy (to, from, SHORT_KEY_SIZE);
}
void copy_item_head(void * p_v_to, void * p_v_from)
{
memcpy (p_v_to, p_v_from, IH_SIZE);
}
/* inserts new or old stat data of a directory (unreachable, nlinks == 0) */
int create_dir_sd (reiserfs_filsys_t * fs,
struct path * path, struct key * key,
void (*modify_item)(struct item_head *, void *))
{
struct item_head ih;
struct stat_data sd;
int key_format;
if (fs->fs_format == REISERFS_FORMAT_3_5)
key_format = KEY_FORMAT_1;
else
key_format = KEY_FORMAT_2;
memset(&sd, 0, sizeof(sd));
make_dir_stat_data (fs->fs_blocksize, key_format, get_key_dirid (key),
get_key_objectid (key), &ih, &sd);
/* if calling user is not root set the owner of the root entry
* to the calling user */
if(getuid()) {
if (key_format == KEY_FORMAT_1) {
struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)&sd;
set_sd_v1_uid (sd_v1, getuid());
set_sd_v1_gid (sd_v1, getgid());
} else {
set_sd_v2_uid (&sd, getuid());
set_sd_v2_gid (&sd, getgid());
}
}
if (modify_item)
modify_item (&ih, &sd);
#if 0
/* set nlink count to 0 and make the item unreachable */
zero_nlink (&ih, &sd, 0);
mark_item_unreachable (&ih);
#endif
reiserfs_insert_item (fs, path, &ih, &sd);
return key_format;
}
void make_sure_root_dir_exists (reiserfs_filsys_t * fs,
void (*modify_item)(struct item_head *, void *),
int ih_flags)
{
INITIALIZE_PATH (path);
/* is there root's stat data */
if (reiserfs_search_by_key_4 (fs, &root_dir_key, &path) == ITEM_NOT_FOUND) {
root_dir_format = create_dir_sd (fs, &path, &root_dir_key, modify_item);
} else {
struct item_head * ih = get_ih (&path);
if (!is_stat_data_ih (ih))
reiserfs_panic ("It must be root's stat data %k\n", &ih->ih_key);
root_dir_format = (get_ih_item_len (get_ih (&path)) == SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
pathrelse (&path);
}
/* add "." and ".." if any of them do not exist. Last two
parameters say: 0 - entry is not added on lost_found pass and 1
- mark item unreachable */
reiserfs_add_entry (fs, &root_dir_key, ".", name_length (".", root_dir_format),
&root_dir_key, ih_flags);
reiserfs_add_entry (fs, &root_dir_key, "..", name_length ("..", root_dir_format),
&parent_root_dir_key, ih_flags);
}
int block_size_ok (int blocksize, int force)
{
int pagesize = getpagesize();
if (blocksize > 4096) {
reiserfs_warning (stderr, "Block sizes larger than 4k are not "
"supported on all architectures.\n");
if (blocksize > pagesize)
reiserfs_warning (stderr, "The newly created filesystem will not "
"be mountable on this system.\n");
else
reiserfs_warning (stderr, "The newly created filesystem may not "
"be mountable on other systems.\n");
check_forcing_ask_confirmation (force);
} else if (blocksize < 4096) {
reiserfs_warning (stderr, "Block sizes smaller than 4k "
"are not supported.\n");
return 0;
}
return 1;
}
/* we only can use a file for filesystem or journal if it is either not
mounted block device or regular file and we are forced to use it */
int can_we_format_it (char * device_name, int force)
{
mode_t mode;
dev_t rdev;
if (misc_device_mounted(device_name) > 0) {
/* device looks mounted */
reiserfs_warning (stderr, "'%s' looks mounted.", device_name);
check_forcing_ask_confirmation (force);
}
mode = misc_device_mode(device_name);
rdev = misc_device_rdev(device_name);
if (!S_ISBLK (mode)) {
/* file is not a block device */
reiserfs_warning (stderr, "%s is not a block special device\n", device_name);
check_forcing_ask_confirmation (force);
} else {
if ((IDE_DISK_MAJOR (major(rdev)) && minor(rdev) % 64 == 0) ||
(SCSI_BLK_MAJOR (major(rdev)) && minor(rdev) % 16 == 0)) {
/* /dev/hda or similar */
reiserfs_warning (stderr, "%s is entire device, not just one partition!\n",
device_name);
check_forcing_ask_confirmation (force);
}
}
return 1;
}
int create_badblock_bitmap (reiserfs_filsys_t * fs, char * badblocks_file) {
FILE * fd;
char buf[128];
__u32 blocknr;
int count;
fs->fs_badblocks_bm = reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
reiserfs_bitmap_zero (fs->fs_badblocks_bm);
if (!badblocks_file)
return 0;
fd = fopen (badblocks_file, "r");
if (fd == NULL) {
fprintf (stderr, "%s: Failed to open the given badblock file '%s'.\n\n",
__FUNCTION__, badblocks_file);
return 1;
}
while (!feof (fd)) {
if (fgets(buf, sizeof(buf), fd) == NULL)
break;
count = sscanf(buf, "%u", &blocknr);
if (count <= 0)
continue;
if (blocknr >= get_sb_block_count (fs->fs_ondisk_sb)) {
fprintf (stderr, "%s: block number (%u) points out of fs size "
"(%u).\n", __FUNCTION__, blocknr,
get_sb_block_count(fs->fs_ondisk_sb));
} else if (not_data_block (fs, blocknr)) {
fprintf (stderr, "%s: block number (%u) belongs to system "
"reiserfs area. It cannot be relocated.\n",
__FUNCTION__, blocknr);
return 1;
} else {
reiserfs_bitmap_set_bit (fs->fs_badblocks_bm, blocknr);
}
}
fclose (fd);
return 0;
}
void badblock_list(reiserfs_filsys_t * fs, badblock_func_t action, void *data) {
struct path badblock_path;
struct key rd_key = badblock_key;
struct key *key;
badblock_path.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
set_type_and_offset (KEY_FORMAT_2, &badblock_key, 1, TYPE_INDIRECT);
while (1) {
if (reiserfs_search_by_key_4 (fs, &rd_key, &badblock_path) == IO_ERROR) {
fprintf (stderr, "%s: Some problems while searching by the key "
"occured. Probably due to tree corruptions.\n",
__FUNCTION__);
pathrelse (&badblock_path);
break;
}
if (get_blkh_nr_items (B_BLK_HEAD (get_bh (&badblock_path))) <=
PATH_LAST_POSITION (&badblock_path))
{
pathrelse (&badblock_path);
break;
}
rd_key = get_ih(&badblock_path)->ih_key;
if (get_key_dirid(&rd_key) != BADBLOCK_DIRID ||
get_key_objectid(&rd_key) != BADBLOCK_OBJID ||
!KEY_IS_INDIRECT_KEY(&rd_key))
{
pathrelse (&badblock_path);
break;
}
if ((key = reiserfs_next_key(&badblock_path)))
rd_key = *key;
else
memset(&rd_key, 0, sizeof(rd_key));
action(fs, &badblock_path, data);
if (get_key_dirid(&rd_key) == 0)
break;
}
}
static void callback_badblock_rm(reiserfs_filsys_t *fs,
struct path *badblock_path,
void *data)
{
struct tree_balance tb;
struct item_head * tmp_ih;
tmp_ih = get_ih(badblock_path);
memset (get_item (badblock_path), 0, get_ih_item_len (tmp_ih));
init_tb_struct (&tb, fs, badblock_path,
-(IH_SIZE + get_ih_item_len(PATH_PITEM_HEAD(badblock_path))));
if (fix_nodes (M_DELETE, &tb, 0) != CARRY_ON)
die ("%s: fix_nodes failed", __FUNCTION__);
do_balance (/*tb.transaction_handle,*/ &tb, 0, 0, M_DELETE, 0/*zero num*/);
}
void mark_badblock(reiserfs_filsys_t *fs,
struct path *badblock_path,
void *data)
{
struct item_head *tmp_ih;
__u32 *ind_item;
__u32 i;
if (!fs->fs_badblocks_bm)
create_badblock_bitmap(fs, NULL);
tmp_ih = get_ih(badblock_path);
ind_item = (__u32 *)get_item(badblock_path);
for (i = 0; i < I_UNFM_NUM(tmp_ih); i++) {
reiserfs_bitmap_set_bit(fs->fs_badblocks_bm,
d32_get(ind_item, i));
}
pathrelse (badblock_path);
}
void add_badblock_list (reiserfs_filsys_t * fs, int replace) {
struct tree_balance tb;
struct path badblock_path;
struct item_head badblock_ih;
__u32 ni;
__u64 offset;
__u32 i, j;
if (fs->fs_badblocks_bm == NULL)
return;
/* delete all items with badblock_key */
if (replace)
badblock_list(fs, callback_badblock_rm, NULL);
memset(&badblock_ih, 0, sizeof(badblock_ih));
set_ih_key_format (&badblock_ih, KEY_FORMAT_2);
set_ih_item_len (&badblock_ih, UNFM_P_SIZE);
set_ih_free_space (&badblock_ih, 0);
set_ih_location (&badblock_ih, 0);
set_key_dirid (&badblock_ih.ih_key, BADBLOCK_DIRID);
set_key_objectid (&badblock_ih.ih_key, BADBLOCK_OBJID);
set_type (KEY_FORMAT_2, &badblock_ih.ih_key, TYPE_INDIRECT);
j = 0;
/* insert all badblock pointers */
for (i = 0; i < fs->fs_badblocks_bm->bm_bit_size; i++) {
int retval;
if (!reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i))
continue;
offset = j * fs->fs_blocksize + 1;
set_offset (KEY_FORMAT_2, &badblock_ih.ih_key, offset);
ni = cpu_to_le32 (i);
retval = usearch_by_position (fs, &badblock_ih.ih_key,
key_format(&badblock_ih.ih_key),
&badblock_path);
switch (retval) {
case (FILE_NOT_FOUND):
init_tb_struct (&tb, fs, &badblock_path,
IH_SIZE + get_ih_item_len(&badblock_ih));
if (fix_nodes (M_INSERT, &tb, &badblock_ih) != CARRY_ON)
die ("reiserfsck_insert_item: fix_nodes failed");
do_balance (&tb, &badblock_ih, (void *)&ni , M_INSERT, 0);
break;
case (POSITION_NOT_FOUND):
case (POSITION_FOUND):
/* Insert the new item to the found position. */
init_tb_struct (&tb, fs, &badblock_path, UNFM_P_SIZE);
if (fix_nodes (M_PASTE, &tb, 0) != CARRY_ON)
die ("reiserfsck_paste_into_item: fix_nodes failed");
do_balance (&tb, 0, (const char *)&ni, M_PASTE, 0);
break;
}
j++;
}
}