--- /dev/null
+/**
+ * \file fsw_reiserfs.c
+ * ReiserFS file system driver code.
+ */
+
+/*-
+ * Copyright (c) 2006 Christoph Pfisterer
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "fsw_reiserfs.h"
+
+
+// functions
+
+static fsw_status_t fsw_reiserfs_volume_mount(struct fsw_reiserfs_volume *vol);
+static void fsw_reiserfs_volume_free(struct fsw_reiserfs_volume *vol);
+static fsw_status_t fsw_reiserfs_volume_stat(struct fsw_reiserfs_volume *vol, struct fsw_volume_stat *sb);
+
+static fsw_status_t fsw_reiserfs_dnode_fill(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno);
+static void fsw_reiserfs_dnode_free(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno);
+static fsw_status_t fsw_reiserfs_dnode_stat(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_dnode_stat *sb);
+static fsw_status_t fsw_reiserfs_get_extent(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_extent *extent);
+
+static fsw_status_t fsw_reiserfs_dir_lookup(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_string *lookup_name, struct fsw_reiserfs_dnode **child_dno);
+static fsw_status_t fsw_reiserfs_dir_read(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_shandle *shand, struct fsw_reiserfs_dnode **child_dno);
+
+static fsw_status_t fsw_reiserfs_readlink(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_string *link);
+
+static fsw_status_t fsw_reiserfs_item_search(struct fsw_reiserfs_volume *vol,
+ fsw_u32 dir_id, fsw_u32 objectid, fsw_u64 offset,
+ struct fsw_reiserfs_item *item);
+static fsw_status_t fsw_reiserfs_item_next(struct fsw_reiserfs_volume *vol,
+ struct fsw_reiserfs_item *item);
+static void fsw_reiserfs_item_release(struct fsw_reiserfs_volume *vol,
+ struct fsw_reiserfs_item *item);
+
+//
+// Dispatch Table
+//
+
+struct fsw_fstype_table FSW_FSTYPE_TABLE_NAME(reiserfs) = {
+ { FSW_STRING_TYPE_ISO88591, 8, 8, "reiserfs" },
+ sizeof(struct fsw_reiserfs_volume),
+ sizeof(struct fsw_reiserfs_dnode),
+
+ fsw_reiserfs_volume_mount,
+ fsw_reiserfs_volume_free,
+ fsw_reiserfs_volume_stat,
+ fsw_reiserfs_dnode_fill,
+ fsw_reiserfs_dnode_free,
+ fsw_reiserfs_dnode_stat,
+ fsw_reiserfs_get_extent,
+ fsw_reiserfs_dir_lookup,
+ fsw_reiserfs_dir_read,
+ fsw_reiserfs_readlink,
+};
+
+// misc data
+
+static fsw_u32 superblock_offsets[3] = {
+ REISERFS_DISK_OFFSET_IN_BYTES >> REISERFS_SUPERBLOCK_BLOCKSIZEBITS,
+ REISERFS_OLD_DISK_OFFSET_IN_BYTES >> REISERFS_SUPERBLOCK_BLOCKSIZEBITS,
+ 0
+};
+
+/**
+ * Mount an reiserfs volume. Reads the superblock and constructs the
+ * root directory dnode.
+ */
+
+static fsw_status_t fsw_reiserfs_volume_mount(struct fsw_reiserfs_volume *vol)
+{
+ fsw_status_t status;
+ void *buffer;
+ fsw_u32 blocksize;
+ int i;
+ struct fsw_string s;
+
+ // allocate memory to keep the superblock around
+ status = fsw_alloc(sizeof(struct reiserfs_super_block), &vol->sb);
+ if (status)
+ return status;
+
+ // read the superblock into its buffer
+ fsw_set_blocksize(vol, REISERFS_SUPERBLOCK_BLOCKSIZE, REISERFS_SUPERBLOCK_BLOCKSIZE);
+ for (i = 0; superblock_offsets[i]; i++) {
+ status = fsw_block_get(vol, superblock_offsets[i], 0, &buffer);
+ if (status)
+ return status;
+ fsw_memcpy(vol->sb, buffer, sizeof(struct reiserfs_super_block));
+ fsw_block_release(vol, superblock_offsets[i], buffer);
+
+ // check for one of the magic strings
+ if (fsw_memeq(vol->sb->s_v1.s_magic,
+ REISERFS_SUPER_MAGIC_STRING, 8)) {
+ vol->version = REISERFS_VERSION_1;
+ break;
+ } else if (fsw_memeq(vol->sb->s_v1.s_magic,
+ REISER2FS_SUPER_MAGIC_STRING, 9)) {
+ vol->version = REISERFS_VERSION_2;
+ break;
+ } else if (fsw_memeq(vol->sb->s_v1.s_magic,
+ REISER2FS_JR_SUPER_MAGIC_STRING, 9)) {
+ vol->version = vol->sb->s_v1.s_version;
+ if (vol->version == REISERFS_VERSION_1 || vol->version == REISERFS_VERSION_2)
+ break;
+ }
+ }
+ if (superblock_offsets[i] == 0)
+ return FSW_UNSUPPORTED;
+
+ // check the superblock
+ if (vol->sb->s_v1.s_root_block == -1) // unfinished 'reiserfsck --rebuild-tree'
+ return FSW_VOLUME_CORRUPTED;
+
+ /*
+ if (vol->sb->s_rev_level != EXT2_GOOD_OLD_REV &&
+ vol->sb->s_rev_level != EXT2_DYNAMIC_REV)
+ return FSW_UNSUPPORTED;
+ if (vol->sb->s_rev_level == EXT2_DYNAMIC_REV &&
+ (vol->sb->s_feature_incompat & ~(EXT2_FEATURE_INCOMPAT_FILETYPE | EXT3_FEATURE_INCOMPAT_RECOVER)))
+ return FSW_UNSUPPORTED;
+ */
+
+ // set real blocksize
+ blocksize = vol->sb->s_v1.s_blocksize;
+ fsw_set_blocksize(vol, blocksize, blocksize);
+
+ // get other info from superblock
+ /*
+ vol->ind_bcnt = EXT2_ADDR_PER_BLOCK(vol->sb);
+ vol->dind_bcnt = vol->ind_bcnt * vol->ind_bcnt;
+ vol->inode_size = EXT2_INODE_SIZE(vol->sb);
+ */
+
+ for (i = 0; i < 16; i++)
+ if (vol->sb->s_label[i] == 0)
+ break;
+ s.type = FSW_STRING_TYPE_ISO88591;
+ s.size = s.len = i;
+ s.data = vol->sb->s_label;
+ status = fsw_strdup_coerce(&vol->g.label, vol->g.host_string_type, &s);
+ if (status)
+ return status;
+
+ // setup the root dnode
+ status = fsw_dnode_create_root(vol, REISERFS_ROOT_OBJECTID, &vol->g.root);
+ if (status)
+ return status;
+ vol->g.root->dir_id = REISERFS_ROOT_PARENT_OBJECTID;
+
+ FSW_MSG_DEBUG((FSW_MSGSTR("fsw_reiserfs_volume_mount: success, blocksize %d tree height %d\n"),
+ blocksize, vol->sb->s_v1.s_tree_height));
+
+ return FSW_SUCCESS;
+}
+
+/**
+ * Free the volume data structure. Called by the core after an unmount or after
+ * an unsuccessful mount to release the memory used by the file system type specific
+ * part of the volume structure.
+ */
+
+static void fsw_reiserfs_volume_free(struct fsw_reiserfs_volume *vol)
+{
+ if (vol->sb)
+ fsw_free(vol->sb);
+}
+
+/**
+ * Get in-depth information on a volume.
+ */
+
+static fsw_status_t fsw_reiserfs_volume_stat(struct fsw_reiserfs_volume *vol, struct fsw_volume_stat *sb)
+{
+ sb->total_bytes = (fsw_u64)vol->sb->s_v1.s_block_count * vol->g.log_blocksize;
+ sb->free_bytes = (fsw_u64)vol->sb->s_v1.s_free_blocks * vol->g.log_blocksize;
+ return FSW_SUCCESS;
+}
+
+/**
+ * Get full information on a dnode from disk. This function is called by the core
+ * whenever it needs to access fields in the dnode structure that may not
+ * be filled immediately upon creation of the dnode. In the case of reiserfs, we
+ * delay fetching of the stat data until dnode_fill is called. The size and
+ * type fields are invalid until this function has been called.
+ */
+
+static fsw_status_t fsw_reiserfs_dnode_fill(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno)
+{
+ fsw_status_t status;
+ fsw_u32 item_len, mode;
+ struct fsw_reiserfs_item item;
+
+ if (dno->sd_v1 || dno->sd_v2)
+ return FSW_SUCCESS;
+
+ FSW_MSG_DEBUG((FSW_MSGSTR("fsw_reiserfs_dnode_fill: object %d/%d\n"), dno->dir_id, dno->g.dnode_id));
+
+ // find stat data item in reiserfs tree
+ status = fsw_reiserfs_item_search(vol, dno->dir_id, dno->g.dnode_id, 0, &item);
+ if (status == FSW_NOT_FOUND) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_dnode_fill: cannot find stat_data for object %d/%d\n"),
+ dno->dir_id, dno->g.dnode_id));
+ return FSW_VOLUME_CORRUPTED;
+ }
+ if (status)
+ return status;
+ if (item.item_offset != 0) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_dnode_fill: got item that's not stat_data\n")));
+ fsw_reiserfs_item_release(vol, &item);
+ return FSW_VOLUME_CORRUPTED;
+ }
+ item_len = item.ih.ih_item_len;
+
+ // get data in appropriate version
+ if (item.ih.ih_version == KEY_FORMAT_3_5 && item_len == SD_V1_SIZE) {
+ // have stat_data_v1 structure
+ status = fsw_memdup((void **)&dno->sd_v1, item.item_data, item_len);
+ fsw_reiserfs_item_release(vol, &item);
+ if (status)
+ return status;
+
+ // get info from the inode
+ dno->g.size = dno->sd_v1->sd_size;
+ mode = dno->sd_v1->sd_mode;
+
+ } else if (item.ih.ih_version == KEY_FORMAT_3_6 && item_len == SD_V2_SIZE) {
+ // have stat_data_v2 structure
+ status = fsw_memdup((void **)&dno->sd_v2, item.item_data, item_len);
+ fsw_reiserfs_item_release(vol, &item);
+ if (status)
+ return status;
+
+ // get info from the inode
+ dno->g.size = dno->sd_v2->sd_size;
+ mode = dno->sd_v2->sd_mode;
+
+ } else {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_dnode_fill: version %d(%d) and size %d(%d) not recognized for stat_data\n"),
+ item.ih.ih_version, KEY_FORMAT_3_6, item_len, SD_V2_SIZE));
+ fsw_reiserfs_item_release(vol, &item);
+ return FSW_VOLUME_CORRUPTED;
+ }
+
+ // get node type from mode field
+ if (S_ISREG(mode))
+ dno->g.type = FSW_DNODE_TYPE_FILE;
+ else if (S_ISDIR(mode))
+ dno->g.type = FSW_DNODE_TYPE_DIR;
+ else if (S_ISLNK(mode))
+ dno->g.type = FSW_DNODE_TYPE_SYMLINK;
+ else
+ dno->g.type = FSW_DNODE_TYPE_SPECIAL;
+
+ return FSW_SUCCESS;
+}
+
+/**
+ * Free the dnode data structure. Called by the core when deallocating a dnode
+ * structure to release the memory used by the file system type specific part
+ * of the dnode structure.
+ */
+
+static void fsw_reiserfs_dnode_free(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno)
+{
+ if (dno->sd_v1)
+ fsw_free(dno->sd_v1);
+ if (dno->sd_v2)
+ fsw_free(dno->sd_v2);
+}
+
+/**
+ * Get in-depth information on a dnode. The core makes sure that fsw_reiserfs_dnode_fill
+ * has been called on the dnode before this function is called. Note that some
+ * data is not directly stored into the structure, but passed to a host-specific
+ * callback that converts it to the host-specific format.
+ */
+
+static fsw_status_t fsw_reiserfs_dnode_stat(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_dnode_stat *sb)
+{
+ if (dno->sd_v1) {
+ if (dno->g.type == FSW_DNODE_TYPE_SPECIAL)
+ sb->used_bytes = 0;
+ else
+ sb->used_bytes = dno->sd_v1->u.sd_blocks * vol->g.log_blocksize;
+ sb->store_time_posix(sb, FSW_DNODE_STAT_CTIME, dno->sd_v1->sd_ctime);
+ sb->store_time_posix(sb, FSW_DNODE_STAT_ATIME, dno->sd_v1->sd_atime);
+ sb->store_time_posix(sb, FSW_DNODE_STAT_MTIME, dno->sd_v1->sd_mtime);
+ sb->store_attr_posix(sb, dno->sd_v1->sd_mode);
+ } else if (dno->sd_v2) {
+ sb->used_bytes = dno->sd_v2->sd_blocks * vol->g.log_blocksize;
+ sb->store_time_posix(sb, FSW_DNODE_STAT_CTIME, dno->sd_v2->sd_ctime);
+ sb->store_time_posix(sb, FSW_DNODE_STAT_ATIME, dno->sd_v2->sd_atime);
+ sb->store_time_posix(sb, FSW_DNODE_STAT_MTIME, dno->sd_v2->sd_mtime);
+ sb->store_attr_posix(sb, dno->sd_v2->sd_mode);
+ }
+
+ return FSW_SUCCESS;
+}
+
+/**
+ * Retrieve file data mapping information. This function is called by the core when
+ * fsw_shandle_read needs to know where on the disk the required piece of the file's
+ * data can be found. The core makes sure that fsw_reiserfs_dnode_fill has been called
+ * on the dnode before. Our task here is to get the physical disk block number for
+ * the requested logical block number.
+ */
+
+static fsw_status_t fsw_reiserfs_get_extent(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_extent *extent)
+{
+ fsw_status_t status;
+ fsw_u64 search_offset, intra_offset;
+ struct fsw_reiserfs_item item;
+ fsw_u32 intra_bno, nr_item;
+
+ // Preconditions: The caller has checked that the requested logical block
+ // is within the file's size. The dnode has complete information, i.e.
+ // fsw_reiserfs_dnode_read_info was called successfully on it.
+
+ FSW_MSG_DEBUG((FSW_MSGSTR("fsw_reiserfs_get_extent: mapping block %d of object %d/%d\n"),
+ extent->log_start, dno->dir_id, dno->g.dnode_id));
+
+ extent->type = FSW_EXTENT_TYPE_SPARSE;
+ extent->log_count = 1;
+
+ // get the item for the requested block
+ search_offset = (fsw_u64)extent->log_start * vol->g.log_blocksize + 1;
+ status = fsw_reiserfs_item_search(vol, dno->dir_id, dno->g.dnode_id, search_offset, &item);
+ if (status)
+ return status;
+ if (item.item_offset == 0) {
+ fsw_reiserfs_item_release(vol, &item);
+ return FSW_SUCCESS; // no data items found, assume all-sparse file
+ }
+ intra_offset = search_offset - item.item_offset;
+
+ // check the kind of block
+ if (item.item_type == TYPE_INDIRECT || item.item_type == V1_INDIRECT_UNIQUENESS) {
+ // indirect item, contains block numbers
+
+ if (intra_offset & (vol->g.log_blocksize - 1)) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_get_extent: intra_offset not block-aligned for indirect block\n")));
+ goto bail;
+ }
+ intra_bno = (fsw_u32)FSW_U64_DIV(intra_offset, vol->g.log_blocksize);
+ nr_item = item.ih.ih_item_len / sizeof(fsw_u32);
+ if (intra_bno >= nr_item) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_get_extent: indirect block too small\n")));
+ goto bail;
+ }
+ extent->type = FSW_EXTENT_TYPE_PHYSBLOCK;
+ extent->phys_start = ((fsw_u32 *)item.item_data)[intra_bno];
+
+ // TODO: check if the following blocks can be aggregated into one extent
+
+ fsw_reiserfs_item_release(vol, &item);
+ return FSW_SUCCESS;
+
+ } else if (item.item_type == TYPE_DIRECT || item.item_type == V1_DIRECT_UNIQUENESS) {
+ // direct item, contains file data
+
+ // TODO: Check if direct items always start on block boundaries. If not, we may have
+ // to do extra work here.
+
+ if (intra_offset != 0) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_get_extent: intra_offset not aligned for direct block\n")));
+ goto bail;
+ }
+
+ extent->type = FSW_EXTENT_TYPE_BUFFER;
+ status = fsw_memdup(&extent->buffer, item.item_data, item.ih.ih_item_len);
+ fsw_reiserfs_item_release(vol, &item);
+ if (status)
+ return status;
+
+ return FSW_SUCCESS;
+
+ }
+
+bail:
+ fsw_reiserfs_item_release(vol, &item);
+ return FSW_VOLUME_CORRUPTED;
+
+ /*
+ // check if the following blocks can be aggregated into one extent
+ file_bcnt = (fsw_u32)((dno->g.size + vol->g.log_blocksize - 1) & (vol->g.log_blocksize - 1));
+ while (path[i] + extent->log_count < buf_bcnt && // indirect block has more block pointers
+ extent->log_start + extent->log_count < file_bcnt) { // file has more blocks
+ if (buffer[path[i] + extent->log_count] == buffer[path[i] + extent->log_count - 1] + 1)
+ extent->log_count++;
+ else
+ break;
+ }
+ */
+}
+
+/**
+ * Lookup a directory's child dnode by name. This function is called on a directory
+ * to retrieve the directory entry with the given name. A dnode is constructed for
+ * this entry and returned. The core makes sure that fsw_reiserfs_dnode_fill has been called
+ * and the dnode is actually a directory.
+ */
+
+static fsw_status_t fsw_reiserfs_dir_lookup(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_string *lookup_name, struct fsw_reiserfs_dnode **child_dno_out)
+{
+ fsw_status_t status;
+ struct fsw_reiserfs_item item;
+ fsw_u32 nr_item, i, name_offset, next_name_offset, name_len;
+ fsw_u32 child_dir_id;
+ struct reiserfs_de_head *dhead;
+ struct fsw_string entry_name;
+
+ // Preconditions: The caller has checked that dno is a directory node.
+
+ // BIG TODOS: Use the hash function to start with the item containing the entry.
+ // Use binary search within the item.
+
+ entry_name.type = FSW_STRING_TYPE_ISO88591;
+
+ // get the item for that position
+ status = fsw_reiserfs_item_search(vol, dno->dir_id, dno->g.dnode_id, FIRST_ITEM_OFFSET, &item);
+ if (status)
+ return status;
+ if (item.item_offset == 0) {
+ fsw_reiserfs_item_release(vol, &item);
+ return FSW_NOT_FOUND; // empty directory or something
+ }
+
+ for(;;) {
+
+ // search the directory item
+ dhead = (struct reiserfs_de_head *)item.item_data;
+ nr_item = item.ih.u.ih_entry_count;
+ next_name_offset = item.ih.ih_item_len;
+ for (i = 0; i < nr_item; i++, dhead++, next_name_offset = name_offset) {
+ // get the name
+ name_offset = dhead->deh_location;
+ name_len = next_name_offset - name_offset;
+ while (name_len > 0 && item.item_data[name_offset + name_len - 1] == 0)
+ name_len--;
+
+ entry_name.len = entry_name.size = name_len;
+ entry_name.data = item.item_data + name_offset;
+
+ // compare name
+ if (fsw_streq(lookup_name, &entry_name)) {
+ // found the entry we're looking for!
+
+ // setup a dnode for the child item
+ status = fsw_dnode_create(dno, dhead->deh_objectid, FSW_DNODE_TYPE_UNKNOWN, &entry_name, child_dno_out);
+ child_dir_id = dhead->deh_dir_id;
+ fsw_reiserfs_item_release(vol, &item);
+ if (status)
+ return status;
+ (*child_dno_out)->dir_id = child_dir_id;
+
+ return FSW_SUCCESS;
+ }
+ }
+
+ // We didn't find the next directory entry in this item. Look for the next
+ // item of the directory.
+
+ status = fsw_reiserfs_item_next(vol, &item);
+ if (status)
+ return status;
+
+ }
+}
+
+/**
+ * Get the next directory entry when reading a directory. This function is called during
+ * directory iteration to retrieve the next directory entry. A dnode is constructed for
+ * the entry and returned. The core makes sure that fsw_reiserfs_dnode_fill has been called
+ * and the dnode is actually a directory. The shandle provided by the caller is used to
+ * record the position in the directory between calls.
+ */
+
+static fsw_status_t fsw_reiserfs_dir_read(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_shandle *shand, struct fsw_reiserfs_dnode **child_dno_out)
+{
+ fsw_status_t status;
+ struct fsw_reiserfs_item item;
+ fsw_u32 nr_item, i, name_offset, next_name_offset, name_len;
+ fsw_u32 child_dir_id;
+ struct reiserfs_de_head *dhead;
+ struct fsw_string entry_name;
+
+ // Preconditions: The caller has checked that dno is a directory node. The caller
+ // has opened a storage handle to the directory's storage and keeps it around between
+ // calls.
+
+ // BIG TODOS: Use binary search within the item.
+
+ // adjust pointer to first entry if necessary
+ if (shand->pos == 0)
+ shand->pos = FIRST_ITEM_OFFSET;
+
+ // get the item for that position
+ status = fsw_reiserfs_item_search(vol, dno->dir_id, dno->g.dnode_id, shand->pos, &item);
+ if (status)
+ return status;
+ if (item.item_offset == 0) {
+ fsw_reiserfs_item_release(vol, &item);
+ return FSW_NOT_FOUND; // empty directory or something
+ }
+
+ for(;;) {
+
+ // search the directory item
+ dhead = (struct reiserfs_de_head *)item.item_data;
+ nr_item = item.ih.u.ih_entry_count;
+ for (i = 0; i < nr_item; i++, dhead++) {
+ if (dhead->deh_offset < shand->pos)
+ continue; // not yet past the last entry returned
+ if (dhead->deh_offset == DOT_OFFSET || dhead->deh_offset == DOT_DOT_OFFSET)
+ continue; // never report . or ..
+
+ // get the name
+ name_offset = dhead->deh_location;
+ if (i == 0)
+ next_name_offset = item.ih.ih_item_len;
+ else
+ next_name_offset = dhead[-1].deh_location;
+ name_len = next_name_offset - name_offset;
+ while (name_len > 0 && item.item_data[name_offset + name_len - 1] == 0)
+ name_len--;
+
+ entry_name.type = FSW_STRING_TYPE_ISO88591;
+ entry_name.len = entry_name.size = name_len;
+ entry_name.data = item.item_data + name_offset;
+
+ if (fsw_streq_cstr(&entry_name, ".reiserfs_priv"))
+ continue; // never report this special file
+
+ // found the next entry!
+ shand->pos = dhead->deh_offset + 1;
+
+ // setup a dnode for the child item
+ status = fsw_dnode_create(dno, dhead->deh_objectid, FSW_DNODE_TYPE_UNKNOWN, &entry_name, child_dno_out);
+ child_dir_id = dhead->deh_dir_id;
+ fsw_reiserfs_item_release(vol, &item);
+ if (status)
+ return status;
+ (*child_dno_out)->dir_id = child_dir_id;
+
+ return FSW_SUCCESS;
+ }
+
+ // We didn't find the next directory entry in this item. Look for the next
+ // item of the directory.
+
+ status = fsw_reiserfs_item_next(vol, &item);
+ if (status)
+ return status;
+
+ }
+}
+
+/**
+ * Get the target path of a symbolic link. This function is called when a symbolic
+ * link needs to be resolved. The core makes sure that the fsw_reiserfs_dnode_fill has been
+ * called on the dnode and that it really is a symlink.
+ */
+
+static fsw_status_t fsw_reiserfs_readlink(struct fsw_reiserfs_volume *vol, struct fsw_reiserfs_dnode *dno,
+ struct fsw_string *link_target)
+{
+ return fsw_dnode_readlink_data(dno, link_target);
+}
+
+/**
+ * Compare an on-disk tree key against the search key.
+ */
+
+static int fsw_reiserfs_compare_key(struct reiserfs_key *key,
+ fsw_u32 dir_id, fsw_u32 objectid, fsw_u64 offset)
+{
+ fsw_u32 key_type;
+ fsw_u64 key_offset;
+
+ if (key->k_dir_id > dir_id)
+ return FIRST_GREATER;
+ if (key->k_dir_id < dir_id)
+ return SECOND_GREATER;
+
+ if (key->k_objectid > objectid)
+ return FIRST_GREATER;
+ if (key->k_objectid < objectid)
+ return SECOND_GREATER;
+
+ // determine format of the on-disk key
+ key_type = (fsw_u32)FSW_U64_SHR(key->u.k_offset_v2.v, 60);
+ if (key_type != TYPE_DIRECT && key_type != TYPE_INDIRECT && key_type != TYPE_DIRENTRY) {
+ // detected 3.5 format (_v1)
+ key_offset = key->u.k_offset_v1.k_offset;
+ } else {
+ // detected 3.6 format (_v2)
+ key_offset = key->u.k_offset_v2.v & (~0ULL >> 4);
+ }
+ if (key_offset > offset)
+ return FIRST_GREATER;
+ if (key_offset < offset)
+ return SECOND_GREATER;
+ return KEYS_IDENTICAL;
+}
+
+/**
+ * Find an item by key in the reiserfs tree.
+ */
+
+static fsw_status_t fsw_reiserfs_item_search(struct fsw_reiserfs_volume *vol,
+ fsw_u32 dir_id, fsw_u32 objectid, fsw_u64 offset,
+ struct fsw_reiserfs_item *item)
+{
+ fsw_status_t status;
+ int comp_result;
+ fsw_u32 tree_bno, next_tree_bno, tree_level, nr_item, i;
+ fsw_u8 *buffer;
+ struct block_head *bhead;
+ struct reiserfs_key *key;
+ struct item_head *ihead;
+
+ FSW_MSG_DEBUG((FSW_MSGSTR("fsw_reiserfs_item_search: searching %d/%d/%lld\n"), dir_id, objectid, offset));
+
+ // BIG TODOS: Use binary search within the item.
+ // Remember tree path for "get next item" function.
+
+ item->valid = 0;
+ item->block_bno = 0;
+
+ // walk the tree
+ tree_bno = vol->sb->s_v1.s_root_block;
+ for (tree_level = vol->sb->s_v1.s_tree_height - 1; ; tree_level--) {
+
+ // get the current tree block into memory
+ status = fsw_block_get(vol, tree_bno, tree_level, (void **)&buffer);
+ if (status)
+ return status;
+ bhead = (struct block_head *)buffer;
+ if (bhead->blk_level != tree_level) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_item_search: tree block %d has not expected level %d\n"), tree_bno, tree_level));
+ fsw_block_release(vol, tree_bno, buffer);
+ return FSW_VOLUME_CORRUPTED;
+ }
+ nr_item = bhead->blk_nr_item;
+ FSW_MSG_DEBUGV((FSW_MSGSTR("fsw_reiserfs_item_search: visiting block %d level %d items %d\n"), tree_bno, tree_level, nr_item));
+ item->path_bno[tree_level] = tree_bno;
+
+ // check if we have reached a leaf block
+ if (tree_level == DISK_LEAF_NODE_LEVEL)
+ break;
+
+ // search internal node block, look for the path to follow
+ key = (struct reiserfs_key *)(buffer + BLKH_SIZE);
+ for (i = 0; i < nr_item; i++, key++) {
+ if (fsw_reiserfs_compare_key(key, dir_id, objectid, offset) == FIRST_GREATER)
+ break;
+ }
+ item->path_index[tree_level] = i;
+ next_tree_bno = ((struct disk_child *)(buffer + BLKH_SIZE + nr_item * KEY_SIZE))[i].dc_block_number;
+ fsw_block_release(vol, tree_bno, buffer);
+ tree_bno = next_tree_bno;
+ }
+
+ // search leaf node block, look for our data
+ ihead = (struct item_head *)(buffer + BLKH_SIZE);
+ for (i = 0; i < nr_item; i++, ihead++) {
+ comp_result = fsw_reiserfs_compare_key(&ihead->ih_key, dir_id, objectid, offset);
+ if (comp_result == KEYS_IDENTICAL)
+ break;
+ if (comp_result == FIRST_GREATER) {
+ // Current key is greater than the search key. Use the last key before this
+ // one as the preliminary result.
+ if (i == 0) {
+ fsw_block_release(vol, tree_bno, buffer);
+ return FSW_NOT_FOUND;
+ }
+ i--, ihead--;
+ break;
+ }
+ }
+ if (i >= nr_item) {
+ // Go back to the last key, it was smaller than the search key.
+ // NOTE: The first key of the next leaf block is guaranteed to be greater than
+ // our search key.
+ i--, ihead--;
+ }
+ item->path_index[tree_level] = i;
+ // Since we may have a key that is smaller than the search key, verify that
+ // it is for the same object.
+ if (ihead->ih_key.k_dir_id != dir_id || ihead->ih_key.k_objectid != objectid) {
+ fsw_block_release(vol, tree_bno, buffer);
+ return FSW_NOT_FOUND; // Found no key for this object at all
+ }
+
+ // return results
+ fsw_memcpy(&item->ih, ihead, sizeof(struct item_head));
+ item->item_type = (fsw_u32)FSW_U64_SHR(ihead->ih_key.u.k_offset_v2.v, 60);
+ if (item->item_type != TYPE_DIRECT &&
+ item->item_type != TYPE_INDIRECT &&
+ item->item_type != TYPE_DIRENTRY) {
+ // 3.5 format (_v1)
+ item->item_type = ihead->ih_key.u.k_offset_v1.k_uniqueness;
+ item->item_offset = ihead->ih_key.u.k_offset_v1.k_offset;
+ } else {
+ // 3.6 format (_v2)
+ item->item_offset = ihead->ih_key.u.k_offset_v2.v & (~0ULL >> 4);
+ }
+ item->item_data = buffer + ihead->ih_item_location;
+ item->valid = 1;
+
+ // add information for block release
+ item->block_bno = tree_bno;
+ item->block_buffer = buffer;
+
+ FSW_MSG_DEBUG((FSW_MSGSTR("fsw_reiserfs_item_search: found %d/%d/%lld (%d)\n"),
+ ihead->ih_key.k_dir_id, ihead->ih_key.k_objectid, item->item_offset, item->item_type));
+ return FSW_SUCCESS;
+}
+
+/**
+ * Find the next item in the reiserfs tree for an already-found item.
+ */
+
+static fsw_status_t fsw_reiserfs_item_next(struct fsw_reiserfs_volume *vol,
+ struct fsw_reiserfs_item *item)
+{
+ fsw_status_t status;
+ fsw_u32 dir_id, objectid;
+ fsw_u64 offset;
+ fsw_u32 tree_bno, next_tree_bno, tree_level, nr_item, nr_ptr_item;
+ fsw_u8 *buffer;
+ struct block_head *bhead;
+ struct item_head *ihead;
+
+ if (!item->valid)
+ return FSW_NOT_FOUND;
+ fsw_reiserfs_item_release(vol, item); // TODO: maybe delay this and/or use the cached block!
+
+ dir_id = item->ih.ih_key.k_dir_id;
+ objectid = item->ih.ih_key.k_objectid;
+ offset = item->item_offset;
+
+ FSW_MSG_DEBUG((FSW_MSGSTR("fsw_reiserfs_item_next: next for %d/%d/%lld\n"), dir_id, objectid, offset));
+
+ // find a node that has more items, moving up until we find one
+
+ for (tree_level = DISK_LEAF_NODE_LEVEL; tree_level < vol->sb->s_v1.s_tree_height; tree_level++) {
+
+ // get the current tree block into memory
+ tree_bno = item->path_bno[tree_level];
+ status = fsw_block_get(vol, tree_bno, tree_level, (void **)&buffer);
+ if (status)
+ return status;
+ bhead = (struct block_head *)buffer;
+ if (bhead->blk_level != tree_level) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_item_next: tree block %d has not expected level %d\n"), tree_bno, tree_level));
+ fsw_block_release(vol, tree_bno, buffer);
+ return FSW_VOLUME_CORRUPTED;
+ }
+ nr_item = bhead->blk_nr_item;
+ FSW_MSG_DEBUGV((FSW_MSGSTR("fsw_reiserfs_item_next: visiting block %d level %d items %d\n"), tree_bno, tree_level, nr_item));
+
+ nr_ptr_item = nr_item + ((tree_level > DISK_LEAF_NODE_LEVEL) ? 1 : 0); // internal nodes have (nr_item) keys and (nr_item+1) pointers
+ item->path_index[tree_level]++;
+ if (item->path_index[tree_level] >= nr_ptr_item) {
+ item->path_index[tree_level] = 0;
+ fsw_block_release(vol, tree_bno, buffer);
+ continue; // this node doesn't have any more items, move up one level
+ }
+
+ // we have a new path to follow, move down to the leaf node again
+ while (tree_level > DISK_LEAF_NODE_LEVEL) {
+ // get next pointer from current block
+ next_tree_bno = ((struct disk_child *)(buffer + BLKH_SIZE + nr_item * KEY_SIZE))[item->path_index[tree_level]].dc_block_number;
+ fsw_block_release(vol, tree_bno, buffer);
+ tree_bno = next_tree_bno;
+ tree_level--;
+
+ // get the current tree block into memory
+ status = fsw_block_get(vol, tree_bno, tree_level, (void **)&buffer);
+ if (status)
+ return status;
+ bhead = (struct block_head *)buffer;
+ if (bhead->blk_level != tree_level) {
+ FSW_MSG_ASSERT((FSW_MSGSTR("fsw_reiserfs_item_next: tree block %d has not expected level %d\n"), tree_bno, tree_level));
+ fsw_block_release(vol, tree_bno, buffer);
+ return FSW_VOLUME_CORRUPTED;
+ }
+ nr_item = bhead->blk_nr_item;
+ FSW_MSG_DEBUGV((FSW_MSGSTR("fsw_reiserfs_item_next: visiting block %d level %d items %d\n"), tree_bno, tree_level, nr_item));
+ item->path_bno[tree_level] = tree_bno;
+ }
+
+ // get the item from the leaf node
+ ihead = ((struct item_head *)(buffer + BLKH_SIZE)) + item->path_index[tree_level];
+
+ // We now have the item that follows the previous one in the tree. Check that it
+ // belongs to the same object.
+ if (ihead->ih_key.k_dir_id != dir_id || ihead->ih_key.k_objectid != objectid) {
+ fsw_block_release(vol, tree_bno, buffer);
+ return FSW_NOT_FOUND; // Found no next key for this object
+ }
+
+ // return results
+ fsw_memcpy(&item->ih, ihead, sizeof(struct item_head));
+ item->item_type = (fsw_u32)FSW_U64_SHR(ihead->ih_key.u.k_offset_v2.v, 60);
+ if (item->item_type != TYPE_DIRECT &&
+ item->item_type != TYPE_INDIRECT &&
+ item->item_type != TYPE_DIRENTRY) {
+ // 3.5 format (_v1)
+ item->item_type = ihead->ih_key.u.k_offset_v1.k_uniqueness;
+ item->item_offset = ihead->ih_key.u.k_offset_v1.k_offset;
+ } else {
+ // 3.6 format (_v2)
+ item->item_offset = ihead->ih_key.u.k_offset_v2.v & (~0ULL >> 4);
+ }
+ item->item_data = buffer + ihead->ih_item_location;
+ item->valid = 1;
+
+ // add information for block release
+ item->block_bno = tree_bno;
+ item->block_buffer = buffer;
+
+ FSW_MSG_DEBUG((FSW_MSGSTR("fsw_reiserfs_item_next: found %d/%d/%lld (%d)\n"),
+ ihead->ih_key.k_dir_id, ihead->ih_key.k_objectid, item->item_offset, item->item_type));
+ return FSW_SUCCESS;
+ }
+
+ // we went to the highest level node and there still were no more items...
+ return FSW_NOT_FOUND;
+}
+
+/**
+ * Release the disk block still referenced by an item search result.
+ */
+
+static void fsw_reiserfs_item_release(struct fsw_reiserfs_volume *vol,
+ struct fsw_reiserfs_item *item)
+{
+ if (!item->valid)
+ return;
+
+ if (item->block_bno > 0) {
+ fsw_block_release(vol, item->block_bno, item->block_buffer);
+ item->block_bno = 0;
+ }
+}
+
+// EOF