btrfs-progs: file: Introduce function to read out file content

Introduce a new function, btrfs_read_file(), to read out data of a file
inode.

This function will iterate through EXTENT_DATA items and handle
inline/prealloc/hole file extents.

Compression is not supported yet.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: David Sterba <dsterba@suse.com>

1 files changed, 168 insertions, 0 deletions

diff --git a/file.c b/file.c
index dd0b04b8..530d34a0 100644
--- a/file.c
+++ b/file.c
@@ -18,6 +18,8 @@
 
 #include <sys/stat.h>
 #include "ctree.h"
+#include "utils.h"
+#include "disk-io.h"
 #include "transaction.h"
 #include "kerncompat.h"
 
@@ -160,3 +162,169 @@ out:
 	btrfs_free_path(path);
 	return ret;
 }
+
+/*
+ * Read out content of one inode.
+ *
+ * @root:  fs/subvolume root containing the inode
+ * @ino:   inode number
+ * @start: offset inside the file, aligned to sectorsize
+ * @len:   length to read, aligned to sectorisize
+ * @dest:  where data will be stored
+ *
+ * NOTE:
+ * 1) compression data is not supported yet
+ * 2) @start and @len must be aligned to sectorsize
+ * 3) data read out is also aligned to sectorsize, not truncated to inode size
+ *
+ * Return < 0 for fatal error during read.
+ * Otherwise return the number of succesfully read data in bytes.
+ */
+int btrfs_read_file_data(struct btrfs_root *root, u64 ino, u64 start, int len,
+			 char *dest)
+{
+	struct btrfs_key key;
+	struct btrfs_path path;
+	struct extent_buffer *leaf;
+	struct btrfs_inode_item *ii;
+	u64 isize;
+	int no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
+	int slot;
+	int read = 0;
+	int ret;
+
+	if (!IS_ALIGNED(start, root->sectorsize) ||
+	    !IS_ALIGNED(len, root->sectorsize)) {
+		warning("@start and @len must be aligned to %u for function %s",
+			root->sectorsize, __func__);
+		return -EINVAL;
+	}
+
+	btrfs_init_path(&path);
+	key.objectid = ino;
+	key.offset = start;
+	key.type = BTRFS_EXTENT_DATA_KEY;
+
+	ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
+	if (ret < 0)
+		goto out;
+
+	if (ret > 0) {
+		ret = btrfs_previous_item(root, &path, ino, BTRFS_EXTENT_DATA_KEY);
+		if (ret > 0) {
+			ret = -ENOENT;
+			goto out;
+		}
+	}
+
+	/*
+	 * Reset @dest to all 0, so we don't need to care about holes in
+	 * no_hole mode, but focus on reading non-hole part.
+	 */
+	memset(dest, 0, len);
+	while (1) {
+		struct btrfs_file_extent_item *fi;
+		u64 extent_start;
+		u64 extent_len;
+		u64 read_start;
+		u64 read_len;
+		u64 read_len_ret;
+		u64 disk_bytenr;
+
+		leaf = path.nodes[0];
+		slot = path.slots[0];
+
+		btrfs_item_key_to_cpu(leaf, &key, slot);
+		if (key.objectid > ino)
+			break;
+		if (key.type != BTRFS_EXTENT_DATA_KEY || key.objectid != ino)
+			goto next;
+
+		extent_start = key.offset;
+		if (extent_start >= start + len)
+			break;
+
+		fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+		if (btrfs_file_extent_compression(leaf, fi) !=
+		    BTRFS_COMPRESS_NONE) {
+			ret = -ENOTTY;
+			break;
+		}
+
+		/* Inline extent, one inode should only one inline extent */
+		if (btrfs_file_extent_type(leaf, fi) ==
+		    BTRFS_FILE_EXTENT_INLINE) {
+			extent_len = btrfs_file_extent_inline_len(leaf, slot,
+								  fi);
+			if (extent_start + extent_len <= start)
+				goto next;
+			read_extent_buffer(leaf, dest,
+				btrfs_file_extent_inline_start(fi), extent_len);
+			read += round_up(extent_len, root->sectorsize);
+			break;
+		}
+
+		extent_len = btrfs_file_extent_num_bytes(leaf, fi);
+		if (extent_start + extent_len <= start)
+			goto next;
+
+		read_start = max(start, extent_start);
+		read_len = min(start + len, extent_start + extent_len) -
+			   read_start;
+
+		/* We have already zeroed @dest, nothing to do */
+		if (btrfs_file_extent_type(leaf, fi) ==
+		    BTRFS_FILE_EXTENT_PREALLOC ||
+		    btrfs_file_extent_disk_num_bytes(leaf, fi) == 0) {
+			read += read_len;
+			goto next;
+		}
+
+		disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi) +
+			      btrfs_file_extent_offset(leaf, fi);
+		read_len_ret = read_len;
+		ret = read_extent_data(root, dest + read_start - start, disk_bytenr,
+				       &read_len_ret, 0);
+		if (ret < 0)
+			break;
+		/* Short read, something went wrong */
+		if (read_len_ret != read_len)
+			return -EIO;
+		read += read_len;
+next:
+		ret = btrfs_next_item(root, &path);
+		if (ret > 0) {
+			ret = 0;
+			break;
+		}
+	}
+
+	/*
+	 * Special trick for no_holes, since for no_holes we don't have good
+	 * method to account skipped and tailling holes, we used
+	 * min(inode size, len) as return value
+	 */
+	if (no_holes) {
+		btrfs_release_path(&path);
+		key.objectid = ino;
+		key.offset = 0;
+		key.type = BTRFS_INODE_ITEM_KEY;
+		ret = btrfs_lookup_inode(NULL, root, &path, &key, 0);
+		if (ret < 0)
+			goto out;
+		if (ret > 0) {
+			ret = -ENOENT;
+			goto out;
+		}
+		ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
+				    struct btrfs_inode_item);
+		isize = round_up(btrfs_inode_size(path.nodes[0], ii),
+				 root->sectorsize);
+		read = min_t(u64, isize - start, len);
+	}
+out:
+	btrfs_release_path(&path);
+	if (!ret)
+		ret = read;
+	return ret;
+}