LSBLK_TREE = (1 << 4),
};
+enum {
+ SORT_STRING = 0, /* default is to use scols_cell_get_data() */
+ SORT_U64 = 1 /* use private pointer from scols_cell_get_userdata() */
+};
+
/* column names */
struct colinfo {
const char *name; /* header */
double whint; /* width hint (N < 1 is in percent of termwidth) */
int flags; /* SCOLS_FL_* */
const char *help;
+
+ int sort_type; /* SORT_* */
};
/* columns descriptions */
[COL_NAME] = { "NAME", 0.25, SCOLS_FL_TREE | SCOLS_FL_NOEXTREMES, N_("device name") },
[COL_KNAME] = { "KNAME", 0.3, 0, N_("internal kernel device name") },
[COL_PKNAME] = { "PKNAME", 0.3, 0, N_("internal parent kernel device name") },
- [COL_MAJMIN] = { "MAJ:MIN", 6, 0, N_("major:minor device number") },
+ [COL_MAJMIN] = { "MAJ:MIN", 6, 0, N_("major:minor device number"), SORT_U64 },
[COL_FSTYPE] = { "FSTYPE", 0.1, SCOLS_FL_TRUNC, N_("filesystem type") },
[COL_TARGET] = { "MOUNTPOINT", 0.10, SCOLS_FL_TRUNC, N_("where the device is mounted") },
[COL_LABEL] = { "LABEL", 0.1, 0, N_("filesystem LABEL") },
[COL_PARTUUID] = { "PARTUUID", 36, 0, N_("partition UUID") },
[COL_PARTFLAGS] = { "PARTFLAGS", 36, 0, N_("partition flags") },
- [COL_RA] = { "RA", 3, SCOLS_FL_RIGHT, N_("read-ahead of the device") },
+ [COL_RA] = { "RA", 3, SCOLS_FL_RIGHT, N_("read-ahead of the device"), SORT_U64 },
[COL_RO] = { "RO", 1, SCOLS_FL_RIGHT, N_("read-only device") },
[COL_RM] = { "RM", 1, SCOLS_FL_RIGHT, N_("removable device") },
[COL_ROTA] = { "ROTA", 1, SCOLS_FL_RIGHT, N_("rotational device") },
[COL_RAND] = { "RAND", 1, SCOLS_FL_RIGHT, N_("adds randomness") },
[COL_MODEL] = { "MODEL", 0.1, SCOLS_FL_TRUNC, N_("device identifier") },
[COL_SERIAL] = { "SERIAL", 0.1, SCOLS_FL_TRUNC, N_("disk serial number") },
- [COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the device") },
+ [COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the device"), SORT_U64 },
[COL_STATE] = { "STATE", 7, SCOLS_FL_TRUNC, N_("state of the device") },
[COL_OWNER] = { "OWNER", 0.1, SCOLS_FL_TRUNC, N_("user name"), },
[COL_GROUP] = { "GROUP", 0.1, SCOLS_FL_TRUNC, N_("group name") },
[COL_MODE] = { "MODE", 10, 0, N_("device node permissions") },
- [COL_ALIOFF] = { "ALIGNMENT", 6, SCOLS_FL_RIGHT, N_("alignment offset") },
- [COL_MINIO] = { "MIN-IO", 6, SCOLS_FL_RIGHT, N_("minimum I/O size") },
- [COL_OPTIO] = { "OPT-IO", 6, SCOLS_FL_RIGHT, N_("optimal I/O size") },
- [COL_PHYSEC] = { "PHY-SEC", 7, SCOLS_FL_RIGHT, N_("physical sector size") },
- [COL_LOGSEC] = { "LOG-SEC", 7, SCOLS_FL_RIGHT, N_("logical sector size") },
+ [COL_ALIOFF] = { "ALIGNMENT", 6, SCOLS_FL_RIGHT, N_("alignment offset"), SORT_U64 },
+ [COL_MINIO] = { "MIN-IO", 6, SCOLS_FL_RIGHT, N_("minimum I/O size"), SORT_U64 },
+ [COL_OPTIO] = { "OPT-IO", 6, SCOLS_FL_RIGHT, N_("optimal I/O size"), SORT_U64 },
+ [COL_PHYSEC] = { "PHY-SEC", 7, SCOLS_FL_RIGHT, N_("physical sector size"), SORT_U64 },
+ [COL_LOGSEC] = { "LOG-SEC", 7, SCOLS_FL_RIGHT, N_("logical sector size"), SORT_U64 },
[COL_SCHED] = { "SCHED", 0.1, 0, N_("I/O scheduler name") },
- [COL_RQ_SIZE]= { "RQ-SIZE", 5, SCOLS_FL_RIGHT, N_("request queue size") },
+ [COL_RQ_SIZE]= { "RQ-SIZE", 5, SCOLS_FL_RIGHT, N_("request queue size"), SORT_U64 },
[COL_TYPE] = { "TYPE", 4, 0, N_("device type") },
- [COL_DALIGN] = { "DISC-ALN", 6, SCOLS_FL_RIGHT, N_("discard alignment offset") },
- [COL_DGRAN] = { "DISC-GRAN", 6, SCOLS_FL_RIGHT, N_("discard granularity") },
- [COL_DMAX] = { "DISC-MAX", 6, SCOLS_FL_RIGHT, N_("discard max bytes") },
+ [COL_DALIGN] = { "DISC-ALN", 6, SCOLS_FL_RIGHT, N_("discard alignment offset"), SORT_U64 },
+ [COL_DGRAN] = { "DISC-GRAN", 6, SCOLS_FL_RIGHT, N_("discard granularity"), SORT_U64 },
+ [COL_DMAX] = { "DISC-MAX", 6, SCOLS_FL_RIGHT, N_("discard max bytes"), SORT_U64 },
[COL_DZERO] = { "DISC-ZERO", 1, SCOLS_FL_RIGHT, N_("discard zeroes data") },
- [COL_WSAME] = { "WSAME", 6, SCOLS_FL_RIGHT, N_("write same max bytes") },
+ [COL_WSAME] = { "WSAME", 6, SCOLS_FL_RIGHT, N_("write same max bytes"), SORT_U64 },
[COL_WWN] = { "WWN", 18, 0, N_("unique storage identifier") },
[COL_HCTL] = { "HCTL", 10, 0, N_("Host:Channel:Target:Lun for SCSI") },
[COL_TRANSPORT] = { "TRAN", 6, 0, N_("device transport type") },
struct lsblk {
struct libscols_table *table; /* output table */
+ struct libscols_column *sort_col;/* sort output by this colum */
+ int sort_id;
+
unsigned int all_devices:1; /* print all devices, including empty */
unsigned int bytes:1; /* print SIZE in bytes */
unsigned int inverse:1; /* print inverse dependencies */
return -1;
}
+static int column_id_to_number(int id)
+{
+ size_t i;
+
+ for (i = 0; i < (size_t) ncolumns; i++)
+ if (columns[i] == id)
+ return i;
+ return -1;
+}
+
static void reset_blkdev_cxt(struct blkdev_cxt *cxt)
{
if (!cxt)
return p;
}
+/* stores data to scols cell userdata (invisible and independent on output)
+ * to make the original values accessible for sort functions
+ */
+static void set_sortdata_u64(struct libscols_line *ln, int col, uint64_t x)
+{
+ struct libscols_cell *ce = scols_line_get_cell(ln, col);
+ uint64_t *data;
+
+ if (!ce)
+ return;
+ data = xmalloc(sizeof(uint64_t));
+ *data = x;
+ scols_cell_set_userdata(ce, data);
+}
+
+static void set_sortdata_u64_from_string(struct libscols_line *ln, int col, const char *str)
+{
+ uint64_t x;
+
+ if (!str || sscanf(str, "%"SCNu64, &x) != 1)
+ return;
+
+ set_sortdata_u64(ln, col, x);
+}
+
+static void unref_sortdata(struct libscols_table *tb)
+{
+ struct libscols_iter *itr;
+ struct libscols_line *ln;
+
+ if (!tb || !lsblk->sort_col)
+ return;
+ itr = scols_new_iter(SCOLS_ITER_FORWARD);
+ if (!itr)
+ return;
+ while (scols_table_next_line(tb, itr, &ln) == 0) {
+ struct libscols_cell *ce = scols_line_get_column_cell(ln,
+ lsblk->sort_col);
+ void *data = scols_cell_get_userdata(ce);
+ free(data);
+ }
+
+ scols_free_iter(itr);
+}
+
static void set_scols_data(struct blkdev_cxt *cxt, int col, int id, struct libscols_line *ln)
{
- int st_rc = 0;
+ int sort = 0, st_rc = 0;
char *str = NULL;
if (!cxt->st.st_rdev && (id == COL_OWNER || id == COL_GROUP ||
id == COL_MODE))
st_rc = stat(cxt->filename, &cxt->st);
+ if (lsblk->sort_id == id)
+ sort = 1;
+
switch(id) {
case COL_NAME:
str = cxt->dm_name ? mk_dm_name(cxt->dm_name) : mk_name(cxt->name);
xasprintf(&str, "%u:%u", cxt->maj, cxt->min);
else
xasprintf(&str, "%3u:%-3u", cxt->maj, cxt->min);
+ if (sort)
+ set_sortdata_u64(ln, col, makedev(cxt->maj, cxt->min));
break;
case COL_FSTYPE:
probe_device(cxt);
break;
case COL_RA:
str = sysfs_strdup(&cxt->sysfs, "queue/read_ahead_kb");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_RO:
str = xstrdup(is_readonly_device(cxt) ? "1" : "0");
xasprintf(&str, "%jd", cxt->size);
else
str = size_to_human_string(SIZE_SUFFIX_1LETTER, cxt->size);
+ if (sort)
+ set_sortdata_u64(ln, col, cxt->size);
break;
case COL_STATE:
if (!cxt->partition && !cxt->dm_name)
break;
case COL_ALIOFF:
str = sysfs_strdup(&cxt->sysfs, "alignment_offset");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_MINIO:
str = sysfs_strdup(&cxt->sysfs, "queue/minimum_io_size");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_OPTIO:
str = sysfs_strdup(&cxt->sysfs, "queue/optimal_io_size");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_PHYSEC:
str = sysfs_strdup(&cxt->sysfs, "queue/physical_block_size");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_LOGSEC:
str = sysfs_strdup(&cxt->sysfs, "queue/logical_block_size");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_SCHED:
str = get_scheduler(cxt);
break;
case COL_RQ_SIZE:
str = sysfs_strdup(&cxt->sysfs, "queue/nr_requests");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_TYPE:
str = get_type(cxt);
str = sysfs_strdup(&cxt->sysfs, "discard_alignment");
if (!str)
str = xstrdup("0");
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
break;
case COL_DGRAN:
- if (lsblk->bytes)
+ if (lsblk->bytes) {
str = sysfs_strdup(&cxt->sysfs, "queue/discard_granularity");
- else {
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
+ } else {
uint64_t x;
if (sysfs_read_u64(&cxt->sysfs,
- "queue/discard_granularity", &x) == 0)
+ "queue/discard_granularity", &x) == 0) {
str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
+ if (sort)
+ set_sortdata_u64(ln, col, x);
+ }
}
break;
case COL_DMAX:
- if (lsblk->bytes)
+ if (lsblk->bytes) {
str = sysfs_strdup(&cxt->sysfs, "queue/discard_max_bytes");
- else {
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
+ } else {
uint64_t x;
if (sysfs_read_u64(&cxt->sysfs,
- "queue/discard_max_bytes", &x) == 0)
+ "queue/discard_max_bytes", &x) == 0) {
str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
+ if (sort)
+ set_sortdata_u64(ln, col, x);
+ }
}
break;
case COL_DZERO:
str = xstrdup("0");
break;
case COL_WSAME:
- if (lsblk->bytes)
+ if (lsblk->bytes) {
str = sysfs_strdup(&cxt->sysfs, "queue/write_same_max_bytes");
- else {
+ if (sort)
+ set_sortdata_u64_from_string(ln, col, str);
+ } else {
uint64_t x;
if (sysfs_read_u64(&cxt->sysfs,
- "queue/write_same_max_bytes", &x) == 0)
+ "queue/write_same_max_bytes", &x) == 0) {
str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
+ if (sort)
+ set_sortdata_u64(ln, col, x);
+ }
}
if (!str)
str = xstrdup("0");
scols_line_refer_data(ln, col, str);
}
-static void print_device(struct blkdev_cxt *cxt, struct libscols_line *scols_parent)
+static void fill_table_line(struct blkdev_cxt *cxt, struct libscols_line *scols_parent)
{
int i;
goto next;
wholedisk_cxt->parent = &part_cxt;
- print_device(&part_cxt, parent_cxt ? parent_cxt->scols_line : NULL);
+ fill_table_line(&part_cxt, parent_cxt ? parent_cxt->scols_line : NULL);
if (!lsblk->nodeps)
process_blkdev(wholedisk_cxt, &part_cxt, 0, NULL);
} else {
/* Print whole disk only once */
if (r)
- print_device(wholedisk_cxt, parent_cxt ? parent_cxt->scols_line : NULL);
+ fill_table_line(wholedisk_cxt, parent_cxt ? parent_cxt->scols_line : NULL);
if (ps == 0 && !lsblk->nodeps)
process_blkdev(&part_cxt, wholedisk_cxt, 0, NULL);
}
if (do_partitions && cxt->npartitions)
return list_partitions(cxt, parent, part_name);
- print_device(cxt, parent ? parent->scols_line : NULL);
+ fill_table_line(cxt, parent ? parent->scols_line : NULL);
return list_deps(cxt);
}
}
}
+/*
+ * see set_sortdata_u64() and columns initialization in main()
+ */
+static int cmp_u64_cells(struct libscols_cell *a,
+ struct libscols_cell *b,
+ __attribute__((__unused__)) void *data)
+{
+ uint64_t *adata = (uint64_t *) scols_cell_get_userdata(a),
+ *bdata = (uint64_t *) scols_cell_get_userdata(b);
+
+ if (adata == NULL && bdata == NULL)
+ return 0;
+ if (adata == NULL)
+ return -1;
+ if (bdata == NULL)
+ return 1;
+ return *adata == *bdata ? 0 : *adata >= *bdata ? 1 : -1;
+}
+
static void __attribute__((__noreturn__)) help(FILE *out)
{
size_t i;
fputs(_(" -s, --inverse inverse dependencies\n"), out);
fputs(_(" -S, --scsi output info about SCSI devices\n"), out);
fputs(_(" -t, --topology output info about topology\n"), out);
+ fputs(_(" -x, --sort <column> sort output by <colum>\n"), out);
fputs(USAGE_SEPARATOR, out);
fputs(USAGE_HELP, out);
fputs(USAGE_VERSION, out);
int main(int argc, char *argv[])
{
- struct lsblk _ls;
+ struct lsblk _ls = { .sort_id = -1 };
int scols_flags = LSBLK_TREE;
int i, c, status = EXIT_FAILURE;
char *outarg = NULL;
{ "paths", 0, 0, 'p' },
{ "pairs", 0, 0, 'P' },
{ "scsi", 0, 0, 'S' },
+ { "sort", 1, 0, 'x' },
{ "version", 0, 0, 'V' },
{ NULL, 0, 0, 0 },
};
memset(lsblk, 0, sizeof(*lsblk));
while((c = getopt_long(argc, argv,
- "abdDe:fhlnmo:OpPiI:rstVS", longopts, NULL)) != -1) {
+ "abdDe:fhlnmo:OpPiI:rstVSx:", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
+ case 'x':
+ scols_flags &= ~LSBLK_TREE; /* disable the default */
+ lsblk->sort_id = column_name_to_id(optarg, strlen(optarg));
+ if (lsblk->sort_id >= 0)
+ break;
+ /* fallthrough */
default:
help(stderr);
}
if (nexcludes == 0 && nincludes == 0)
excludes[nexcludes++] = 1; /* default: ignore RAM disks */
+ if (lsblk->sort_id >= 0 && column_id_to_number(lsblk->sort_id) < 0)
+ errx(EXIT_FAILURE, _("the sort column has to be between output columns."));
+
mnt_init_debug(0);
/*
for (i = 0; i < ncolumns; i++) {
struct colinfo *ci = get_column_info(i);
- int fl = ci->flags;
+ struct libscols_column *cl;
+ int id = get_column_id(i), fl = ci->flags;
- if (!(scols_flags & LSBLK_TREE) && get_column_id(i) == COL_NAME)
+ if (!(scols_flags & LSBLK_TREE) && id == COL_NAME)
fl &= ~SCOLS_FL_TREE;
- if (!scols_table_new_column(lsblk->table, ci->name, ci->whint, fl)) {
+ cl = scols_table_new_column(lsblk->table, ci->name, ci->whint, fl);
+ if (!cl) {
warn(_("failed to initialize output column"));
goto leave;
}
+ if (!lsblk->sort_col && lsblk->sort_id == id) {
+ lsblk->sort_col = cl;
+ scols_column_set_cmpfunc(cl,
+ ci->sort_type == SORT_STRING ?
+ scols_cmpstr_cells : cmp_u64_cells, NULL);
+ }
}
if (optind == argc)
else while (optind < argc)
status = process_one_device(argv[optind++]);
+ if (lsblk->sort_col)
+ scols_sort_table(lsblk->table, lsblk->sort_col);
+
scols_print_table(lsblk->table);
leave:
+ if (lsblk->sort_col)
+ unref_sortdata(lsblk->table);
+
scols_unref_table(lsblk->table);
mnt_unref_table(mtab);
projects / thirdparty / util-linux.git / commitdiff
