summaryrefslogtreecommitdiffstats
path: root/sys-utils/lsmem.c
diff options
context:
space:
mode:
Diffstat (limited to 'sys-utils/lsmem.c')
-rw-r--r--sys-utils/lsmem.c494
1 files changed, 494 insertions, 0 deletions
diff --git a/sys-utils/lsmem.c b/sys-utils/lsmem.c
new file mode 100644
index 000000000..13e2414d8
--- /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;
+}
generated by cgit v1.2.3-55-g7522 (git 2.39.0) at 2024-06-06 20:21:14 +0200