[COL_SCHED] = { "SCHED", 0.1, 0, N_("I/O scheduler name") },
[COL_SERIAL] = { "SERIAL", 0.1, SCOLS_FL_TRUNC, N_("disk serial number") },
[COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the device"), COLTYPE_SIZE },
- [COL_START] = { "START", 5, SCOLS_FL_RIGHT, N_("partition start offset"), COLTYPE_NUM },
+ [COL_START] = { "START", 5, SCOLS_FL_RIGHT, N_("partition start offset (in 512-byte sectors)"), COLTYPE_NUM },
[COL_STATE] = { "STATE", 7, SCOLS_FL_TRUNC, N_("state of the device") },
[COL_SUBSYS] = { "SUBSYSTEMS", 0.1, SCOLS_FL_NOEXTREMES, N_("de-duplicated chain of subsystems") },
[COL_TARGETS] = { "MOUNTPOINTS", 0.10, SCOLS_FL_WRAP | SCOLS_FL_NOEXTREMES, N_("all locations where device is mounted") },
{
size_t i;
+ /* name as diplayed for users */
for (i = 0; i < ARRAY_SIZE(infos); i++) {
const char *cn = infos[i].name;
if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
return i;
}
+
+ /* name as used in expressions, JSON output etc. */
+ if (strnchr(name, namesz, '_')) {
+ char *buf = NULL;
+ size_t bufsz = 0;
+
+ for (i = 0; i < ARRAY_SIZE(infos); i++) {
+ if (scols_shellvar_name(infos[i].name, &buf, &bufsz) != 0)
+ continue;
+ if (!strncasecmp(name, buf, namesz) && !*(buf + namesz)) {
+ free(buf);
+ return i;
+ }
+ }
+ free(buf);
+ }
+
warnx(_("unknown column: %s"), name);
return -1;
}
/* 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)
+static void set_rawdata_u64(struct libscols_line *ln, int col, uint64_t x)
{
struct libscols_cell *ce = scols_line_get_cell(ln, col);
uint64_t *data;
*data = num;
}
-static void unref_sortdata(struct libscols_table *tb)
+static void unref_line_rawdata(struct libscols_line *ln, struct libscols_table *tb)
+{
+ size_t i;
+
+ for (i = 0; i < ncolumns; i++) {
+ struct libscols_column *cl = scols_table_get_column(tb, i);
+ struct libscols_cell *ce;
+ void *data;
+
+ if (cl != lsblk->sort_col && !scols_column_has_data_func(cl))
+ continue;
+
+ ce = scols_line_get_column_cell(ln, cl);
+ data = scols_cell_get_userdata(ce);
+ free(data);
+ }
+}
+
+static void unref_table_rawdata(struct libscols_table *tb)
{
struct libscols_iter *itr;
struct libscols_line *ln;
- if (!tb || !lsblk->sort_col)
+ if (!tb || !lsblk->rawdata)
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);
- }
+ while (scols_table_next_line(tb, itr, &ln) == 0)
+ unref_line_rawdata(ln, tb);
scols_free_iter(itr);
}
}
static void device_read_bytes(struct lsblk_device *dev, char *path, char **str,
- uint64_t *sortdata)
+ uint64_t *rawdata)
{
uint64_t x;
if (lsblk->bytes) {
ul_path_read_string(dev->sysfs, str, path);
- if (sortdata)
- str2u64(*str, sortdata);
+ if (rawdata)
+ str2u64(*str, rawdata);
return;
}
if (ul_path_read_u64(dev->sysfs, &x, path) == 0) {
*str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
- if (sortdata)
- *sortdata = x;
+ if (rawdata)
+ *rawdata = x;
}
}
}
/*
- * Generates data (string) for column specified by column ID for specified device. If sortdata
+ * Generates data (string) for column specified by column ID for specified device. If rawdata
* is not NULL then returns number usable to sort the column if the data are available for the
* column.
*/
struct lsblk_device *dev, /* device */
struct lsblk_device *parent, /* device parent as defined in the tree */
int id, /* column ID (COL_*) */
- uint64_t *sortdata, /* returns sort data as number */
+ uint64_t *rawdata, /* returns sort data as number */
size_t *datasiz)
{
struct lsblk_devprop *prop = NULL;
xasprintf(&str, "%u:%u", dev->maj, dev->min);
else
xasprintf(&str, "%3u:%-3u", dev->maj, dev->min);
- if (sortdata)
- *sortdata = makedev(dev->maj, dev->min);
+ if (rawdata)
+ *rawdata = makedev(dev->maj, dev->min);
break;
case COL_MAJ:
xasprintf(&str, "%u", dev->maj);
- if (sortdata)
- *sortdata = dev->maj;
+ if (rawdata)
+ *rawdata = dev->maj;
break;
case COL_MIN:
xasprintf(&str, "%u", dev->min);
- if (sortdata)
- *sortdata = dev->min;
+ if (rawdata)
+ *rawdata = dev->min;
break;
case COL_FSTYPE:
prop = lsblk_device_get_properties(dev);
break;
case COL_RA:
ul_path_read_string(dev->sysfs, &str, "queue/read_ahead_kb");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_RO:
str = xstrdup(is_readonly_device(dev) ? "1" : "0");
xasprintf(&str, "%ju", dev->size);
else
str = size_to_human_string(SIZE_SUFFIX_1LETTER, dev->size);
- if (sortdata)
- *sortdata = dev->size;
+ if (rawdata)
+ *rawdata = dev->size;
break;
case COL_START:
ul_path_read_string(dev->sysfs, &str, "start");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_STATE:
if (!device_is_partition(dev) && !dev->dm_name)
break;
case COL_ALIOFF:
ul_path_read_string(dev->sysfs, &str, "alignment_offset");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_MINIO:
ul_path_read_string(dev->sysfs, &str, "queue/minimum_io_size");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_OPTIO:
ul_path_read_string(dev->sysfs, &str, "queue/optimal_io_size");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_PHYSEC:
ul_path_read_string(dev->sysfs, &str, "queue/physical_block_size");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_LOGSEC:
ul_path_read_string(dev->sysfs, &str, "queue/logical_block_size");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_SCHED:
str = get_scheduler(dev);
break;
case COL_RQ_SIZE:
ul_path_read_string(dev->sysfs, &str, "queue/nr_requests");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_TYPE:
str = get_type(dev);
ul_path_read_string(dev->sysfs, &str, "discard_alignment");
if (!str)
str = xstrdup("0");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_DGRAN:
if (lsblk->bytes) {
ul_path_read_string(dev->sysfs, &str, "queue/discard_granularity");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
} else {
uint64_t x = device_get_discard_granularity(dev);
str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
- if (sortdata)
- *sortdata = x;
+ if (rawdata)
+ *rawdata = x;
}
break;
case COL_DMAX:
- device_read_bytes(dev, "queue/discard_max_bytes", &str, sortdata);
+ device_read_bytes(dev, "queue/discard_max_bytes", &str, rawdata);
break;
case COL_DZERO:
if (device_get_discard_granularity(dev) > 0)
str = xstrdup("0");
break;
case COL_WSAME:
- device_read_bytes(dev, "queue/write_same_max_bytes", &str, sortdata);
+ device_read_bytes(dev, "queue/write_same_max_bytes", &str, rawdata);
if (!str)
str = xstrdup("0");
break;
xasprintf(&str, "%ju", x);
else
str = size_to_human_string(SIZE_SUFFIX_1LETTER, x);
- if (sortdata)
- *sortdata = x;
+ if (rawdata)
+ *rawdata = x;
}
break;
}
case COL_ZONE_WGRAN:
- device_read_bytes(dev, "queue/zone_write_granularity", &str, sortdata);
+ device_read_bytes(dev, "queue/zone_write_granularity", &str, rawdata);
break;
case COL_ZONE_APP:
- device_read_bytes(dev, "queue/zone_append_max_bytes", &str, sortdata);
+ device_read_bytes(dev, "queue/zone_append_max_bytes", &str, rawdata);
break;
case COL_ZONE_NR:
ul_path_read_string(dev->sysfs, &str, "queue/nr_zones");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_ZONE_OMAX:
ul_path_read_string(dev->sysfs, &str, "queue/max_open_zones");
if (!str)
str = xstrdup("0");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_ZONE_AMAX:
ul_path_read_string(dev->sysfs, &str, "queue/max_active_zones");
if (!str)
str = xstrdup("0");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
case COL_DAX:
ul_path_read_string(dev->sysfs, &str, "queue/dax");
break;
case COL_DISKSEQ:
ul_path_read_string(dev->sysfs, &str, "diskseq");
- if (sortdata)
- str2u64(str, sortdata);
+ if (rawdata)
+ str2u64(str, rawdata);
break;
};
size_t colnum)
{
struct libscols_cell *ce;
+ struct libscols_column *cl = scols_table_get_column(lsblk->table, colnum);
char *data;
size_t datasiz = 0;
int rc, id = get_column_id(colnum);
- if (lsblk->sort_id != id)
- data = device_get_data(dev, parent, id, NULL, &datasiz);
- else {
- uint64_t sortdata = (uint64_t) -1;
+ if (lsblk->sort_id == id || scols_column_has_data_func(cl)) {
+ uint64_t rawdata = (uint64_t) -1;
- data = device_get_data(dev, parent, id, &sortdata, &datasiz);
- if (data && sortdata != (uint64_t) -1)
- set_sortdata_u64(ln, colnum, sortdata);
- }
+ data = device_get_data(dev, parent, id, &rawdata, &datasiz);
+ if (data && rawdata != (uint64_t) -1)
+ set_rawdata_u64(ln, colnum, rawdata);
+ } else
+ data = device_get_data(dev, parent, id, NULL, &datasiz);
if (!data)
return;
struct libscols_line *ln;
struct lsblk_iter itr;
struct lsblk_device *child = NULL;
- int link_group = 0;
+ int link_group = 0, nocount = 0;
DBG(DEV, ul_debugobj(dev, "add '%s' to scols", dev->name));
if (x)
scols_line_remove_child(x, ln);
+ unref_line_rawdata(ln, tab);
scols_table_remove_line(tab, ln);
ln = NULL;
}
scols_line_link_group(ln, gr, 0);
}
+ /* The same device could be printed more than once, don't use it in counter */
+ if (dev->scols_line)
+ nocount = 1;
+
dev->scols_line = ln;
if (dev->npartitions == 0)
DBG(DEV, ul_debugobj(dev, "%s <- child done", dev->name));
}
- if (lsblk->hlighter) {
+ /* apply highligther */
+ if (ln && lsblk->hlighter) {
int status = 0;
if (scols_line_apply_filter(ln, lsblk->hlighter, &status) == 0
scols_line_set_color(ln, lsblk->hlighter_seq);
}
+ /* apply counters */
+ if (!nocount) {
+ for (i = 0; ln && i < lsblk->ncts; i++)
+ scols_line_apply_filter(ln, lsblk->ct_filters[i], NULL);
+ }
+
/* Let's be careful with number of open files */
ul_path_close_dirfd(dev->sysfs);
}
}
/*
- * see set_sortdata_u64() and columns initialization in main()
+ * see set_rawdata_u64() and columns initialization in main()
*/
static int cmp_u64_cells(struct libscols_cell *a,
struct libscols_cell *b,
return *adata == *bdata ? 0 : *adata >= *bdata ? 1 : -1;
}
+static void *get_u64_cell(const struct libscols_column *cl __attribute__((__unused__)),
+ struct libscols_cell *ce,
+ void *data __attribute__((__unused__)))
+{
+ return scols_cell_get_userdata(ce);
+}
+
static void device_set_dedupkey(
struct lsblk_device *dev,
struct lsblk_device *parent,
f = scols_new_filter(NULL);
if (!f)
err(EXIT_FAILURE, _("failed to allocate filter"));
- if (scols_filter_parse_string(f, query) != 0)
+ if (query && scols_filter_parse_string(f, query) != 0)
errx(EXIT_FAILURE, _("failed to parse \"%s\": %s"), query,
scols_filter_get_errmsg(f));
return f;
}
+static struct libscols_filter *new_counter_filter(const char *query)
+{
+ lsblk->ct_filters = xreallocarray(lsblk->ct_filters, lsblk->ncts + 1,
+ sizeof(struct libscols_filter *));
+
+ lsblk->ct_filters[lsblk->ncts] = new_filter(query);
+ lsblk->ncts++;
+
+ return lsblk->ct_filters[lsblk->ncts - 1];
+}
+
+static void set_counter_properties(const char *str0)
+{
+ struct libscols_filter *fltr = NULL;
+ struct libscols_counter *ct;
+ char *p, *str = xstrdup(str0);
+ char *name = NULL, *param = NULL, *func = NULL;
+
+ for (p = strtok(str, ":"); p != NULL; p = strtok((char *)0, ":")) {
+ if (!name)
+ name = p;
+ else if (!param)
+ param = p;
+ else if (!func)
+ func = p;
+ else
+ errx(EXIT_FAILURE, _("unexpected counter specification: %s"), str0);
+ }
+
+ if (!name)
+ errx(EXIT_FAILURE, _("counter not properly specified"));
+
+ /* use the latest counter filter (--ct-filter) or create empty */
+ if (lsblk->ncts)
+ fltr = lsblk->ct_filters[lsblk->ncts - 1];
+ else
+ fltr = new_counter_filter(NULL);
+
+ ct = scols_filter_new_counter(fltr);
+ if (!ct)
+ err(EXIT_FAILURE, _("failed to allocate counter"));
+
+ scols_counter_set_name(ct, name);
+ if (param)
+ scols_counter_set_param(ct, param);
+ if (func) {
+ int x;
+
+ if (strcmp(func, "max") == 0)
+ x = SCOLS_COUNTER_MAX;
+ else if (strcmp(func, "min") == 0)
+ x = SCOLS_COUNTER_MIN;
+ else if (strcmp(func, "sum") == 0)
+ x = SCOLS_COUNTER_SUM;
+ else if (strcmp(func, "count") == 0)
+ x = SCOLS_COUNTER_COUNT;
+ else
+ errx(EXIT_FAILURE, _("unsupported counter type: %s"), func);
+
+ scols_counter_set_func(ct, x);
+ }
+ free(str);
+}
+
+static void print_counters(void)
+{
+ struct libscols_iter *itr;
+ size_t i;
+
+ fputc('\n', stdout);
+ fputs(_("Summary:\n"), stdout);
+
+ itr = scols_new_iter(SCOLS_ITER_FORWARD);
+ if (!itr)
+ err(EXIT_FAILURE, _("failed to allocate iterator"));
+
+ for (i = 0; i < lsblk->ncts; i++) {
+ struct libscols_filter *fltr = lsblk->ct_filters[i];
+ struct libscols_counter *ct = NULL;
+
+ scols_reset_iter(itr, SCOLS_ITER_FORWARD);
+ while (scols_filter_next_counter(fltr, itr, &ct) == 0) {
+ printf("%16llu %s\n",
+ scols_counter_get_result(ct),
+ scols_counter_get_name(ct));
+ }
+ }
+
+ scols_free_iter(itr);
+}
+
+static void set_column_type(const struct colinfo *ci, struct libscols_column *cl, int fl)
+{
+ switch (ci->type) {
+ case COLTYPE_SIZE:
+ /* See init_scols_filter(), it may overwrite the type */
+ if (!lsblk->bytes)
+ break;
+ /* fallthrough */
+ case COLTYPE_NUM:
+ scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
+ scols_column_set_data_type(cl, SCOLS_DATA_U64);
+ return;
+ case COLTYPE_BOOL:
+ scols_column_set_json_type(cl, SCOLS_JSON_BOOLEAN);
+ scols_column_set_data_type(cl, SCOLS_DATA_BOOLEAN);
+ return;
+ default:
+ break;
+ }
+
+ /* default */
+ if (fl & SCOLS_FL_WRAP)
+ scols_column_set_json_type(cl, SCOLS_JSON_ARRAY_STRING);
+ else
+ scols_column_set_json_type(cl, SCOLS_JSON_STRING);
+
+ scols_column_set_data_type(cl, SCOLS_DATA_STRING);
+}
+
static void init_scols_filter(struct libscols_table *tb, struct libscols_filter *f)
{
struct libscols_iter *itr;
const char *name = NULL;
+ int nerrs = 0;
itr = scols_new_iter(SCOLS_ITER_FORWARD);
if (!itr)
while (scols_filter_next_holder(f, itr, &name, 0) == 0) {
struct libscols_column *col = scols_table_get_column_by_name(tb, name);
+ int id = column_name_to_id(name, strlen(name));
+ const struct colinfo *ci = id >= 0 ? &infos[id] : NULL;
+ if (!ci) {
+ nerrs++;
+ continue; /* report all unknown columns */
+ }
if (!col) {
- int id = column_name_to_id(name, strlen(name));
- const struct colinfo *ci = id >= 0 ? &infos[id] : NULL;
-
- if (!ci)
- goto fail;
add_column(id);
col = scols_table_new_column(lsblk->table, ci->name,
ci->whint, SCOLS_FL_HIDDEN);
if (!col)
err(EXIT_FAILURE,_("failed to allocate output column"));
+
+ set_column_type(ci, col, ci->flags);
+ }
+
+ /* For sizes use rawdata (u64) rather than strings from table */
+ if (ci->type == COLTYPE_SIZE
+ && !lsblk->bytes
+ && !scols_column_has_data_func(col)) {
+
+ scols_column_set_data_type(col, SCOLS_DATA_U64);
+ scols_column_set_data_func(col, get_u64_cell, NULL);
+ lsblk->rawdata = 1;
}
+
scols_filter_assign_column(f, itr, name, col);
}
scols_free_iter(itr);
- return;
-fail:
+
+ if (!nerrs)
+ return;
+
errx(EXIT_FAILURE, _("failed to initialize filter"));
}
+
static void __attribute__((__noreturn__)) usage(void)
{
FILE *out = stdout;
fputs(_(" -P, --pairs use key=\"value\" output format\n"), out);
fputs(_(" -Q, --filter <query> restrict output\n"), out);
fputs(_(" -H, --highlight <query> colorize lines maching the query\n"), out);
+ fputs(_(" --ct-filter <query> restrict the next counters\n"), out);
+ fputs(_(" --ct <name>[:<param>[:<function>]] define custom counter\n"), out);
fputs(_(" -S, --scsi output info about SCSI devices\n"), out);
fputs(_(" -N, --nvme output info about NVMe devices\n"), out);
fputs(_(" -v, --virtio output info about virtio devices\n"), out);
int force_tree = 0, has_tree_col = 0;
enum {
- OPT_SYSROOT = CHAR_MAX + 1
+ OPT_SYSROOT = CHAR_MAX + 1,
+ OPT_COUNTER_FILTER,
+ OPT_COUNTER
};
static const struct option longopts[] = {
{ "tree", optional_argument, NULL, 'T' },
{ "version", no_argument, NULL, 'V' },
{ "width", required_argument, NULL, 'w' },
+ { "ct-filter", required_argument, NULL, OPT_COUNTER_FILTER },
+ { "ct", required_argument, NULL, OPT_COUNTER },
{ NULL, 0, NULL, 0 },
};
lsblk = &_ls;
lsblk_init_debug();
+ scols_init_debug(0);
while((c = getopt_long(argc, argv,
"AabdDzE:e:fH:hJlNnMmo:OpPQ:iI:rstVvST::w:x:y",
errtryhelp(EXIT_FAILURE);
break;
+ case OPT_COUNTER_FILTER:
+ new_counter_filter(optarg);
+ break;
+ case OPT_COUNTER:
+ set_counter_properties(optarg);
+ break;
+
case 'h':
usage();
case 'V':
}
lsblk_mnt_init();
- scols_init_debug(0);
ul_path_init_debug();
/*
}
if (!lsblk->sort_col && lsblk->sort_id == id) {
lsblk->sort_col = cl;
+ lsblk->rawdata = 1;
scols_column_set_cmpfunc(cl,
ci->type == COLTYPE_NUM ? cmp_u64_cells :
ci->type == COLTYPE_SIZE ? cmp_u64_cells :
if (fl & SCOLS_FL_WRAP)
scols_column_set_wrapfunc(cl, NULL, scols_wrapzero_nextchunk, NULL);
- if (lsblk->flags & LSBLK_JSON) {
- switch (ci->type) {
- case COLTYPE_SIZE:
- if (!lsblk->bytes)
- break;
- /* fallthrough */
- case COLTYPE_NUM:
- scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
- break;
- case COLTYPE_BOOL:
- scols_column_set_json_type(cl, SCOLS_JSON_BOOLEAN);
- break;
- default:
- if (fl & SCOLS_FL_WRAP)
- scols_column_set_json_type(cl, SCOLS_JSON_ARRAY_STRING);
- else
- scols_column_set_json_type(cl, SCOLS_JSON_STRING);
- break;
- }
- }
+ set_column_type(ci, cl, fl);
}
if (lsblk->filter)
scols_table_enable_colors(lsblk->table, 1);
init_scols_filter(lsblk->table, lsblk->hlighter);
}
+ for (i = 0; i < lsblk->ncts; i++)
+ init_scols_filter(lsblk->table, lsblk->ct_filters[i]);
tr = lsblk_new_devtree();
if (!tr)
scols_print_table(lsblk->table);
+ if (lsblk->ncts)
+ print_counters();
leave:
- if (lsblk->sort_col)
- unref_sortdata(lsblk->table);
+ if (lsblk->rawdata)
+ unref_table_rawdata(lsblk->table);
scols_unref_table(lsblk->table);
scols_unref_filter(lsblk->filter);
scols_unref_filter(lsblk->hlighter);
+ for (i = 0; i < lsblk->ncts; i++)
+ scols_unref_filter(lsblk->ct_filters[i]);
+ free(lsblk->ct_filters);
+
lsblk_mnt_deinit();
lsblk_properties_deinit();
lsblk_unref_devtree(tr);