lsmem: new tool

Move the s390 specific lsmem tool to util-linux.

The lsmem tool was originally written in perl and is part of the
s390-tools package which can be found here:
https://www.ibm.com/developerworks/linux/linux390/s390-tools.html

Given that the tool is architecture independent, there is no reason to
keep it in an s390 specific repository. It seems to be useful for
other architectures as well.

This patch converts the tool to C and adds it to util-linux, while the
command line options stay compatible. The only exception is the option
"-v" which used to be the short form of "--version". That got changed
to "-V" so it behaves like most other tools contained within
util-linux.

The lsmem tool inspect the contents of /sys/devices/system/memory and
prints a summary output similar to what lscpu does:

RANGE                                 SIZE STATE   REMOVABLE BLOCK
0x0000000000000000-0x000000005fffffff 1,5G online  yes       0-5
0x0000000060000000-0x000000007fffffff 512M online  no        6-7
0x0000000080000000-0x000000013fffffff   3G online  yes       8-19
0x0000000140000000-0x000000014fffffff 256M offline -         20
0x0000000150000000-0x000000017fffffff 768M online  no        21-23

Memory block size   :     256M
Total online memory :     5,8G
Total offline memory:     256M

In order to keep the output small the tool merges subsequent address
ranges where the attributes are identical. To avoid merging of line
the "-a" option can be used.

The lsmem tool also has "--extendend" and "--parsable" option which
can be used to customize the output, e.g.  limit the output to
specified columns. This is quite similar to what the lscpu tool does.

This is based on a patch from Clemens von Mann.

Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>

5 files changed, 605 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index 064010b20b..6ead2f1ddd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -110,6 +110,7 @@ update.log
 /lscpu
 /lslocks
 /lslogins
+/lsmem
 /lsns
 /mcookie
 /mesg
diff --git a/configure.ac b/configure.ac
index 1bd7d2e896..505abdaac7 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1475,6 +1475,13 @@ UL_BUILD_INIT([flock], [check])
 UL_REQUIRES_HAVE([flock], [timer], [timer_create function])
 AM_CONDITIONAL([BUILD_FLOCK], [test "x$build_flock" = xyes])
 
+AC_ARG_ENABLE([lsmem],
+  AS_HELP_STRING([--disable-lsmem], [do not build lsmem]),
+  [], [UL_DEFAULT_ENABLE([lsmem], [yes])]
+)
+UL_BUILD_INIT([lsmem])
+AM_CONDITIONAL([BUILD_LSMEM], [test "x$build_lsmem" = xyes])
+
 UL_BUILD_INIT([ipcmk], [yes])
 AM_CONDITIONAL([BUILD_IPCMK], [test "x$build_ipcmk" = xyes])
 
diff --git a/sys-utils/Makemodule.am b/sys-utils/Makemodule.am
index 94003031f3..5de02e1fb1 100644
--- a/sys-utils/Makemodule.am
+++ b/sys-utils/Makemodule.am
@@ -1,3 +1,11 @@
+if BUILD_LSMEM
+usrbin_exec_PROGRAMS += lsmem
+dist_man_MANS += sys-utils/lsmem.1
+lsmem_SOURCES = sys-utils/lsmem.c
+lsmem_LDADD = $(LDADD) libcommon.la libsmartcols.la
+lsmem_CFLAGS = $(AM_CFLAGS) -I$(ul_libsmartcols_incdir)
+endif
+
 if BUILD_FLOCK
 usrbin_exec_PROGRAMS += flock
 dist_man_MANS += sys-utils/flock.1
diff --git a/sys-utils/lsmem.1 b/sys-utils/lsmem.1
new file mode 100644
index 0000000000..bb457dd74e
--- /dev/null
+++ b/sys-utils/lsmem.1
@@ -0,0 +1,95 @@
+.TH LSMEM 1 "October 2016" "util-linux" "User Commands"
+.SH NAME
+lsmem \- list the ranges of available memory with their online status
+.SH SYNOPSIS
+.B lsmem
+.RB [ \-h "] [" \-V "] [" \-a "] [" \-s " \fIdirectory\fP] [" \-e [=\fIlist\fP]| \-p [=\fIlist\fP]]
+.br
+.SH DESCRIPTION
+The \fBlsmem\fP command lists the ranges of available memory with their online
+status. The listed memory blocks correspond to the memory block representation
+in sysfs. The command also shows the memory block size and the amount of memory
+in online and offline state.
+.sp
+By default \fBlsmem\fP prints a human readable output table with the RANGE,
+SIZE, STATE, REMOVABLE, and BLOCK columns.
+.sp
+Use the \fB--extended\fP or \fB--parse\fP option to customize the output
+table. You can change the table format and limit, extend, or rearrange the
+table columns.
+.sp
+Not all columns are supported on all systems.  If an unsupported column is
+specified, \fBlsmem\fP prints the column but does not provide any data for it.
+
+.SS COLUMNS
+.TP
+.B RANGE
+Start and end address of the memory range.
+.TP
+.B SIZE
+Size of the memory range.
+.TP
+.B STATE
+Indication of the online status of the memory range. State "on->off" means
+that the address range is in transition from online to offline.
+.TP
+.B REMOVABLE
+"yes" if the memory range can be set offline, "no" if it cannot be set offline.
+A dash ("\-") means that the range is already offline.
+.TP
+.B BLOCK
+Memory block number or numbers that correspond to the memory range.
+.TP
+.B NODE
+Numa node of memory.
+.SH OPTIONS
+.TP
+.BR \-a ", " \-\-all
+List each individual memory block, instead of combining memory blocks with
+similar attributes.
+.TP
+.BR \-e , " \-\-extended" [=\fIlist\fP]
+Display extended memory information in human-readable format.
+
+If the \fIlist\fP argument is omitted, all columns for which data is available
+are included in the command output.
+
+The \fIlist\fP argument is a comma-separated list of column labels that specifies
+the columns to be included in the output table and their sequence in the
+table. See \fBCOLUMNS\fP for valid column labels. Column labels are not case
+sensitive. The specification consisting of option, equal sign (=), and \fIlist\fP
+must not contain any white space.
+
+Examples: '\fB-e=range,size,state\fP' or '\fB--extended=NODE,state,size,RANGE\fP'.
+.TP
+.BR \-h ", " \-\-help
+Display help text and exit.
+.TP
+.BR \-p , " \-\-parse" [=\fIlist\fP]
+Optimize the command output for easy parsing.
+
+If the \fIlist\fP argument is omitted, all columns for which data is available
+are included in the command output.
+
+The \fIlist\fP argument is a comma-separated list of column labels that specifies
+the columns to be included in the output table and their sequence in the
+table. See \fBCOLUMNS\fP for valid column labels. Column labels are not case
+sensitive. The specification consisting of option, equal sign (=), and \fIlist\fP
+must not contain any white space.
+
+Examples: '\fB-p=range,size,state\fP' or '\fB--parse=NODE,state,size,RANGE\fP'.
+.TP
+.BR \-s , " \-\-sysroot " \fIdirectory\fP
+Gather memory data for a Linux instance other than the instance from which the
+\fBlsmem\fP command is issued.  The specified \fIdirectory\fP is the system
+root of the Linux instance to be inspected.
+.TP
+.BR \-V ", " \-\-version
+Display version information and exit.
+.SH SEE ALSO
+.BR chmem (8)
+.SH AVAILABILITY
+The \fBlsmem\fP command is part of the util-linux package and is available from
+.UR ftp://\:ftp.kernel.org\:/pub\:/linux\:/utils\:/util-linux/
+Linux Kernel Archive
+.UE .
diff --git a/sys-utils/lsmem.c b/sys-utils/lsmem.c
new file mode 100644
index 0000000000..13e2414d8d
--- /dev/null
+++ b/sys-utils/lsmem.c
@@ -0,0 +1,494 @@
+/*
+ * lsmem - Show memory configuration
+ *
+ * Copyright IBM Corp. 2016
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it would 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <c.h>
+#include <nls.h>
+#include <path.h>
+#include <strutils.h>
+#include <closestream.h>
+#include <xalloc.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <strutils.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <assert.h>
+#include <optutils.h>
+#include <libsmartcols.h>
+
+#define _PATH_SYS_MEMORY		"/sys/devices/system/memory"
+#define _PATH_SYS_MEMORY_BLOCK_SIZE	_PATH_SYS_MEMORY "/block_size_bytes"
+
+#define MEMORY_STATE_ONLINE		0
+#define MEMORY_STATE_OFFLINE		1
+#define MEMORY_STATE_GOING_OFFLINE	2
+#define MEMORY_STATE_UNKNOWN		3
+
+struct memory_block {
+	uint64_t	index;
+	uint64_t	count;
+	int		state;
+	int		node;
+	unsigned int	removable:1;
+};
+
+enum {
+	OUTPUT_READABLE = 0,	/* default */
+	OUTPUT_PARSABLE,	/* -p */
+};
+
+struct lsmem_desc {
+	struct dirent		**dirs;
+	int			ndirs;
+	struct memory_block	*blocks;
+	int			nblocks;
+	unsigned int		have_nodes : 1;
+	uint64_t		block_size;
+	uint64_t		mem_online;
+	uint64_t		mem_offline;
+};
+
+struct lsmem_modifier {
+	int		mode; /* OUTPUT_* */
+	unsigned int	compat : 1;
+	unsigned int	list_all_blocks : 1;
+};
+
+enum {
+	COL_RANGE,
+	COL_SIZE,
+	COL_STATE,
+	COL_REMOVABLE,
+	COL_BLOCK,
+	COL_NODE,
+};
+
+struct lsmem_coldesc {
+	const int flags;
+	const char *name;
+	const char *help;
+};
+
+static struct lsmem_coldesc coldescs[] = {
+	[COL_RANGE]	= { 0,		    "RANGE",	 N_("adress range")},
+	[COL_SIZE]	= { SCOLS_FL_RIGHT, "SIZE",	 N_("size of memory")},
+	[COL_STATE]	= { 0,		    "STATE",	 N_("state of memory")},
+	[COL_REMOVABLE]	= { 0,		    "REMOVABLE", N_("memory is removable")},
+	[COL_BLOCK]	= { 0,		    "BLOCK",	 N_("memory block")},
+	[COL_NODE]	= { 0,		    "NODE",	 N_("node information")},
+};
+
+static int column_name_to_id(const char *name, size_t namesz)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(coldescs); i++) {
+		const char *cn = coldescs[i].name;
+
+		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
+			return i;
+	}
+	warnx(_("unknown column: %s"), name);
+	return -1;
+}
+
+static char *get_cell_header(int col, char *buf, size_t bufsz)
+{
+	snprintf(buf, bufsz, "%s", coldescs[col].name);
+	return buf;
+}
+
+static char *get_cell_data(struct lsmem_desc *desc, int idx, int col,
+			   struct lsmem_modifier *mod,
+			   char *buf, size_t bufsz)
+{
+	struct memory_block *blk;
+	uint64_t start, size;
+
+	blk = &desc->blocks[idx];
+	start = blk->index * desc->block_size;
+	size = blk->count * desc->block_size;
+
+	switch (col) {
+	case COL_RANGE:
+		snprintf(buf, bufsz, "0x%016"PRIx64"-0x%016"PRIx64, start, start + size - 1);
+		break;
+	case COL_SIZE:
+		if (mod->mode == OUTPUT_PARSABLE)
+			snprintf(buf, bufsz, "%"PRId64, size);
+		else
+			snprintf(buf, bufsz, "%s", size_to_human_string(SIZE_SUFFIX_1LETTER, size));
+		break;
+	case COL_STATE:
+		if (blk->state == MEMORY_STATE_ONLINE)
+			snprintf(buf, bufsz, _("online"));
+		else if (blk->state == MEMORY_STATE_OFFLINE)
+			snprintf(buf, bufsz, _("offline"));
+		else if (blk->state == MEMORY_STATE_GOING_OFFLINE)
+			snprintf(buf, bufsz, _("on->off"));
+		else /* unknown */
+			snprintf(buf, bufsz, "?");
+		break;
+	case COL_REMOVABLE:
+		if (blk->state == MEMORY_STATE_ONLINE)
+			snprintf(buf, bufsz, "%s", blk->removable ? _("yes") : _("no"));
+		else
+			snprintf(buf, bufsz, "-");
+		break;
+	case COL_BLOCK:
+		if (blk->count == 1)
+			snprintf(buf, bufsz, "%"PRId64, blk->index);
+		else
+			snprintf(buf, bufsz, "%"PRId64"-%"PRId64,
+				 blk->index, blk->index + blk->count - 1);
+		break;
+	case COL_NODE:
+		if (desc->have_nodes)
+			snprintf(buf, bufsz, "%d", blk->node);
+		else
+			snprintf(buf, bufsz, "-");
+		break;
+	}
+	return buf;
+}
+
+static void print_parsable(struct lsmem_desc *desc, int *cols, int ncols,
+			   struct lsmem_modifier *mod)
+{
+	char buf[BUFSIZ], *data;
+	int c, i;
+
+	fputs("# ", stdout);
+	for (i = 0; i < ncols; i++) {
+		data = get_cell_header(cols[i], buf, sizeof(buf));
+		if (i > 0)
+			fputc(',', stdout);
+		fputs(data && *data ? data : "", stdout);
+	}
+	fputc('\n', stdout);
+
+	for (i = 0; i < desc->nblocks; i++) {
+		for (c = 0; c < ncols; c++) {
+			if (c > 0)
+				putchar(',');
+			data = get_cell_data(desc, i, cols[c], mod, buf, sizeof(buf));
+			fputs(data && *data ? data : "", stdout);
+		}
+		fputc('\n', stdout);
+	}
+}
+
+static void print_readable_table(struct lsmem_desc *desc, int *cols, int ncols,
+				 struct lsmem_modifier *mod)
+{
+	struct libscols_table *table;
+	char buf[BUFSIZ], *data;
+	int c, i;
+
+	scols_init_debug(0);
+	table = scols_new_table();
+	if (!table)
+		err(EXIT_FAILURE, _("Failed to initialize output table"));
+	for (i = 0; i < ncols; i++) {
+		data = get_cell_header(cols[i], buf, sizeof(buf));
+		if (!scols_table_new_column(table, xstrdup(data), 0, coldescs[i].flags))
+			err(EXIT_FAILURE, _("Failed to initialize output column"));
+	}
+	for (i = 0; i < desc->nblocks; i++) {
+		struct libscols_line *line;
+
+		line = scols_table_new_line(table, NULL);
+		if (!line)
+			err(EXIT_FAILURE, _("Failed to initialize output line"));
+
+		for (c = 0; c < ncols; c++) {
+			data = get_cell_data(desc, i, cols[c], mod, buf, sizeof(buf));
+			if (!data || !*data)
+				data = "-";
+			scols_line_set_data(line, c, data);
+		}
+	}
+	scols_print_table(table);
+	scols_unref_table(table);
+}
+
+static void print_readable(struct lsmem_desc *desc, int *cols, int ncols,
+			   struct lsmem_modifier *mod)
+{
+	print_readable_table(desc, cols, ncols, mod);
+	fputc('\n', stdout);
+	fprintf(stdout, _("Memory block size   : %8s\n"),
+		size_to_human_string(SIZE_SUFFIX_1LETTER, desc->block_size));
+	fprintf(stdout, _("Total online memory : %8s\n"),
+		size_to_human_string(SIZE_SUFFIX_1LETTER, desc->mem_online));
+	fprintf(stdout, _("Total offline memory: %8s\n"),
+		size_to_human_string(SIZE_SUFFIX_1LETTER, desc->mem_offline));
+}
+
+static int memory_block_get_node(char *name)
+{
+	struct dirent *de;
+	char *path;
+	DIR *dir;
+	int node;
+
+	path = path_strdup(_PATH_SYS_MEMORY"/%s", name);
+	dir = opendir(path);
+	free(path);
+	if (!dir)
+		err(EXIT_FAILURE, _("Failed to open %s"), path);
+	node = -1;
+	while ((de = readdir(dir)) != NULL) {
+		if (strncmp("node", de->d_name, 4))
+			continue;
+		if (!isdigit_string(de->d_name + 4))
+			continue;
+		node = strtol(de->d_name + 4, NULL, 10);
+	}
+	closedir(dir);
+	return node;
+}
+
+static void memory_block_read_attrs(struct lsmem_desc *desc, char *name,
+				    struct memory_block *blk)
+{
+	char line[BUFSIZ];
+
+	blk->count = 1;
+	blk->index = strtoumax(name + 6, NULL, 10); /* get <num> of "memory<num>" */
+	blk->removable = path_read_u64(_PATH_SYS_MEMORY"/%s/%s", name, "removable");
+	blk->state = MEMORY_STATE_UNKNOWN;
+	path_read_str(line, sizeof(line), _PATH_SYS_MEMORY"/%s/%s", name, "state");
+	if (strcmp(line, "offline") == 0)
+		blk->state = MEMORY_STATE_OFFLINE;
+	else if (strcmp(line, "online") == 0)
+		blk->state = MEMORY_STATE_ONLINE;
+	else if (strcmp(line, "going-offline") == 0)
+		blk->state = MEMORY_STATE_GOING_OFFLINE;
+	if (desc->have_nodes)
+		blk->node = memory_block_get_node(name);
+}
+
+static int is_mergeable(struct lsmem_desc *desc, char *enabled,
+			struct memory_block *blk,
+			struct lsmem_modifier *mod)
+{
+	struct memory_block *curr;
+
+	if (!desc->nblocks)
+		return 0;
+	curr = &desc->blocks[desc->nblocks - 1];
+	if (mod->list_all_blocks)
+		return 0;
+	if (curr->index + curr->count != blk->index)
+		return 0;
+	if (enabled[COL_STATE] && (curr->state != blk->state))
+		return 0;
+	if (enabled[COL_REMOVABLE] && (curr->removable != blk->removable))
+		return 0;
+	if (enabled[COL_NODE] && desc->have_nodes) {
+		if (curr->node != blk->node)
+			return 0;
+	}
+	return 1;
+}
+
+static void read_info(struct lsmem_desc *desc, int *cols, int ncols,
+		      struct lsmem_modifier *mod)
+{
+	char enabled[ARRAY_SIZE(coldescs)];
+	struct memory_block blk;
+	char line[BUFSIZ];
+	int i;
+
+	path_read_str(line, sizeof(line), _PATH_SYS_MEMORY_BLOCK_SIZE);
+	desc->block_size = strtoumax(line, NULL, 16);
+
+	memset(enabled, 0, sizeof(enabled));
+	for (i = 0; i < ncols; i++)
+		enabled[cols[i]] = 1;
+	for (i = 0; i < desc->ndirs; i++) {
+		memory_block_read_attrs(desc, desc->dirs[i]->d_name, &blk);
+		if (is_mergeable(desc, enabled, &blk, mod)) {
+			desc->blocks[desc->nblocks - 1].count++;
+			continue;
+		}
+		desc->nblocks++;
+		desc->blocks = xrealloc(desc->blocks, desc->nblocks * sizeof(blk));
+		*&desc->blocks[desc->nblocks - 1] = blk;
+	}
+	for (i = 0; i < desc->nblocks; i++) {
+		if (desc->blocks[i].state == MEMORY_STATE_ONLINE)
+			desc->mem_online += desc->block_size * desc->blocks[i].count;
+		else
+			desc->mem_offline += desc->block_size * desc->blocks[i].count;
+	}
+}
+
+static int memory_block_filter(const struct dirent *de)
+{
+	if (strncmp("memory", de->d_name, 6))
+		return 0;
+	return isdigit_string(de->d_name + 6);
+}
+
+static void read_basic_info(struct lsmem_desc *desc)
+{
+	char *dir;
+
+	if (!path_exist(_PATH_SYS_MEMORY_BLOCK_SIZE))
+		errx(EXIT_FAILURE, _("This system does not support memory blocks"));
+
+	dir = path_strdup(_PATH_SYS_MEMORY);
+	desc->ndirs = scandir(dir, &desc->dirs, memory_block_filter, versionsort);
+	free(dir);
+	if (desc->ndirs <= 0)
+		err(EXIT_FAILURE, _("Failed to read %s"), _PATH_SYS_MEMORY);
+
+	if (memory_block_get_node(desc->dirs[0]->d_name) != -1)
+		desc->have_nodes = 1;
+}
+
+static void __attribute__((__noreturn__)) lsmem_usage(FILE *out)
+{
+	unsigned int i;
+
+	fputs(USAGE_HEADER, out);
+	fprintf(out, _(" %s [options]\n"), program_invocation_short_name);
+
+	fputs(USAGE_SEPARATOR, out);
+	fputs(_("List the ranges of available memory with their online status.\n"), out);
+
+	fputs(USAGE_OPTIONS, out);
+	fputs(_(" -a, --all               list each individiual memory block\n"), out);
+	fputs(_(" -e, --extended[=<list>] print customized output in a readable format\n"), out);
+	fputs(_(" -p, --parse[=<list>]    print customized output in a parsable format\n"), out);
+	fputs(_(" -s, --sysroot <dir>     use the specified directory as system root\n"), out);
+	fputs(USAGE_SEPARATOR, out);
+	fputs(USAGE_HELP, out);
+	fputs(USAGE_VERSION, out);
+
+	fputs(_("\nAvailable columns:\n"), out);
+
+	for (i = 0; i < ARRAY_SIZE(coldescs); i++)
+		fprintf(out, " %10s  %s\n", coldescs[i].name, coldescs[i].help);
+
+	fprintf(out, USAGE_MAN_TAIL("lsmem(1)"));
+
+	exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS);
+}
+
+int main(int argc, char **argv)
+{
+	struct lsmem_modifier _mod = { .mode = OUTPUT_READABLE, .compat = 1 }, *mod = &_mod;
+	struct lsmem_desc _desc = { }, *desc = &_desc;
+	int columns[ARRAY_SIZE(coldescs)], ncolumns = 0;
+	int c;
+
+	static const struct option longopts[] = {
+		{"all",		no_argument,		NULL, 'a'},
+		{"extended",	optional_argument,	NULL, 'e'},
+		{"help",	no_argument,		NULL, 'h'},
+		{"parse",	optional_argument,	NULL, 'p'},
+		{"sysroot",	required_argument,	NULL, 's'},
+		{"version",	no_argument,		NULL, 'V'},
+		{NULL,		0,			NULL, 0}
+	};
+	static const ul_excl_t excl[] = {	/* rows and cols in ASCII order */
+		{ 'e','p' },
+		{ 0 }
+	};
+	int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
+
+	setlocale(LC_ALL, "");
+	bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+	atexit(close_stdout);
+
+	while ((c = getopt_long(argc, argv, "ae::hp::s:V", longopts, NULL)) != -1) {
+
+		err_exclusive_options(c, longopts, excl, excl_st);
+
+		switch (c) {
+		case 'a':
+			mod->list_all_blocks = 1;
+			break;
+		case 'h':
+			lsmem_usage(stdout);
+			break;
+		case 'p':
+		case 'e':
+			if (optarg) {
+				if (*optarg == '=')
+					optarg++;
+				ncolumns = string_to_idarray(optarg,
+							     columns, ARRAY_SIZE(columns),
+							     column_name_to_id);
+				if (ncolumns < 0)
+					return EXIT_FAILURE;
+			}
+			mod->mode = c == 'p' ? OUTPUT_PARSABLE : OUTPUT_READABLE;
+			mod->compat = 0;
+			break;
+		case 's':
+			path_set_prefix(optarg);
+			break;
+		case 'V':
+			printf(UTIL_LINUX_VERSION);
+			return 0;
+		default:
+			lsmem_usage(stderr);
+		}
+	}
+
+	if (argc != optind)
+		lsmem_usage(stderr);
+
+	read_basic_info(desc);
+
+	if (!ncolumns) {
+		/* No list was given. Print the following lines by default */
+		columns[ncolumns++] = COL_RANGE;
+		columns[ncolumns++] = COL_SIZE;
+		columns[ncolumns++] = COL_STATE;
+		columns[ncolumns++] = COL_REMOVABLE;
+		columns[ncolumns++] = COL_BLOCK;
+		if (!mod->compat) {
+			/* Print everything else what is there if the
+			 * extended or parsable mode has been specified */
+			if (desc->have_nodes)
+				columns[ncolumns++] = COL_NODE;
+		}
+	}
+
+	read_info(desc, columns, ncolumns, mod);
+
+	switch (mod->mode) {
+	case OUTPUT_READABLE:
+		print_readable(desc, columns, ncolumns, mod);
+		break;
+	case OUTPUT_PARSABLE:
+		print_parsable(desc, columns, ncolumns, mod);
+		break;
+	}
+	return 0;
+}