vhaudiquet/u-boot-krane
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fs: btrfs: use fs_ls_generic() and drop custom implementation

Browse Source 
Now that generic callbacks for opendir/readdir/closedir are implemented,
the custom btrfs_ls() implementation is no longer needed, along with the
btrfs_iter_dir() callback iterator.

Use fs_ls_generic() instead.

Signed-off-by: Alexey Charkov <alchark@flipper.net>
Reviewed-by: Qu Wenruo <wqu@suse.com>
This commit is contained in:
Alexey Charkov
2026-07-10 15:55:01 -06:00
committed by Tom Rini
parent 5f064aef5d
commit 31cf3f1778
5 changed files with 4 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fs/btrfs/btrfs.c
-129
View File
@@ -17,107 +17,6 @@
struct btrfs_fs_info *current_fs_info;
static int show_dir(struct btrfs_root *root, struct extent_buffer *eb,
struct btrfs_dir_item *di)
{
struct btrfs_fs_info *fs_info = root->fs_info;
struct btrfs_inode_item ii;
struct btrfs_key key;
static const char* dir_item_str[] = {
[BTRFS_FT_REG_FILE] = " ",
[BTRFS_FT_DIR] = "DIR",
[BTRFS_FT_CHRDEV] = "CHR",
[BTRFS_FT_BLKDEV] = "BLK",
[BTRFS_FT_FIFO] = "FIF",
[BTRFS_FT_SOCK] = "SCK",
[BTRFS_FT_SYMLINK] = "SYM",
};
u8 type = btrfs_dir_type(eb, di);
char namebuf[BTRFS_NAME_LEN];
char *target = NULL;
char filetime[32];
time_t mtime;
int ret = 0;
/* skip XATTRs in directory listing */
if (type == BTRFS_FT_XATTR)
return 0;
btrfs_dir_item_key_to_cpu(eb, di, &key);
if (key.type == BTRFS_ROOT_ITEM_KEY) {
struct btrfs_root *subvol;
/* It's a subvolume, get its mtime from root item */
subvol = btrfs_read_fs_root(fs_info, &key);
if (IS_ERR(subvol)) {
ret = PTR_ERR(subvol);
error("Can't find root %llu", key.objectid);
return ret;
}
mtime = btrfs_stack_timespec_sec(&subvol->root_item.otime);
} else {
struct btrfs_path path;
/* It's regular inode, get its mtime from inode item */
btrfs_init_path(&path);
ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
if (ret > 0)
ret = -ENOENT;
if (ret < 0) {
error("Can't find inode %llu", key.objectid);
btrfs_release_path(&path);
return ret;
}
read_extent_buffer(path.nodes[0], &ii,
btrfs_item_ptr_offset(path.nodes[0], path.slots[0]),
sizeof(ii));
btrfs_release_path(&path);
mtime = btrfs_stack_timespec_sec(&ii.mtime);
}
ctime_r(&mtime, filetime);
if (type == BTRFS_FT_SYMLINK) {
target = malloc(fs_info->sectorsize);
if (!target) {
error("Can't alloc memory for symlink %llu",
key.objectid);
return -ENOMEM;
}
ret = btrfs_readlink(root, key.objectid, target);
if (ret < 0) {
error("Failed to read symlink %llu", key.objectid);
goto out;
}
target[ret] = '\0';
}
if (type < ARRAY_SIZE(dir_item_str) && dir_item_str[type])
printf("<%s> ", dir_item_str[type]);
else
printf("?%3u? ", type);
if (type == BTRFS_FT_CHRDEV || type == BTRFS_FT_BLKDEV) {
ASSERT(key.type == BTRFS_INODE_ITEM_KEY);
printf("%4llu,%5llu ", btrfs_stack_inode_rdev(&ii) >> 20,
btrfs_stack_inode_rdev(&ii) & 0xfffff);
} else {
if (key.type == BTRFS_INODE_ITEM_KEY)
printf("%10llu ", btrfs_stack_inode_size(&ii));
else
printf("%10llu ", 0ULL);
}
read_extent_buffer(eb, namebuf, (unsigned long)(di + 1),
btrfs_dir_name_len(eb, di));
printf("%24.24s %.*s", filetime, btrfs_dir_name_len(eb, di), namebuf);
if (type == BTRFS_FT_SYMLINK)
printf(" -> %s", target ? target : "?");
printf("\n");
out:
free(target);
return ret;
}
int btrfs_probe(struct blk_desc *fs_dev_desc,
struct disk_partition *fs_partition)
{
@@ -133,34 +32,6 @@ int btrfs_probe(struct blk_desc *fs_dev_desc,
return ret;
}
int btrfs_ls(const char *path)
{
struct btrfs_fs_info *fs_info = current_fs_info;
struct btrfs_root *root = fs_info->fs_root;
u64 ino = BTRFS_FIRST_FREE_OBJECTID;
u8 type;
int ret;
ASSERT(fs_info);
ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
path, &root, &ino, &type, 40);
if (ret < 0) {
printf("Cannot lookup path %s\n", path);
return ret;
}
if (type != BTRFS_FT_DIR) {
error("Not a directory: %s", path);
return -ENOENT;
}
ret = btrfs_iter_dir(root, ino, show_dir);
if (ret < 0) {
error("An error occurred while listing directory %s", path);
return ret;
}
return 0;
}
/*
* The fs layer closes and re-probes btrfs between readdir() calls (see
* fs_readdir() in fs/fs.c), freeing and reallocating fs_info, so root cannot
fs/btrfs/ctree.h
-5
View File
@@ -1220,11 +1220,6 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
struct btrfs_path *path, u64 dir,
const char *name, int name_len,
int mod);
typedef int (*btrfs_iter_dir_callback_t)(struct btrfs_root *root,
struct extent_buffer *eb,
struct btrfs_dir_item *di);
int btrfs_iter_dir(struct btrfs_root *root, u64 ino,
btrfs_iter_dir_callback_t callback);
int btrfs_next_dir_entry(struct btrfs_root *root, u64 ino, u64 *offset,
char *namebuf, int namebuf_len, u8 *ftype);
/* inode.c */
fs/btrfs/dir-item.c
+3 -56
View File
@@ -114,65 +114,12 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
return btrfs_match_dir_item_name(root, path, name, name_len);
}
int btrfs_iter_dir(struct btrfs_root *root, u64 ino,
btrfs_iter_dir_callback_t callback)
{
struct btrfs_path path;
struct btrfs_key key;
int ret;
btrfs_init_path(&path);
key.objectid = ino;
key.type = BTRFS_DIR_INDEX_KEY;
key.offset = 0;
ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
if (ret < 0)
return ret;
/* Should not happen */
if (ret == 0) {
ret = -EUCLEAN;
goto out;
}
if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
ret = btrfs_next_leaf(root, &path);
if (ret < 0)
goto out;
if (ret > 0) {
ret = 0;
goto out;
}
}
do {
struct btrfs_dir_item *di;
btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
if (key.objectid != ino || key.type != BTRFS_DIR_INDEX_KEY)
break;
di = btrfs_item_ptr(path.nodes[0], path.slots[0],
struct btrfs_dir_item);
if (verify_dir_item(root, path.nodes[0], di)) {
ret = -EUCLEAN;
goto out;
}
ret = callback(root, path.nodes[0], di);
if (ret < 0)
goto out;
} while (!(ret = btrfs_next_item(root, &path)));
if (ret > 0)
ret = 0;
out:
btrfs_release_path(&path);
return ret;
}
/*
* btrfs_next_dir_entry() - read one directory entry at or after a cursor
*
* Streaming counterpart to btrfs_iter_dir() for the fs-layer readdir, which
* is re-entered once per entry: returns the first real entry whose
* BTRFS_DIR_INDEX_KEY offset is >= *offset and advances *offset past it.
* Iterator for the fs-layer readdir, which is re-entered once per entry:
* returns the first real entry whose BTRFS_DIR_INDEX_KEY offset is
* >= *offset and advances *offset past it.
*
* @root, @ino: directory to read
* @offset: in/out cursor; DIR_INDEX offset to resume from
fs/fs.c
+1 -1
View File
@@ -320,7 +320,7 @@ static struct fstype_info fstypes[] = {
.null_dev_desc_ok = false,
.probe = btrfs_probe,
.close = btrfs_close,
.ls = btrfs_ls,
.ls = fs_ls_generic,
.exists = btrfs_exists,
.size = btrfs_size,
.read = btrfs_read,
include/btrfs.h
-1
View File
@@ -15,7 +15,6 @@ struct fs_dirent;
int btrfs_probe(struct blk_desc *fs_dev_desc,
struct disk_partition *fs_partition);
int btrfs_ls(const char *);
int btrfs_exists(const char *);
int btrfs_size(const char *, loff_t *);
int btrfs_read(const char *, void *, loff_t, loff_t, loff_t *);