2012-08-08 08:54:48 +00:00
|
|
|
/*
|
2014-02-25 07:42:29 +00:00
|
|
|
* Copyright (C) 2012 FUJITSU LIMITED. All rights reserved.
|
2012-08-08 08:54:48 +00:00
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* 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 021110-1307, USA.
|
|
|
|
|
*/
|
|
|
|
|
|
2015-01-21 16:49:26 +00:00
|
|
|
#ifndef __BTRFS_LIST_H__
|
|
|
|
|
#define __BTRFS_LIST_H__
|
|
|
|
|
|
2013-01-07 22:24:35 +00:00
|
|
|
#if BTRFS_FLAT_INCLUDES
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
#include "kerncompat.h"
|
2019-06-20 13:30:57 +00:00
|
|
|
#include "kernel-lib/rbtree.h"
|
2015-06-10 00:21:42 +00:00
|
|
|
#include "ioctl.h"
|
2013-01-07 22:24:35 +00:00
|
|
|
#else
|
|
|
|
|
#include <btrfs/kerncompat.h>
|
2015-06-10 00:21:42 +00:00
|
|
|
#include <btrfs/rbtree.h>
|
|
|
|
|
#include <btrfs/ioctl.h>
|
2013-01-07 22:24:35 +00:00
|
|
|
#endif /* BTRFS_FLAT_INCLUDES */
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
|
2015-06-10 00:21:42 +00:00
|
|
|
#include <time.h>
|
|
|
|
|
|
2016-10-31 10:11:50 +00:00
|
|
|
enum btrfs_list_layout {
|
|
|
|
|
BTRFS_LIST_LAYOUT_DEFAULT = 0,
|
|
|
|
|
BTRFS_LIST_LAYOUT_TABLE,
|
|
|
|
|
BTRFS_LIST_LAYOUT_RAW
|
|
|
|
|
};
|
2013-02-01 07:56:26 +00:00
|
|
|
|
2013-02-01 07:56:22 +00:00
|
|
|
/*
|
|
|
|
|
* one of these for each root we find.
|
|
|
|
|
*/
|
|
|
|
|
struct root_info {
|
|
|
|
|
struct rb_node rb_node;
|
|
|
|
|
struct rb_node sort_node;
|
|
|
|
|
|
|
|
|
|
/* this root's id */
|
|
|
|
|
u64 root_id;
|
|
|
|
|
|
|
|
|
|
/* equal the offset of the root's key */
|
|
|
|
|
u64 root_offset;
|
|
|
|
|
|
|
|
|
|
/* flags of the root */
|
|
|
|
|
u64 flags;
|
|
|
|
|
|
|
|
|
|
/* the id of the root that references this one */
|
|
|
|
|
u64 ref_tree;
|
|
|
|
|
|
|
|
|
|
/* the dir id we're in from ref_tree */
|
|
|
|
|
u64 dir_id;
|
|
|
|
|
|
|
|
|
|
u64 top_id;
|
|
|
|
|
|
|
|
|
|
/* generation when the root is created or last updated */
|
|
|
|
|
u64 gen;
|
|
|
|
|
|
|
|
|
|
/* creation generation of this root in sec*/
|
|
|
|
|
u64 ogen;
|
|
|
|
|
|
|
|
|
|
/* creation time of this root in sec*/
|
|
|
|
|
time_t otime;
|
|
|
|
|
|
|
|
|
|
u8 uuid[BTRFS_UUID_SIZE];
|
|
|
|
|
u8 puuid[BTRFS_UUID_SIZE];
|
2014-08-13 21:18:17 +00:00
|
|
|
u8 ruuid[BTRFS_UUID_SIZE];
|
2013-02-01 07:56:22 +00:00
|
|
|
|
|
|
|
|
/* path from the subvol we live in to this root, including the
|
|
|
|
|
* root's name. This is null until we do the extra lookup ioctl.
|
|
|
|
|
*/
|
|
|
|
|
char *path;
|
|
|
|
|
|
|
|
|
|
/* the name of this root in the directory it lives in */
|
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
|
|
char *full_path;
|
2013-10-23 17:00:09 +00:00
|
|
|
|
|
|
|
|
int deleted;
|
2013-02-01 07:56:22 +00:00
|
|
|
};
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
|
|
|
|
|
typedef int (*btrfs_list_filter_func)(struct root_info *, u64);
|
|
|
|
|
typedef int (*btrfs_list_comp_func)(struct root_info *, struct root_info *,
|
|
|
|
|
int);
|
|
|
|
|
|
|
|
|
|
struct btrfs_list_filter {
|
|
|
|
|
btrfs_list_filter_func filter_func;
|
|
|
|
|
u64 data;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct btrfs_list_comparer {
|
|
|
|
|
btrfs_list_comp_func comp_func;
|
|
|
|
|
int is_descending;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct btrfs_list_filter_set {
|
|
|
|
|
int total;
|
|
|
|
|
int nfilters;
|
2013-10-23 17:00:09 +00:00
|
|
|
int only_deleted;
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
struct btrfs_list_filter filters[0];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct btrfs_list_comparer_set {
|
|
|
|
|
int total;
|
|
|
|
|
int ncomps;
|
|
|
|
|
struct btrfs_list_comparer comps[0];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum btrfs_list_column_enum {
|
|
|
|
|
BTRFS_LIST_OBJECTID,
|
|
|
|
|
BTRFS_LIST_GENERATION,
|
|
|
|
|
BTRFS_LIST_OGENERATION,
|
|
|
|
|
BTRFS_LIST_PARENT,
|
|
|
|
|
BTRFS_LIST_TOP_LEVEL,
|
|
|
|
|
BTRFS_LIST_OTIME,
|
2013-02-01 07:56:21 +00:00
|
|
|
BTRFS_LIST_PUUID,
|
2014-08-13 21:18:17 +00:00
|
|
|
BTRFS_LIST_RUUID,
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
BTRFS_LIST_UUID,
|
|
|
|
|
BTRFS_LIST_PATH,
|
|
|
|
|
BTRFS_LIST_ALL,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum btrfs_list_filter_enum {
|
|
|
|
|
BTRFS_LIST_FILTER_ROOTID,
|
|
|
|
|
BTRFS_LIST_FILTER_SNAPSHOT_ONLY,
|
2012-09-18 09:14:37 +00:00
|
|
|
BTRFS_LIST_FILTER_FLAGS,
|
Btrfs-progs: introduce -g -c --sort options into btrfs subvol list command
This patch introduces '-g' '-c' '--sort' options
The option '-g' can help you filter the subvolumes by the generation, you may
use it just like:
btrfs subvol list -g +/-value <path>
'+' means the generation of the subvolumes should >= the value you specified.
'-' means the generation should <= the value
If you don't input either '+' nor '-', this command will list the subvolumes
that their generation equals to the value.
However if you want to find gengeration between value1 and value2
you may use the above like:
btrfs sub list -g -value1 -g +value2 <path>
The option '-c' can help you filter the subvolumes by the ogeneration, you may
use it just like:
btrfs subvol list -c +/-value <path>
The usage is the same to '-g'
You might want to list subvolumes in order of some items, such as root id, gen
and so on, you can use '--sort'. Now you can sort the subvolumes by root id,
gen, ogen and path.
For example:
If you want to list subvolumes in order of rootid, you can use the option like
that:
btrfs sub list --sort=+/-rooid <path>
Here, '+' means the result is sorted by ascending order. '-' is by descending
order. If you don't specify either '+' nor '-', the result is sorted by
default - ascending order.
If you want to combine sort items, you do it like that:
btrfs sub list --sort=-rootid,+path,ogen,gen <path>
Signed-off-by: Wang Shilong <wangsl-fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-19 09:21:51 +00:00
|
|
|
BTRFS_LIST_FILTER_GEN,
|
|
|
|
|
BTRFS_LIST_FILTER_GEN_EQUAL = BTRFS_LIST_FILTER_GEN,
|
|
|
|
|
BTRFS_LIST_FILTER_GEN_LESS,
|
|
|
|
|
BTRFS_LIST_FILTER_GEN_MORE,
|
|
|
|
|
BTRFS_LIST_FILTER_CGEN,
|
|
|
|
|
BTRFS_LIST_FILTER_CGEN_EQUAL = BTRFS_LIST_FILTER_CGEN,
|
|
|
|
|
BTRFS_LIST_FILTER_CGEN_LESS,
|
|
|
|
|
BTRFS_LIST_FILTER_CGEN_MORE,
|
2012-09-27 17:04:20 +00:00
|
|
|
BTRFS_LIST_FILTER_TOPID_EQUAL,
|
2012-12-11 14:24:58 +00:00
|
|
|
BTRFS_LIST_FILTER_FULL_PATH,
|
2013-02-01 07:56:24 +00:00
|
|
|
BTRFS_LIST_FILTER_BY_PARENT,
|
2013-10-23 17:00:09 +00:00
|
|
|
BTRFS_LIST_FILTER_DELETED,
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
BTRFS_LIST_FILTER_MAX,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum btrfs_list_comp_enum {
|
|
|
|
|
BTRFS_LIST_COMP_ROOTID,
|
|
|
|
|
BTRFS_LIST_COMP_OGEN,
|
|
|
|
|
BTRFS_LIST_COMP_GEN,
|
Btrfs-progs: introduce -g -c --sort options into btrfs subvol list command
This patch introduces '-g' '-c' '--sort' options
The option '-g' can help you filter the subvolumes by the generation, you may
use it just like:
btrfs subvol list -g +/-value <path>
'+' means the generation of the subvolumes should >= the value you specified.
'-' means the generation should <= the value
If you don't input either '+' nor '-', this command will list the subvolumes
that their generation equals to the value.
However if you want to find gengeration between value1 and value2
you may use the above like:
btrfs sub list -g -value1 -g +value2 <path>
The option '-c' can help you filter the subvolumes by the ogeneration, you may
use it just like:
btrfs subvol list -c +/-value <path>
The usage is the same to '-g'
You might want to list subvolumes in order of some items, such as root id, gen
and so on, you can use '--sort'. Now you can sort the subvolumes by root id,
gen, ogen and path.
For example:
If you want to list subvolumes in order of rootid, you can use the option like
that:
btrfs sub list --sort=+/-rooid <path>
Here, '+' means the result is sorted by ascending order. '-' is by descending
order. If you don't specify either '+' nor '-', the result is sorted by
default - ascending order.
If you want to combine sort items, you do it like that:
btrfs sub list --sort=-rootid,+path,ogen,gen <path>
Signed-off-by: Wang Shilong <wangsl-fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-19 09:21:51 +00:00
|
|
|
BTRFS_LIST_COMP_PATH,
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
BTRFS_LIST_COMP_MAX,
|
|
|
|
|
};
|
|
|
|
|
|
Btrfs-progs: introduce -g -c --sort options into btrfs subvol list command
This patch introduces '-g' '-c' '--sort' options
The option '-g' can help you filter the subvolumes by the generation, you may
use it just like:
btrfs subvol list -g +/-value <path>
'+' means the generation of the subvolumes should >= the value you specified.
'-' means the generation should <= the value
If you don't input either '+' nor '-', this command will list the subvolumes
that their generation equals to the value.
However if you want to find gengeration between value1 and value2
you may use the above like:
btrfs sub list -g -value1 -g +value2 <path>
The option '-c' can help you filter the subvolumes by the ogeneration, you may
use it just like:
btrfs subvol list -c +/-value <path>
The usage is the same to '-g'
You might want to list subvolumes in order of some items, such as root id, gen
and so on, you can use '--sort'. Now you can sort the subvolumes by root id,
gen, ogen and path.
For example:
If you want to list subvolumes in order of rootid, you can use the option like
that:
btrfs sub list --sort=+/-rooid <path>
Here, '+' means the result is sorted by ascending order. '-' is by descending
order. If you don't specify either '+' nor '-', the result is sorted by
default - ascending order.
If you want to combine sort items, you do it like that:
btrfs sub list --sort=-rootid,+path,ogen,gen <path>
Signed-off-by: Wang Shilong <wangsl-fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-19 09:21:51 +00:00
|
|
|
int btrfs_list_parse_sort_string(char *optarg,
|
|
|
|
|
struct btrfs_list_comparer_set **comps);
|
|
|
|
|
int btrfs_list_parse_filter_string(char *optarg,
|
|
|
|
|
struct btrfs_list_filter_set **filters,
|
|
|
|
|
enum btrfs_list_filter_enum type);
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
void btrfs_list_setup_print_column(enum btrfs_list_column_enum column);
|
|
|
|
|
struct btrfs_list_filter_set *btrfs_list_alloc_filter_set(void);
|
2016-10-31 10:51:54 +00:00
|
|
|
void btrfs_list_setup_filter(struct btrfs_list_filter_set **filter_set,
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
enum btrfs_list_filter_enum filter, u64 data);
|
|
|
|
|
struct btrfs_list_comparer_set *btrfs_list_alloc_comparer_set(void);
|
|
|
|
|
|
2013-02-01 07:56:20 +00:00
|
|
|
int btrfs_list_subvols_print(int fd, struct btrfs_list_filter_set *filter_set,
|
2012-09-20 11:04:22 +00:00
|
|
|
struct btrfs_list_comparer_set *comp_set,
|
2018-11-26 17:16:28 +00:00
|
|
|
enum btrfs_list_layout layout, int full_path,
|
2016-10-31 10:11:50 +00:00
|
|
|
const char *raw_prefix);
|
Btrfs-progs: restructure list_subvolumes
The current code of list_subvols() has very bad scalability, if we want to
add new filter conditions or new sort methods, we have to modify lots of code.
Beside that, the most code of list_snapshots() is similar to list_subvols(),
So I restructure list_subvols(), and split the subvolume filter function,
the subvolume sort function and the output function from list_subvols().
In order to implement it, we defined some importtant structures:
struct btrfs_list_filter {
btrfs_list_filter_func filter_func;
void *data;
};
struct btrfs_list_comparer {
btrfs_list_comp_func comp_func;
int is_descending;
};
struct {
char *name;
char *column_name;
int need_print;
} btrfs_list_columns[];
If we want to add a new filter condition, we can choose a suitable filter
function, or implement a new filter function[1], and add it into a set of
the filters, and then pass the filter set into list_subvols(). We also can
mix several filters (just add those filters into the set, and pass the set
into list_subvols()) if the users specify two or more filter conditions.
The subvolume sort function is similar to the subvolume filter function. The
differentiation is the order of comparers in the array which is passed into
list_subvols() show us the priority of the sort methods.
The output function is different with the above two functions, we define a
array to manage all the columns that can be outputed, and use a member variant
(->need_print) to control the output of the relative column. Some columns are
outputed by default. But we can change it according to the requirement of the
users.
After appling this patch, we needn't implement a independent list_snapshots()
function, just pass a filter function which is used to identify the snapshot
into list_subvols().
[1]: If we implement new filter functions or compare functions, we must add
them into the array all_filter_funcs or the array all_comp_funcs, and modify
the relative enum variants(btrfs_list_filter_enum, btrfs_list_comp_enum).
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-09-18 06:51:49 +00:00
|
|
|
int btrfs_list_find_updated_files(int fd, u64 root_id, u64 oldest_gen);
|
|
|
|
|
int btrfs_list_get_default_subvolume(int fd, u64 *default_id);
|
|
|
|
|
char *btrfs_list_path_for_root(int fd, u64 root);
|
2013-02-25 22:54:37 +00:00
|
|
|
int btrfs_list_get_path_rootid(int fd, u64 *treeid);
|
2013-02-01 07:56:23 +00:00
|
|
|
int btrfs_get_subvol(int fd, struct root_info *the_ri);
|
2016-10-31 12:56:28 +00:00
|
|
|
int btrfs_get_toplevel_subvol(int fd, struct root_info *the_ri);
|
2015-01-21 16:49:26 +00:00
|
|
|
|
|
|
|
|
#endif
|
