| /* |
| * 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++; |
| } |
| } |