diff --git a/SOURCES/0142-lsmem-chmem-backport-new-commands.patch b/SOURCES/0142-lsmem-chmem-backport-new-commands.patch new file mode 100644 index 00000000..caeb953b --- /dev/null +++ b/SOURCES/0142-lsmem-chmem-backport-new-commands.patch @@ -0,0 +1,1607 @@ +From 4fde7a853f61fa025a9d42a7571161a69fdae162 Mon Sep 17 00:00:00 2001 +From: Karel Zak +Date: Mon, 23 Oct 2017 15:54:54 +0200 +Subject: [PATCH] lsmem, chmem: backport new commands + +Addresses: https://bugzilla.redhat.com/show_bug.cgi?id=1496421 +Signed-off-by: Karel Zak +--- + configure.ac | 19 ++ + include/c.h | 10 + + include/path.h | 5 +- + include/strutils.h | 1 + + lib/path.c | 36 ++- + lib/strutils.c | 17 +- + sys-utils/Makemodule.am | 14 + + sys-utils/chmem.8 | 114 ++++++++ + sys-utils/chmem.c | 447 +++++++++++++++++++++++++++++++ + sys-utils/lsmem.1 | 95 +++++++ + sys-utils/lsmem.c | 687 ++++++++++++++++++++++++++++++++++++++++++++++++ + 11 files changed, 1432 insertions(+), 13 deletions(-) + create mode 100644 sys-utils/chmem.8 + create mode 100644 sys-utils/chmem.c + create mode 100644 sys-utils/lsmem.1 + create mode 100644 sys-utils/lsmem.c + +diff --git a/configure.ac b/configure.ac +index 96c5838cf..d561e01d0 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -1138,6 +1138,25 @@ UL_REQUIRES_SYSCALL_CHECK([pivot_root], [UL_CHECK_SYSCALL([pivot_root])]) + AM_CONDITIONAL(BUILD_PIVOT_ROOT, test "x$build_pivot_root" = xyes) + + ++AC_ARG_ENABLE([lsmem], ++ AS_HELP_STRING([--disable-lsmem], [do not build lsmem]), ++ [], enable_lsmem=check ++) ++UL_BUILD_INIT([lsmem]) ++UL_REQUIRES_LINUX([lsmem]) ++UL_REQUIRES_BUILD([lsmem], [libsmartcols]) ++AM_CONDITIONAL([BUILD_LSMEM], [test "x$build_lsmem" = xyes]) ++ ++ ++AC_ARG_ENABLE([chmem], ++ AS_HELP_STRING([--disable-chmem], [do not build chmem]), ++ [], enable_chmem=check ++) ++UL_BUILD_INIT([chmem]) ++UL_REQUIRES_LINUX([chmem]) ++AM_CONDITIONAL([BUILD_CHMEM], [test "x$build_chmem" = xyes]) ++ ++ + AC_ARG_ENABLE([elvtune], + AS_HELP_STRING([--enable-elvtune], [build elvtune (only works with 2.2 and 2.4 kernels)]), + [], enable_elvtune=no +diff --git a/include/c.h b/include/c.h +index 8ff61b484..124035ea5 100644 +--- a/include/c.h ++++ b/include/c.h +@@ -302,6 +302,16 @@ static inline int usleep(useconds_t usec) + + #define UTIL_LINUX_VERSION _("%s from %s\n"), program_invocation_short_name, PACKAGE_STRING + ++/* backported to RHEL */ ++#define USAGE_COLUMNS _("\nAvailable output columns:\n") ++#define USAGE_OPTSTR_HELP _("display this help") ++#define USAGE_OPTSTR_VERSION _("display version") ++#define USAGE_HELP_OPTIONS(marg_dsc) \ ++ "%-" #marg_dsc "s%s\n" \ ++ "%-" #marg_dsc "s%s\n" \ ++ , " -h, --help", USAGE_OPTSTR_HELP \ ++ , " -V, --version", USAGE_OPTSTR_VERSION ++ + /* + * scanf modifiers for "strings allocation" + */ +diff --git a/include/path.h b/include/path.h +index 45da692f8..1ab5724fc 100644 +--- a/include/path.h ++++ b/include/path.h +@@ -4,6 +4,10 @@ + #include + #include + ++extern int path_set_prefix(const char *); ++ ++extern const char *path_get(const char *path, ...); ++ + extern char *path_strdup(const char *path, ...) + __attribute__ ((__format__ (__printf__, 1, 2))); + extern FILE *path_fopen(const char *mode, int exit_on_err, const char *path, ...) +@@ -27,7 +31,6 @@ extern cpu_set_t *path_read_cpuset(int, const char *path, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + extern cpu_set_t *path_read_cpulist(int, const char *path, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); +-extern void path_set_prefix(const char *); + #endif /* HAVE_CPU_SET_T */ + + #endif /* UTIL_LINUX_PATH_H */ +diff --git a/include/strutils.h b/include/strutils.h +index aa7b95f96..1f028e4ed 100644 +--- a/include/strutils.h ++++ b/include/strutils.h +@@ -25,6 +25,7 @@ extern uint32_t strtou32_or_err(const char *str, const char *errmesg); + + extern int64_t strtos64_or_err(const char *str, const char *errmesg); + extern uint64_t strtou64_or_err(const char *str, const char *errmesg); ++extern uint64_t strtox64_or_err(const char *str, const char *errmesg); + + extern double strtod_or_err(const char *str, const char *errmesg); + +diff --git a/lib/path.c b/lib/path.c +index e47d31418..49ca9b5e0 100644 +--- a/lib/path.c ++++ b/lib/path.c +@@ -38,6 +38,20 @@ + static size_t prefixlen; + static char pathbuf[PATH_MAX]; + ++int ++path_set_prefix(const char *prefix) ++{ ++ size_t len = strlen(prefix); ++ ++ if (len >= sizeof(pathbuf) - 1) { ++ errno = ENAMETOOLONG; ++ return -1; ++ } ++ prefixlen = len; ++ strcpy(pathbuf, prefix); ++ return 0; ++} ++ + static const char * + path_vcreate(const char *path, va_list ap) + { +@@ -49,6 +63,19 @@ path_vcreate(const char *path, va_list ap) + return pathbuf; + } + ++const char * ++path_get(const char *path, ...) ++{ ++ const char *p; ++ va_list ap; ++ ++ va_start(ap, path); ++ p = path_vcreate(path, ap); ++ va_end(ap); ++ ++ return p; ++} ++ + char * + path_strdup(const char *path, ...) + { +@@ -246,13 +273,6 @@ path_read_cpulist(int maxcpus, const char *path, ...) + + return set; + } +- + #endif /* HAVE_CPU_SET_T */ + +-void +-path_set_prefix(const char *prefix) +-{ +- prefixlen = strlen(prefix); +- strncpy(pathbuf, prefix, sizeof(pathbuf)); +- pathbuf[sizeof(pathbuf) - 1] = '\0'; +-} ++ +diff --git a/lib/strutils.c b/lib/strutils.c +index 4b8a8130d..2458a2c2f 100644 +--- a/lib/strutils.c ++++ b/lib/strutils.c +@@ -237,27 +237,36 @@ err: + errx(STRTOXX_EXIT_CODE, "%s: '%s'", errmesg, str); + } + +-uint64_t strtou64_or_err(const char *str, const char *errmesg) ++static uint64_t _strtou64_or_err(const char *str, const char *errmesg, int base) + { + uintmax_t num; + char *end = NULL; + ++ errno = 0; + if (str == NULL || *str == '\0') + goto err; +- errno = 0; +- num = strtoumax(str, &end, 10); ++ num = strtoumax(str, &end, base); + + if (errno || str == end || (end && *end)) + goto err; + + return num; + err: +- if (errno) ++ if (errno == ERANGE) + err(STRTOXX_EXIT_CODE, "%s: '%s'", errmesg, str); + + errx(STRTOXX_EXIT_CODE, "%s: '%s'", errmesg, str); + } + ++uint64_t strtou64_or_err(const char *str, const char *errmesg) ++{ ++ return _strtou64_or_err(str, errmesg, 10); ++} ++ ++uint64_t strtox64_or_err(const char *str, const char *errmesg) ++{ ++ return _strtou64_or_err(str, errmesg, 16); ++} + + double strtod_or_err(const char *str, const char *errmesg) + { +diff --git a/sys-utils/Makemodule.am b/sys-utils/Makemodule.am +index 0496b84e3..21585ce80 100644 +--- a/sys-utils/Makemodule.am ++++ b/sys-utils/Makemodule.am +@@ -1,3 +1,17 @@ ++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_CHMEM ++usrbin_exec_PROGRAMS += chmem ++dist_man_MANS += sys-utils/chmem.8 ++chmem_SOURCES = sys-utils/chmem.c ++chmem_LDADD = $(LDADD) libcommon.la ++endif + + usrbin_exec_PROGRAMS += flock + dist_man_MANS += sys-utils/flock.1 +diff --git a/sys-utils/chmem.8 b/sys-utils/chmem.8 +new file mode 100644 +index 000000000..dae7413d4 +--- /dev/null ++++ b/sys-utils/chmem.8 +@@ -0,0 +1,114 @@ ++.TH CHMEM 8 "October 2016" "util-linux" "System Administration" ++.SH NAME ++chmem \- configure memory ++.SH SYNOPSIS ++.B chmem ++.RB [ \-h "] [" \-V "] [" \-v "] [" \-e | \-d "]" ++[\fISIZE\fP|\fIRANGE\fP|\fB\-b\fP \fIBLOCKRANGE\fP] ++[-z ZONE] ++.SH DESCRIPTION ++The chmem command sets a particular size or range of memory online or offline. ++. ++.IP "\(hy" 2 ++Specify \fISIZE\fP as [m|M|g|G]. With m or M, specifies the memory ++size in MiB (1024 x 1024 bytes). With g or G, specifies the memory size ++in GiB (1024 x 1024 x 1024 bytes). The default unit is MiB. ++. ++.IP "\(hy" 2 ++Specify \fIRANGE\fP in the form 0x-0x as shown in the output of the ++\fBlsmem\fP command. is the hexadecimal address of the first byte and ++is the hexadecimal address of the last byte in the memory range. ++. ++.IP "\(hy" 2 ++Specify \fIBLOCKRANGE\fP in the form - or as shown in the ++output of the \fBlsmem\fP command. is the number of the first memory block ++and is the number of the last memory block in the memory ++range. Alternatively a single block can be specified. \fIBLOCKRANGE\fP requires ++the \fB--blocks\fP option. ++. ++.IP "\(hy" 2 ++Specify \fIZONE\fP as the name of a memory zone, as shown in the output of the ++\fBlsmem -o +ZONES\fP command. The output shows one or more valid memory zones ++for each memory range. If multiple zones are shown, then the memory range ++currently belongs to the first zone. By default, chmem will set memory online ++to the zone Movable, if this is among the valid zones. This default can be ++changed by specifying the \fB--zone\fP option with another valid zone. ++For memory ballooning, it is recommended to select the zone Movable for memory ++online and offline, if possible. Memory in this zone is much more likely to be ++able to be offlined again, but it cannot be used for arbitrary kernel ++allocations, only for migratable pages (e.g. anonymous and page cache pages). ++Use the \fB\-\-help\fR option to see all available zones. ++. ++.PP ++\fISIZE\fP and \fIRANGE\fP must be aligned to the Linux memory block size, as ++shown in the output of the \fBlsmem\fP command. ++ ++Setting memory online can fail for various reasons. On virtualized systems it ++can fail if the hypervisor does not have enough memory left, for example ++because memory was overcommitted. Setting memory offline can fail if Linux ++cannot free the memory. If only part of the requested memory can be set online ++or offline, a message tells you how much memory was set online or offline ++instead of the requested amount. ++ ++When setting memory online \fBchmem\fP starts with the lowest memory block ++numbers. When setting memory offline \fBchmem\fP starts with the highest memory ++block numbers. ++.SH OPTIONS ++.TP ++.BR \-b ", " \-\-blocks ++Use a \fIBLOCKRANGE\fP parameter instead of \fIRANGE\fP or \fISIZE\fP for the ++\fB--enable\fP and \fB--disable\fP options. ++.TP ++.BR \-d ", " \-\-disable ++Set the specified \fIRANGE\fP, \fISIZE\fP, or \fIBLOCKRANGE\fP of memory offline. ++.TP ++.BR \-e ", " \-\-enable ++Set the specified \fIRANGE\fP, \fISIZE\fP, or \fIBLOCKRANGE\fP of memory online. ++.TP ++.BR \-z ", " \-\-zone ++Select the memory \fIZONE\fP where to set the specified \fIRANGE\fP, \fISIZE\fP, ++or \fIBLOCKRANGE\fP of memory online or offline. By default, memory will be set ++online to the zone Movable, if possible. ++.TP ++.BR \-h ", " \-\-help ++Print a short help text, then exit. ++.TP ++.BR \-v ", " \-\-verbose ++Verbose mode. Causes \fBchmem\fP to print debugging messages about it's ++progress. ++.TP ++.BR \-V ", " \-\-version ++Print the version number, then exit. ++.SH RETURN CODES ++.B chmem ++has the following return codes: ++.TP ++.BR 0 ++success ++.TP ++.BR 1 ++failure ++.TP ++.BR 64 ++partial success ++.SH EXAMPLES ++.TP ++.B chmem --enable 1024 ++This command requests 1024 MiB of memory to be set online. ++.TP ++.B chmem -e 2g ++This command requests 2 GiB of memory to be set online. ++.TP ++.B chmem --disable 0x00000000e4000000-0x00000000f3ffffff ++This command requests the memory range starting with 0x00000000e4000000 ++and ending with 0x00000000f3ffffff to be set offline. ++.TP ++.B chmem -b -d 10 ++This command requests the memory block number 10 to be set offline. ++.SH SEE ALSO ++.BR lsmem (1) ++.SH AVAILABILITY ++The \fBchmem\fP command is part of the util-linux package and is available from ++.UR https://\:www.kernel.org\:/pub\:/linux\:/utils\:/util-linux/ ++Linux Kernel Archive ++.UE . +diff --git a/sys-utils/chmem.c b/sys-utils/chmem.c +new file mode 100644 +index 000000000..0e5e84727 +--- /dev/null ++++ b/sys-utils/chmem.c +@@ -0,0 +1,447 @@ ++/* ++ * chmem - Memory configuration tool ++ * ++ * 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 ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "c.h" ++#include "nls.h" ++#include "path.h" ++#include "strutils.h" ++#include "strv.h" ++#include "optutils.h" ++#include "closestream.h" ++#include "xalloc.h" ++ ++/* partial success, otherwise we return regular EXIT_{SUCCESS,FAILURE} */ ++#define CHMEM_EXIT_SOMEOK 64 ++ ++#define _PATH_SYS_MEMORY "/sys/devices/system/memory" ++#define _PATH_SYS_MEMORY_BLOCK_SIZE _PATH_SYS_MEMORY "/block_size_bytes" ++ ++struct chmem_desc { ++ struct dirent **dirs; ++ int ndirs; ++ uint64_t block_size; ++ uint64_t start; ++ uint64_t end; ++ uint64_t size; ++ unsigned int use_blocks : 1; ++ unsigned int is_size : 1; ++ unsigned int verbose : 1; ++ unsigned int have_zones : 1; ++}; ++ ++enum { ++ CMD_MEMORY_ENABLE = 0, ++ CMD_MEMORY_DISABLE, ++ CMD_NONE ++}; ++ ++enum zone_id { ++ ZONE_DMA = 0, ++ ZONE_DMA32, ++ ZONE_NORMAL, ++ ZONE_HIGHMEM, ++ ZONE_MOVABLE, ++ ZONE_DEVICE, ++}; ++ ++static char *zone_names[] = { ++ [ZONE_DMA] = "DMA", ++ [ZONE_DMA32] = "DMA32", ++ [ZONE_NORMAL] = "Normal", ++ [ZONE_HIGHMEM] = "Highmem", ++ [ZONE_MOVABLE] = "Movable", ++ [ZONE_DEVICE] = "Device", ++}; ++ ++/* ++ * name must be null-terminated ++ */ ++static int zone_name_to_id(const char *name) ++{ ++ size_t i; ++ ++ for (i = 0; i < ARRAY_SIZE(zone_names); i++) { ++ if (!strcasecmp(name, zone_names[i])) ++ return i; ++ } ++ return -1; ++} ++ ++static void idxtostr(struct chmem_desc *desc, uint64_t idx, char *buf, size_t bufsz) ++{ ++ uint64_t start, end; ++ ++ start = idx * desc->block_size; ++ end = start + desc->block_size - 1; ++ snprintf(buf, bufsz, ++ _("Memory Block %"PRIu64" (0x%016"PRIx64"-0x%016"PRIx64")"), ++ idx, start, end); ++} ++ ++static int chmem_size(struct chmem_desc *desc, int enable, int zone_id) ++{ ++ char *name, *onoff, line[BUFSIZ], str[BUFSIZ]; ++ uint64_t size, index; ++ const char *zn; ++ int i, rc; ++ ++ size = desc->size; ++ onoff = enable ? "online" : "offline"; ++ i = enable ? 0 : desc->ndirs - 1; ++ ++ if (enable && zone_id >= 0) { ++ if (zone_id == ZONE_MOVABLE) ++ onoff = "online_movable"; ++ else ++ onoff = "online_kernel"; ++ } ++ ++ for (; i >= 0 && i < desc->ndirs && size; i += enable ? 1 : -1) { ++ name = desc->dirs[i]->d_name; ++ index = strtou64_or_err(name + 6, _("Failed to parse index")); ++ path_read_str(line, sizeof(line), _PATH_SYS_MEMORY "/%s/state", name); ++ if (strncmp(onoff, line, 6) == 0) ++ continue; ++ ++ if (desc->have_zones) { ++ path_read_str(line, sizeof(line), ++ _PATH_SYS_MEMORY "/%s/valid_zones", name); ++ if (zone_id >= 0) { ++ zn = zone_names[zone_id]; ++ if (enable && !strcasestr(line, zn)) ++ continue; ++ if (!enable && strncasecmp(line, zn, strlen(zn))) ++ continue; ++ } else if (enable) { ++ /* By default, use zone Movable for online, if valid */ ++ if (strcasestr(line, zone_names[ZONE_MOVABLE])) ++ onoff = "online_movable"; ++ else ++ onoff = "online"; ++ } ++ } ++ ++ idxtostr(desc, index, str, sizeof(str)); ++ rc = path_write_str(onoff, _PATH_SYS_MEMORY"/%s/state", name); ++ if (rc == -1 && desc->verbose) { ++ if (enable) ++ fprintf(stdout, _("%s enable failed\n"), str); ++ else ++ fprintf(stdout, _("%s disable failed\n"), str); ++ } else if (rc == 0 && desc->verbose) { ++ if (enable) ++ fprintf(stdout, _("%s enabled\n"), str); ++ else ++ fprintf(stdout, _("%s disabled\n"), str); ++ } ++ if (rc == 0) ++ size--; ++ } ++ if (size) { ++ uint64_t bytes; ++ char *sizestr; ++ ++ bytes = (desc->size - size) * desc->block_size; ++ sizestr = size_to_human_string(SIZE_SUFFIX_1LETTER, bytes); ++ if (enable) ++ warnx(_("Could only enable %s of memory"), sizestr); ++ else ++ warnx(_("Could only disable %s of memory"), sizestr); ++ free(sizestr); ++ } ++ return size == 0 ? 0 : size == desc->size ? -1 : 1; ++} ++ ++static int chmem_range(struct chmem_desc *desc, int enable, int zone_id) ++{ ++ char *name, *onoff, line[BUFSIZ], str[BUFSIZ]; ++ uint64_t index, todo; ++ const char *zn; ++ int i, rc; ++ ++ todo = desc->end - desc->start + 1; ++ onoff = enable ? "online" : "offline"; ++ ++ if (enable && zone_id >= 0) { ++ if (zone_id == ZONE_MOVABLE) ++ onoff = "online_movable"; ++ else ++ onoff = "online_kernel"; ++ } ++ ++ for (i = 0; i < desc->ndirs; i++) { ++ name = desc->dirs[i]->d_name; ++ index = strtou64_or_err(name + 6, _("Failed to parse index")); ++ if (index < desc->start) ++ continue; ++ if (index > desc->end) ++ break; ++ idxtostr(desc, index, str, sizeof(str)); ++ path_read_str(line, sizeof(line), _PATH_SYS_MEMORY "/%s/state", name); ++ if (strncmp(onoff, line, 6) == 0) { ++ if (desc->verbose && enable) ++ fprintf(stdout, _("%s already enabled\n"), str); ++ else if (desc->verbose && !enable) ++ fprintf(stdout, _("%s already disabled\n"), str); ++ todo--; ++ continue; ++ } ++ ++ if (desc->have_zones) { ++ path_read_str(line, sizeof(line), ++ _PATH_SYS_MEMORY "/%s/valid_zones", name); ++ if (zone_id >= 0) { ++ zn = zone_names[zone_id]; ++ if (enable && !strcasestr(line, zn)) { ++ warnx(_("%s enable failed: Zone mismatch"), str); ++ continue; ++ } ++ if (!enable && strncasecmp(line, zn, strlen(zn))) { ++ warnx(_("%s disable failed: Zone mismatch"), str); ++ continue; ++ } ++ } else if (enable) { ++ /* By default, use zone Movable for online, if valid */ ++ if (strcasestr(line, zone_names[ZONE_MOVABLE])) ++ onoff = "online_movable"; ++ else ++ onoff = "online"; ++ } ++ } ++ ++ rc = path_write_str(onoff, _PATH_SYS_MEMORY"/%s/state", name); ++ if (rc == -1) { ++ if (enable) ++ warn(_("%s enable failed"), str); ++ else ++ warn(_("%s disable failed"), str); ++ } else if (desc->verbose) { ++ if (enable) ++ fprintf(stdout, _("%s enabled\n"), str); ++ else ++ fprintf(stdout, _("%s disabled\n"), str); ++ } ++ if (rc == 0) ++ todo--; ++ } ++ return todo == 0 ? 0 : todo == desc->end - desc->start + 1 ? -1 : 1; ++} ++ ++static int filter(const struct dirent *de) ++{ ++ if (strncmp("memory", de->d_name, 6)) ++ return 0; ++ return isdigit_string(de->d_name + 6); ++} ++ ++static void read_info(struct chmem_desc *desc) ++{ ++ char line[BUFSIZ]; ++ ++ desc->ndirs = scandir(_PATH_SYS_MEMORY, &desc->dirs, filter, versionsort); ++ if (desc->ndirs <= 0) ++ err(EXIT_FAILURE, _("Failed to read %s"), _PATH_SYS_MEMORY); ++ path_read_str(line, sizeof(line), _PATH_SYS_MEMORY_BLOCK_SIZE); ++ desc->block_size = strtoumax(line, NULL, 16); ++} ++ ++static void parse_single_param(struct chmem_desc *desc, char *str) ++{ ++ if (desc->use_blocks) { ++ desc->start = strtou64_or_err(str, _("Failed to parse block number")); ++ desc->end = desc->start; ++ return; ++ } ++ desc->is_size = 1; ++ desc->size = strtosize_or_err(str, _("Failed to parse size")); ++ if (isdigit(str[strlen(str) - 1])) ++ desc->size *= 1024*1024; ++ if (desc->size % desc->block_size) { ++ errx(EXIT_FAILURE, _("Size must be aligned to memory block size (%s)"), ++ size_to_human_string(SIZE_SUFFIX_1LETTER, desc->block_size)); ++ } ++ desc->size /= desc->block_size; ++} ++ ++static void parse_range_param(struct chmem_desc *desc, char *start, char *end) ++{ ++ if (desc->use_blocks) { ++ desc->start = strtou64_or_err(start, _("Failed to parse start")); ++ desc->end = strtou64_or_err(end, _("Failed to parse end")); ++ return; ++ } ++ if (strlen(start) < 2 || start[1] != 'x') ++ errx(EXIT_FAILURE, _("Invalid start address format: %s"), start); ++ if (strlen(end) < 2 || end[1] != 'x') ++ errx(EXIT_FAILURE, _("Invalid end address format: %s"), end); ++ desc->start = strtox64_or_err(start, _("Failed to parse start address")); ++ desc->end = strtox64_or_err(end, _("Failed to parse end address")); ++ if (desc->start % desc->block_size || (desc->end + 1) % desc->block_size) { ++ errx(EXIT_FAILURE, ++ _("Start address and (end address + 1) must be aligned to " ++ "memory block size (%s)"), ++ size_to_human_string(SIZE_SUFFIX_1LETTER, desc->block_size)); ++ } ++ desc->start /= desc->block_size; ++ desc->end /= desc->block_size; ++} ++ ++static void parse_parameter(struct chmem_desc *desc, char *param) ++{ ++ char **split; ++ ++ split = strv_split(param, "-"); ++ if (strv_length(split) > 2) ++ errx(EXIT_FAILURE, _("Invalid parameter: %s"), param); ++ if (strv_length(split) == 1) ++ parse_single_param(desc, split[0]); ++ else ++ parse_range_param(desc, split[0], split[1]); ++ strv_free(split); ++ if (desc->start > desc->end) ++ errx(EXIT_FAILURE, _("Invalid range: %s"), param); ++} ++ ++static void __attribute__((__noreturn__)) usage(void) ++{ ++ FILE *out = stdout; ++ size_t i; ++ ++ fputs(USAGE_HEADER, out); ++ fprintf(out, _(" %s [options] [SIZE|RANGE|BLOCKRANGE]\n"), program_invocation_short_name); ++ ++ fputs(USAGE_SEPARATOR, out); ++ fputs(_("Set a particular size or range of memory online or offline.\n"), out); ++ ++ fputs(USAGE_OPTIONS, out); ++ fputs(_(" -e, --enable enable memory\n"), out); ++ fputs(_(" -d, --disable disable memory\n"), out); ++ fputs(_(" -b, --blocks use memory blocks\n"), out); ++ fputs(_(" -z, --zone select memory zone (see below)\n"), out); ++ fputs(_(" -v, --verbose verbose output\n"), out); ++ printf(USAGE_HELP_OPTIONS(20)); ++ ++ fputs(_("\nSupported zones:\n"), out); ++ for (i = 0; i < ARRAY_SIZE(zone_names); i++) ++ fprintf(out, " %s\n", zone_names[i]); ++ ++ printf(USAGE_MAN_TAIL("chmem(8)")); ++ ++ exit(EXIT_SUCCESS); ++} ++ ++int main(int argc, char **argv) ++{ ++ struct chmem_desc _desc = { }, *desc = &_desc; ++ int cmd = CMD_NONE, zone_id = -1; ++ char *zone = NULL; ++ int c, rc; ++ ++ static const struct option longopts[] = { ++ {"block", no_argument, NULL, 'b'}, ++ {"disable", no_argument, NULL, 'd'}, ++ {"enable", no_argument, NULL, 'e'}, ++ {"help", no_argument, NULL, 'h'}, ++ {"verbose", no_argument, NULL, 'v'}, ++ {"version", no_argument, NULL, 'V'}, ++ {"zone", required_argument, NULL, 'z'}, ++ {NULL, 0, NULL, 0} ++ }; ++ ++ static const ul_excl_t excl[] = { /* rows and cols in ASCII order */ ++ { 'd','e' }, ++ { 0 } ++ }; ++ int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT; ++ ++ setlocale(LC_ALL, ""); ++ bindtextdomain(PACKAGE, LOCALEDIR); ++ textdomain(PACKAGE); ++ atexit(close_stdout); ++ ++ read_info(desc); ++ ++ while ((c = getopt_long(argc, argv, "bdehvVz:", longopts, NULL)) != -1) { ++ ++ err_exclusive_options(c, longopts, excl, excl_st); ++ ++ switch (c) { ++ case 'd': ++ cmd = CMD_MEMORY_DISABLE; ++ break; ++ case 'e': ++ cmd = CMD_MEMORY_ENABLE; ++ break; ++ case 'b': ++ desc->use_blocks = 1; ++ break; ++ case 'h': ++ usage(); ++ break; ++ case 'v': ++ desc->verbose = 1; ++ break; ++ case 'V': ++ printf(UTIL_LINUX_VERSION); ++ return EXIT_SUCCESS; ++ case 'z': ++ zone = xstrdup(optarg); ++ break; ++ default: ++ errtryhelp(EXIT_FAILURE); ++ } ++ } ++ ++ if ((argc == 1) || (argc != optind + 1) || (cmd == CMD_NONE)) { ++ warnx(_("bad usage")); ++ errtryhelp(EXIT_FAILURE); ++ } ++ ++ parse_parameter(desc, argv[optind]); ++ ++ /* The valid_zones sysfs attribute was introduced with kernel 3.18 */ ++ if (path_exist(_PATH_SYS_MEMORY "/memory0/valid_zones")) ++ desc->have_zones = 1; ++ else if (zone) ++ warnx(_("zone ignored, no valid_zones sysfs attribute present")); ++ ++ if (zone && desc->have_zones) { ++ zone_id = zone_name_to_id(zone); ++ if (zone_id == -1) { ++ warnx(_("unknown memory zone: %s"), zone); ++ errtryhelp(EXIT_FAILURE); ++ } ++ } ++ ++ if (desc->is_size) ++ rc = chmem_size(desc, cmd == CMD_MEMORY_ENABLE ? 1 : 0, zone_id); ++ else ++ rc = chmem_range(desc, cmd == CMD_MEMORY_ENABLE ? 1 : 0, zone_id); ++ ++ return rc == 0 ? EXIT_SUCCESS : ++ rc < 0 ? EXIT_FAILURE : CHMEM_EXIT_SOMEOK; ++} +diff --git a/sys-utils/lsmem.1 b/sys-utils/lsmem.1 +new file mode 100644 +index 000000000..3f5cd7d4b +--- /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 ++[options] ++.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. ++ ++The default output compatible with original implementation from s390-tools, but ++it's strongly recommended to avoid using default outputs in your scripts. ++Always explicitly define expected columns by using the \fB\-\-output\fR option ++together with a columns list in environments where a stable output is required. ++ ++The \fBlsmem\fP command lists a new memory range always when the current memory ++block distinguish from the previous block by STATE, REMOVABLE, NODE or ZONES ++attribute. This default behavior is possible to override by the ++\fB\-\-split\fR option (e.g. \fBlsmem \-\-split=STATE,ZONES\fR). The special ++word "none" may be used to ignore all differences between memory blocks and to ++create as large as possible continuous ranges. The opposite semantic is ++\fB\-\-all\fR to list individual memory blocks. The default split policy is ++subject to change. Always explicitly use \fB\-\-split\fR in environments where ++a stable output is required. ++ ++Note that some output columns may provide inaccurate information if a split policy ++forces \fBlsmem\fP to ignore diffrences in some attributes. For example if you ++merge removable and non-removable memory blocks to the one range than all ++the range will be marked as non-removable on \fBlsmem\fP output. ++ ++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. ++ ++Use the \fB\-\-help\fR option to see the columns description. ++ ++.SH OPTIONS ++.TP ++.BR \-a ", " \-\-all ++List each individual memory block, instead of combining memory blocks with ++similar attributes. ++.TP ++.BR \-b , " \-\-bytes" ++Print the SIZE column in bytes rather than in a human-readable format. ++.TP ++.BR \-h ", " \-\-help ++Display help text and exit. ++.TP ++.BR \-n , " \-\-noheadings" ++Do not print a header line. ++.TP ++.BR \-o , " \-\-output " \fIlist\fP ++Specify which output columns to print. Use \fB\-\-help\fR ++to get a list of all supported columns. ++The default list of columns may be extended if \fIlist\fP is ++specified in the format \fB+\fIlist\fP (e.g. \fBlsmem \-o +NODE\fP). ++.TP ++.BR \-P , " \-\-pairs" ++Produce output in the form of key="value" pairs. ++All potentially unsafe characters are hex-escaped (\\x). ++.TP ++.BR \-r , " \-\-raw" ++Produce output in raw format. All potentially unsafe characters are hex-escaped ++(\\x). ++.TP ++.BR \-S , " \-\-split " \fIlist\fP ++Specify which columns (attributes) use to split memory blocks to ranges. The ++supported columns are STATE, REMOVABLE, NODE and ZONES, or "none". The another columns are ++silently ignored. For more details see DESCRIPTION above. ++.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. ++.TP ++\fB\-\-summary\fR[=\fIwhen\fR] ++This option controls summary lines output. The optional argument \fIwhen\fP can be ++\fBnever\fR, \fBalways\fR or \fBonly\fR. If the \fIwhen\fR argument is ++omitted, it defaults to \fB"only"\fR. The summary output is suppresed for ++\fB\-\-raw\fR and \fB\-\-pairs\fR. ++.SH AUTHOR ++.B lsmem ++was originally written by Gerald Schaefer for s390-tools in Perl. The C version ++for util-linux was written by Clemens von Mann, Heiko Carstens and Karel Zak. ++.SH SEE ALSO ++.BR chmem (8) ++.SH AVAILABILITY ++The \fBlsmem\fP command is part of the util-linux package and is available from ++.UR https://\:www.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 000000000..34a2847af +--- /dev/null ++++ b/sys-utils/lsmem.c +@@ -0,0 +1,687 @@ ++/* ++ * lsmem - Show memory configuration ++ * ++ * Copyright IBM Corp. 2016 ++ * Copyright (C) 2016 Karel Zak ++ * ++ * 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 ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#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 ++ ++enum zone_id { ++ ZONE_DMA = 0, ++ ZONE_DMA32, ++ ZONE_NORMAL, ++ ZONE_HIGHMEM, ++ ZONE_MOVABLE, ++ ZONE_DEVICE, ++ ZONE_NONE, ++ ZONE_UNKNOWN, ++ MAX_NR_ZONES, ++}; ++ ++struct memory_block { ++ uint64_t index; ++ uint64_t count; ++ int state; ++ int node; ++ int nr_zones; ++ int zones[MAX_NR_ZONES]; ++ unsigned int removable:1; ++}; ++ ++struct lsmem { ++ struct dirent **dirs; ++ int ndirs; ++ struct memory_block *blocks; ++ int nblocks; ++ uint64_t block_size; ++ uint64_t mem_online; ++ uint64_t mem_offline; ++ ++ struct libscols_table *table; ++ unsigned int have_nodes : 1, ++ raw : 1, ++ export : 1, ++ noheadings : 1, ++ summary : 1, ++ list_all : 1, ++ bytes : 1, ++ want_summary : 1, ++ want_table : 1, ++ split_by_node : 1, ++ split_by_state : 1, ++ split_by_removable : 1, ++ split_by_zones : 1, ++ have_zones : 1; ++}; ++ ++ ++enum { ++ COL_RANGE, ++ COL_SIZE, ++ COL_STATE, ++ COL_REMOVABLE, ++ COL_BLOCK, ++ COL_NODE, ++ COL_ZONES, ++}; ++ ++static char *zone_names[] = { ++ [ZONE_DMA] = "DMA", ++ [ZONE_DMA32] = "DMA32", ++ [ZONE_NORMAL] = "Normal", ++ [ZONE_HIGHMEM] = "Highmem", ++ [ZONE_MOVABLE] = "Movable", ++ [ZONE_DEVICE] = "Device", ++ [ZONE_NONE] = "None", /* block contains more than one zone, can't be offlined */ ++ [ZONE_UNKNOWN] = "Unknown", ++}; ++ ++/* column names */ ++struct coldesc { ++ 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 */ ++static struct coldesc coldescs[] = { ++ [COL_RANGE] = { "RANGE", 0, 0, N_("start and end address of the memory range")}, ++ [COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the memory range")}, ++ [COL_STATE] = { "STATE", 0, SCOLS_FL_RIGHT, N_("online status of the memory range")}, ++ [COL_REMOVABLE] = { "REMOVABLE", 0, SCOLS_FL_RIGHT, N_("memory is removable")}, ++ [COL_BLOCK] = { "BLOCK", 0, SCOLS_FL_RIGHT, N_("memory block number or blocks range")}, ++ [COL_NODE] = { "NODE", 0, SCOLS_FL_RIGHT, N_("numa node of memory")}, ++ [COL_ZONES] = { "ZONES", 0, SCOLS_FL_RIGHT, N_("valid zones for the memory range")}, ++}; ++ ++/* columns[] array specifies all currently wanted output column. The columns ++ * are defined by coldescs[] array and you can specify (on command line) each ++ * column twice. That's enough, dynamically allocated array of the columns is ++ * unnecessary overkill and over-engineering in this case */ ++static int columns[ARRAY_SIZE(coldescs) * 2]; ++static size_t ncolumns; ++ ++static inline size_t err_columns_index(size_t arysz, size_t idx) ++{ ++ if (idx >= arysz) ++ errx(EXIT_FAILURE, _("too many columns specified, " ++ "the limit is %zu columns"), ++ arysz - 1); ++ return idx; ++} ++ ++/* ++ * name must be null-terminated ++ */ ++static int zone_name_to_id(const char *name) ++{ ++ size_t i; ++ ++ for (i = 0; i < ARRAY_SIZE(zone_names); i++) { ++ if (!strcasecmp(name, zone_names[i])) ++ return i; ++ } ++ return ZONE_UNKNOWN; ++} ++ ++#define add_column(ary, n, id) \ ++ ((ary)[ err_columns_index(ARRAY_SIZE(ary), (n)) ] = (id)) ++ ++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 inline int get_column_id(int num) ++{ ++ assert(num >= 0); ++ assert((size_t) num < ncolumns); ++ assert(columns[num] < (int) ARRAY_SIZE(coldescs)); ++ ++ return columns[num]; ++} ++ ++static inline struct coldesc *get_column_desc(int num) ++{ ++ return &coldescs[ get_column_id(num) ]; ++} ++ ++static inline void reset_split_policy(struct lsmem *l, int enable) ++{ ++ l->split_by_state = enable; ++ l->split_by_node = enable; ++ l->split_by_removable = enable; ++ l->split_by_zones = enable; ++} ++ ++static void add_scols_line(struct lsmem *lsmem, struct memory_block *blk) ++{ ++ size_t i; ++ struct libscols_line *line; ++ ++ line = scols_table_new_line(lsmem->table, NULL); ++ if (!line) ++ err_oom(); ++ ++ for (i = 0; i < ncolumns; i++) { ++ char *str = NULL; ++ ++ switch (get_column_id(i)) { ++ case COL_RANGE: ++ { ++ uint64_t start = blk->index * lsmem->block_size; ++ uint64_t size = blk->count * lsmem->block_size; ++ xasprintf(&str, "0x%016"PRIx64"-0x%016"PRIx64, start, start + size - 1); ++ break; ++ } ++ case COL_SIZE: ++ if (lsmem->bytes) ++ xasprintf(&str, "%"PRId64, (uint64_t) blk->count * lsmem->block_size); ++ else ++ str = size_to_human_string(SIZE_SUFFIX_1LETTER, ++ (uint64_t) blk->count * lsmem->block_size); ++ break; ++ case COL_STATE: ++ str = xstrdup( ++ blk->state == MEMORY_STATE_ONLINE ? _("online") : ++ blk->state == MEMORY_STATE_OFFLINE ? _("offline") : ++ blk->state == MEMORY_STATE_GOING_OFFLINE ? _("on->off") : ++ "?"); ++ break; ++ case COL_REMOVABLE: ++ if (blk->state == MEMORY_STATE_ONLINE) ++ str = xstrdup(blk->removable ? _("yes") : _("no")); ++ else ++ str = xstrdup("-"); ++ break; ++ case COL_BLOCK: ++ if (blk->count == 1) ++ xasprintf(&str, "%"PRId64, blk->index); ++ else ++ xasprintf(&str, "%"PRId64"-%"PRId64, ++ blk->index, blk->index + blk->count - 1); ++ break; ++ case COL_NODE: ++ if (lsmem->have_nodes) ++ xasprintf(&str, "%d", blk->node); ++ else ++ str = xstrdup("-"); ++ break; ++ case COL_ZONES: ++ if (lsmem->have_zones) { ++ char valid_zones[BUFSIZ]; ++ int j, zone_id; ++ ++ valid_zones[0] = '\0'; ++ for (j = 0; j < blk->nr_zones; j++) { ++ zone_id = blk->zones[j]; ++ if (strlen(valid_zones) + ++ strlen(zone_names[zone_id]) > BUFSIZ - 2) ++ break; ++ strcat(valid_zones, zone_names[zone_id]); ++ if (j + 1 < blk->nr_zones) ++ strcat(valid_zones, "/"); ++ } ++ str = xstrdup(valid_zones); ++ } else ++ str = xstrdup("-"); ++ break; ++ } ++ ++ if (str && scols_line_refer_data(line, i, str) != 0) ++ err_oom(); ++ } ++} ++ ++static void fill_scols_table(struct lsmem *lsmem) ++{ ++ int i; ++ ++ for (i = 0; i < lsmem->nblocks; i++) ++ add_scols_line(lsmem, &lsmem->blocks[i]); ++} ++ ++static void print_summary(struct lsmem *lsmem) ++{ ++ if (lsmem->bytes) { ++ printf("%-23s %15"PRId64"\n",_("Memory block size:"), lsmem->block_size); ++ printf("%-23s %15"PRId64"\n",_("Total online memory:"), lsmem->mem_online); ++ printf("%-23s %15"PRId64"\n",_("Total offline memory:"), lsmem->mem_offline); ++ } else { ++ printf("%-23s %5s\n",_("Memory block size:"), ++ size_to_human_string(SIZE_SUFFIX_1LETTER, lsmem->block_size)); ++ printf("%-23s %5s\n",_("Total online memory:"), ++ size_to_human_string(SIZE_SUFFIX_1LETTER, lsmem->mem_online)); ++ printf("%-23s %5s\n",_("Total offline memory:"), ++ size_to_human_string(SIZE_SUFFIX_1LETTER, lsmem->mem_offline)); ++ } ++} ++ ++static int memory_block_get_node(char *name) ++{ ++ struct dirent *de; ++ const char *path; ++ DIR *dir; ++ int node; ++ ++ path = path_get(_PATH_SYS_MEMORY"/%s", name); ++ if (!path || !(dir= opendir(path))) ++ err(EXIT_FAILURE, _("Failed to open %s"), path ? path : name); ++ ++ 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); ++ break; ++ } ++ closedir(dir); ++ return node; ++} ++ ++static void memory_block_read_attrs(struct lsmem *lsmem, char *name, ++ struct memory_block *blk) ++{ ++ char *token = NULL; ++ char line[BUFSIZ]; ++ int i; ++ ++ blk->count = 1; ++ blk->index = strtoumax(name + 6, NULL, 10); /* get of "memory" */ ++ blk->removable = path_read_u64(_PATH_SYS_MEMORY"/%s/removable", name); ++ blk->state = MEMORY_STATE_UNKNOWN; ++ ++ path_read_str(line, sizeof(line), _PATH_SYS_MEMORY"/%s/state", name); ++ 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 (lsmem->have_nodes) ++ blk->node = memory_block_get_node(name); ++ ++ blk->nr_zones = 0; ++ if (lsmem->have_zones) { ++ path_read_str(line, sizeof(line), _PATH_SYS_MEMORY"/%s/valid_zones", name); ++ token = strtok(line, " "); ++ } ++ for (i = 0; i < MAX_NR_ZONES; i++) { ++ if (token) { ++ blk->zones[i] = zone_name_to_id(token); ++ blk->nr_zones++; ++ token = strtok(NULL, " "); ++ } ++ } ++} ++ ++static int is_mergeable(struct lsmem *lsmem, struct memory_block *blk) ++{ ++ struct memory_block *curr; ++ int i; ++ ++ if (!lsmem->nblocks) ++ return 0; ++ curr = &lsmem->blocks[lsmem->nblocks - 1]; ++ if (lsmem->list_all) ++ return 0; ++ if (curr->index + curr->count != blk->index) ++ return 0; ++ if (lsmem->split_by_state && curr->state != blk->state) ++ return 0; ++ if (lsmem->split_by_removable && curr->removable != blk->removable) ++ return 0; ++ if (lsmem->split_by_node && lsmem->have_nodes) { ++ if (curr->node != blk->node) ++ return 0; ++ } ++ if (lsmem->split_by_zones && lsmem->have_zones) { ++ if (curr->nr_zones != blk->nr_zones) ++ return 0; ++ for (i = 0; i < curr->nr_zones; i++) { ++ if (curr->zones[i] == ZONE_UNKNOWN || ++ curr->zones[i] != blk->zones[i]) ++ return 0; ++ } ++ } ++ return 1; ++} ++ ++static void read_info(struct lsmem *lsmem) ++{ ++ struct memory_block blk; ++ char line[BUFSIZ]; ++ int i; ++ ++ path_read_str(line, sizeof(line), _PATH_SYS_MEMORY_BLOCK_SIZE); ++ lsmem->block_size = strtoumax(line, NULL, 16); ++ ++ for (i = 0; i < lsmem->ndirs; i++) { ++ memory_block_read_attrs(lsmem, lsmem->dirs[i]->d_name, &blk); ++ if (is_mergeable(lsmem, &blk)) { ++ lsmem->blocks[lsmem->nblocks - 1].count++; ++ continue; ++ } ++ lsmem->nblocks++; ++ lsmem->blocks = xrealloc(lsmem->blocks, lsmem->nblocks * sizeof(blk)); ++ *&lsmem->blocks[lsmem->nblocks - 1] = blk; ++ } ++ for (i = 0; i < lsmem->nblocks; i++) { ++ if (lsmem->blocks[i].state == MEMORY_STATE_ONLINE) ++ lsmem->mem_online += lsmem->block_size * lsmem->blocks[i].count; ++ else ++ lsmem->mem_offline += lsmem->block_size * lsmem->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 *lsmem) ++{ ++ const char *dir; ++ ++ if (!path_exist(_PATH_SYS_MEMORY_BLOCK_SIZE)) ++ errx(EXIT_FAILURE, _("This system does not support memory blocks")); ++ ++ dir = path_get(_PATH_SYS_MEMORY); ++ if (!dir) ++ err(EXIT_FAILURE, _("Failed to read %s"), _PATH_SYS_MEMORY); ++ ++ lsmem->ndirs = scandir(dir, &lsmem->dirs, memory_block_filter, versionsort); ++ if (lsmem->ndirs <= 0) ++ err(EXIT_FAILURE, _("Failed to read %s"), _PATH_SYS_MEMORY); ++ ++ if (memory_block_get_node(lsmem->dirs[0]->d_name) != -1) ++ lsmem->have_nodes = 1; ++ ++ /* The valid_zones sysfs attribute was introduced with kernel 3.18 */ ++ if (path_exist(_PATH_SYS_MEMORY "/memory0/valid_zones")) ++ lsmem->have_zones = 1; ++} ++ ++static void __attribute__((__noreturn__)) usage(void) ++{ ++ FILE *out = stdout; ++ size_t 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(_(" -P, --pairs use key=\"value\" output format\n"), out); ++ fputs(_(" -a, --all list each individual memory block\n"), out); ++ fputs(_(" -b, --bytes print SIZE in bytes rather than in human readable format\n"), out); ++ fputs(_(" -n, --noheadings don't print headings\n"), out); ++ fputs(_(" -o, --output output columns\n"), out); ++ fputs(_(" -r, --raw use raw output format\n"), out); ++ fputs(_(" -S, --split split ranges by specified columns\n"), out); ++ fputs(_(" -s, --sysroot use the specified directory as system root\n"), out); ++ fputs(_(" --summary[=when] print summary information (never,always or only)\n"), out); ++ ++ fputs(USAGE_SEPARATOR, out); ++ printf(USAGE_HELP_OPTIONS(22)); ++ ++ fputs(USAGE_COLUMNS, out); ++ for (i = 0; i < ARRAY_SIZE(coldescs); i++) ++ fprintf(out, " %10s %s\n", coldescs[i].name, _(coldescs[i].help)); ++ ++ printf(USAGE_MAN_TAIL("lsmem(1)")); ++ ++ exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS); ++} ++ ++int main(int argc, char **argv) ++{ ++ struct lsmem _lsmem = { ++ .want_table = 1, ++ .want_summary = 1 ++ }, *lsmem = &_lsmem; ++ ++ const char *outarg = NULL, *splitarg = NULL; ++ int c; ++ size_t i; ++ ++ enum { ++ LSMEM_OPT_SUMARRY = CHAR_MAX + 1 ++ }; ++ ++ static const struct option longopts[] = { ++ {"all", no_argument, NULL, 'a'}, ++ {"bytes", no_argument, NULL, 'b'}, ++ {"help", no_argument, NULL, 'h'}, ++ {"noheadings", no_argument, NULL, 'n'}, ++ {"output", required_argument, NULL, 'o'}, ++ {"pairs", no_argument, NULL, 'P'}, ++ {"raw", no_argument, NULL, 'r'}, ++ {"sysroot", required_argument, NULL, 's'}, ++ {"split", required_argument, NULL, 'S'}, ++ {"version", no_argument, NULL, 'V'}, ++ {"summary", optional_argument, NULL, LSMEM_OPT_SUMARRY }, ++ {NULL, 0, NULL, 0} ++ }; ++ static const ul_excl_t excl[] = { /* rows and cols in ASCII order */ ++ { 'J', 'P', 'r' }, ++ { 'S', 'a' }, ++ { 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, "abhJno:PrS:s:V", longopts, NULL)) != -1) { ++ ++ err_exclusive_options(c, longopts, excl, excl_st); ++ ++ switch (c) { ++ case 'a': ++ lsmem->list_all = 1; ++ break; ++ case 'b': ++ lsmem->bytes = 1; ++ break; ++ case 'h': ++ usage(); ++ break; ++ case 'n': ++ lsmem->noheadings = 1; ++ break; ++ case 'o': ++ outarg = optarg; ++ break; ++ case 'P': ++ lsmem->export = 1; ++ lsmem->want_summary = 0; ++ break; ++ case 'r': ++ lsmem->raw = 1; ++ lsmem->want_summary = 0; ++ break; ++ case 's': ++ if(path_set_prefix(optarg)) ++ err(EXIT_FAILURE, _("invalid argument to %s"), "--sysroot"); ++ break; ++ case 'S': ++ splitarg = optarg; ++ break; ++ case 'V': ++ printf(UTIL_LINUX_VERSION); ++ return 0; ++ case LSMEM_OPT_SUMARRY: ++ if (optarg) { ++ if (strcmp(optarg, "never") == 0) ++ lsmem->want_summary = 0; ++ else if (strcmp(optarg, "only") == 0) ++ lsmem->want_table = 0; ++ else if (strcmp(optarg, "always") == 0) ++ lsmem->want_summary = 1; ++ else ++ errx(EXIT_FAILURE, _("unsupported --summary argument")); ++ } else ++ lsmem->want_table = 0; ++ break; ++ default: ++ errtryhelp(EXIT_FAILURE); ++ } ++ } ++ ++ if (argc != optind) { ++ warnx(_("bad usage")); ++ errtryhelp(EXIT_FAILURE); ++ } ++ ++ if (lsmem->want_table + lsmem->want_summary == 0) ++ errx(EXIT_FAILURE, _("options --{raw,pairs} and --summary=only are mutually exclusive")); ++ ++ /* Shortcut to avoid scols machinery on --summary=only */ ++ if (lsmem->want_table == 0 && lsmem->want_summary) { ++ read_basic_info(lsmem); ++ read_info(lsmem); ++ print_summary(lsmem); ++ return EXIT_SUCCESS; ++ } ++ ++ /* ++ * Default columns ++ */ ++ if (!ncolumns) { ++ add_column(columns, ncolumns++, COL_RANGE); ++ add_column(columns, ncolumns++, COL_SIZE); ++ add_column(columns, ncolumns++, COL_STATE); ++ add_column(columns, ncolumns++, COL_REMOVABLE); ++ add_column(columns, ncolumns++, COL_BLOCK); ++ } ++ ++ if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns), ++ (int *) &ncolumns, column_name_to_id) < 0) ++ return EXIT_FAILURE; ++ ++ /* ++ * Initialize output ++ */ ++ scols_init_debug(0); ++ ++ if (!(lsmem->table = scols_new_table())) ++ errx(EXIT_FAILURE, _("failed to initialize output table")); ++ scols_table_enable_raw(lsmem->table, lsmem->raw); ++ scols_table_enable_export(lsmem->table, lsmem->export); ++ scols_table_enable_noheadings(lsmem->table, lsmem->noheadings); ++ ++ for (i = 0; i < ncolumns; i++) { ++ struct coldesc *ci = get_column_desc(i); ++ if (!scols_table_new_column(lsmem->table, ci->name, ci->whint, ci->flags)) ++ err(EXIT_FAILURE, _("Failed to initialize output column")); ++ } ++ ++ if (splitarg) { ++ int split[ARRAY_SIZE(coldescs)] = { 0 }; ++ static size_t nsplits = 0; ++ ++ reset_split_policy(lsmem, 0); /* disable all */ ++ ++ if (strcasecmp(splitarg, "none") == 0) ++ ; ++ else if (string_add_to_idarray(splitarg, split, ARRAY_SIZE(split), ++ (int *) &nsplits, column_name_to_id) < 0) ++ return EXIT_FAILURE; ++ ++ for (i = 0; i < nsplits; i++) { ++ switch (split[i]) { ++ case COL_STATE: ++ lsmem->split_by_state = 1; ++ break; ++ case COL_NODE: ++ lsmem->split_by_node = 1; ++ break; ++ case COL_REMOVABLE: ++ lsmem->split_by_removable = 1; ++ break; ++ case COL_ZONES: ++ lsmem->split_by_zones = 1; ++ break; ++ } ++ } ++ } else ++ reset_split_policy(lsmem, 1); /* enable all */ ++ ++ /* ++ * Read data and print output ++ */ ++ read_basic_info(lsmem); ++ read_info(lsmem); ++ ++ if (lsmem->want_table) { ++ fill_scols_table(lsmem); ++ scols_print_table(lsmem->table); ++ ++ if (lsmem->want_summary) ++ fputc('\n', stdout); ++ } ++ ++ if (lsmem->want_summary) ++ print_summary(lsmem); ++ ++ scols_unref_table(lsmem->table); ++ return 0; ++} +-- +2.13.6