static void sprintf_item_head(char *buf, struct item_head *ih)
{
if (ih) {
strcpy(buf,
(ih_version(ih) == KEY_FORMAT_3_6) ? "*3.6* " : "*3.5*");
sprintf_le_key(buf + strlen(buf), &(ih->ih_key));
sprintf(buf + strlen(buf), ", item_len %d, item_location %d, "
"free_space(entry_count) %d",
ih_item_len(ih), ih_location(ih), ih_free_space(ih));
} else
sprintf(buf, "[NULL]");
}
/* %H */
static int print_item_head (FILE * stream,
const struct printf_info *info,
const void *const *args)
{
const struct item_head * ih;
char * buffer;
int len;
ih = *((const struct item_head **)(args[0]));
len = asprintf (&buffer, "%u %u 0x%Lx %s, "
"len %u, entry count %u, fsck need %u, format %s",
le32_to_cpu(ih->ih_key.k_dir_id),
le32_to_cpu(ih->ih_key.k_objectid),
get_offset (&ih->ih_key), key_of_what (&ih->ih_key),
ih_item_len(ih), ih_entry_count (ih),
ih_fsck_need(ih),
ih_key_format (ih) == KEY_FORMAT_2 ? "new" :
((ih_key_format (ih) == KEY_FORMAT_1) ? "old" : "BAD"));
FPRINTF;
}
static int is_leaf(char *buf, int blocksize, struct buffer_head *bh)
{
struct block_head *blkh;
struct item_head *ih;
int used_space;
int prev_location;
int i;
int nr;
blkh = (struct block_head *)buf;
if (blkh_level(blkh) != DISK_LEAF_NODE_LEVEL) {
reiserfs_warning(NULL, "reiserfs-5080",
"this should be caught earlier");
return 0;
}
nr = blkh_nr_item(blkh);
if (nr < 1 || nr > ((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN))) {
/* item number is too big or too small */
reiserfs_warning(NULL, "reiserfs-5081",
"nr_item seems wrong: %z", bh);
return 0;
}
ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
used_space = BLKH_SIZE + IH_SIZE * nr + (blocksize - ih_location(ih));
if (used_space != blocksize - blkh_free_space(blkh)) {
/* free space does not match to calculated amount of use space */
reiserfs_warning(NULL, "reiserfs-5082",
"free space seems wrong: %z", bh);
return 0;
}
// return 1 here
/* check tables of item heads */
ih = (struct item_head *)(buf + BLKH_SIZE);
prev_location = blocksize;
for (i = 0; i < nr; i++, ih++) {
if (le_ih_k_type(ih) == TYPE_ANY) {
reiserfs_warning(NULL, "reiserfs-5083",
"wrong item type for item %h",
ih);
return 0;
}
if (ih_location(ih) >= blocksize
|| ih_location(ih) < IH_SIZE * nr) {
reiserfs_warning(NULL, "reiserfs-5084",
"item location seems wrong: %h",
ih);
return 0;
}
if (ih_item_len(ih) < 1
|| ih_item_len(ih) > MAX_ITEM_LEN(blocksize)) {
reiserfs_warning(NULL, "reiserfs-5085",
"item length seems wrong: %h",
ih);
return 0;
}
if (prev_location - ih_location(ih) != ih_item_len(ih)) {
reiserfs_warning(NULL, "reiserfs-5086",
"item location seems wrong "
"(second one): %h", ih);
return 0;
}
prev_location = ih_location(ih);
}
// one may imagine much more checks
return 1;
}
/* this first locks inode (neither reads nor sync are permitted),
reads tail through page cache, insert direct item. When direct item
inserted successfully inode is left locked. Return value is always
what we expect from it (number of cut bytes). But when tail remains
in the unformatted node, we set mode to SKIP_BALANCING and unlock
inode */
int indirect2direct (struct reiserfs_transaction_handle *th,
struct inode * p_s_inode,
struct page *page,
struct path * p_s_path, /* path to the indirect item. */
const struct cpu_key * p_s_item_key, /* Key to look for unformatted node pointer to be cut. */
loff_t n_new_file_size, /* New file size. */
char * p_c_mode)
{
struct super_block * p_s_sb = p_s_inode->i_sb;
struct item_head s_ih;
unsigned long n_block_size = p_s_sb->s_blocksize;
char * tail;
int tail_len, round_tail_len;
loff_t pos, pos1; /* position of first byte of the tail */
struct cpu_key key;
p_s_sb->u.reiserfs_sb.s_indirect2direct ++;
*p_c_mode = M_SKIP_BALANCING;
/* store item head path points to. */
copy_item_head (&s_ih, PATH_PITEM_HEAD(p_s_path));
tail_len = (n_new_file_size & (n_block_size - 1));
if (get_inode_sd_version (p_s_inode) == STAT_DATA_V2)
round_tail_len = ROUND_UP (tail_len);
else
round_tail_len = tail_len;
pos = le_ih_k_offset (&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
pos1 = pos;
// we are protected by i_sem. The tail can not disapper, not
// append can be done either
// we are in truncate or packing tail in file_release
tail = (char *)kmap(page) ; /* this can schedule */
if (path_changed (&s_ih, p_s_path)) {
/* re-search indirect item */
if ( search_for_position_by_key (p_s_sb, p_s_item_key, p_s_path) == POSITION_NOT_FOUND )
reiserfs_panic(p_s_sb, "PAP-5520: indirect2direct: "
"item to be converted %K does not exist", p_s_item_key);
copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
#ifdef CONFIG_REISERFS_CHECK
pos = le_ih_k_offset (&s_ih) - 1 +
(ih_item_len(&s_ih) / UNFM_P_SIZE - 1) * p_s_sb->s_blocksize;
if (pos != pos1)
reiserfs_panic (p_s_sb, "vs-5530: indirect2direct: "
"tail position changed while we were reading it");
#endif
}
/* Set direct item header to insert. */
make_le_item_head (&s_ih, 0, get_inode_item_key_version (p_s_inode), pos1 + 1,
TYPE_DIRECT, round_tail_len, 0xffff/*ih_free_space*/);
/* we want a pointer to the first byte of the tail in the page.
** the page was locked and this part of the page was up to date when
** indirect2direct was called, so we know the bytes are still valid
*/
tail = tail + (pos & (PAGE_CACHE_SIZE - 1)) ;
PATH_LAST_POSITION(p_s_path)++;
key = *p_s_item_key;
set_cpu_key_k_type (&key, TYPE_DIRECT);
key.key_length = 4;
/* Insert tail as new direct item in the tree */
if ( reiserfs_insert_item(th, p_s_path, &key, &s_ih,
tail ? tail : NULL) < 0 ) {
/* No disk memory. So we can not convert last unformatted node
to the direct item. In this case we used to adjust
indirect items's ih_free_space. Now ih_free_space is not
used, it would be ideal to write zeros to corresponding
unformatted node. For now i_size is considered as guard for
going out of file size */
kunmap(page) ;
return n_block_size - round_tail_len;
}
kunmap(page) ;
/* this will invalidate all the buffers in the page after
** pos1
*/
unmap_buffers(page, pos1) ;
// note: we have now the same as in above direct2indirect
// conversion: there are two keys which have matching first three
// key components. They only differ by the fouhth one.
/* We have inserted new direct item and must remove last
unformatted node. */
p_s_inode->i_blocks += (p_s_sb->s_blocksize / 512);
*p_c_mode = M_CUT;
/* we store position of first direct item in the in-core inode */
//mark_file_with_tail (p_s_inode, pos1 + 1);
p_s_inode->u.reiserfs_i.i_first_direct_byte = pos1 + 1;
return n_block_size - round_tail_len;
}
/* path points to first direct item of the file regarless of how many of
them are there */
int direct2indirect (struct reiserfs_transaction_handle *th, struct inode * inode,
struct path * path, struct buffer_head * unbh,
loff_t tail_offset)
{
struct super_block * sb = inode->i_sb;
struct buffer_head *up_to_date_bh ;
struct item_head * p_le_ih = PATH_PITEM_HEAD (path);
unsigned long total_tail = 0 ;
struct cpu_key end_key; /* Key to search for the last byte of the
converted item. */
struct item_head ind_ih; /* new indirect item to be inserted or
key of unfm pointer to be pasted */
int n_blk_size,
n_retval; /* returned value for reiserfs_insert_item and clones */
struct unfm_nodeinfo unfm_ptr; /* Handle on an unformatted node
that will be inserted in the
tree. */
sb->u.reiserfs_sb.s_direct2indirect ++;
n_blk_size = sb->s_blocksize;
/* and key to search for append or insert pointer to the new
unformatted node. */
copy_item_head (&ind_ih, p_le_ih);
set_le_ih_k_offset (&ind_ih, tail_offset);
set_le_ih_k_type (&ind_ih, TYPE_INDIRECT);
/* Set the key to search for the place for new unfm pointer */
make_cpu_key (&end_key, inode, tail_offset, TYPE_INDIRECT, 4);
// FIXME: we could avoid this
if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND ) {
reiserfs_warning ("PAP-14030: direct2indirect: "
"pasted or inserted byte exists in the tree %K. "
"Use fsck to repair.\n", &end_key);
pathrelse(path);
return -EIO;
}
p_le_ih = PATH_PITEM_HEAD (path);
unfm_ptr.unfm_nodenum = cpu_to_le32 (unbh->b_blocknr);
unfm_ptr.unfm_freespace = 0; // ???
if ( is_statdata_le_ih (p_le_ih) ) {
/* Insert new indirect item. */
set_ih_free_space (&ind_ih, 0); /* delete at nearest future */
put_ih_item_len( &ind_ih, UNFM_P_SIZE );
PATH_LAST_POSITION (path)++;
n_retval = reiserfs_insert_item (th, path, &end_key, &ind_ih,
(char *)&unfm_ptr);
} else {
/* Paste into last indirect item of an object. */
n_retval = reiserfs_paste_into_item(th, path, &end_key,
(char *)&unfm_ptr, UNFM_P_SIZE);
}
if ( n_retval ) {
return n_retval;
}
// note: from here there are two keys which have matching first
// three key components. They only differ by the fourth one.
/* Set the key to search for the direct items of the file */
make_cpu_key (&end_key, inode, max_reiserfs_offset (inode), TYPE_DIRECT, 4);
/* Move bytes from the direct items to the new unformatted node
and delete them. */
while (1) {
int tail_size;
/* end_key.k_offset is set so, that we will always have found
last item of the file */
if ( search_for_position_by_key (sb, &end_key, path) == POSITION_FOUND )
reiserfs_panic (sb, "PAP-14050: direct2indirect: "
"direct item (%K) not found", &end_key);
p_le_ih = PATH_PITEM_HEAD (path);
RFALSE( !is_direct_le_ih (p_le_ih),
"vs-14055: direct item expected(%K), found %h",
&end_key, p_le_ih);
tail_size = (le_ih_k_offset (p_le_ih) & (n_blk_size - 1))
+ ih_item_len(p_le_ih) - 1;
/* we only send the unbh pointer if the buffer is not up to date.
** this avoids overwriting good data from writepage() with old data
** from the disk or buffer cache
** Special case: unbh->b_page will be NULL if we are coming through
** DIRECT_IO handler here.
*/
if ( !unbh->b_page || buffer_uptodate(unbh) || Page_Uptodate(unbh->b_page)) {
up_to_date_bh = NULL ;
} else {
up_to_date_bh = unbh ;
}
n_retval = reiserfs_delete_item (th, path, &end_key, inode,
up_to_date_bh) ;
total_tail += n_retval ;
if (tail_size == n_retval)
// done: file does not have direct items anymore
break;
}
/* if we've copied bytes from disk into the page, we need to zero
** out the unused part of the block (it was not up to date before)
** the page is still kmapped (by whoever called reiserfs_get_block)
*/
if (up_to_date_bh) {
unsigned pgoff = (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
memset(page_address(unbh->b_page) + pgoff, 0, n_blk_size - total_tail) ;
}
inode->u.reiserfs_i.i_first_direct_byte = U32_MAX;
reiserfs_update_tail_transaction(inode);
return 0;
}
static int indirect_bytes_number(struct item_head *ih, int block_size)
{
return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih);
}
//////////////////////////////////////////////////////////////////////////////
// direct item functions
//
static int direct_bytes_number(struct item_head *ih, int block_size)
{
return ih_item_len(ih);
}
/* FIXME: we can improve fixing of broken keys: we can ssfe direct items which
go after stat data and have broken keys */
static void pass0_correct_leaf (reiserfs_filsys_t fs,
struct buffer_head * bh)
{
int i, j;
struct item_head * ih;
__u32 * ind_item;
unsigned long unfm_ptr;
int dirty = 0;
start_again:
ih = B_N_PITEM_HEAD (bh, 0);
for (i = 0; i < node_item_number (bh); i ++, ih ++) {
if (ih->ih_key.k_dir_id == 0 || ih->ih_key.k_objectid == 0) {
/* sometimes stat datas get k_objectid==0 or k_dir_id==0 */
if (i == (node_item_number (bh) - 1)) {
/* */
if (i == 0) {
fsck_log ("block %lu: item %d: (%H) is alone in the block\n",
bh->b_blocknr, i, ih);
return;
}
/* delete last item */
delete_item (fs, bh, i - 1);
return;
}
/* there is next item: if it is not stat data - take its k_dir_id
and k_objectid. if key order will be still wrong - the changed
item will be deleted */
if (!is_stat_data_ih (ih + 1)) {
fsck_log ("block %lu: item %d: (%H) fixed to ", bh->b_blocknr, i, ih);
ih->ih_key.k_dir_id = (ih + 1)->ih_key.k_dir_id;
ih->ih_key.k_objectid = (ih + 1)->ih_key.k_objectid;
set_offset (KEY_FORMAT_1, &ih->ih_key, 0);
set_type (KEY_FORMAT_1, &ih->ih_key, TYPE_STAT_DATA);
fsck_log ("(%H)\n", ih);
dirty = 1;
} else if (i == 0) {
delete_item (fs, bh, i);
goto start_again;
}
}
/* this recovers corruptions like the below:
1774 1732 0 0
116262638 1732 1 3
1774 1736 0 0 */
if (i && is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih)) {
if (ih->ih_key.k_objectid != (ih - 1)->ih_key.k_objectid ||
ih->ih_key.k_dir_id != (ih - 1)->ih_key.k_dir_id ||
get_offset (&ih->ih_key) != 1) {
if (is_direntry_ih (ih)) {
fsck_log ("block %lu: item %d: no \".\" entry found in "
"the first item of a directory\n", bh->b_blocknr, i);
} else {
fsck_log ("block %lu: item %d: (%H) fixed to ",
bh->b_blocknr, i, ih);
ih->ih_key.k_dir_id = (ih - 1)->ih_key.k_dir_id;
ih->ih_key.k_objectid = (ih - 1)->ih_key.k_objectid;
if (ih_item_len (ih - 1) == SD_SIZE) {
/* stat data is new, therefore this item is new too */
set_offset (KEY_FORMAT_2, &(ih->ih_key), 1);
if (ih_entry_count (ih) != 0xffff)
set_type (KEY_FORMAT_2, &(ih->ih_key), TYPE_INDIRECT);
else
set_type (KEY_FORMAT_2, &(ih->ih_key), TYPE_DIRECT);
set_ih_key_format (ih, KEY_FORMAT_2);
} else {
/* stat data is old, therefore this item is old too */
set_offset (KEY_FORMAT_1, &(ih->ih_key), 1);
if (ih_entry_count (ih) != 0xffff)
set_type (KEY_FORMAT_1, &(ih->ih_key), TYPE_INDIRECT);
else
set_type (KEY_FORMAT_1, &(ih->ih_key), TYPE_DIRECT);
set_ih_key_format (ih, KEY_FORMAT_1);
}
fsck_log ("%H\n", ih);
dirty = 1;
}
}
}
/* FIXME: corruptions like:
56702 66802 1 2
56702 65536 0 0
56702 66803 1 2
do not get recovered (both last items will be deleted) */
/* delete item if it is not in correct order of object items */
if (i && not_of_one_file (&ih->ih_key, &(ih - 1)->ih_key) &&
!is_stat_data_ih (ih)) {
fsck_log ("block %lu: item %d: %H follows non stat item %H - deleted\n",
bh->b_blocknr, i, ih, ih - 1);
delete_item (fs, bh, i);
goto start_again;
}
if (i && comp_keys (&(ih - 1)->ih_key, &ih->ih_key) != -1) {
/* previous item has key not smaller than the key of currect item */
if (is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih)) {
/* fix key of stat data such as if it was stat data of that item */
fsck_log ("pass0: block %lu: %d-th item %k is out of order, made a stat data of %d-th (%k)\n",
bh->b_blocknr, i - 1, &(ih - 1)->ih_key, i, &ih->ih_key);
(ih - 1)->ih_key.k_dir_id = ih->ih_key.k_dir_id;
(ih - 1)->ih_key.k_objectid = ih->ih_key.k_objectid;
set_offset (KEY_FORMAT_1, &(ih - 1)->ih_key, 0);
set_type (KEY_FORMAT_1, &(ih - 1)->ih_key, TYPE_STAT_DATA);
dirty = 1;
} else {
/* ok, we have to delete one of these two - decide which one */
int retval;
/* something will be deleted */
dirty = 1;
retval = upper_correct (bh, ih - 1, i - 1);
switch (retval) {
case 0:
/* delete upper item */
fsck_log ("pass0: block %lu: %d-th (upper) item (%k) is out of order, deleted\n",
bh->b_blocknr, i - 1, &(ih - 1)->ih_key);
delete_item (fs, bh, i - 1);
goto start_again;
case 1:
/* delete lower item */
fsck_log ("pass0: block %lu: %d-th (lower) item (%k) is out of order, deleted\n",
bh->b_blocknr, i, &ih->ih_key);
delete_item (fs, bh, i);
goto start_again;
default:
/* upper item was the first item of a node */
}
retval = lower_correct (bh, ih, i);
switch (retval) {
case 0:
/* delete lower item */
fsck_log ("pass0: block %lu: %d-th (lower) item (%k) is out of order, deleted\n",
bh->b_blocknr, i, &ih->ih_key);
delete_item (fs, bh, i);
goto start_again;
case 1:
/* delete upper item */
fsck_log ("pass0: block %lu: %d-th (upper) item (%k) is out of order, deleted\n",
bh->b_blocknr, i - 1, &(ih - 1)->ih_key);
delete_item (fs, bh, i - 1);
goto start_again;
default:
/* there wer only two items in a node, so we could not
decide what to delete, go and ask user */
}
fsck_log ("pass0: which of these items looks better (other will be deleted)?\n"
"%H\n%H\n", ih - 1, ih);
if (fsck_user_confirmed (fs, "1 or 2?", "1\n", 1))
delete_item (fs, bh, i - 1);
else
delete_item (fs, bh, i);
goto start_again;
}
}
if (is_stat_data_ih (ih) && (ih_item_len (ih) != SD_SIZE &&
ih_item_len (ih) != SD_V1_SIZE)) {
fsck_log ("pass0: block %lu, stat data of wrong length %H - deleted\n",
bh, ih);
delete_item (fs, bh, i);
goto start_again;
}
dirty += correct_key_format (ih);
if (is_stat_data_ih (ih)) {
;/*correct_stat_data (fs, bh, i);*/
}
if (is_direntry_ih (ih)) {
verify_directory_item (fs, bh, i);
continue;
}
if (!is_indirect_ih (ih))
continue;
ind_item = (__u32 *)B_I_PITEM (bh, ih);
for (j = 0; j < I_UNFM_NUM (ih); j ++) {
unfm_ptr = le32_to_cpu (ind_item [j]);
if (!unfm_ptr)
continue;
if (fsck_mode (fs) == FSCK_ZERO_FILES) {
/* FIXME: this is temporary mode of fsck */
ind_item [j] = 0;
reiserfs_bitmap_clear_bit (fsck_new_bitmap(fs), unfm_ptr);
tmp_zeroed ++;
dirty = 1;
continue;
}
if (not_data_block (fs, unfm_ptr) || /* journal area or bitmap or super block */
unfm_ptr >= SB_BLOCK_COUNT (fs)) {/* garbage in pointer */
stats (fs)->wrong_pointers ++;
/*
fsck_log ("pass0: %d-th pointer (%lu) in item %k (leaf block %lu) is wrong\n",
j, unfm_ptr, &ih->ih_key, bh->b_blocknr);
*/
ind_item [j] = 0;
dirty = 1;
continue;
}
#if 0
if (!was_block_used (unfm_ptr)) {
/* this will get to a pool of allocable blocks */
ind_item [j] = 0;
dirty = 1;
stat_wrong_pointer_found (fs);
continue;
}
#endif
/* mark block in bitmaps of unformatted nodes */
register_unfm (unfm_ptr);
}
}
/* mark all objectids in use */
ih = B_N_PITEM_HEAD (bh, 0);
for (i = 0; i < node_item_number (bh); i ++, ih ++) {
mark_objectid_really_used (proper_id_map (fs), le32_to_cpu (ih->ih_key.k_dir_id));
mark_objectid_really_used (proper_id_map (fs), le32_to_cpu (ih->ih_key.k_objectid));
}
if (node_item_number (bh) < 1) {
/* pass 1 will skip this */
stats(fs)->all_contents_removed ++;
fsck_log ("pass0: block %lu got all items deleted\n",
bh->b_blocknr);
} else {
/* pass1 will use this bitmap */
pass0_mark_leaf (bh->b_blocknr);
}
if (dirty) {
stats(fs)->leaves_corrected ++;
mark_buffer_dirty (bh);
}
}
static int is_bad_sd (struct item_head * ih, char * item)
{
struct stat_data * sd = (struct stat_data *)item;
if (le32_to_cpu(ih->ih_key.u.k_offset_v1.k_offset) || le32_to_cpu(ih->ih_key.u.k_offset_v1.k_uniqueness)) {
reiserfs_warning (stderr, "Bad SD? %H\n", ih);
return 1;
}
if (ih_item_len (ih) == SD_V1_SIZE) {
/* looks like old stat data */
if (ih_key_format (ih) != KEY_FORMAT_1)
fsck_log ("item %H has wrong format\n", ih);
return 0;
}
if (!S_ISDIR (sd_v2_mode(sd)) && !S_ISREG(sd_v2_mode(sd)) &&
!S_ISCHR (sd_v2_mode(sd)) && !S_ISBLK(sd_v2_mode(sd)) &&
!S_ISLNK (sd_v2_mode(sd)) && !S_ISFIFO(sd_v2_mode(sd)) &&
!S_ISSOCK(sd_v2_mode(sd))) {
/*fsck_log ("file %k unexpected mode encountered 0%o\n", &ih->ih_key, sd_v2_mode(sd))*/;
}
return 0;
}
int is_bad_directory (struct item_head * ih, char * item, int dev, int blocksize)
{
int i;
char * name;
int namelen, entrylen;
struct reiserfs_de_head * deh = (struct reiserfs_de_head *)item;
__u32 prev_offset = 0;
__u16 prev_location = ih_item_len (ih);
int min_entry_size = 1;/* we have no way to understand whether the
filesystem were created in 3.6 format or
converted to it. So, we assume that minimal name
length is 1 */
if (ih_item_len (ih) / (DEH_SIZE + min_entry_size) < ih_entry_count (ih))
/* entry count is too big */
return 1;
for (i = 0; i < ih_entry_count (ih); i ++, deh ++) {
entrylen = entry_length(ih, deh, i);
if (entrylen > REISERFS_MAX_NAME_LEN (blocksize)) {
return 1;
}
if (deh_offset (deh) <= prev_offset) {
return 1;
}
prev_offset = deh_offset (deh);
if (deh_location(deh) + entrylen != prev_location) {
return 1;
}
prev_location = deh_location (deh);
namelen = name_length (ih, deh, i);
name = name_in_entry (deh, i);
if (!is_properly_hashed (fs, name, namelen, deh_offset (deh))) {
return 1;
}
}
return 0;
}
/* change incorrect block adresses by 0. Do not consider such item as incorrect */
static int is_bad_indirect (struct item_head * ih, char * item, int dev, int blocksize)
{
int i;
int bad = 0;
int blocks;
if (ih_item_len(ih) % UNFM_P_SIZE) {
fsck_log ("is_bad_indirect: indirect item of %H of invalid length\n", ih);
return 1;
}
blocks = SB_BLOCK_COUNT (fs);
for (i = 0; i < I_UNFM_NUM (ih); i ++) {
__u32 * ind = (__u32 *)item;
if (le32_to_cpu (ind[i]) >= blocks) {
bad ++;
fsck_log ("is_bad_indirect: %d-th pointer of item %H looks bad (%lu)\n",
i, ih, le32_to_cpu (ind [i]));
continue;
}
}
return bad;
}
/*
* path points to first direct item of the file regardless of how many of
* them are there
*/
int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
struct treepath *path, struct buffer_head *unbh,
loff_t tail_offset)
{
struct super_block *sb = inode->i_sb;
struct buffer_head *up_to_date_bh;
struct item_head *p_le_ih = tp_item_head(path);
unsigned long total_tail = 0;
/* Key to search for the last byte of the converted item. */
struct cpu_key end_key;
/*
* new indirect item to be inserted or key
* of unfm pointer to be pasted
*/
struct item_head ind_ih;
int blk_size;
/* returned value for reiserfs_insert_item and clones */
int retval;
/* Handle on an unformatted node that will be inserted in the tree. */
unp_t unfm_ptr;
BUG_ON(!th->t_trans_id);
REISERFS_SB(sb)->s_direct2indirect++;
blk_size = sb->s_blocksize;
/*
* and key to search for append or insert pointer to the new
* unformatted node.
*/
copy_item_head(&ind_ih, p_le_ih);
set_le_ih_k_offset(&ind_ih, tail_offset);
set_le_ih_k_type(&ind_ih, TYPE_INDIRECT);
/* Set the key to search for the place for new unfm pointer */
make_cpu_key(&end_key, inode, tail_offset, TYPE_INDIRECT, 4);
/* FIXME: we could avoid this */
if (search_for_position_by_key(sb, &end_key, path) == POSITION_FOUND) {
reiserfs_error(sb, "PAP-14030",
"pasted or inserted byte exists in "
"the tree %K. Use fsck to repair.", &end_key);
pathrelse(path);
return -EIO;
}
p_le_ih = tp_item_head(path);
unfm_ptr = cpu_to_le32(unbh->b_blocknr);
if (is_statdata_le_ih(p_le_ih)) {
/* Insert new indirect item. */
set_ih_free_space(&ind_ih, 0); /* delete at nearest future */
put_ih_item_len(&ind_ih, UNFM_P_SIZE);
PATH_LAST_POSITION(path)++;
retval =
reiserfs_insert_item(th, path, &end_key, &ind_ih, inode,
(char *)&unfm_ptr);
} else {
/* Paste into last indirect item of an object. */
retval = reiserfs_paste_into_item(th, path, &end_key, inode,
(char *)&unfm_ptr,
UNFM_P_SIZE);
}
if (retval) {
return retval;
}
/*
* note: from here there are two keys which have matching first
* three key components. They only differ by the fourth one.
*/
/* Set the key to search for the direct items of the file */
make_cpu_key(&end_key, inode, max_reiserfs_offset(inode), TYPE_DIRECT,
4);
/*
* Move bytes from the direct items to the new unformatted node
* and delete them.
*/
while (1) {
int tail_size;
/*
* end_key.k_offset is set so, that we will always have found
* last item of the file
*/
if (search_for_position_by_key(sb, &end_key, path) ==
POSITION_FOUND)
reiserfs_panic(sb, "PAP-14050",
"direct item (%K) not found", &end_key);
p_le_ih = tp_item_head(path);
RFALSE(!is_direct_le_ih(p_le_ih),
"vs-14055: direct item expected(%K), found %h",
&end_key, p_le_ih);
tail_size = (le_ih_k_offset(p_le_ih) & (blk_size - 1))
+ ih_item_len(p_le_ih) - 1;
/*
* we only send the unbh pointer if the buffer is not
* up to date. this avoids overwriting good data from
* writepage() with old data from the disk or buffer cache
* Special case: unbh->b_page will be NULL if we are coming
* through DIRECT_IO handler here.
*/
if (!unbh->b_page || buffer_uptodate(unbh)
|| PageUptodate(unbh->b_page)) {
up_to_date_bh = NULL;
} else {
up_to_date_bh = unbh;
}
retval = reiserfs_delete_item(th, path, &end_key, inode,
up_to_date_bh);
total_tail += retval;
/* done: file does not have direct items anymore */
if (tail_size == retval)
break;
}
/*
* if we've copied bytes from disk into the page, we need to zero
* out the unused part of the block (it was not up to date before)
*/
if (up_to_date_bh) {
unsigned pgoff =
(tail_offset + total_tail - 1) & (PAGE_SIZE - 1);
char *kaddr = kmap_atomic(up_to_date_bh->b_page);
memset(kaddr + pgoff, 0, blk_size - total_tail);
kunmap_atomic(kaddr);
}
REISERFS_I(inode)->i_first_direct_byte = U32_MAX;
return 0;
}
int indirect2direct(struct reiserfs_transaction_handle *th,
struct inode *inode, struct page *page,
struct treepath *path,
const struct cpu_key *item_key,
loff_t n_new_file_size,
char *mode)
{
struct super_block *sb = inode->i_sb;
struct item_head s_ih;
unsigned long block_size = sb->s_blocksize;
char *tail;
int tail_len, round_tail_len;
loff_t pos, pos1;
struct cpu_key key;
BUG_ON(!th->t_trans_id);
REISERFS_SB(sb)->s_indirect2direct++;
*mode = M_SKIP_BALANCING;
copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
tail_len = (n_new_file_size & (block_size - 1));
if (get_inode_sd_version(inode) == STAT_DATA_V2)
round_tail_len = ROUND_UP(tail_len);
else
round_tail_len = tail_len;
pos =
le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * sb->s_blocksize;
pos1 = pos;
tail = (char *)kmap(page);
if (path_changed(&s_ih, path)) {
if (search_for_position_by_key(sb, item_key, path)
== POSITION_NOT_FOUND)
reiserfs_panic(sb, "PAP-5520",
"item to be converted %K does not exist",
item_key);
copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
#ifdef CONFIG_REISERFS_CHECK
pos = le_ih_k_offset(&s_ih) - 1 +
(ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * sb->s_blocksize;
if (pos != pos1)
reiserfs_panic(sb, "vs-5530", "tail position "
"changed while we were reading it");
#endif
}
make_le_item_head(&s_ih, NULL, get_inode_item_key_version(inode),
pos1 + 1, TYPE_DIRECT, round_tail_len,
0xffff );
tail = tail + (pos & (PAGE_CACHE_SIZE - 1));
PATH_LAST_POSITION(path)++;
key = *item_key;
set_cpu_key_k_type(&key, TYPE_DIRECT);
key.key_length = 4;
if (reiserfs_insert_item(th, path, &key, &s_ih, inode,
tail ? tail : NULL) < 0) {
kunmap(page);
return block_size - round_tail_len;
}
kunmap(page);
reiserfs_update_sd(th, inode);
*mode = M_CUT;
REISERFS_I(inode)->i_first_direct_byte = pos1 + 1;
return block_size - round_tail_len;
}
int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
struct treepath *path, struct buffer_head *unbh,
loff_t tail_offset)
{
struct super_block *sb = inode->i_sb;
struct buffer_head *up_to_date_bh;
struct item_head *p_le_ih = PATH_PITEM_HEAD(path);
unsigned long total_tail = 0;
struct cpu_key end_key;
struct item_head ind_ih;
int blk_size, retval;
unp_t unfm_ptr;
BUG_ON(!th->t_trans_id);
REISERFS_SB(sb)->s_direct2indirect++;
blk_size = sb->s_blocksize;
copy_item_head(&ind_ih, p_le_ih);
set_le_ih_k_offset(&ind_ih, tail_offset);
set_le_ih_k_type(&ind_ih, TYPE_INDIRECT);
make_cpu_key(&end_key, inode, tail_offset, TYPE_INDIRECT, 4);
if (search_for_position_by_key(sb, &end_key, path) == POSITION_FOUND) {
reiserfs_error(sb, "PAP-14030",
"pasted or inserted byte exists in "
"the tree %K. Use fsck to repair.", &end_key);
pathrelse(path);
return -EIO;
}
p_le_ih = PATH_PITEM_HEAD(path);
unfm_ptr = cpu_to_le32(unbh->b_blocknr);
if (is_statdata_le_ih(p_le_ih)) {
set_ih_free_space(&ind_ih, 0);
put_ih_item_len(&ind_ih, UNFM_P_SIZE);
PATH_LAST_POSITION(path)++;
retval =
reiserfs_insert_item(th, path, &end_key, &ind_ih, inode,
(char *)&unfm_ptr);
} else {
retval = reiserfs_paste_into_item(th, path, &end_key, inode,
(char *)&unfm_ptr,
UNFM_P_SIZE);
}
if (retval) {
return retval;
}
make_cpu_key(&end_key, inode, max_reiserfs_offset(inode), TYPE_DIRECT,
4);
while (1) {
int tail_size;
if (search_for_position_by_key(sb, &end_key, path) ==
POSITION_FOUND)
reiserfs_panic(sb, "PAP-14050",
"direct item (%K) not found", &end_key);
p_le_ih = PATH_PITEM_HEAD(path);
RFALSE(!is_direct_le_ih(p_le_ih),
"vs-14055: direct item expected(%K), found %h",
&end_key, p_le_ih);
tail_size = (le_ih_k_offset(p_le_ih) & (blk_size - 1))
+ ih_item_len(p_le_ih) - 1;
if (!unbh->b_page || buffer_uptodate(unbh)
|| PageUptodate(unbh->b_page)) {
up_to_date_bh = NULL;
} else {
up_to_date_bh = unbh;
}
retval = reiserfs_delete_item(th, path, &end_key, inode,
up_to_date_bh);
total_tail += retval;
if (tail_size == retval)
break;
}
if (up_to_date_bh) {
unsigned pgoff =
(tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
char *kaddr = kmap_atomic(up_to_date_bh->b_page);
memset(kaddr + pgoff, 0, blk_size - total_tail);
kunmap_atomic(kaddr);
}
REISERFS_I(inode)->i_first_direct_byte = U32_MAX;
return 0;
}
static int
indirect_bytes_number(struct item_head *ih, int block_size)
{
return (ih_item_len(ih) / UNFM_P_SIZE * block_size);
}
/* preconditions: reiserfs_read_super already executed, therefore
* INFO block is valid
* returns: 0 if error, nonzero iff we were able to find the file successfully
* postconditions: on a nonzero return, INFO->fileinfo contains the info
* of the file we were trying to look up, filepos is 0 and filemax is
* the size of the file.
*/
static int
reiserfs_open_file( char *dirname )
{
struct reiserfs_de_head *de_head;
char *rest, ch;
__u32 dir_id, objectid, parent_dir_id = 0, parent_objectid = 0;
char linkbuf[PATH_MAX]; /* buffer for following symbolic links */
int link_count = 0;
int mode;
errnum = 0;
dir_id = cpu_to_le32(REISERFS_ROOT_PARENT_OBJECTID);
objectid = cpu_to_le32(REISERFS_ROOT_OBJECTID);
while ( 1 )
{
DEBUG_F( "dirname=%s\n", dirname );
/* Search for the stat info first. */
if ( !search_stat( dir_id, objectid ) )
return 0;
DEBUG_F( "sd_mode=0%o sd_size=%Lu\n",
sd_mode((struct stat_data *) INFO->current_item ),
sd_size(INFO->current_ih, INFO->current_item ));
mode = sd_mode((struct stat_data *)INFO->current_item);
/* If we've got a symbolic link, then chase it. */
if ( S_ISLNK( mode ) )
{
int len = 0;
DEBUG_F("link count = %d\n", link_count);
DEBUG_SLEEP;
if ( ++link_count > MAX_LINK_COUNT )
{
DEBUG_F("Symlink loop\n");
errnum = FILE_ERR_SYMLINK_LOOP;
return 0;
}
/* Get the symlink size. */
INFO->file->len = sd_size(INFO->current_ih, INFO->current_item);
/* Find out how long our remaining name is. */
while ( dirname[len] && !isspace( dirname[len] ) )
len++;
if ( INFO->file->len + len > sizeof ( linkbuf ) - 1 )
{
errnum = FILE_ERR_LENGTH;
return 0;
}
/* Copy the remaining name to the end of the symlink data. Note *
* that DIRNAME and LINKBUF may overlap! */
memmove( linkbuf + INFO->file->len, dirname, len + 1 );
INFO->fileinfo.k_dir_id = dir_id;
INFO->fileinfo.k_objectid = objectid;
INFO->file->pos = 0;
if ( !next_key()
|| reiserfs_read_data( linkbuf, INFO->file->len ) != INFO->file->len ) {
DEBUG_F("reiserfs_open_file - if !next_key || reiserfs_read_data\n");
DEBUG_SLEEP;
errnum = FILE_IOERR;
return 0;
}
DEBUG_F( "symlink=%s\n", linkbuf );
DEBUG_SLEEP;
dirname = linkbuf;
if ( *dirname == '/' )
{
/* It's an absolute link, so look it up in root. */
dir_id = cpu_to_le32(REISERFS_ROOT_PARENT_OBJECTID);
objectid = cpu_to_le32(REISERFS_ROOT_OBJECTID);
}
else
{
/* Relative, so look it up in our parent directory. */
dir_id = parent_dir_id;
objectid = parent_objectid;
}
/* Now lookup the new name. */
continue;
}
/* if we have a real file (and we're not just printing *
* possibilities), then this is where we want to exit */
if ( !*dirname || isspace( *dirname ) )
{
if ( !S_ISREG( mode ) )
{
errnum = FILE_ERR_BAD_TYPE;
return 0;
}
INFO->file->pos = 0;
INFO->file->len = sd_size(INFO->current_ih, INFO->current_item);
INFO->fileinfo.k_dir_id = dir_id;
INFO->fileinfo.k_objectid = objectid;
return next_key();
}
/* continue with the file/directory name interpretation */
while ( *dirname == '/' )
dirname++;
if ( !S_ISDIR( mode ) )
{
errnum = FILE_ERR_NOTDIR;
return 0;
}
for ( rest = dirname; ( ch = *rest ) && !isspace( ch ) && ch != '/';
rest++ ) ;
*rest = 0;
while ( 1 )
{
char *name_end;
int num_entries;
if ( !next_key() )
return 0;
if ( INFO->current_ih->ih_key.k_objectid != objectid )
break;
name_end = INFO->current_item + ih_item_len(INFO->current_ih);
de_head = ( struct reiserfs_de_head * ) INFO->current_item;
num_entries = ih_entry_count(INFO->current_ih);
while ( num_entries > 0 )
{
char *filename = INFO->current_item + deh_location(de_head);
char tmp = *name_end;
if( deh_state(de_head) & (1 << DEH_Visible))
{
int cmp;
/* Directory names in ReiserFS are not null * terminated.
* We write a temporary 0 behind it. * NOTE: that this
* may overwrite the first block in * the tree cache.
* That doesn't hurt as long as we * don't call next_key
* () in between. */
*name_end = 0;
cmp = strcmp( dirname, filename );
*name_end = tmp;
if ( cmp == 0 )
goto found;
}
/* The beginning of this name marks the end of the next name.
*/
name_end = filename;
de_head++;
num_entries--;
}
}
errnum = FILE_ERR_NOTFOUND;
*rest = ch;
return 0;
found:
*rest = ch;
dirname = rest;
parent_dir_id = dir_id;
parent_objectid = objectid;
dir_id = de_head->deh_dir_id; /* LE */
objectid = de_head->deh_objectid; /* LE */
}
}
static int
reiserfs_read_data( char *buf, __u32 len )
{
__u32 blocksize;
__u32 offset;
__u32 to_read;
char *prev_buf = buf;
errnum = 0;
DEBUG_F( "reiserfs_read_data: INFO->file->pos=%Lu len=%u, offset=%Lu\n",
INFO->file->pos, len, (__u64) IH_KEY_OFFSET(INFO->current_ih) - 1 );
if ( INFO->current_ih->ih_key.k_objectid != INFO->fileinfo.k_objectid
|| IH_KEY_OFFSET( INFO->current_ih ) > INFO->file->pos + 1 )
{
search_stat( INFO->fileinfo.k_dir_id, INFO->fileinfo.k_objectid );
goto get_next_key;
}
while ( errnum == 0 )
{
if ( INFO->current_ih->ih_key.k_objectid != INFO->fileinfo.k_objectid )
break;
offset = INFO->file->pos - IH_KEY_OFFSET( INFO->current_ih ) + 1;
blocksize = ih_item_len(INFO->current_ih);
DEBUG_F( " loop: INFO->file->pos=%Lu len=%u, offset=%u blocksize=%u\n",
INFO->file->pos, len, offset, blocksize );
if ( IH_KEY_ISTYPE( INFO->current_ih, TYPE_DIRECT )
&& offset < blocksize )
{
to_read = blocksize - offset;
if ( to_read > len )
to_read = len;
memcpy( buf, INFO->current_item + offset, to_read );
goto update_buf_len;
}
else if ( IH_KEY_ISTYPE( INFO->current_ih, TYPE_INDIRECT ) )
{
blocksize = ( blocksize >> 2 ) << INFO->blocksize_shift;
while ( offset < blocksize )
{
__u32 blocknr = le32_to_cpu(((__u32 *)
INFO->current_item)[offset >> INFO->blocksize_shift]);
int blk_offset = offset & (INFO->blocksize - 1);
to_read = INFO->blocksize - blk_offset;
if ( to_read > len )
to_read = len;
/* Journal is only for meta data.
Data blocks can be read directly without using block_read */
read_disk_block( INFO->file, blocknr, blk_offset, to_read,
buf );
update_buf_len:
len -= to_read;
buf += to_read;
offset += to_read;
INFO->file->pos += to_read;
if ( len == 0 )
goto done;
}
}
get_next_key:
next_key();
}
static int
is_leaf(char *buf, int blocksize, struct buf *bp)
{
struct item_head *ih;
struct block_head *blkh;
int used_space, prev_location, i, nr;
blkh = (struct block_head *)buf;
if (blkh_level(blkh) != DISK_LEAF_NODE_LEVEL) {
reiserfs_log(LOG_WARNING, "this should be caught earlier");
return (0);
}
nr = blkh_nr_item(blkh);
if (nr < 1 || nr >
((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN))) {
/* Item number is too big or too small */
reiserfs_log(LOG_WARNING, "nr_item seems wrong\n");
return (0);
}
ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
used_space = BLKH_SIZE + IH_SIZE * nr + (blocksize - ih_location(ih));
if (used_space != blocksize - blkh_free_space(blkh)) {
/*
* Free space does not match to calculated amount of
* use space
*/
reiserfs_log(LOG_WARNING, "free space seems wrong\n");
return (0);
}
/* FIXME: it is_leaf will hit performance too much - we may have
* return 1 here */
/* Check tables of item heads */
ih = (struct item_head *)(buf + BLKH_SIZE);
prev_location = blocksize;
for (i = 0; i < nr; i++, ih++) {
if (le_ih_k_type(ih) == TYPE_ANY) {
reiserfs_log(LOG_WARNING,
"wrong item type for item\n");
return (0);
}
if (ih_location(ih) >= blocksize ||
ih_location(ih) < IH_SIZE * nr) {
reiserfs_log(LOG_WARNING,
"item location seems wrong\n");
return (0);
}
if (ih_item_len(ih) < 1 ||
ih_item_len(ih) > MAX_ITEM_LEN(blocksize)) {
reiserfs_log(LOG_WARNING, "item length seems wrong\n");
return (0);
}
if (prev_location - ih_location(ih) != ih_item_len(ih)) {
reiserfs_log(LOG_WARNING,
"item location seems wrong (second one)\n");
return (0);
}
prev_location = ih_location(ih);
}
/* One may imagine much more checks */
return 1;
}
/* check directory item and try to recover something */
static int verify_directory_item (reiserfs_filsys_t fs, struct buffer_head * bh,
int item_num)
{
struct item_head * ih;
struct item_head tmp;
char * item;
struct reiserfs_de_head * deh;
char * name;
int name_len;
int bad;
int i, j;
#if 0
int bad_entries; /* how many bad neighboring entries */
int total_entry_len;
char * entries, * end;
#endif
int dirty;
int entry_count;
int hash_code;
int bad_locations;
#ifdef DEBUG_VERIFY_DENTRY
char * direntries;
#endif
ih = B_N_PITEM_HEAD (bh, item_num);
item = B_I_PITEM (bh,ih);
deh = (struct reiserfs_de_head *)item;
dirty = 0;
bad_locations = 0;
entry_count = ih_entry_count (ih);
/* check deh_location */
for (i = 0; i < ih_entry_count (ih); i ++) {
/* silently fix deh_state */
if (deh [i].deh_state != (1 << DEH_Visible)) {
deh [i].deh_state = cpu_to_le16 (1 << DEH_Visible);
mark_buffer_dirty (bh);
}
if (dir_entry_bad_location (deh + i, ih, !i))
mark_de_bad_location (deh + i);
}
#ifdef DEBUG_VERIFY_DENTRY
direntries = getmem (ih_entry_count (ih) * sizeof (int));
printf ("entries with bad locations: ");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad_location (deh + i))
printf ("%d ", i);
}
printf ("\n");
#endif /* DEBUG_VERIFY_DENTRY */
/* find entries names in which have mismatching deh_offset */
for (i = ih_entry_count (ih) - 1; i >= 0; i --) {
if (de_bad (deh + i))
/* bad location */
continue;
if (i) {
if (deh_location (deh + i - 1) < deh_location (deh + i))
mark_de_bad_location (deh + i - 1);
}
name = name_in_entry (deh + i, i);
/* we found a name, but we not always we can get its length as
it depends on deh_location of previous entry */
name_len = try_to_get_name_length (ih, deh + i, i);
#ifdef DEBUG_VERIFY_DENTRY
if (name_len == 0)
printf ("trying to find name length for %d-th entry\n", i);
#endif /* DEBUG_VERIFY_DENTRY */
if (is_dot (name, name_len)) {
if (i != 0)
fsck_log ("block %lu: item %d: \".\" is %d-th entry\n",
bh->b_blocknr, item_num, i);
/* check and fix "." */
if (deh_offset (deh + i) != DOT_OFFSET) {
set_deh_offset(&(deh[i]), DOT_OFFSET);
mark_buffer_dirty (bh);
}
/* "." must point to the directory it is in */
if (not_of_one_file (&(deh[i].deh_dir_id), &(ih->ih_key))) { /* endian safe */
fsck_log ("verify_direntry: block %lu, item %H has entry \".\" "
"pointing to (%K) instead of (%K)\n",
bh->b_blocknr, ih,
&(deh[i].deh_dir_id), &(ih->ih_key));
deh[i].deh_dir_id = ih->ih_key.k_dir_id; /* both LE */
deh[i].deh_objectid = ih->ih_key.k_objectid; /* both LE */
mark_buffer_dirty (bh);
}
} else if (is_dot_dot (name, name_len)) {
if (i != 1)
fsck_log ("block %lu: item %d: \"..\" is %d-th entry\n",
bh->b_blocknr, item_num, i);
/* check and fix ".." */
if (deh_offset (deh + i) != DOT_DOT_OFFSET)
set_deh_offset(&(deh[i]), DOT_DOT_OFFSET);
} else {
int min_length, max_length;
/* check other name */
if (name_len == 0) {
/* we do not know the length of name - we will try to find it */
min_length = 1;
max_length = item + ih_item_len (ih) - name;
} else
/* we kow name length, so we will try only one name length */
min_length = max_length = name_len;
for (j = min_length; j <= max_length; j ++) {
hash_code = find_hash_in_use (name, j,
GET_HASH_VALUE (deh_offset (deh + i)),
rs_hash (fs->s_rs));
add_hash_hit (fs, hash_code);
if (code2func (hash_code) != 0) {
/* deh_offset matches to some hash of the name */
if (!name_len) {
fsck_log ("pass0: block %lu, item %H: entry %d. found a name \"%.*s\" "
"matching to deh_offset %u. FIXME: should set deh_location "
"of previous entry (not ready)\n",
bh->b_blocknr, ih, i, j, name, deh_offset (deh + i));
/* FIXME: if next byte is 0 we think that the name is aligned to 8 byte boundary */
if (i) {
set_deh_location( &(deh[i - 1]),
deh_location (deh + i) +
((name[j] || SB_VERSION (fs) ==
REISERFS_VERSION_1) ? j : ROUND_UP (j)));
mark_de_good_location (deh + i - 1);
mark_buffer_dirty (bh);
}
}
break;
}
}
if (j == max_length + 1) {
/* deh_offset does not match to anything. it will be
deleted for now, but maybe we could just fix a
deh_offset if it is in ordeer */
mark_de_bad_offset (deh + i);
}
}
} /* for */
#if 0
/* find entries names in which have mismatching deh_offset */
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad (deh + i))
/* bad location */
continue;
name = name_in_entry (deh + i, i);
/* we found a name, but we not always we can get its length as
it depends on deh_location of previous entry */
name_len = try_to_get_name_length (ih, deh + i, i);
if (i == 0 && is_dot (name, name_len)) {
/* check and fix "." */
if (deh_offset (deh + i) != DOT_OFFSET) {
deh[i].deh_offset = cpu_to_le32 (DOT_OFFSET);
}
/* "." must point to the directory it is in */
if (not_of_one_file (&(deh[i].deh_dir_id), &(ih->ih_key))) {
fsck_log ("verify_direntry: block %lu, item %H has entry \".\" "
"pointing to (%K) instead of (%K)\n",
bh->b_blocknr, ih,
&(deh[i].deh_dir_id), &(ih->ih_key));
deh[i].deh_dir_id = ih->ih_key.k_dir_id; /* both 32 bit LE */
deh[i].deh_objectid = ih->ih_key.k_objectid; /* both 32 bit LE */
mark_buffer_dirty (bh);
}
} else if (i == 1 && is_dot_dot (name, name_len)) {
/* check and fix ".." */
if (deh_offset (deh + i) != DOT_DOT_OFFSET)
deh[i].deh_offset = cpu_to_le32 (DOT_DOT_OFFSET);
} else {
int min_length, max_length;
/* check other name */
if (name_len == 0) {
/* we do not know the length of name - we will try to find it */
min_length = 1;
max_length = item + ih_item_len (ih) - name;
} else
/* we kow name length, so we will try only one name length */
min_length = max_length = name_len;
for (j = min_length; j <= max_length; j ++) {
hash_code = find_hash_in_use (name, j,
GET_HASH_VALUE (deh_offset (deh + i)),
rs_hash (fs->s_rs));
add_hash_hit (fs, hash_code);
if (code2func (hash_code) != 0) {
/* deh_offset matches to some hash of the name */
if (!name_len) {
fsck_log ("pass0: block %lu, item %H: entry %d. found a name \"%.*s\" "
"matching to deh_offset %u. FIXME: should set deh_location "
"of previous entry (not ready)\n",
bh->b_blocknr, ih, i, j, name, deh_offset (deh + i));
/* FIXME: if next byte is 0 we think that the name is aligned to 8 byte boundary */
deh[i - 1].deh_location = cpu_to_le16 (deh_location (deh + i) +
((name[j] || SB_VERSION (fs) == REISERFS_VERSION_1) ? j : ROUND_UP (j)));
}
break;
}
}
if (j == max_length + 1) {
/* deh_offset does not match to anything. it will be
deleted for now, but maybe we could just fix a
deh_offset if it is in ordeer */
mark_de_bad_offset (deh + i);
}
}
}
#endif
#ifdef DEBUG_VERIFY_DENTRY
printf ("entries with mismatching deh_offsets: ");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad_offset (deh + i))
printf ("%d ", i);
}
printf ("\n");
#endif /* DEBUG_VERIFY_DENTRY */
/* correct deh_locations such that code cutting entries will not get
screwed up */
{
int prev_loc;
int loc_fixed;
prev_loc = ih_item_len (ih);
for (i = 0; i < ih_entry_count (ih); i ++) {
loc_fixed = 0;
if (de_bad_location (deh + i)) {
set_deh_location(&(deh[i]), prev_loc/* - 1*/);
mark_buffer_dirty (bh);
loc_fixed = 1;
} else {
if (deh_location (deh + i) >= prev_loc) {
set_deh_location(&(deh[i]), prev_loc/* - 1*/);
mark_buffer_dirty (bh);
loc_fixed = 1;
}
}
prev_loc = deh_location (deh + i);
if (i == ih_entry_count (ih) - 1) {
/* last entry starts right after an array of dir entry headers */
if (!de_bad (deh + i) &&
deh_location (deh + i) != (DEH_SIZE * ih_entry_count (ih))) {
/* free space in the directory item */
fsck_log ("verify_direntry: block %lu, item %H has free
pace\n",
bh->b_blocknr, ih);
cut_entry (fs, bh, item_num, ih_entry_count (ih), 0);
}
if (deh_location (deh + i) != (DEH_SIZE * ih_entry_count (ih)))
{
set_deh_location(&(deh[i]), DEH_SIZE * ih_entry_count (ih));
loc_fixed = 1;
mark_buffer_dirty (bh);
}
}
#ifdef DEBUG_VERIFY_DENTRY
if (loc_fixed)
direntries [i] = 1;
#endif
} /* for */
#ifdef DEBUG_VERIFY_DENTRY
printf ("entries with fixed deh_locations: ");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (direntries [i])
printf ("%d ", i);
}
printf ("\n");
#endif /* DEBUG_VERIFY_DENTRY */
}
#ifdef DEBUG_VERIFY_DENTRY
printf (" N location name\n");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad (deh + i) ||
(i && de_bad (deh + i - 1)) || /* previous entry marked bad */
(i < ih_entry_count (ih) - 1 && de_bad (deh + i + 1))) { /* next
ntry is marked bad */
/* print only entries to be deleted and their nearest neighbors */
printf ("%3d: %8d ", i, deh_location (deh + i));
if (de_bad (deh + i))
printf ("will be deleted\n");
else
printf ("\"%.*s\"\n", name_length (ih, deh + i, i),
name_in_entry (deh + i, i));
}
}
#endif
bad = 0;
tmp = *ih;
/* delete entries which are marked bad */
for (i = 0; i < ih_entry_count (ih); i ++) {
deh = B_I_DEH (bh, ih) + i;
if (de_bad (deh)) {
bad ++;
if (ih_entry_count (ih) == 1) {
delete_item (fs, bh, item_num);
break;
} else {
cut_entry (fs, bh, item_num, i, 1);
}
i --;
}
}
if (bad == ih_entry_count (&tmp)) {
fsck_log ("pass0: block %lu, item %H - all entries were deleted\n", bh->b_blocknr, &tmp);
return 0;
}
deh = B_I_DEH (bh, ih);
if (get_offset (&ih->ih_key) != deh_offset (deh)) {
fsck_log ("verify_direntry: block %lu, item %H: k_offset and deh_offset %u mismatched\n",
bh->b_blocknr, ih, deh_offset (deh));
set_offset (KEY_FORMAT_1, &ih->ih_key, deh_offset (deh));
mark_buffer_dirty (bh);
}
if (bad)
fsck_log ("pass0: block %lu, item %H: %d entries were deleted of \n",
bh->b_blocknr, &tmp, bad);
return 0;
#if 0
/* FIXME: temporary */
if (bad_locations > ih_entry_count (ih) / 2) {
fsck_log ("pass0: block %u: item %d (%H) had too bad directory - deleted\n",
bh->b_blocknr, item_num, ih);
delete_item (fs, bh, item_num);
return 0;
}
if (!dirty)
return 0;
/* something is broken */
fsck_log ("pass0: block %lu: %d-th item (%H) has %d bad entries..",
bh->b_blocknr, item_num, ih, dirty);
if (get_offset (&ih->ih_key) == DOT_OFFSET) {
/* first item of directory - make sure that "." and ".." are in place */
if (deh_offset (deh) != DOT_OFFSET || name_in_entry (deh, 0)[0] != '.') {
set_deh_offset(deh, DOT_OFFSET);
name_in_entry (deh, 0)[0] = '.';
}
if (deh_offset (deh + 1) != DOT_DOT_OFFSET ||
name_in_entry (deh + 1, 1)[0] != '.' || name_in_entry (deh + 1, 1)[1] != '.') {
set_deh_offset((deh + 1), DOT_DOT_OFFSET);
name_in_entry (deh + 1, 1)[0] = '.';
name_in_entry (deh + 1, 1)[1] = '.';
}
}
end = item + ih_item_len (ih);
deh += ih_entry_count (ih);
entries = (char *)deh;
total_entry_len = ih_item_len (ih) - DEH_SIZE * ih_entry_count (ih);
i = ih_entry_count (ih);
bad_entries = 0;
do {
i --;
deh --;
name_len = prob_name (fs, &entries, total_entry_len, deh_offset (deh));
if (!name_len) {
if (!bad_entries) {
set_deh_location(deh, entries - item);
} else {
set_deh_location(deh, deh_location((deh + 1)) + 1 );
}
bad_entries ++;
/*fsck_log ("verify_directory_item: entry %d: in string \'%s\' there is no substring matching hash %ld\n",
i, bad_name (entries, total_entry_len), masked_offset);*/
mark_de_bad (deh);
continue;
}
bad_entries = 0;
/*fsck_log ("verify_directory_item: entry %d: found \"%s\" name matching hash %ld\n",
i, bad_name (entries, name_len), masked_offset);*/
/* 'entries' points now to the name which match given offset -
so, set deh_location */
set_deh_location(deh, entries - item);
deh->deh_state = 0;
mark_de_visible (deh);
entries += name_len;
total_entry_len = end - entries;
/* skip padding zeros */
while (!*entries) {
entries ++;
total_entry_len --;
}
/* 'entries' points now at the place where next (previous)
entry should start */
} while ((char *)deh != item);
/* fixme: this will not work if all entries are to be deleted */
for (i = 0; i < ih_entry_count (ih); i ++, deh ++) {
deh = (struct reiserfs_de_head *)B_I_PITEM (bh, ih) + i;
if (de_bad (deh)) {
if (ih_entry_count (ih) == 1) {
delete_item (fs, bh, i);
break;
} else {
cut_entry (fs, bh, item_num, i);
}
i --;
}
/*
fsck_log ("verify_directory_item: %d-th entry is to be deleted: "
"\"%s\" does not match to hash %lu\n",
i, bad_name (name_in_entry (deh, i), name_length (ih, deh, i)),
deh_offset (deh));
*/
}
fsck_log ("%d entries were deleted\n", entry_count - ih_entry_count (ih));
mark_buffer_dirty (bh);
return 0;
#endif
}
/* The function is NOT SCHEDULE-SAFE! */
int
search_for_position_by_key(struct reiserfs_sb_info *p_s_sbi,
const struct cpu_key *p_cpu_key, /* Key to search (cpu variable) */
struct path *p_s_search_path) /* Filled up by this function. */
{
int retval, n_blk_size;
off_t item_offset, offset;
struct item_head *p_le_ih; /* Pointer to on-disk structure */
struct reiserfs_dir_entry de;
/* If searching for directory entry. */
if (is_direntry_cpu_key(p_cpu_key))
return (search_by_entry_key(p_s_sbi, p_cpu_key,
p_s_search_path, &de));
/* If not searching for directory entry. */
/* If item is found. */
retval = search_item(p_s_sbi, p_cpu_key, p_s_search_path);
if (retval == IO_ERROR)
return (retval);
if (retval == ITEM_FOUND) {
if (ih_item_len(B_N_PITEM_HEAD(
PATH_PLAST_BUFFER(p_s_search_path),
PATH_LAST_POSITION(p_s_search_path))) == 0) {
reiserfs_log(LOG_WARNING, "item length equals zero\n");
}
pos_in_item(p_s_search_path) = 0;
return (POSITION_FOUND);
}
if (PATH_LAST_POSITION(p_s_search_path) == 0) {
reiserfs_log(LOG_WARNING, "position equals zero\n");
}
/* Item is not found. Set path to the previous item. */
p_le_ih = B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_search_path),
--PATH_LAST_POSITION(p_s_search_path));
n_blk_size = p_s_sbi->s_blocksize;
if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) {
return (FILE_NOT_FOUND);
}
item_offset = le_ih_k_offset(p_le_ih);
offset = cpu_key_k_offset(p_cpu_key);
/* Needed byte is contained in the item pointed to by the path.*/
if (item_offset <= offset &&
item_offset + op_bytes_number(p_le_ih, n_blk_size) > offset) {
pos_in_item(p_s_search_path) = offset - item_offset;
if (is_indirect_le_ih(p_le_ih)) {
pos_in_item(p_s_search_path) /= n_blk_size;
}
return (POSITION_FOUND);
}
/* Needed byte is not contained in the item pointed to by the
* path. Set pos_in_item out of the item. */
if (is_indirect_le_ih(p_le_ih))
pos_in_item(p_s_search_path) =
ih_item_len(p_le_ih) / UNFM_P_SIZE;
else
pos_in_item(p_s_search_path) =
ih_item_len(p_le_ih);
return (POSITION_NOT_FOUND);
}
/*
* this first locks inode (neither reads nor sync are permitted),
* reads tail through page cache, insert direct item. When direct item
* inserted successfully inode is left locked. Return value is always
* what we expect from it (number of cut bytes). But when tail remains
* in the unformatted node, we set mode to SKIP_BALANCING and unlock
* inode
*/
int indirect2direct(struct reiserfs_transaction_handle *th,
struct inode *inode, struct page *page,
struct treepath *path, /* path to the indirect item. */
const struct cpu_key *item_key, /* Key to look for
* unformatted node
* pointer to be cut. */
loff_t n_new_file_size, /* New file size. */
char *mode)
{
struct super_block *sb = inode->i_sb;
struct item_head s_ih;
unsigned long block_size = sb->s_blocksize;
char *tail;
int tail_len, round_tail_len;
loff_t pos, pos1; /* position of first byte of the tail */
struct cpu_key key;
BUG_ON(!th->t_trans_id);
REISERFS_SB(sb)->s_indirect2direct++;
*mode = M_SKIP_BALANCING;
/* store item head path points to. */
copy_item_head(&s_ih, tp_item_head(path));
tail_len = (n_new_file_size & (block_size - 1));
if (get_inode_sd_version(inode) == STAT_DATA_V2)
round_tail_len = ROUND_UP(tail_len);
else
round_tail_len = tail_len;
pos =
le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * sb->s_blocksize;
pos1 = pos;
/*
* we are protected by i_mutex. The tail can not disapper, not
* append can be done either
* we are in truncate or packing tail in file_release
*/
tail = (char *)kmap(page); /* this can schedule */
if (path_changed(&s_ih, path)) {
/* re-search indirect item */
if (search_for_position_by_key(sb, item_key, path)
== POSITION_NOT_FOUND)
reiserfs_panic(sb, "PAP-5520",
"item to be converted %K does not exist",
item_key);
copy_item_head(&s_ih, tp_item_head(path));
#ifdef CONFIG_REISERFS_CHECK
pos = le_ih_k_offset(&s_ih) - 1 +
(ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * sb->s_blocksize;
if (pos != pos1)
reiserfs_panic(sb, "vs-5530", "tail position "
"changed while we were reading it");
#endif
}
/* Set direct item header to insert. */
make_le_item_head(&s_ih, NULL, get_inode_item_key_version(inode),
pos1 + 1, TYPE_DIRECT, round_tail_len,
0xffff /*ih_free_space */ );
/*
* we want a pointer to the first byte of the tail in the page.
* the page was locked and this part of the page was up to date when
* indirect2direct was called, so we know the bytes are still valid
*/
tail = tail + (pos & (PAGE_SIZE - 1));
PATH_LAST_POSITION(path)++;
key = *item_key;
set_cpu_key_k_type(&key, TYPE_DIRECT);
key.key_length = 4;
/* Insert tail as new direct item in the tree */
if (reiserfs_insert_item(th, path, &key, &s_ih, inode,
tail ? tail : NULL) < 0) {
/*
* No disk memory. So we can not convert last unformatted node
* to the direct item. In this case we used to adjust
* indirect items's ih_free_space. Now ih_free_space is not
* used, it would be ideal to write zeros to corresponding
* unformatted node. For now i_size is considered as guard for
* going out of file size
*/
kunmap(page);
return block_size - round_tail_len;
}
kunmap(page);
/* make sure to get the i_blocks changes from reiserfs_insert_item */
reiserfs_update_sd(th, inode);
/*
* note: we have now the same as in above direct2indirect
* conversion: there are two keys which have matching first three
* key components. They only differ by the fourth one.
*/
/*
* We have inserted new direct item and must remove last
* unformatted node.
*/
*mode = M_CUT;
/* we store position of first direct item in the in-core inode */
/* mark_file_with_tail (inode, pos1 + 1); */
REISERFS_I(inode)->i_first_direct_byte = pos1 + 1;
return block_size - round_tail_len;
}