rpms/s390utils
7
0
Fork 0
Code Issues Pull Requests Releases Activity
c46bddaf55
s390utils/0049-hyptop-Show-hypervisor-performance-data-on-System-z.patch

8265 lines
185 KiB
Diff
Raw Normal View History

updated to recent RHEL-6 package
2011-03-25 13:59:32 +00:00
From 096c2b87270417456ce9d92046838795ccd32ad1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dan=20Hor=C3=A1k?= <dan@danny.cz>
Date: Fri, 28 Jan 2011 13:16:36 +0100
Subject: [PATCH 49/61] hyptop: Show hypervisor performance data on System z
Summary: hyptop: Show hypervisor performance data on System z
Description: hyptop provides a dynamic real-time view of a System z hypervisor
environment. It works with the z/VM and LPAR hypervisor. Depending
on the available data it shows e.g. CPU and memory consumption of
active LPARs or z/VM guests. The tool provides a curses based
user interface similar to the popular Linux 'top' command.
---
Makefile | 2 +-
hyptop/Makefile | 27 +
hyptop/dg_debugfs.c | 86 ++++
hyptop/dg_debugfs.h | 20 +
hyptop/dg_debugfs_lpar.c | 361 ++++++++++++++
hyptop/dg_debugfs_vm.c | 267 ++++++++++
hyptop/helper.c | 383 ++++++++++++++
hyptop/helper.h | 100 ++++
hyptop/hyptop.8 | 213 ++++++++
hyptop/hyptop.c | 352 +++++++++++++
hyptop/hyptop.h | 220 +++++++++
hyptop/nav_desc.c | 243 +++++++++
hyptop/nav_desc.h | 55 ++
hyptop/opts.c | 416 ++++++++++++++++
hyptop/opts.h | 20 +
hyptop/sd.h | 479 ++++++++++++++++++
hyptop/sd_core.c | 435 ++++++++++++++++
hyptop/sd_cpu_items.c | 178 +++++++
hyptop/sd_sys_items.c | 325 ++++++++++++
hyptop/table.c | 1231 ++++++++++++++++++++++++++++++++++++++++++++++
hyptop/table.h | 424 ++++++++++++++++
hyptop/table_col_unit.c | 369 ++++++++++++++
hyptop/tbox.c | 240 +++++++++
hyptop/tbox.h | 52 ++
hyptop/win_cpu_types.c | 248 ++++++++++
hyptop/win_cpu_types.h | 26 +
hyptop/win_fields.c | 272 ++++++++++
hyptop/win_fields.h | 31 ++
hyptop/win_help.c | 122 +++++
hyptop/win_help.h | 23 +
hyptop/win_sys.c | 387 +++++++++++++++
hyptop/win_sys_list.c | 380 ++++++++++++++
32 files changed, 7986 insertions(+), 1 deletions(-)
create mode 100644 hyptop/Makefile
create mode 100644 hyptop/dg_debugfs.c
create mode 100644 hyptop/dg_debugfs.h
create mode 100644 hyptop/dg_debugfs_lpar.c
create mode 100644 hyptop/dg_debugfs_vm.c
create mode 100644 hyptop/helper.c
create mode 100644 hyptop/helper.h
create mode 100644 hyptop/hyptop.8
create mode 100644 hyptop/hyptop.c
create mode 100644 hyptop/hyptop.h
create mode 100644 hyptop/nav_desc.c
create mode 100644 hyptop/nav_desc.h
create mode 100644 hyptop/opts.c
create mode 100644 hyptop/opts.h
create mode 100644 hyptop/sd.h
create mode 100644 hyptop/sd_core.c
create mode 100644 hyptop/sd_cpu_items.c
create mode 100644 hyptop/sd_sys_items.c
create mode 100644 hyptop/table.c
create mode 100644 hyptop/table.h
create mode 100644 hyptop/table_col_unit.c
create mode 100644 hyptop/tbox.c
create mode 100644 hyptop/tbox.h
create mode 100644 hyptop/win_cpu_types.c
create mode 100644 hyptop/win_cpu_types.h
create mode 100644 hyptop/win_fields.c
create mode 100644 hyptop/win_fields.h
create mode 100644 hyptop/win_help.c
create mode 100644 hyptop/win_help.h
create mode 100644 hyptop/win_sys.c
create mode 100644 hyptop/win_sys_list.c
diff --git a/Makefile b/Makefile
index 4b798bc..89c5fc5 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ LIB_DIRS = libvtoc libu2s
SUB_DIRS = $(LIB_DIRS) zipl zdump fdasd dasdfmt dasdview tunedasd \
tape390 osasnmpd qetharp ip_watcher qethconf scripts zconf \
vmconvert vmcp man mon_tools dasdinfo vmur cpuplugd ipl_tools \
- ziomon iucvterm
+ ziomon iucvterm hyptop
all: subdirs_make
diff --git a/hyptop/Makefile b/hyptop/Makefile
new file mode 100644
index 0000000..43d9e0f
--- /dev/null
+++ b/hyptop/Makefile
@@ -0,0 +1,27 @@
+include ../common.mak
+
+CPPFLAGS += -I../include
+
+all: hyptop
+
+LDLIBS += -lncurses
+
+OBJECTS = hyptop.o opts.o helper.o \
+ sd_core.o sd_sys_items.o sd_cpu_items.o \
+ tbox.o table.o table_col_unit.o \
+ dg_debugfs.o dg_debugfs_lpar.o dg_debugfs_vm.o \
+ win_sys_list.o win_sys.o win_fields.o \
+ win_cpu_types.o win_help.o nav_desc.o
+
+$(OBJECTS): *.h Makefile
+
+hyptop: $(OBJECTS)
+
+install: all
+ $(INSTALL) -g $(GROUP) -o $(OWNER) -m 755 hyptop $(USRSBINDIR)
+ $(INSTALL) -g $(GROUP) -o $(OWNER) -m 644 hyptop.8 $(MANDIR)/man8
+
+clean:
+ rm -f *.o *~ hyptop core
+
+.PHONY: all install clean
diff --git a/hyptop/dg_debugfs.c b/hyptop/dg_debugfs.c
new file mode 100644
index 0000000..13a6342
--- /dev/null
+++ b/hyptop/dg_debugfs.c
@@ -0,0 +1,86 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Common functions for debugfs data gatherer
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "helper.h"
+#include "hyptop.h"
+#include "dg_debugfs.h"
+
+static char *l_debugfs_dir;
+
+static void l_check_rc(int rc, int exit_on_err)
+{
+ if (!exit_on_err)
+ return;
+ if (rc == -EACCES)
+ ERR_EXIT("Permission denied, check \"%s/s390_hypfs/\"\n",
+ l_debugfs_dir);
+ if (rc != -ENOENT)
+ ERR_EXIT("Could not initialize data gatherer (%s)\n",
+ strerror(-rc));
+}
+
+static void l_check_rc_final(int rc, int exit_on_err)
+{
+ if (!exit_on_err)
+ return;
+ l_check_rc(rc, exit_on_err);
+ ERR_EXIT("Could not initialize data gatherer (%s)\n", strerror(-rc));
+}
+
+/*
+ * Initialize debugfs data gatherer backend
+ */
+int dg_debugfs_init(int exit_on_err)
+{
+ int rc;
+
+ l_debugfs_dir = ht_mount_point_get("debugfs");
+ if (!l_debugfs_dir) {
+ if (!exit_on_err)
+ return -ENODEV;
+ ERR_EXIT("Debugfs is not mounted, try \"mount none -t debugfs "
+ "/sys/kernel/debug\"\n");
+ }
+ rc = dg_debugfs_vm_init();
+ if (rc == 0)
+ return 0;
+ else
+ l_check_rc(rc, exit_on_err);
+ rc = dg_debugfs_lpar_init();
+ if (rc == 0)
+ return 0;
+ else
+ l_check_rc_final(rc, exit_on_err);
+ return rc;
+}
+
+/*
+ * Open a debugfs file
+ */
+int dg_debugfs_open(const char *file)
+{
+ char path[PATH_MAX];
+ int fh;
+
+ path[0] = 0;
+ strcat(path, l_debugfs_dir);
+ strcat(path, "/s390_hypfs/");
+ strcat(path, file);
+ fh = open(path, O_RDONLY);
+ if (fh == -1)
+ return -errno;
+ else
+ return fh;
+}
+
diff --git a/hyptop/dg_debugfs.h b/hyptop/dg_debugfs.h
new file mode 100644
index 0000000..f46956c
--- /dev/null
+++ b/hyptop/dg_debugfs.h
@@ -0,0 +1,20 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Common functions for debugfs data gatherer
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef DG_DEBUGFS_H
+#define DG_DEBUGFS_H
+
+#define DBFS_WAIT_TIME_US 10000
+
+extern int dg_debugfs_init(int exit_on_err);
+extern int dg_debugfs_vm_init(void);
+extern int dg_debugfs_lpar_init(void);
+extern int dg_debugfs_open(const char *file);
+
+#endif /* DG_DEBUGFS_H */
diff --git a/hyptop/dg_debugfs_lpar.c b/hyptop/dg_debugfs_lpar.c
new file mode 100644
index 0000000..4ae1b6d
--- /dev/null
+++ b/hyptop/dg_debugfs_lpar.c
@@ -0,0 +1,361 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Hyptop LPAR data gatherer that operates on debugfs
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <unistd.h>
+#include <string.h>
+#include <iconv.h>
+#include <errno.h>
+#include "hyptop.h"
+#include "sd.h"
+#include "helper.h"
+#include "dg_debugfs.h"
+
+#define LPAR_NAME_LEN 8
+#define TMP_SIZE 64
+#define LPAR_PHYS_FLG 0x80
+#define CPU_TYPE_LEN 16
+#define DEBUGFS_FILE "diag_204"
+
+static u64 l_update_time_us;
+static long l_204_buf_size;
+
+/*
+ * Diag data structure definition
+ */
+
+struct l_x_info_blk_hdr {
+ u8 npar;
+ u8 flags;
+ u8 reserved1[6];
+ u64 curtod1;
+ u64 curtod2;
+ u8 reserved[40];
+} __attribute__ ((packed));
+
+struct l_x_sys_hdr {
+ u8 reserved1;
+ u8 cpus;
+ u8 rcpus;
+ u8 reserved2[5];
+ char sys_name[LPAR_NAME_LEN];
+ u8 reserved3[80];
+} __attribute__ ((packed));
+
+static inline void l_sys_hdr__sys_name(struct l_x_sys_hdr *hdr, char *name)
+{
+ memcpy(name, hdr->sys_name, LPAR_NAME_LEN);
+ ht_ebcdic_to_ascii(name, LPAR_NAME_LEN);
+ name[LPAR_NAME_LEN] = 0;
+ ht_strstrip(name);
+}
+
+struct l_x_cpu_info {
+ u16 cpu_addr;
+ u8 reserved1[2];
+ u8 ctidx;
+ u8 reserved2[3];
+ u64 acc_time;
+ u64 lp_time;
+ u8 reserved3[6];
+ u8 reserved4[2];
+ u64 online_time;
+ u8 reserved5[56];
+} __attribute__ ((packed));
+
+static void l_idx2name(int index, char *name)
+{
+ switch (index) {
+ case 0:
+ strcpy(name, SD_CPU_TYPE_STR_CP);
+ break;
+ case 3:
+ strcpy(name, SD_CPU_TYPE_STR_IFL);
+ break;
+ default:
+ strcpy(name, SD_CPU_TYPE_STR_UN);
+ }
+}
+
+struct l_x_phys_hdr {
+ u8 reserved1[1];
+ u8 cpus;
+ u8 reserved2[94];
+} __attribute__ ((packed));
+
+struct l_x_phys_cpu {
+ u16 cpu_addr;
+ u8 reserved1[2];
+ u8 ctidx;
+ u8 reserved2[3];
+ u64 mgm_time;
+ u8 reserved3[80];
+} __attribute__ ((packed));
+
+/*
+ * Fill CPU with data
+ */
+static void l_sd_cpu_fill(struct sd_cpu *cpu, struct l_x_cpu_info *cpu_info)
+{
+ sd_cpu_cpu_time_us_set(cpu, cpu_info->lp_time);
+ sd_cpu_mgm_time_us_set(cpu, G0(cpu_info->acc_time - cpu_info->lp_time));
+ sd_cpu_online_time_us_set(cpu, cpu_info->online_time);
+}
+
+/*
+ * Fill system with data
+ */
+static void *l_sd_sys_fill(struct sd_sys *lpar, struct l_x_sys_hdr *sys_hdr)
+{
+ struct l_x_cpu_info *cpu_info;
+ int i;
+
+ cpu_info = (struct l_x_cpu_info *) (sys_hdr + 1);
+
+ for (i = 0; i < sys_hdr->rcpus; i++) {
+ char cpu_type[CPU_TYPE_LEN + 1];
+ struct sd_cpu *cpu;
+ char cpu_id[10];
+
+ sprintf(cpu_id, "%i", cpu_info->cpu_addr);
+
+ cpu = sd_cpu_get(lpar, cpu_id);
+ if (!cpu) {
+ l_idx2name(cpu_info->ctidx, cpu_type);
+ cpu = sd_cpu_new(lpar, cpu_id, cpu_type, 1);
+ }
+
+ l_sd_cpu_fill(cpu, cpu_info);
+
+ sd_cpu_commit(cpu);
+ cpu_info++;
+ }
+ return cpu_info;
+}
+
+/*
+ * Fill one physical CPU with data
+ */
+static void l_sd_cpu_phys_fill(struct sd_sys *sys,
+ struct l_x_phys_cpu *cpu_info)
+{
+ char cpu_type[CPU_TYPE_LEN + 1];
+ char cpu_id[TMP_SIZE];
+ struct sd_cpu *cpu;
+
+ snprintf(cpu_id, TMP_SIZE, "%i", cpu_info->cpu_addr);
+ cpu = sd_cpu_get(sys, cpu_id);
+ if (!cpu) {
+ l_idx2name(cpu_info->ctidx, cpu_type);
+ cpu = sd_cpu_new(sys, cpu_id, cpu_type, 1);
+ }
+ sd_cpu_mgm_time_us_set(cpu, cpu_info->mgm_time);
+ sd_cpu_real_type_set(cpu, cpu_type);
+ sd_cpu_commit(cpu);
+}
+
+/*
+ * Fill all physical CPUs with data
+ */
+static void l_sd_sys_root_cpu_phys_fill(struct sd_sys *sys,
+ struct l_x_phys_hdr *phys_hdr)
+{
+ struct l_x_phys_cpu *cpu_info;
+ int i;
+
+ cpu_info = (struct l_x_phys_cpu *) (phys_hdr + 1);
+ for (i = 0; i < phys_hdr->cpus; i++) {
+ l_sd_cpu_phys_fill(sys, cpu_info);
+ cpu_info++;
+ }
+}
+
+/*
+ * Header for debugfs file "diag_204"
+ */
+struct l_debugfs_d204_hdr {
+ u64 len;
+ u16 version;
+ u8 reserved[54];
+} __attribute__ ((packed));
+
+struct l_debugfs_d204 {
+ struct l_debugfs_d204_hdr h;
+ char buf[];
+} __attribute__ ((packed));
+
+/*
+ * Read debugfs file
+ */
+static void l_read_debugfs(struct l_debugfs_d204_hdr **hdr,
+ struct l_x_info_blk_hdr **data)
+{
+ long real_buf_size;
+ ssize_t rc;
+ void *buf;
+ int fh;
+
+ do {
+ fh = dg_debugfs_open(DEBUGFS_FILE);
+ *hdr = buf = ht_alloc(l_204_buf_size);
+ rc = read(fh, buf, l_204_buf_size);
+ if (rc == -1)
+ ERR_EXIT_ERRNO("Reading hypervisor data failed");
+ close(fh);
+ real_buf_size = (*hdr)->len + sizeof(struct l_debugfs_d204_hdr);
+ if (rc == real_buf_size)
+ break;
+ l_204_buf_size = real_buf_size;
+ ht_free(buf);
+ } while (1);
+ *data = buf + sizeof(struct l_debugfs_d204_hdr);
+}
+
+/*
+ * Fill System Data
+ */
+static void l_sd_sys_root_fill(struct sd_sys *sys)
+{
+ struct l_x_info_blk_hdr *time_hdr;
+ struct l_debugfs_d204_hdr *hdr;
+ struct l_x_sys_hdr *sys_hdr;
+ static int first = 1;
+ struct sd_sys *lpar;
+ char lpar_id[10];
+ int i;
+
+ do {
+ l_read_debugfs(&hdr, &time_hdr);
+ if (l_update_time_us != ht_ext_tod_2_us(&time_hdr->curtod1)) {
+ l_update_time_us = ht_ext_tod_2_us(&time_hdr->curtod1);
+ break;
+ }
+ /*
+ * Got old snapshot from kernel. Wait some time until
+ * new snapshot is available.
+ */
+ ht_free(hdr);
+ usleep(DBFS_WAIT_TIME_US);
+ } while (1);
+ sys_hdr = ((void *) time_hdr) + sizeof(struct l_x_info_blk_hdr);
+ for (i = 0; i < time_hdr->npar; i++) {
+ l_sys_hdr__sys_name(sys_hdr, lpar_id);
+ lpar = sd_sys_get(sys, lpar_id);
+ if (!lpar)
+ lpar = sd_sys_new(sys, lpar_id);
+ sys_hdr = l_sd_sys_fill(lpar, sys_hdr);
+ sd_sys_commit(lpar);
+ }
+
+ if (first && (time_hdr->flags & LPAR_PHYS_FLG)) {
+ l_sd_sys_root_cpu_phys_fill(sys, (void *) sys_hdr);
+ first = 0;
+ }
+ ht_free(hdr);
+ sd_sys_commit(sys);
+}
+
+/*
+ * Update system data
+ */
+static void l_sd_update(void)
+{
+ struct sd_sys *root = sd_sys_root_get();
+
+ sd_sys_update_start(root);
+ l_sd_sys_root_fill(root);
+ sd_sys_update_end(root, l_update_time_us);
+}
+
+/*
+ * Supported system items
+ */
+static struct sd_sys_item *l_sys_item_vec[] = {
+ &sd_sys_item_cpu_cnt,
+ &sd_sys_item_cpu_diff,
+ &sd_sys_item_mgm_diff,
+ &sd_sys_item_cpu,
+ &sd_sys_item_mgm,
+ &sd_sys_item_online,
+ NULL,
+};
+
+/*
+ * Default system items
+ */
+static struct sd_sys_item *l_sys_item_enable_vec[] = {
+ &sd_sys_item_cpu_cnt,
+ &sd_sys_item_cpu_diff,
+ &sd_sys_item_mgm_diff,
+ &sd_sys_item_cpu,
+ &sd_sys_item_mgm,
+ &sd_sys_item_online,
+ NULL,
+};
+
+/*
+ * Supported CPU items
+ */
+static struct sd_cpu_item *l_cpu_item_vec[] = {
+ &sd_cpu_item_type,
+ &sd_cpu_item_cpu_diff,
+ &sd_cpu_item_mgm_diff,
+ &sd_cpu_item_cpu,
+ &sd_cpu_item_mgm,
+ &sd_cpu_item_online,
+ NULL,
+};
+
+/*
+ * Default CPU items
+ */
+static struct sd_cpu_item *l_cpu_item_enable_vec[] = {
+ &sd_cpu_item_type,
+ &sd_cpu_item_cpu_diff,
+ &sd_cpu_item_mgm_diff,
+ NULL,
+};
+
+/*
+ * Supported CPU types
+ */
+static struct sd_cpu_type *l_cpu_type_vec[] = {
+ &sd_cpu_type_ifl,
+ &sd_cpu_type_cp,
+ &sd_cpu_type_un,
+ NULL,
+};
+
+/*
+ * Define data gatherer structure
+ */
+static struct sd_dg l_sd_dg = {
+ .update_sys = l_sd_update,
+ .cpu_type_vec = l_cpu_type_vec,
+ .sys_item_vec = l_sys_item_vec,
+ .sys_item_enable_vec = l_sys_item_enable_vec,
+ .cpu_item_vec = l_cpu_item_vec,
+ .cpu_item_enable_vec = l_cpu_item_enable_vec,
+};
+
+/*
+ * Initialize LPAR debugfs data gatherer
+ */
+int dg_debugfs_lpar_init(void)
+{
+ int fh;
+
+ l_204_buf_size = sizeof(struct l_debugfs_d204_hdr);
+ fh = dg_debugfs_open(DEBUGFS_FILE);
+ if (fh < 0)
+ return fh;
+ else
+ close(fh);
+ sd_dg_register(&l_sd_dg);
+ return 0;
+}
diff --git a/hyptop/dg_debugfs_vm.c b/hyptop/dg_debugfs_vm.c
new file mode 100644
index 0000000..6aec28f
--- /dev/null
+++ b/hyptop/dg_debugfs_vm.c
@@ -0,0 +1,267 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Hyptop z/VM data gatherer that operates on debugfs
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include "hyptop.h"
+#include "sd.h"
+#include "helper.h"
+#include "dg_debugfs.h"
+
+#define VM_CPU_TYPE "UN"
+#define VM_CPU_ID "ALL"
+#define NAME_LEN 8
+#define DEBUGFS_FILE "diag_2fc"
+
+static u64 l_update_time_us;
+static long l_2fc_buf_size;
+
+/*
+ * Diag 2fc data structure definition
+ */
+struct l_diag2fc_data {
+ u32 version;
+ u32 flags;
+ u64 used_cpu;
+ u64 el_time;
+ u64 mem_min_kb;
+ u64 mem_max_kb;
+ u64 mem_share_kb;
+ u64 mem_used_kb;
+ u32 pcpus;
+ u32 lcpus;
+ u32 vcpus;
+ u32 cpu_min;
+ u32 cpu_max;
+ u32 cpu_shares;
+ u32 cpu_use_samp;
+ u32 cpu_delay_samp;
+ u32 page_wait_samp;
+ u32 idle_samp;
+ u32 other_samp;
+ u32 total_samp;
+ char guest_name[NAME_LEN];
+};
+
+/*
+ * Header for debugfs file "diag_2fc"
+ */
+struct l_debugfs_d2fc_hdr {
+ u64 len;
+ u16 version;
+ char tod_ext[16];
+ u64 count;
+ char reserved[30];
+} __attribute__ ((packed));
+
+struct l_debugfs_d2fc {
+ struct l_debugfs_d2fc_hdr h;
+ char diag2fc_buf[];
+} __attribute__ ((packed));
+
+/*
+ * Fill "guest" with data
+ */
+static void l_sd_sys_fill(struct sd_sys *guest, struct l_diag2fc_data *data)
+{
+ struct sd_cpu *cpu;
+
+ cpu = sd_cpu_get(guest, VM_CPU_ID);
+ if (!cpu)
+ cpu = sd_cpu_new(guest, VM_CPU_ID, SD_CPU_TYPE_STR_UN,
+ data->vcpus);
+
+ sd_cpu_cnt(cpu) = data->vcpus;
+ sd_cpu_cpu_time_us_set(cpu, data->used_cpu);
+ sd_cpu_online_time_us_set(cpu, data->el_time);
+
+ sd_sys_weight_cur_set(guest, data->cpu_shares);
+ sd_sys_weight_min_set(guest, data->cpu_min);
+ sd_sys_weight_max_set(guest, data->cpu_max);
+
+ sd_sys_mem_min_kib_set(guest, data->mem_min_kb);
+ sd_sys_mem_max_kib_set(guest, data->mem_max_kb);
+ sd_sys_mem_use_kib_set(guest, data->mem_used_kb);
+
+ sd_sys_update_time_us_set(guest, l_update_time_us);
+ sd_sys_commit(guest);
+}
+
+/*
+ * Read debugfs file
+ */
+static void l_read_debugfs(struct l_debugfs_d2fc_hdr **hdr,
+ struct l_diag2fc_data **data)
+{
+ long real_buf_size;
+ ssize_t rc;
+ void *buf;
+ int fh;
+
+ do {
+ fh = dg_debugfs_open(DEBUGFS_FILE);
+ *hdr = buf = ht_alloc(l_2fc_buf_size);
+ rc = read(fh, buf, l_2fc_buf_size);
+ if (rc == -1)
+ ERR_EXIT_ERRNO("Reading hypervisor data failed");
+ close(fh);
+ real_buf_size = (*hdr)->len + sizeof(struct l_debugfs_d2fc_hdr);
+ if (rc == real_buf_size)
+ break;
+ l_2fc_buf_size = real_buf_size;
+ ht_free(buf);
+ } while (1);
+ *data = buf + sizeof(struct l_debugfs_d2fc_hdr);
+}
+
+/*
+ * Fill System Data
+ */
+static void l_sd_sys_root_fill(struct sd_sys *sys)
+{
+ struct l_diag2fc_data *d2fc_data;
+ struct l_debugfs_d2fc_hdr *hdr;
+ struct sd_cpu *cpu;
+ unsigned int i;
+
+ do {
+ l_read_debugfs(&hdr, &d2fc_data);
+ if (l_update_time_us != ht_ext_tod_2_us(&hdr->tod_ext)) {
+ l_update_time_us = ht_ext_tod_2_us(&hdr->tod_ext);
+ break;
+ }
+ /*
+ * Got old snapshot from kernel. Wait some time until
+ * new snapshot is available.
+ */
+ ht_free(hdr);
+ usleep(DBFS_WAIT_TIME_US);
+ } while (1);
+
+ cpu = sd_cpu_get(sys, VM_CPU_ID);
+ if (!cpu)
+ cpu = sd_cpu_new(sys, VM_CPU_ID, SD_CPU_TYPE_STR_UN,
+ d2fc_data[0].lcpus);
+
+ for (i = 0; i < hdr->count; i++) {
+ struct l_diag2fc_data *data = &d2fc_data[i];
+ char guest_name[NAME_LEN + 1];
+ struct sd_sys *guest;
+
+ guest_name[NAME_LEN] = 0;
+ memcpy(guest_name, data->guest_name, NAME_LEN);
+ ht_ebcdic_to_ascii(guest_name, NAME_LEN);
+ ht_strstrip(guest_name);
+
+ guest = sd_sys_get(sys, guest_name);
+ if (!guest)
+ guest = sd_sys_new(sys, guest_name);
+ l_sd_sys_fill(guest, data);
+ }
+ ht_free(hdr);
+ sd_sys_commit(sys);
+}
+
+/*
+ * Update system data
+ */
+static void l_sd_update(void)
+{
+ struct sd_sys *root = sd_sys_root_get();
+
+ sd_sys_update_start(root);
+ l_sd_sys_root_fill(root);
+ sd_sys_update_end(root, l_update_time_us);
+}
+
+/*
+ * Supported system items
+ */
+static struct sd_sys_item *l_sys_item_vec[] = {
+ &sd_sys_item_cpu_cnt,
+ &sd_sys_item_cpu_diff,
+ &sd_sys_item_cpu,
+ &sd_sys_item_online,
+ &sd_sys_item_mem_use,
+ &sd_sys_item_mem_max,
+ &sd_sys_item_weight_min,
+ &sd_sys_item_weight_cur,
+ &sd_sys_item_weight_max,
+ NULL,
+};
+
+/*
+ * Default system items
+ */
+static struct sd_sys_item *l_sys_item_enable_vec[] = {
+ &sd_sys_item_cpu_cnt,
+ &sd_sys_item_cpu_diff,
+ &sd_sys_item_cpu,
+ &sd_sys_item_online,
+ &sd_sys_item_mem_max,
+ &sd_sys_item_mem_use,
+ &sd_sys_item_weight_cur,
+ NULL,
+};
+
+/*
+ * Supported CPU items
+ */
+static struct sd_cpu_item *l_cpu_item_vec[] = {
+ &sd_cpu_item_cpu_diff,
+ &sd_cpu_item_cpu,
+ &sd_cpu_item_online,
+ NULL,
+};
+
+/*
+ * Default CPU items
+ */
+static struct sd_cpu_item *l_cpu_item_enable_vec[] = {
+ &sd_cpu_item_cpu_diff,
+ NULL,
+};
+
+/*
+ * Supported CPU types
+ */
+static struct sd_cpu_type *l_cpu_type_vec[] = {
+ &sd_cpu_type_un,
+ NULL,
+};
+
+/*
+ * Define data gatherer structure
+ */
+static struct sd_dg dg_debugfs_vm_dg = {
+ .update_sys = l_sd_update,
+ .cpu_type_vec = l_cpu_type_vec,
+ .sys_item_vec = l_sys_item_vec,
+ .sys_item_enable_vec = l_sys_item_enable_vec,
+ .cpu_item_vec = l_cpu_item_vec,
+ .cpu_item_enable_vec = l_cpu_item_enable_vec,
+};
+
+/*
+ * Initialize z/VM debugfs data gatherer
+ */
+int dg_debugfs_vm_init(void)
+{
+ int fh;
+
+ fh = dg_debugfs_open(DEBUGFS_FILE);
+ if (fh < 0)
+ return fh;
+ else
+ close(fh);
+ l_2fc_buf_size = sizeof(struct l_debugfs_d2fc_hdr);
+ sd_dg_register(&dg_debugfs_vm_dg);
+ return 0;
+}
diff --git a/hyptop/helper.c b/hyptop/helper.c
new file mode 100644
index 0000000..bcdea9f
--- /dev/null
+++ b/hyptop/helper.c
@@ -0,0 +1,383 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Helper functions
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ * Christian Borntraeger <borntraeger@de.ibm.com>
+ */
+
+#include <mntent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <iconv.h>
+#include <limits.h>
+#include <time.h>
+#include <sys/time.h>
+#include <mntent.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include "helper.h"
+#include "hyptop.h"
+#include "sd.h"
+
+/*
+ * Globals
+ */
+static iconv_t l_iconv_ebcdic_ascii;
+static int l_underline_cnt;
+static int l_reverse_cnt;
+static int l_bold_cnt;
+
+/*
+ * Print time of day
+ */
+void ht_print_time(void)
+{
+ char time_str[40];
+ struct timeval tv;
+ struct tm *tm;
+
+ gettimeofday(&tv, NULL);
+ tm = localtime(&tv.tv_sec);
+ strftime(time_str, sizeof(time_str), "%H:%M:%S", tm);
+ hyptop_printf("%s", time_str);
+}
+
+/*
+ * Alloc uninitialized memory and exit on failure
+ */
+void *ht_alloc(size_t size)
+{
+ void *ptr;
+
+ ptr = malloc(size);
+ if (!ptr)
+ ERR_EXIT("Out of memory (%zu Kb)", size / 1024);
+ return ptr;
+}
+
+/*
+ * Alloc memory initialized with "0" and exit on failure
+ */
+void *ht_zalloc(size_t size)
+{
+ void *ptr;
+
+ ptr = calloc(1, size);
+ if (!ptr)
+ ERR_EXIT("Out of memory (%zu Kb)", size / 1024);
+ return ptr;
+}
+
+/*
+ * Realloc memory and exit on failure
+ */
+void *ht_realloc(void *old_ptr, size_t size)
+{
+ void *ptr;
+
+ assert(size != 0);
+ if (old_ptr)
+ ptr = realloc(old_ptr, size);
+ else
+ ptr = calloc(1, size);
+ if (!ptr)
+ ERR_EXIT("Out of memory (%lu Kb)", (unsigned long) size / 1024);
+ return ptr;
+}
+
+/*
+ * Convert EBCDIC string to ASCII
+ */
+void ht_ebcdic_to_ascii(char *inout, size_t len)
+{
+ iconv(l_iconv_ebcdic_ascii, &inout, &len, &inout, &len);
+}
+
+/*
+ * Get mount point for file system tye "fs_type"
+ */
+char *ht_mount_point_get(const char *fs_type)
+{
+ struct mntent *mntbuf;
+ FILE *mounts;
+
+ mounts = setmntent(_PATH_MOUNTED, "r");
+ if (!mounts)
+ ERR_EXIT_ERRNO("Could not find \"%s\" mount point", fs_type);
+ while ((mntbuf = getmntent(mounts)) != NULL) {
+ if (strcmp(mntbuf->mnt_type, fs_type) == 0)
+ return ht_strdup(mntbuf->mnt_dir);
+ }
+ endmntent(mounts);
+ return NULL;
+}
+
+/*
+ * Remove all trailing blanks and reture pointer to first non blank character
+ */
+char *ht_strstrip(char *s)
+{
+ size_t size;
+ char *end;
+
+ size = strlen(s);
+
+ if (!size)
+ return s;
+
+ end = s + size - 1;
+ while (end >= s && isspace(*end))
+ end--;
+ *(end + 1) = '\0';
+
+ while (*s && isspace(*s))
+ s++;
+
+ return s;
+}
+
+/*
+ * Return copy of string
+ */
+char *ht_strdup(const char *str)
+{
+ char *rc;
+
+ rc = ht_alloc(strlen(str) + 1);
+ strcpy(rc, str);
+ return rc;
+}
+
+/*
+ * Print help icon in current line
+ */
+void ht_print_help_icon(void)
+{
+ hyptop_print_seek_back(6);
+ ht_underline_on();
+ hyptop_printf("?");
+ ht_underline_off();
+ hyptop_printf("=help");
+}
+
+/*
+ * Print headline
+ */
+void ht_print_head(const char *sys)
+{
+ struct sd_cpu_type *cpu_type;
+ int i;
+
+ ht_print_time();
+ hyptop_printf(" ");
+ if (sys) {
+ ht_bold_on();
+ hyptop_printf("%s", sys);
+ ht_bold_off();
+ hyptop_printf(" ");
+ }
+ hyptop_printf("CPU-");
+ ht_underline_on();
+ hyptop_printf("T");
+ ht_underline_off();
+ hyptop_printf(": ");
+
+ sd_cpu_type_iterate(cpu_type, i) {
+ if (!sd_cpu_type_selected(cpu_type))
+ continue;
+ hyptop_printf("%s(%i) ", sd_cpu_type_id(cpu_type),
+ sd_cpu_type_cpu_cnt(cpu_type));
+ }
+ ht_print_help_icon();
+ hyptop_print_nl();
+}
+
+/*
+ * Curses attribute functions
+ */
+static void ht_attr_on(int attr)
+{
+ if (g.o.batch_mode_specified)
+ return;
+ attron(attr);
+}
+
+static void ht_attr_off(int attr)
+{
+ if (g.o.batch_mode_specified)
+ return;
+ attroff(attr);
+}
+
+void ht_bold_on(void)
+{
+ if (l_bold_cnt == 0)
+ ht_attr_on(A_BOLD);
+ l_bold_cnt++;
+}
+
+void ht_bold_off(void)
+{
+
+ l_bold_cnt--;
+ if (l_bold_cnt == 0)
+ ht_attr_off(A_BOLD);
+}
+
+void ht_underline_on(void)
+{
+ if (l_underline_cnt == 0)
+ ht_attr_on(A_UNDERLINE);
+ l_underline_cnt++;
+}
+
+void ht_underline_off(void)
+{
+ l_underline_cnt--;
+ if (l_underline_cnt == 0)
+ ht_attr_off(A_UNDERLINE);
+}
+
+void ht_reverse_on(void)
+{
+ if (l_reverse_cnt == 0)
+ ht_attr_on(A_REVERSE);
+ l_reverse_cnt++;
+}
+
+void ht_reverse_off(void)
+{
+ l_reverse_cnt--;
+ if (l_reverse_cnt == 0)
+ ht_attr_off(A_REVERSE);
+}
+
+/*
+ * Print scroll bar
+ */
+void ht_print_scroll_bar(int row_cnt, int row_start, int rows_add_top,
+ int rows_add_bottom, int can_scroll_up,
+ int can_scroll_down, int with_border)
+{
+ int row_cnt_displ, bar_len, start, i;
+ double scale1, scale2;
+
+ row_cnt_displ = MIN(row_cnt, g.c.row_cnt - rows_add_top
+ - rows_add_bottom);
+ if (row_cnt_displ <= 0)
+ return;
+ /* scale1: Scaling factor virtual screen to physical screen */
+ scale1 = ((double) row_cnt_displ) / ((double) row_cnt);
+ /* scale2: Scaling factor physical screen to scroll bar size */
+ scale2 = ((double) row_cnt_displ - 2) / row_cnt_displ;
+ bar_len = MAX(((double) row_cnt_displ * scale1 * scale2 + 0.5), 1);
+ /* start: Start row in scroll bar */
+ start = ((double) row_start) * scale1 * scale2 + 0.5;
+
+ if (row_cnt_displ - 2 - start < bar_len)
+ start = row_cnt_displ - 2 - bar_len;
+
+ ht_reverse_on();
+
+ if (with_border) {
+ ht_underline_on();
+ hyptop_printf_pos(rows_add_top - 1, g.c.col_cnt - 1, " ");
+ ht_underline_off();
+ hyptop_printf_pos(row_cnt_displ + rows_add_top,
+ g.c.col_cnt - 1, " ");
+ }
+
+ ht_underline_on();
+ if (can_scroll_up) {
+ ht_bold_on();
+ hyptop_printf_pos(rows_add_top, g.c.col_cnt - 1, "^");
+ ht_bold_off();
+ } else {
+ hyptop_printf_pos(rows_add_top, g.c.col_cnt - 1, "^");
+ }
+ ht_underline_off();
+
+ if (row_cnt_displ == 1)
+ goto out;
+
+ ht_underline_on();
+ if (can_scroll_down) {
+ ht_bold_on();
+ hyptop_printf_pos(row_cnt_displ - 1 + rows_add_top,
+ g.c.col_cnt - 1, "v");
+ ht_bold_off();
+ } else {
+ hyptop_printf_pos(row_cnt_displ - 1 + rows_add_top,
+ g.c.col_cnt - 1, "v");
+ }
+ ht_underline_off();
+
+ if (row_cnt_displ == 2)
+ goto out;
+
+ for (i = 0; i < row_cnt_displ - 2; i++)
+ hyptop_printf_pos(i + rows_add_top + 1, g.c.col_cnt - 1,
+ " ");
+ ht_underline_on();
+ hyptop_printf_pos(i + rows_add_top, g.c.col_cnt - 1, " ");
+ ht_underline_off();
+
+ ht_bold_on();
+ for (i = 0; i < bar_len; i++) {
+ if (i + start == row_cnt_displ - 3)
+ ht_underline_on();
+ hyptop_printf_pos(i + start + 1 + rows_add_top,
+ g.c.col_cnt - 1, "#");
+ if (i + start == row_cnt_displ - 3)
+ ht_underline_off();
+ }
+ ht_bold_off();
+out:
+ ht_reverse_off();
+}
+
+/*
+ * Convert string to uppercase
+ */
+void ht_str_to_upper(char *str)
+{
+ while (*str) {
+ *str = toupper(*str);
+ str++;
+ }
+}
+
+/*
+ * Convert ext TOD to microseconds
+ */
+u64 ht_ext_tod_2_us(void *tod_ext)
+{
+ char *tod_ptr = tod_ext;
+ u64 us, *tod1, *tod2;
+
+ tod1 = (u64 *) tod_ptr;
+ tod2 = (u64 *) &tod_ptr[8];
+ us = *tod1 << 8;
+ us |= *tod2 >> 58;
+ us = us >> 12;
+
+ return us;
+}
+
+/*
+ * Initialize helper module
+ */
+void hyptop_helper_init(void)
+{
+ l_iconv_ebcdic_ascii = iconv_open("ISO-8859-1", "EBCDIC-US");
+ if (l_iconv_ebcdic_ascii == (iconv_t) -1)
+ ERR_EXIT("Could not initilize iconv\n");
+}
diff --git a/hyptop/helper.h b/hyptop/helper.h
new file mode 100644
index 0000000..61717f3
--- /dev/null
+++ b/hyptop/helper.h
@@ -0,0 +1,100 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Helper functions
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ * Christian Borntraeger <borntraeger@de.ibm.com>
+ */
+
+#ifndef HELPER_H
+#define HELPER_H
+
+#include <stdlib.h>
+#include <limits.h>
+#include <sys/types.h>
+#include "zt_common.h"
+
+/*
+ * min/max macros
+ */
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
+#define MIN(x, y) ((x) < (y) ? (x) : (y))
+#define G0(x) MAX(0, (s64) (x))
+
+/*
+ * Helper Prototypes
+ */
+extern void hyptop_helper_init(void);
+extern char *ht_strstrip(char *str);
+extern char *ht_strdup(const char *str);
+extern void ht_print_head(const char *sys);
+extern void ht_print_help_icon(void);
+extern void ht_ebcdic_to_ascii(char *inout, size_t len);
+extern char *ht_mount_point_get(const char *fs_type);
+extern u64 ht_ext_tod_2_us(void *tod_ext);
+extern void ht_print_time(void);
+
+/*
+ * Memory alloc functions
+ */
+extern void *ht_zalloc(size_t size);
+extern void *ht_alloc(size_t size);
+extern void *ht_realloc(void *ptr, size_t size);
+static inline void ht_free(void *ptr)
+{
+ free(ptr);
+}
+
+/*
+ * Curses extensions
+ */
+
+#define KEY_RETURN 0012
+#define KEY_ESCAPE 0033
+
+void ht_bold_on(void);
+void ht_bold_off(void);
+void ht_reverse_on(void);
+void ht_reverse_off(void);
+void ht_underline_on(void);
+void ht_underline_off(void);
+void ht_str_to_upper(char *str);
+
+void ht_print_scroll_bar(int row_cnt, int row_start, int row_bar_start,
+ int row_bar_bottom, int can_scroll_up,
+ int can_scroll_down, int with_boder);
+
+/*
+ * Error Macros
+ */
+#define ERR_MSG(x...) \
+do { \
+ hyptop_text_mode(); \
+ fflush(stdout); \
+ fprintf(stderr, "%s: ", g.prog_name);\
+ fprintf(stderr, x); \
+} while (0)
+
+#define ERR_EXIT(x...) \
+do { \
+ hyptop_text_mode(); \
+ fflush(stdout); \
+ fprintf(stderr, "%s: ", g.prog_name); \
+ fprintf(stderr, x); \
+ hyptop_exit(1); \
+ exit(1); \
+} while (0)
+
+#define ERR_EXIT_ERRNO(x...) \
+do { \
+ fflush(stdout); \
+ fprintf(stderr, "%s: ", g.prog_name); \
+ fprintf(stderr, x); \
+ fprintf(stderr, " (%s)", strerror(errno)); \
+ fprintf(stderr, "\n"); \
+ hyptop_exit(1); \
+} while (0)
+
+#endif /* HELPER_H */
diff --git a/hyptop/hyptop.8 b/hyptop/hyptop.8
new file mode 100644
index 0000000..99a729c
--- /dev/null
+++ b/hyptop/hyptop.8
@@ -0,0 +1,213 @@
+.TH HYPTOP 8 "Nov 2009" "s390-tools"
+.SH NAME
+hyptop \- Show hypervisor performance data on System z
+
+.SH SYNOPSIS
+.B hyptop
+[OPTIONS]
+
+.SH DESCRIPTION
+.B hyptop
+provides a dynamic real-time view of a hypervisor environment on System z.
+It works with either the z/VM or the LPAR hypervisor. Depending on the available
+data it shows for example CPU and memory information about running LPARs or
+z/VM guests.
+
+hyptop provides two windows:
+.IP " -"
+sys_list: Shows a list of systems that the hypervisor is currently running
+.IP " -"
+sys: Shows one system in more detail.
+
+.PP
+You can run hyptop in interactive mode (default) or in batch mode with
+the "\-b" option. For how to use the interactive mode, see the online help
+(enter "?" after hyptop is started).
+
+.SH OPTIONS
+.TP
+.BR "\-h" " or " "\-\-help"
+Print usage information, then exit.
+
+.TP
+.BR "\-v" " or " "\-\-version"
+Print version information, then exit.
+
+.TP
+.BR "\-w <WINDOW NAME>" " or " "\-\-window=<WINDOW NAME>"
+Select current window. Use the options "--sys", "--fields", and "--sort" to
+modify the current window. The last window specified with the "--window" option
+will be used as start window. The default window is "sys_list".
+.TP
+.BR "\-s <SYSTEM>,..." " or " "\-\-sys=<SYSTEM>,..."
+Select systems for current window. If this option is specified, only the
+selected systems are shown for the window. For window "sys" only one
+system can be specified.
+.TP
+.BR "\-f <F_LETTER>[:<UNIT>],..." " or " "\-\-fields=<F_LETTER>[:<UNIT>],..."
+Select fields and units in the current window. "F_LETTER" is the field
+letter that identifies uniquely a field (for example "c" for CPU time).
+"UNIT" is the used entity for displaying data for the field (for example "us"
+for microseconds). See FIELDS and UNITS below for definitions.
+If the "--fields" option is specified, only the selected fields are
+shown.
+.TP
+.BR "\-S <F_LETTER>" " or " "\-\-sort=<F_LETTER>"
+Select sort field for current window. To reverse the sort order, specify the
+option twice. See FIELDS below for definitions.
+.TP
+.BR "\-t <TYPE>,..." " or " "\-\-cpu_types=<TYPE>,..."
+Select CPU types that are used for CPU time calculations. See CPU TYPES
+below for definitions.
+.TP
+.BR "\-b" " or " "\-\-batch_mode"
+Use batch mode (no curses). This can be useful for sending output from hyptop
+to another program, a file, or a line mode terminal.
+In this mode no user input is accepted.
+.TP
+.BR "\-d <SECONDS>" " or " "\-\-delay=<SECONDS>"
+Specifies the delay between screen updates.
+.TP
+.BR "\-n <ITERATIONS>" " or " "\-\-iterations=<ITERATIONS>"
+Specifies the maximum number of iterations before ending.
+
+.SH PREREQUISITES
+The following things are required to run hyptop:
+
+.IP " -"
+The Linux kernel must have the required support to provide the
+performance data.
+.IP " -"
+debugfs has to be mounted.
+.IP " -"
+The hyptop user must have read permission for the required debugfs files.
+
+.PP
+To mount debugfs, you can use this command:
+
+# mount none -t debugfs /sys/kernel/debug
+
+To make this persistent, add the following to "/etc/fstab":
+
+none /sys/kernel/debug debugfs defaults 0 0
+
+
+.SH FIELDS
+The supported fields depend on the available data on the hypervisor.
+This is different between LPAR and z/VM. It might also depend on
+machine type, z/VM version and kernel version. Each field has a unique
+field letter that can be used to select the field in interactive mode
+or through the "--fields" command line option.
+
+The following fields are available under LPAR:
+
+ In "sys_list" and "sys" window:
+ 'c' - CPU time per second
+ 'm' - Management time per second
+ 'C' - Total CPU time
+ 'M' - Total management time
+ 'o' - Online time
+
+ In "sys_list" window:
+ '#' - Number of CPUs
+
+ In "sys" window:
+ 'p' - CPU type
+ 'v' - Visualization of CPU time per second
+
+The following fields are available under z/VM:
+
+ In "sys_list" and "sys" window:
+ 'c' - CPU time per second
+ 'C' - Total CPU time
+ 'o' - Online time
+
+ In "sys_list" window:
+ '#' - Number of CPUs
+ 'u' - Used memory
+ 'a' - Maximum memory
+ 'n' - Minimum weight
+ 't' - Current weight
+ 'x' - Maximum weight
+
+ In "sys" window:
+ 'v' - Visualization of CPU time per second
+
+.SH UNITS
+Depending on the field type the values can be displayed in different units.
+The following units are supported:
+
+ Time:
+ 'us' - Microseconds (10^-6 seconds)
+ 'ms' - Millisconds (10^-3 seconds)
+ '%' - Hundreds of a second (10^-2 seconds) or percent
+ 's' - Seconds
+ 'm' - Minutes
+ 'hm' - Hours & Minutes
+ 'dhm' - Days & Hours & Minutes
+
+ Memory:
+ 'kib' - Kibibytes (1.024 bytes)
+ 'mib' - Mebibytes (1.048.576 bytes)
+ 'gib' - Gibibytes (1.073.741.824 bytes)
+
+ Miscellaneous:
+ 'str' - String
+ '#' - Count/Number
+ 'vis' - Visualization
+
+.SH CPU TYPES
+Depending on the hypervisor different CPU types are supported. These CPU
+types can be selected either interactively or with the "--cpu_types"
+command line option. The calculation of the CPU data only uses CPUs of
+the specified types.
+
+On LPAR the following CPU types are supported:
+ 'IFL' - Integrated Facility for Linux
+ 'CP' - CP processor type
+ 'UN' - Unspecified processor type (other than CP or IFL)
+
+NOTE: It is possible that on older machines also IFLs are shown as CPs.
+On z/VM currently only the processor type 'UN' is available.
+
+.SH EXAMPLES
+To start hyptop with the "sys_list" window in interactive mode, enter:
+.br
+
+ # hyptop
+
+.br
+To start hyptop with the "sys_list" window in batch mode, enter:
+.br
+
+ # hyptop -b
+
+.br
+To start hyptop with the "sys_list" window in interactive mode with the fields
+CPU time (in milliseconds) and online time (unit default) and sort the
+output according to online time, enter:
+.br
+
+ # hyptop -f c:ms,o -S o
+
+.br
+To start hyptop with the "sys" window with system "MYLPAR" with the fields CPU
+time (unit milliseconds) and online time (unit default) and sort the
+output reverse according the online time, enter:
+.br
+
+ # hyptop -w sys -s MYLPAR -f c:ms,o -S o -S o
+
+.br
+To start hyptop with the "sys_list" window in batch mode with update delay 5
+seconds and 10 iterations, enter:
+.br
+
+ # hyptop -b -d 5 -n 10
+
+.br
+To start hyptop with the "sys_list" window and use only CPU types IFL and CP
+for CPU time calculation, enter:
+.br
+
+ # hyptop -t ifl,cp
diff --git a/hyptop/hyptop.c b/hyptop/hyptop.c
new file mode 100644
index 0000000..c42e8b0
--- /dev/null
+++ b/hyptop/hyptop.c
@@ -0,0 +1,352 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Main & init functions
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <ncurses.h>
+#include <time.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include "helper.h"
+#include "sd.h"
+#include "hyptop.h"
+#include "win_cpu_types.h"
+#include "opts.h"
+#include "dg_debugfs.h"
+
+#ifdef WITH_HYPFS
+#include "dg_hypfs.h"
+#endif
+
+/*
+ * Globals for the whole program
+ */
+struct hyptop_globals g;
+
+/*
+ * Get current terminal size and tell curses about it
+ */
+static void l_term_size_get(void)
+{
+ struct winsize ws;
+
+ g.c.col_cnt = 80;
+ g.c.row_cnt = 24;
+
+ if (ioctl(1, TIOCGWINSZ, &ws) != -1) {
+ if ((ws.ws_col != 0) && (ws.ws_row != 0)) {
+ g.c.col_cnt = ws.ws_col;
+ g.c.row_cnt = ws.ws_row;
+ }
+ }
+ resizeterm(g.c.row_cnt, g.c.col_cnt);
+}
+
+/*
+ * Process input
+ */
+static enum hyptop_win_action l_process_input(struct hyptop_win *win)
+{
+ int c;
+
+ /* Skip all resize events */
+ while ((c = wgetch(stdscr)) == KEY_RESIZE) {}
+ return win->process_input(win, c);
+}
+
+/*
+ * Process input with timeout
+ */
+static enum hyptop_win_action l_process_input_timeout(time_t time_s,
+ long time_us)
+{
+ struct timeval tv;
+ fd_set fds;
+ int rc;
+
+ while (1) {
+ FD_ZERO(&fds);
+ FD_SET(0, &fds);
+ tv.tv_sec = time_s;
+ tv.tv_usec = time_us;
+ rc = select(1, &fds, NULL, NULL, &tv);
+ switch (rc) {
+ case 0:
+ /* Timeout */
+ return WIN_KEEP;
+ case 1:
+ /* Input */
+ if (l_process_input(g.w.cur) == WIN_SWITCH)
+ return WIN_SWITCH;
+ continue;
+ case -1:
+ if (errno != EINTR)
+ ERR_EXIT_ERRNO("Select call failed");
+ /* Signal: Resize */
+ hyptop_update_term();
+ continue;
+ default:
+ assert(0);
+ }
+ }
+}
+
+/*
+ * Sleep
+ */
+static enum hyptop_win_action l_sleep(time_t time_s, long time_us)
+{
+ struct timespec ts;
+
+ ts.tv_sec = time_s;
+ ts.tv_nsec = time_us * 1000;
+
+ nanosleep(&ts, NULL);
+ return WIN_KEEP;
+}
+
+/*
+ * External process input with timeout funciton
+ */
+enum hyptop_win_action hyptop_process_input_timeout(void)
+{
+ enum hyptop_win_action rc;
+
+ if (g.o.batch_mode_specified) {
+ opts_iterations_next();
+ rc = l_sleep(g.o.delay_s, g.o.delay_us);
+ } else {
+ rc = l_process_input_timeout(g.o.delay_s, g.o.delay_us);
+ opts_iterations_next();
+ }
+ return rc;
+}
+
+/*
+ * External process input funciton
+ */
+enum hyptop_win_action hyptop_process_input(void)
+{
+ return l_process_input_timeout(-1U, 0);
+}
+
+/*
+ * Signal handler for exiting hyptop
+ */
+static void l_sig_exit(int sig)
+{
+ (void) sig;
+
+ hyptop_exit(0);
+}
+
+/*
+ * Install signal handler
+ */
+static void l_sig_handler_init(void)
+{
+ struct sigaction sigact;
+
+ /* Ignore signals SIGUSR1 and SIGUSR2 */
+ if (sigemptyset(&sigact.sa_mask) < 0)
+ goto fail;
+ sigact.sa_flags = 0;
+ sigact.sa_handler = SIG_IGN;
+ if (sigaction(SIGUSR1, &sigact, NULL) < 0)
+ goto fail;
+ if (sigaction(SIGUSR2, &sigact, NULL) < 0)
+ goto fail;
+
+ /* Exit on SIGINT, SIGTERM, SIGHUP, ... */
+ if (sigemptyset(&sigact.sa_mask) < 0)
+ goto fail;
+ sigact.sa_handler = l_sig_exit;
+ if (sigaction(SIGINT, &sigact, NULL) < 0)
+ goto fail;
+ if (sigaction(SIGTERM, &sigact, NULL) < 0)
+ goto fail;
+ if (sigaction(SIGHUP, &sigact, NULL) < 0)
+ goto fail;
+ if (sigaction(SIGQUIT, &sigact, NULL) < 0)
+ goto fail;
+ if (sigaction(SIGALRM, &sigact, NULL) < 0)
+ goto fail;
+ if (sigaction(SIGPIPE, &sigact, NULL) < 0)
+ goto fail;
+ return;
+fail:
+ ERR_EXIT_ERRNO("Could not initialize signal handler");
+}
+
+/*
+ * Start curses
+ */
+static int l_initscr(void)
+{
+ if (!initscr())
+ return ERR;
+ g.c.initialized = 1;
+ atexit(hyptop_text_mode);
+ return 0;
+}
+
+/*
+ * Init curses
+ */
+static void l_term_init(void)
+{
+ if (g.o.batch_mode_specified)
+ return;
+
+ if (l_initscr() == ERR)
+ goto fail;
+ if (noecho() == ERR)
+ goto fail;
+ if (nodelay(stdscr, TRUE) == ERR)
+ goto fail;
+ if (cbreak() == ERR) /* Line buffering disabled. pass on everything */
+ goto fail;
+ if (keypad(stdscr, TRUE) == ERR)
+ goto fail;
+ curs_set(0); /* prevent cursor from blinking */
+ l_term_size_get();
+ l_sig_handler_init();
+ return;
+fail:
+ ERR_EXIT("Could not initialize curses, try \"--batchmode\"\n");
+}
+
+/*
+ * Initialize data gatherer
+ */
+#ifdef WITH_HYPFS
+static void l_dg_init(void)
+{
+ if (dg_debugfs_init(0) == 0)
+ return;
+ if (dg_hypfs_init() == 0)
+ return;
+ ERR_EXIT("Could not initialize data gatherer\n");
+}
+#else
+static void l_dg_init(void)
+{
+ dg_debugfs_init(1);
+}
+#endif
+
+/*
+ * Windows event loop
+ */
+static void l_event_loop(void)
+{
+ while (1)
+ g.w.cur->run(g.w.cur);
+}
+
+/*
+ * Clear terminal and write new window content to it
+ */
+void l_update_term_curses(void)
+{
+ /* Init screen */
+ l_term_size_get();
+ curs_set(0); /* pervent cursor from blinking */
+ move(0, 0);
+ erase();
+ hyptop_printf_init();
+ /* Write window to screen */
+ g.w.cur->update_term(g.w.cur);
+ refresh();
+}
+
+/*
+ * Write window content in line mode
+ */
+void l_update_term_batch(void)
+{
+ g.w.cur->update_term(g.w.cur);
+ printf("\n");
+}
+
+/*
+ * Update terminal with new window content
+ */
+void hyptop_update_term(void)
+{
+ if (g.o.batch_mode_specified)
+ l_update_term_batch();
+ else
+ l_update_term_curses();
+}
+
+/*
+ * Switch to new window "win"
+ */
+enum hyptop_win_action win_switch(struct hyptop_win *win)
+{
+ assert(g.w.prev_cnt < sizeof(g.w.prev) / sizeof(void *));
+ g.w.prev[g.w.prev_cnt] = g.w.cur;
+ g.w.prev_cnt++;
+ g.w.cur = win;
+ return WIN_SWITCH;
+}
+
+/*
+ * Switch back to previous window
+ */
+enum hyptop_win_action win_back(void)
+{
+ g.w.prev_cnt--;
+ g.w.cur = g.w.prev[g.w.prev_cnt];
+ return WIN_SWITCH;
+}
+
+/*
+ * Switch to text mode
+ */
+void hyptop_text_mode(void)
+{
+ if (!g.c.initialized)
+ return;
+ g.c.initialized = 0;
+ clear();
+ refresh();
+ endwin();
+}
+
+/*
+ * Exit hyptop
+ */
+void hyptop_exit(int rc)
+{
+ hyptop_text_mode();
+ exit(rc);
+}
+
+/*
+ * Initialize all modules and start first window
+ */
+int main(int argc, char *argv[])
+{
+ opts_parse(argc, argv);
+ hyptop_helper_init();
+ sd_init();
+ l_dg_init();
+ opt_verify_systems();
+ l_term_init();
+
+ win_sys_list_init();
+ win_sys_init();
+ g.win_cpu_types = win_cpu_types_new();
+ l_event_loop();
+ return 0;
+}
diff --git a/hyptop/hyptop.h b/hyptop/hyptop.h
new file mode 100644
index 0000000..fe39976
--- /dev/null
+++ b/hyptop/hyptop.h
@@ -0,0 +1,220 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Command line options, window definition, print functions, etc.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef HYPTOP_H
+#define HYPTOP_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ncurses.h>
+#include <termios.h>
+#include "list.h"
+#include "helper.h"
+#include "table.h"
+#include "nav_desc.h"
+
+#define HYPTOP_OPT_DEFAULT_DELAY 2
+#define HYPTOP_MAX_WIN_DEPTH 4
+#define HYPTOP_MAX_LINE 512
+#define PROG_NAME "hyptop"
+
+/*
+ * Options info
+ */
+struct hyptop_str_vec_opt {
+ unsigned int specified;
+ char **vec;
+ unsigned int cnt;
+};
+
+struct hyptop_col_vec_opt {
+ unsigned int specified;
+ struct table_col_spec **vec;
+ unsigned int cnt;
+};
+
+struct hyptop_win_opts {
+ struct hyptop_str_vec_opt sys;
+ struct hyptop_col_vec_opt fields;
+ unsigned int sort_field_specified;
+ char sort_field;
+};
+
+struct hyptop_opts {
+ unsigned int win_specified;
+ unsigned int batch_mode_specified;
+ unsigned int iterations_specified;
+ unsigned int iterations;
+ unsigned int iterations_act;
+
+ struct hyptop_win *cur_win;
+ struct hyptop_str_vec_opt cpu_types;
+
+ int delay_s;
+ int delay_us;
+};
+
+/*
+ * Curses info
+ */
+struct hyptop_curses {
+ int row_cnt;
+ int col_cnt;
+ char line[HYPTOP_MAX_LINE];
+ int x;
+ int y;
+ int initialized;
+};
+
+/*
+ * Window info
+ */
+struct hyptop_win_info {
+ struct hyptop_win *cur;
+ struct hyptop_win *prev[HYPTOP_MAX_WIN_DEPTH];
+ unsigned int prev_cnt;
+};
+
+/*
+ * Globals definition
+ */
+struct hyptop_globals {
+ struct hyptop_opts o;
+ struct hyptop_curses c;
+ struct hyptop_win_info w;
+ const char *prog_name;
+ struct hyptop_win *win_cpu_types;
+};
+
+extern struct hyptop_globals g;
+
+/*
+ * Print functions
+ */
+#define hyptop_printf_pos(y, x, p...) \
+ do { \
+ if (g.o.batch_mode_specified) \
+ printf(p); \
+ else { \
+ int len; \
+ len = snprintf(g.c.line, sizeof(g.c.line) - 1, p); \
+ len = MIN(len, (g.c.col_cnt - (x))); \
+ if (len > 0) { \
+ mvaddnstr((y), (x), g.c.line, len); \
+ } \
+ } \
+ } while (0)
+
+#define hyptop_printf(p...) \
+ do { \
+ if (g.o.batch_mode_specified) \
+ printf(p); \
+ else { \
+ int len; \
+ len = snprintf(g.c.line, sizeof(g.c.line) - 1, p); \
+ len = MIN(len, (g.c.col_cnt - g.c.x)); \
+ if (len > 0) { \
+ mvaddnstr(g.c.y, g.c.x, g.c.line, len); \
+ g.c.x += len; \
+ } \
+ } \
+ } while (0)
+
+static inline void hyptop_printf_init(void)
+{
+ g.c.x = 0;
+ g.c.y = 0;
+}
+
+static inline void hyptop_print_seek_back(int i)
+{
+ unsigned int cnt = MAX(g.c.col_cnt - g.c.x - i, 0);
+
+ if (g.o.batch_mode_specified)
+ return;
+ if (cnt) {
+ memset(g.c.line, ' ', cnt);
+ assert(cnt < sizeof(g.c.line));
+ g.c.line[cnt] = 0;
+ addstr(g.c.line);
+ }
+ g.c.x = g.c.col_cnt - i;
+}
+
+static inline void hyptop_print_nl(void)
+{
+ unsigned int cnt = MAX(g.c.col_cnt - g.c.x, 0);
+
+ if (g.o.batch_mode_specified) {
+ printf("\n");
+ return;
+ }
+ if (cnt) {
+ memset(g.c.line, ' ', g.c.col_cnt - g.c.x);
+ assert(cnt < sizeof(g.c.line));
+ g.c.line[cnt] = 0;
+ addstr(g.c.line);
+ }
+ g.c.x = 0;
+ g.c.y++;
+}
+
+/*
+ * hyptop windows
+ */
+
+enum hyptop_win_action {
+ WIN_SWITCH,
+ WIN_KEEP,
+};
+
+extern enum hyptop_win_action hyptop_process_input_timeout(void);
+extern enum hyptop_win_action hyptop_process_input(void);
+extern enum hyptop_win_action win_switch(struct hyptop_win *w);
+extern enum hyptop_win_action win_back(void);
+
+struct hyptop_win;
+struct hyptop_win {
+ enum hyptop_win_action (*process_input)(struct hyptop_win *w, int c);
+ void (*update_term)(struct hyptop_win *w);
+ void (*run)(struct hyptop_win *w);
+ const char *id;
+ const char *desc;
+ struct nav_desc **desc_normal_vec;
+ struct nav_desc **desc_select_vec;
+ struct nav_desc **desc_general_vec;
+ struct hyptop_win_opts opts;
+};
+
+/*
+ * Window sys_list
+ */
+extern struct hyptop_win win_sys_list;
+extern void win_sys_list_init(void);
+
+/*
+ * Window sys
+ */
+extern struct hyptop_win win_sys;
+extern void win_sys_set(const char *sys_id);
+extern void win_sys_init(void);
+
+/*
+ * Window cpu_types
+ */
+extern void win_cpu_types_init(void);
+
+/*
+ * Misc functions
+ */
+extern void hyptop_update_term(void);
+extern void hyptop_exit(int rc);
+extern void hyptop_text_mode(void);
+
+#endif /* HYPTOP_H */
diff --git a/hyptop/nav_desc.c b/hyptop/nav_desc.c
new file mode 100644
index 0000000..703489f
--- /dev/null
+++ b/hyptop/nav_desc.c
@@ -0,0 +1,243 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Description of navigation keys
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "nav_desc.h"
+#include "tbox.h"
+
+#define L_KEY_LEN 14
+#define L_KEY_FMT "%-14s"
+
+/* Select mode */
+
+struct nav_desc nav_desc_select_mode_enter = {
+ .desc = "Enter select mode",
+ .keys = {"RIGHT", "l", NULL},
+};
+
+struct nav_desc nav_desc_select_mode_leave = {
+ .desc = "Leave select mode",
+ .keys = {"LEFT", "h", NULL},
+};
+
+/* "sys" Window */
+
+struct nav_desc nav_desc_win_enter_sys = {
+ .desc = "Go to the \"sys\" window for selected system",
+ .keys = {"RIGHT", "l", NULL},
+};
+
+struct nav_desc nav_desc_win_leave_sys = {
+ .desc = "Go to the previous window",
+ .keys = {"LEFT", "h", "q", NULL},
+};
+
+struct nav_desc nav_desc_win_leave_sys_fast = {
+ .desc = "Go to the previous window",
+ .keys = {"q", NULL},
+};
+
+/* "fields" window */
+
+struct nav_desc nav_desc_win_enter_fields = {
+ .desc = "Go to the \"fields\" window",
+ .keys = {"f", NULL},
+} ;
+
+struct nav_desc nav_desc_win_leave_fields = {
+ .desc = "Go to the previous window",
+ .keys = {"LEFT", "ENTER", "h", "f", "q", NULL},
+};
+
+struct nav_desc nav_desc_win_leave_fields_fast = {
+ .desc = "Go to the previous window",
+ .keys = {"f", "q", NULL},
+};
+
+/* "cpu_types" window */
+
+struct nav_desc nav_desc_win_enter_cpu_types = {
+ .desc = "Go to the \"cpu_types\" window",
+ .keys = {"t", NULL},
+};
+
+struct nav_desc nav_desc_win_leave_cpu_types = {
+ .desc = "Go to the previous window",
+ .keys = {"LEFT", "ENTER", "h", "t", "q", NULL},
+};
+
+struct nav_desc nav_desc_win_leave_cpu_types_fast = {
+ .desc = "Go to the previous window",
+ .keys = {"t", "q", NULL},
+};
+
+/* Marks */
+
+struct nav_desc nav_desc_marks_clear = {
+ .desc = "Clear all marked rows",
+ .keys = {"SPACE", NULL},
+};
+
+struct nav_desc nav_desc_mark_toggle = {
+ .desc = "Toggle mark for selected row",
+ .keys = {"SPACE", NULL},
+};
+
+struct nav_desc nav_desc_mark_toggle_view = {
+ .desc = "Toggle view for marked rows",
+ .keys = {".", NULL},
+};
+
+/* Units */
+
+struct nav_desc nav_desc_col_unit_increase = {
+ .desc = "Increase unit type of selected column",
+ .keys = {"+", NULL},
+};
+
+struct nav_desc nav_desc_col_unit_decrease = {
+ .desc = "Decrease unit type of selected column",
+ .keys = {"-", NULL},
+};
+
+struct nav_desc nav_desc_row_unit_increase = {
+ .desc = "Increase unit type of selected row",
+ .keys = {"+", NULL},
+};
+
+struct nav_desc nav_desc_row_unit_decrease = {
+ .desc = "Decrease unit type of selected row",
+ .keys = {"-", NULL},
+};
+
+/* Select columns */
+
+struct nav_desc nav_desc_select_col_next = {
+ .desc = "Select next column",
+ .keys = {">", NULL},
+};
+
+struct nav_desc nav_desc_select_col_prev = {
+ .desc = "Select previous column",
+ .keys = {"<", NULL},
+};
+
+struct nav_desc nav_desc_select_col_hotkey = {
+ .desc = "Select column with hotkey",
+ .keys = {"<key>", NULL},
+};
+
+/* Quit */
+
+struct nav_desc nav_desc_quit = {
+ .desc = "Quit program",
+ .keys = {"q", NULL},
+};
+
+/* Select rows */
+
+struct nav_desc nav_desc_toggle_mark_hotkey = {
+ .desc = "Toggle mark for row with hotkey",
+ .keys = {"<key>", NULL},
+};
+
+/* Navigation */
+
+struct nav_desc nav_desc_scroll_up_line = {
+ .desc = "Scroll up one line",
+ .keys = {"UP", "k", NULL},
+};
+
+struct nav_desc nav_desc_scroll_down_line = {
+ .desc = "Scroll down one line",
+ .keys = {"DOWN", "j", NULL},
+};
+
+struct nav_desc nav_desc_scroll_up_page = {
+ .desc = "Scroll up one page",
+ .keys = {"PGUP", NULL},
+};
+
+struct nav_desc nav_desc_scroll_down_page = {
+ .desc = "Scroll down one page",
+ .keys = {"PGDOWN", NULL},
+};
+
+struct nav_desc nav_desc_scroll_up_head = {
+ .desc = "Scroll up to head of window",
+ .keys = {"g", NULL},
+};
+
+struct nav_desc nav_desc_scroll_down_tail = {
+ .desc = "Scroll down to tail of window",
+ .keys = {"G", NULL},
+};
+
+/*
+ * Add navigation descriptons to text box
+ */
+static void l_nav_desc_add(struct tbox *tb, struct nav_desc *desc)
+{
+ char keys_str[L_KEY_LEN + 1];
+ unsigned int i, first;
+ char *key;
+
+ first = 1;
+ keys_str[0] = 0;
+ for (i = 0; (key = desc->keys[i]); i++) {
+ /*
+ * If we have used the whole space for the keys,
+ * we write the line and begin a new one
+ */
+ if (strlen(desc->keys[i]) + strlen(keys_str) + 1 > L_KEY_LEN) {
+ tbox_printf(tb, " " L_KEY_FMT ": %s", keys_str,
+ desc->desc);
+ keys_str[0] = 0;
+ first = 1;
+ }
+ if (!first)
+ strcat(keys_str, ",");
+ else
+ first = 0;
+ strcat(keys_str, "'");
+ strcat(keys_str, desc->keys[i]);
+ strcat(keys_str, "'");
+ assert(strlen(keys_str) <= L_KEY_LEN);
+ }
+ tbox_printf(tb, " " L_KEY_FMT ": %s", keys_str, desc->desc);
+}
+
+/*
+ * Add navigation descriptions for "normal", "select" and "general" to text box
+ */
+void nav_desc_add(struct tbox *tb,
+ struct nav_desc **desc_normal,
+ struct nav_desc **desc_select,
+ struct nav_desc **desc_general)
+{
+ unsigned int i;
+
+ tbox_printf(tb, "\\BSupported keys in this window\\B");
+ tbox_printf(tb, " ");
+
+ tbox_printf(tb, "NORMAL MODE:");
+ for (i = 0; (desc_normal[i]); i++)
+ l_nav_desc_add(tb, desc_normal[i]);
+ tbox_printf(tb, " ");
+ tbox_printf(tb, "SELECT MODE:");
+ for (i = 0; (desc_select[i]); i++)
+ l_nav_desc_add(tb, desc_select[i]);
+ tbox_printf(tb, " ");
+ tbox_printf(tb, "GENERAL:");
+ for (i = 0; (desc_general[i]); i++)
+ l_nav_desc_add(tb, desc_general[i]);
+ tbox_printf(tb, " ");
+}
diff --git a/hyptop/nav_desc.h b/hyptop/nav_desc.h
new file mode 100644
index 0000000..05fcde9
--- /dev/null
+++ b/hyptop/nav_desc.h
@@ -0,0 +1,55 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Description of navigation keys
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef NAV_DESC_H
+#define NAV_DESC_H
+
+#include "tbox.h"
+
+struct nav_desc {
+ char *desc;
+ char *keys[];
+};
+
+void nav_desc_add(struct tbox *tb,
+ struct nav_desc **desc_normal,
+ struct nav_desc **desc_select,
+ struct nav_desc **desc_general);
+
+struct nav_desc nav_desc_quit;
+struct nav_desc nav_desc_select_mode_enter;
+struct nav_desc nav_desc_select_mode_leave;
+struct nav_desc nav_desc_win_enter_sys;
+struct nav_desc nav_desc_win_leave_sys;
+struct nav_desc nav_desc_win_leave_sys_fast;
+struct nav_desc nav_desc_win_enter_fields;
+struct nav_desc nav_desc_win_leave_fields;
+struct nav_desc nav_desc_win_leave_fields_fast;
+struct nav_desc nav_desc_win_enter_cpu_types;
+struct nav_desc nav_desc_win_leave_cpu_types;
+struct nav_desc nav_desc_win_leave_cpu_types_fast;
+struct nav_desc nav_desc_marks_clear;
+struct nav_desc nav_desc_mark_toggle;
+struct nav_desc nav_desc_mark_toggle_view;
+struct nav_desc nav_desc_col_unit_increase;
+struct nav_desc nav_desc_col_unit_decrease;
+struct nav_desc nav_desc_row_unit_increase;
+struct nav_desc nav_desc_row_unit_decrease;
+struct nav_desc nav_desc_select_col_next;
+struct nav_desc nav_desc_select_col_prev;
+struct nav_desc nav_desc_select_col_hotkey;
+struct nav_desc nav_desc_toggle_mark_hotkey;
+struct nav_desc nav_desc_scroll_up_line;
+struct nav_desc nav_desc_scroll_down_line;
+struct nav_desc nav_desc_scroll_up_page;
+struct nav_desc nav_desc_scroll_down_page;
+struct nav_desc nav_desc_scroll_up_head;
+struct nav_desc nav_desc_scroll_down_tail;
+
+#endif /* NAV_DESC_H */
diff --git a/hyptop/opts.c b/hyptop/opts.c
new file mode 100644
index 0000000..05a4126
--- /dev/null
+++ b/hyptop/opts.c
@@ -0,0 +1,416 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Command line parsing
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include "zt_common.h"
+#include "helper.h"
+#include "hyptop.h"
+#include "getopt.h"
+#include "sd.h"
+
+static const char l_copyright_str[] = "Copyright IBM Corp. 2010";
+
+/*
+ * Help text for tool
+ */
+static char HELP_TEXT[] =
+"Usage: hyptop [OPTIONS]\n"
+"\n"
+"Show hypervisor performance data on System z.\n"
+"\n"
+"-h, --help Print this help, then exit\n"
+"-v, --version Print version information, then exit\n"
+"-w, --window WIN_NAME Current window (\"sys\" or \"sys_list\")\n"
+"-s, --sys SYSTEM[,..] Systems for current window\n"
+"-f, --fields LETTER[:UNIT][,..] Fields and units for current window\n"
+"-S, --sort LETTER Sort field for current window\n"
+"-t, --cpu_types TYPE[,..] CPU types used for time calculations\n"
+"-b, --batch_mode Use batch mode (no curses)\n"
+"-d, --delay SECONDS Delay time between screen updates\n"
+"-n, --iterations NUMBER Number of iterations before ending\n";
+
+/*
+ * Initialize default settings
+ */
+static void l_init_defaults(void)
+{
+ g.prog_name = PROG_NAME;
+ g.o.delay_s = HYPTOP_OPT_DEFAULT_DELAY;
+ g.w.cur = &win_sys_list;
+ g.o.cur_win = &win_sys_list;
+}
+
+/*
+ * Print "help" hint
+ */
+static void l_std_usage_exit(void)
+{
+ fprintf(stderr, "Try '%s --help' for more information.\n",
+ g.prog_name);
+ hyptop_exit(1);
+}
+
+/*
+ * Print help text
+ */
+static void l_usage(void)
+{
+ printf("%s", HELP_TEXT);
+}
+
+/*
+ * Print version information
+ */
+static void l_print_version(void)
+{
+ printf("%s: Hypervisor Top version %s\n", g.prog_name, RELEASE_STRING);
+ printf("%s\n", l_copyright_str);
+}
+
+/*
+ * Check if string is a number
+ */
+static int l_number_check(const char *str)
+{
+ const char *ptr = str;
+ while (*ptr) {
+ if (!isdigit(*ptr))
+ ERR_EXIT("The argument \"%s\" is not an integer\n",
+ str);
+ ptr++;
+ }
+ return 1;
+}
+
+/*
+ * Set delay option
+ */
+static void l_delay_set(char *delay_string)
+{
+ int secs;
+
+ l_number_check(delay_string);
+ if (sscanf(delay_string, "%i", &secs) != 1)
+ ERR_EXIT("The delay value \"%s\" is invalid\n", delay_string);
+ g.o.delay_s = secs;
+ g.o.delay_us = 0;
+}
+
+/*
+ * Get number of occurances of character 'c' in "str"
+ */
+static int l_get_char_cnt(char *str, char c)
+{
+ unsigned int i;
+ int cnt = 0;
+
+ for (i = 0; str[i] != 0; i++) {
+ if (str[i] == c)
+ cnt++;
+ }
+ return cnt;
+}
+
+/*
+ * Return copy of string with removed trailing and leading blanks
+ */
+static char *l_trim_str_new(char *str)
+{
+ char *rc;
+ int i;
+
+ for (i = 0; *(str + i) == ' '; i++) {}
+ rc = ht_strdup(str + i);
+ ht_strstrip(rc);
+ if (strlen(rc) == 0)
+ ERR_EXIT("The argument \"%s\" is invalid\n", str);
+ return rc;
+}
+
+/*
+ * Get column specification for string
+ */
+static struct table_col_spec *l_get_col_spec(char *str)
+{
+ struct table_col_spec *col_spec;
+ unsigned int i;
+ char *key_str;
+
+ col_spec = ht_zalloc(sizeof(*col_spec));
+
+ for (i = strlen(str); i > 0; i--) {
+ if (str[i] == ':') {
+ col_spec->unit_str = l_trim_str_new(&str[i + 1]);
+ str[i] = 0;
+ }
+ }
+ key_str = l_trim_str_new(str);
+ if (strlen(key_str) > 1)
+ ERR_EXIT("The field key \"%s\" is invalid\n", key_str);
+ col_spec->hotkey = key_str[0];
+ ht_free(key_str);
+ return col_spec;
+}
+
+/*
+ * Set the "--fields" option
+ */
+static void l_fields_set(char *str)
+{
+ struct hyptop_col_vec_opt *opt = &g.o.cur_win->opts.fields;
+ unsigned int i, j;
+
+ opt->cnt = l_get_char_cnt(str, ',') + 1;
+ opt->vec = ht_zalloc(sizeof(void *) * (opt->cnt + 1));
+
+ j = 0;
+ for (i = strlen(str); i > 0; i--) {
+ if (str[i] != ',')
+ continue;
+ opt->vec[j] = l_get_col_spec(&str[i + 1]);
+ str[i] = 0;
+ j++;
+ }
+ opt->vec[j] = l_get_col_spec(str);
+ opt->specified = 1;
+}
+
+/*
+ * Set the "--sort_field" option
+ */
+static void l_sort_field_set(char *str)
+{
+ if (strlen(str) > 1)
+ ERR_EXIT("The sort field \"%s\" is invalid\n", str);
+ if (g.o.cur_win->opts.sort_field_specified &&
+ g.o.cur_win->opts.sort_field != str[0])
+ g.o.cur_win->opts.sort_field_specified = 0;
+ g.o.cur_win->opts.sort_field_specified++;
+ g.o.cur_win->opts.sort_field = str[0];
+}
+
+/*
+ * Setup a string vector out of a comma separated list in "str"
+ */
+static void l_str_vec_set(char *str, struct hyptop_str_vec_opt *opt)
+{
+ unsigned int i, j;
+
+ opt->cnt = l_get_char_cnt(str, ',') + 1;
+ opt->vec = ht_zalloc(sizeof(void *) * (opt->cnt + 1));
+
+ j = 0;
+ for (i = strlen(str); i > 0; i--) {
+ if (str[i] != ',')
+ continue;
+ opt->vec[j] = l_trim_str_new(&str[i + 1]);
+ str[i] = 0;
+ j++;
+ }
+ opt->vec[j] = l_trim_str_new(str);
+ opt->specified = 1;
+}
+
+/*
+ * Set the "--sys" option
+ */
+static void l_sys_set(char *str)
+{
+ l_str_vec_set(str, &g.o.cur_win->opts.sys);
+}
+
+/*
+ * Set the "--cpu_types" option
+ */
+static void l_cpu_types_set(char *str)
+{
+ l_str_vec_set(str, &g.o.cpu_types);
+}
+
+/*
+ * Set the "--window" option
+ */
+static void l_window_set(const char *str)
+{
+ g.o.win_specified = 1;
+ if (strcmp(str, win_sys_list.id) == 0)
+ g.o.cur_win = &win_sys_list;
+ else if (strcmp(str, win_sys.id) == 0)
+ g.o.cur_win = &win_sys;
+ else
+ ERR_EXIT("The window \"%s\" is unknown\n", str);
+}
+
+/*
+ * Set the "--iterations" option
+ */
+static void l_iterations_set(const char *str)
+{
+ l_number_check(str);
+ g.o.iterations_specified = 1;
+ g.o.iterations = atoi(str);
+}
+
+/*
+ * Set the "--batch_mode" option
+ */
+static void l_batch_mode_set(void)
+{
+ g.o.batch_mode_specified = 1;
+}
+
+/*
+ * Make option consisteny checks at end of command line parsing
+ */
+static void l_parse_finish(void)
+{
+ if (g.o.iterations_specified && g.o.iterations == 0)
+ hyptop_exit(0);
+ if (g.o.cur_win != &win_sys)
+ return;
+ if (!win_sys.opts.sys.specified)
+ ERR_EXIT("Specify a system for window \"sys\"\n");
+ if (win_sys.opts.sys.cnt != 1)
+ ERR_EXIT("More than one system for window \"sys\" has been "
+ "specified\n");
+ win_switch(&win_sys);
+}
+
+/*
+ * Main command line parsing function
+ */
+void opts_parse(int argc, char *argv[])
+{
+ int opt, index;
+ static struct option long_options[] = {
+ { "version", no_argument, NULL, 'v'},
+ { "help", no_argument, NULL, 'h'},
+ { "batch_mode", no_argument, NULL, 'b'},
+ { "delay", required_argument, NULL, 'd'},
+ { "window", required_argument, NULL, 'w'},
+ { "sys", required_argument, NULL, 's'},
+ { "iterations", required_argument, NULL, 'n'},
+ { "fields", required_argument, NULL, 'f'},
+ { "sort_field", required_argument, NULL, 'S'},
+ { "cpu_types", required_argument, NULL, 't'},
+ { 0, 0, 0, 0 }
+ };
+ static const char option_string[] = "vhbd:w:s:n:f:t:S:";
+
+ l_init_defaults();
+ while (1) {
+ opt = getopt_long(argc, argv, option_string,
+ long_options, &index);
+ if (opt == -1)
+ break;
+ switch (opt) {
+ case 'v':
+ l_print_version();
+ hyptop_exit(0);
+ case 'h':
+ l_usage();
+ hyptop_exit(0);
+ case 'b':
+ l_batch_mode_set();
+ break;
+ case 'd':
+ l_delay_set(optarg);
+ break;
+ case 'w':
+ l_window_set(optarg);
+ break;
+ case 's':
+ l_sys_set(optarg);
+ break;
+ case 'n':
+ l_iterations_set(optarg);
+ break;
+ case 't':
+ l_cpu_types_set(optarg);
+ break;
+ case 'f':
+ l_fields_set(optarg);
+ break;
+ case 'S':
+ l_sort_field_set(optarg);
+ break;
+ default:
+ l_std_usage_exit();
+ }
+ }
+ if (optind != argc)
+ ERR_EXIT("Invalid positional parameter \"%s\" specified\n",
+ argv[optind]);
+ l_parse_finish();
+}
+
+/*
+ * Has "sys_name" been specified on command line?
+ */
+int opts_sys_specified(struct hyptop_win *win, const char* sys_name)
+{
+ unsigned int i;
+
+ if (!win->opts.sys.specified)
+ return 1;
+ for (i = 0; i < win->opts.sys.cnt; i++) {
+ if (strcmp(win->opts.sys.vec[i], sys_name) == 0)
+ return 1;
+ }
+ return 0;
+}
+
+/*
+ * Verify that all specified systems are available for window
+ */
+static void l_verify_systems(struct hyptop_win *win)
+{
+ char *sys_name;
+ unsigned int i;
+
+ for (i = 0; i < win->opts.sys.cnt; i++) {
+ if (sd_sys_get(sd_sys_root_get(), win->opts.sys.vec[i]))
+ continue;
+ sys_name = ht_strdup(win->opts.sys.vec[i]);
+ ht_str_to_upper(win->opts.sys.vec[i]);
+ if (sd_sys_get(sd_sys_root_get(), win->opts.sys.vec[i])) {
+ ht_free(sys_name);
+ continue;
+ }
+ ERR_EXIT("System \"%s\" is not available\n", sys_name);
+ }
+}
+
+/*
+ * Verify that all specified systems are available for all windows
+ */
+void opt_verify_systems(void)
+{
+ l_verify_systems(&win_sys_list);
+ l_verify_systems(&win_sys);
+ if (g.o.cur_win == &win_sys)
+ win_sys_set(win_sys.opts.sys.vec[0]);
+}
+
+/*
+ * Increase iterations count and exit if necessary
+ */
+void opts_iterations_next(void)
+{
+ if (g.o.iterations_specified) {
+ g.o.iterations_act++;
+ if (g.o.iterations_act >= g.o.iterations)
+ hyptop_exit(0);
+ }
+ if (g.o.batch_mode_specified)
+ printf("---------------------------------------------------"
+ "----------------------------\n");
+}
+
diff --git a/hyptop/opts.h b/hyptop/opts.h
new file mode 100644
index 0000000..babeda1
--- /dev/null
+++ b/hyptop/opts.h
@@ -0,0 +1,20 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Command line parsing
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef OPTS_H
+#define OPTS_H
+
+#include "hyptop.h"
+
+extern void opts_parse(int argc, char *argv[]);
+extern void opts_iterations_next(void);
+extern int opts_sys_specified(struct hyptop_win *win, const char* sys_name);
+extern void opt_verify_systems(void);
+
+#endif /* OPTS_H */
diff --git a/hyptop/sd.h b/hyptop/sd.h
new file mode 100644
index 0000000..7dd4c93
--- /dev/null
+++ b/hyptop/sd.h
@@ -0,0 +1,479 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * System data module: Provide database for system data (e.g. CPU and memory)
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef SD_H
+#define SD_H
+
+#include "helper.h"
+#include "table.h"
+
+#define SD_DG_INIT_INTERVAL_MS 200
+#define SD_SYS_ID_SIZE 9
+
+/*
+ * CPU info
+ */
+struct sd_cpu_info {
+ u64 cpu_time_us;
+ u64 mgm_time_us;
+ u64 wait_time_us;
+ s64 steal_time_us;
+ u64 online_time_us;
+};
+
+/*
+ * Memory Info
+ */
+struct sd_mem {
+ u64 min_kib;
+ u64 max_kib;
+ u64 use_kib;
+};
+
+/*
+ * Weight
+ */
+struct sd_weight {
+ u16 cur;
+ u16 min;
+ u16 max;
+};
+
+/*
+ * System Name
+ */
+struct sd_sys_name {
+ char os[9];
+};
+
+struct sd_sys;
+
+/*
+ * SD info
+ */
+struct sd_info {
+ u8 active;
+ struct sd_sys *parent;
+};
+
+struct sd_cpu;
+
+/*
+ * SD System (can be e.g. CEC, VM or guest/LPAR)
+ */
+struct sd_sys {
+ struct list list;
+ struct sd_info i;
+ u64 update_time_us;
+ u32 child_cnt;
+ u32 child_cnt_active;
+ struct list child_list;
+ u32 cpu_cnt;
+ u32 cpu_cnt_active;
+ struct list cpu_list;
+ char id[SD_SYS_ID_SIZE];
+ struct sd_sys_name name;
+ struct sd_mem mem;
+ struct sd_weight weight;
+};
+
+#define sd_sys_id(sys) ((sys)->id)
+#define sd_sys_name_os(sys) ((sys)->name.os)
+
+void sd_sys_update_start(struct sd_sys *sys);
+void sd_sys_update_end(struct sd_sys *sys, u64 update_time_us);
+struct sd_sys *sd_sys_root_get(void);
+struct sd_sys *sd_sys_get(struct sd_sys *parent, const char *id);
+struct sd_sys *sd_sys_new(struct sd_sys *parent, const char *id);
+
+static inline void sd_sys_weight_cur_set(struct sd_sys *sys, u64 value)
+{
+ sys->weight.cur = value;
+}
+
+static inline void sd_sys_weight_min_set(struct sd_sys *sys, u64 value)
+{
+ sys->weight.min = value;
+}
+
+static inline void sd_sys_weight_max_set(struct sd_sys *sys, u64 value)
+{
+ sys->weight.max = value;
+}
+
+static inline void sd_sys_mem_use_kib_set(struct sd_sys *sys, u64 value)
+{
+ sys->mem.use_kib = value;
+}
+
+static inline void sd_sys_mem_min_kib_set(struct sd_sys *sys, u64 value)
+{
+ sys->mem.min_kib = value;
+}
+
+static inline void sd_sys_mem_max_kib_set(struct sd_sys *sys, u64 value)
+{
+ sys->mem.max_kib = value;
+}
+
+static inline void sd_sys_update_time_us_set(struct sd_sys *sys, u64 value)
+{
+ sys->update_time_us = value;
+}
+
+/*
+ * CPU type
+ */
+#define CPU_TYPE_ID_LEN 16
+#define CPU_TYPE_DESC_LEN 64
+
+#define SD_CPU_TYPE_STR_IFL "IFL"
+#define SD_CPU_TYPE_STR_CP "CP"
+#define SD_CPU_TYPE_STR_UN "UN"
+
+struct sd_cpu_type {
+ char id[CPU_TYPE_ID_LEN];
+ char desc[CPU_TYPE_DESC_LEN];
+ u32 idx;
+ int cpu_cnt;
+ char hotkey;
+};
+
+#define sd_cpu_type_id(type) (type->id)
+#define sd_cpu_type_desc(type) (type->desc)
+
+int sd_cpu_type_selected(struct sd_cpu_type *cpu_type);
+void sd_cpu_type_select_toggle(struct sd_cpu_type *cpu_type);
+void sd_cpu_type_select(struct sd_cpu_type *cpu_type);
+void sd_cpu_type_select_all(void);
+void sd_cpu_type_select_none(void);
+struct sd_cpu_type *sd_cpu_type_by_id(const char *id);
+
+static inline int sd_cpu_type_cpu_cnt(struct sd_cpu_type *type)
+{
+ return type->cpu_cnt;
+}
+
+static inline void sd_sys_commit(struct sd_sys *sys)
+{
+ struct sd_sys *parent = sys->i.parent;
+
+ sys->i.active = 1;
+ if (parent)
+ parent->child_cnt_active++;
+}
+
+extern struct sd_cpu_type sd_cpu_type_ifl;
+extern struct sd_cpu_type sd_cpu_type_cp;
+extern struct sd_cpu_type sd_cpu_type_un;
+
+/*
+ * SD CPU
+ */
+enum sd_cpu_state {
+ SD_CPU_STATE_UNKNOWN = 0,
+ SD_CPU_STATE_OPERATING = 1,
+ SD_CPU_STATE_STOPPED = 2,
+ SD_CPU_STATE_DECONFIG = 3,
+};
+
+struct sd_cpu {
+ struct list list;
+ struct sd_info i;
+ char id[9];
+ struct sd_cpu_type *type;
+ char real_type[CPU_TYPE_ID_LEN];
+ struct sd_cpu_info d1;
+ struct sd_cpu_info d2;
+ struct sd_cpu_info *d_cur;
+ struct sd_cpu_info *d_prev;
+ u16 cnt;
+ enum sd_cpu_state state;
+};
+
+static inline char *sd_cpu_state_str(enum sd_cpu_state state)
+{
+ static char *state_str[] = {"UK", "OP", "ST", "DC"};
+
+ return state_str[(int) state];
+}
+
+#define sd_cpu_has_diff(cpu) (cpu->d_prev != NULL)
+#define sd_cpu_diff(cpu, member) (cpu->d_cur->member - cpu->d_prev->member)
+
+#define sd_cpu_id(cpu) (cpu->id)
+#define sd_cpu_cnt(cpu) (cpu->cnt)
+#define sd_cpu_type_str(cpu) (cpu->type->id)
+#define sd_cpu_state(cpu) (cpu->state)
+
+struct sd_cpu *sd_cpu_get(struct sd_sys *sys, const char *cpu_id);
+struct sd_cpu *sd_cpu_new(struct sd_sys *parent, const char *id,
+ const char *type, int cnt);
+
+static inline void sd_cpu_state_set(struct sd_cpu *cpu, enum sd_cpu_state state)
+{
+ cpu->state = state;
+}
+
+static inline void sd_cpu_real_type_set(struct sd_cpu *cpu, const char *type)
+{
+ strncpy(cpu->real_type, type, sizeof(cpu->real_type));
+}
+
+static inline void sd_cpu_cpu_time_us_set(struct sd_cpu *cpu, u64 value)
+{
+ cpu->d_cur->cpu_time_us = value;
+}
+
+static inline void sd_cpu_mgm_time_us_set(struct sd_cpu *cpu, u64 value)
+{
+ cpu->d_cur->mgm_time_us = value;
+}
+
+static inline void sd_cpu_wait_time_us_set(struct sd_cpu *cpu, u64 value)
+{
+ cpu->d_cur->wait_time_us = value;
+}
+
+static inline void sd_cpu_steal_time_us_set(struct sd_cpu *cpu, s64 value)
+{
+ cpu->d_cur->steal_time_us = value;
+}
+
+static inline void sd_cpu_online_time_us_set(struct sd_cpu *cpu, u64 value)
+{
+ cpu->d_cur->online_time_us = value;
+}
+
+static inline void sd_cpu_commit(struct sd_cpu *cpu)
+{
+ struct sd_sys *parent = cpu->i.parent;
+
+ cpu->i.active = 1;
+ if (parent)
+ parent->cpu_cnt_active++;
+}
+
+/*
+ * Item types
+ */
+enum sd_item_type {
+ SD_TYPE_U16,
+ SD_TYPE_U32,
+ SD_TYPE_U64,
+ SD_TYPE_S64,
+ SD_TYPE_STR,
+};
+
+/*
+ * CPU item
+ */
+struct sd_cpu_item {
+ struct table_col table_col;
+ enum sd_item_type type;
+ int offset;
+ char *desc;
+ u64 (*fn_u64)(struct sd_cpu_item *, struct sd_cpu *);
+ s64 (*fn_s64)(struct sd_cpu_item *, struct sd_cpu *);
+ char *(*fn_str)(struct sd_cpu_item *, struct sd_cpu *);
+};
+
+#define sd_cpu_item_type(x) ((x)->type)
+#define sd_cpu_item_table_col(item) (&(item)->table_col)
+
+extern int sd_cpu_item_available(struct sd_cpu_item *item);
+extern int sd_cpu_item_cnt(void);
+
+/*
+ * Item access functions
+ */
+static inline u64 sd_cpu_item_u64(struct sd_cpu_item *item,
+ struct sd_cpu *cpu)
+{
+ return item->fn_u64(item, cpu);
+}
+
+static inline u64 sd_cpu_item_s64(struct sd_cpu_item *item,
+ struct sd_cpu *cpu)
+{
+ return item->fn_s64(item, cpu);
+}
+
+static inline char *sd_cpu_item_str(struct sd_cpu_item *item,
+ struct sd_cpu *cpu)
+{
+ if (item->fn_str)
+ return item->fn_str(item, cpu);
+ else
+ return ((char *) cpu) + item->offset;
+}
+
+/*
+ * Predefined CPU items
+ */
+extern struct sd_cpu_item sd_cpu_item_type;
+extern struct sd_cpu_item sd_cpu_item_state;
+extern struct sd_cpu_item sd_cpu_item_cpu_diff;
+extern struct sd_cpu_item sd_cpu_item_mgm_diff;
+extern struct sd_cpu_item sd_cpu_item_wait_diff;
+extern struct sd_cpu_item sd_cpu_item_steal_diff;
+extern struct sd_cpu_item sd_cpu_item_cpu;
+extern struct sd_cpu_item sd_cpu_item_mgm;
+extern struct sd_cpu_item sd_cpu_item_wait;
+extern struct sd_cpu_item sd_cpu_item_steal;
+extern struct sd_cpu_item sd_cpu_item_online;
+
+/*
+ * System item
+ */
+struct sd_sys_item {
+ struct table_col table_col;
+ enum sd_item_type type;
+ int offset;
+ char *desc;
+ int info;
+ u64 (*fn_u64)(struct sd_sys_item *, struct sd_sys *);
+ s64 (*fn_s64)(struct sd_sys_item *, struct sd_sys *);
+};
+
+#define sd_sys_item_table_col(item) (&item->table_col)
+#define sd_sys_item_type(item) (item->type)
+
+extern int sd_sys_item_available(struct sd_sys_item *item);
+extern int sd_sys_item_cnt(void);
+
+/*
+ * Item access functions
+ */
+static inline u64 sd_sys_item_u64(struct sd_sys *sys,
+ struct sd_sys_item *item)
+{
+ return item->fn_u64(item, sys);
+}
+
+static inline s64 sd_sys_item_s64(struct sd_sys *sys,
+ struct sd_sys_item *item)
+{
+ return item->fn_s64(item, sys);
+}
+
+static inline char *sd_sys_item_str(struct sd_sys *sys,
+ struct sd_sys_item *item)
+{
+ return ((char *) sys) + item->offset;
+}
+
+/*
+ * Predefined System items
+ */
+extern struct sd_sys_item sd_sys_item_cpu_cnt;
+extern struct sd_sys_item sd_sys_item_cpu_oper_cnt;
+extern struct sd_sys_item sd_sys_item_cpu_deconf_cnt;
+extern struct sd_sys_item sd_sys_item_cpu_stop_cnt;
+extern struct sd_sys_item sd_sys_item_cpu_diff;
+extern struct sd_sys_item sd_sys_item_mgm_diff;
+extern struct sd_sys_item sd_sys_item_wait_diff;
+extern struct sd_sys_item sd_sys_item_steal_diff;
+
+extern struct sd_sys_item sd_sys_item_cpu;
+extern struct sd_sys_item sd_sys_item_mgm;
+extern struct sd_sys_item sd_sys_item_wait;
+extern struct sd_sys_item sd_sys_item_steal;
+extern struct sd_sys_item sd_sys_item_online;
+
+extern struct sd_sys_item sd_sys_item_mem_max;
+extern struct sd_sys_item sd_sys_item_mem_min;
+extern struct sd_sys_item sd_sys_item_mem_use;
+
+extern struct sd_sys_item sd_sys_item_weight_cur;
+extern struct sd_sys_item sd_sys_item_weight_min;
+extern struct sd_sys_item sd_sys_item_weight_max;
+
+extern struct sd_sys_item sd_sys_item_os_name;
+
+extern struct sd_sys_item sd_sys_item_samples_total;
+extern struct sd_sys_item sd_sys_item_samples_cpu_using;
+
+/*
+ * Data gatherer backend
+ */
+struct sd_dg {
+ void (*update_sys)(void);
+ struct sd_cpu_type **cpu_type_vec;
+ struct sd_sys_item **sys_item_vec;
+ struct sd_sys_item **sys_item_enable_vec;
+ struct sd_cpu_item **cpu_item_vec;
+ struct sd_cpu_item **cpu_item_enable_vec;
+};
+
+void sd_dg_register(struct sd_dg *);
+
+/*
+ * Iterators
+ */
+#define sd_sys_iterate(parent, sys) \
+ list_iterate(sys, &parent->child_list, list)
+
+#define sd_cpu_iterate(parent, cpuptr) \
+ list_iterate(cpu, &parent->cpu_list, list)
+
+#define sd_sys_item_iterate(ptr, i) \
+ for (i = 0; (ptr = sd.dg->sys_item_vec[i]); i++)
+
+#define sd_sys_item_enable_iterate(ptr, i) \
+ for (i = 0; (ptr = sd.dg->sys_item_enable_vec[i]); i++)
+
+#define sd_cpu_item_iterate(ptr, i) \
+ for (i = 0; (ptr = sd.dg->cpu_item_vec[i]); i++)
+
+#define sd_cpu_item_enable_iterate(ptr, i) \
+ for (i = 0; (ptr = sd.dg->cpu_item_enable_vec[i]); i++)
+
+#define sd_cpu_type_iterate(ptr, i) \
+ for (i = 0; (ptr = sd.dg->cpu_type_vec[i]); i++)
+
+
+/*
+ * Offset macros
+ */
+#define SD_SYSTEM_OFFSET(x) \
+ ((unsigned long)(void *)&(((struct sd_sys *) NULL)->x))
+#define SD_CPU_INFO_OFFSET(x) \
+ ((unsigned long)(void *)&(((struct sd_cpu_info *) NULL)->x))
+
+static inline u64 l_cpu_info_u64(struct sd_cpu_info *info,
+ unsigned long offset)
+{
+ return *(u64 *)(((char *) info) + offset);
+}
+
+static inline s64 l_cpu_info_s64(struct sd_cpu_info *info,
+ unsigned long offset)
+{
+ return *(s64 *)(((char *) info) + offset);
+}
+
+/*
+ * Misc
+ */
+void sd_update(void);
+extern void sd_init(void);
+
+static inline u64 l_sub_64(u64 x, u64 y)
+{
+ return x < y ? 0 : x - y;
+}
+
+struct sd_globals {
+ struct sd_dg *dg;
+};
+
+extern struct sd_globals sd;
+
+#endif /* SD_H */
diff --git a/hyptop/sd_core.c b/hyptop/sd_core.c
new file mode 100644
index 0000000..c3aeaa0
--- /dev/null
+++ b/hyptop/sd_core.c
@@ -0,0 +1,435 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * System data module: Provide backend independent database for system data
+ * (e.g. for CPU and memory data)
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <string.h>
+#include <time.h>
+#include "sd.h"
+#include "hyptop.h"
+#include "helper.h"
+#include "opts.h"
+
+/*
+ * Internal globals for system data
+ */
+static u32 l_cpu_type_selected_mask;
+static int l_cpu_type_cnt;
+static int l_sys_item_cnt;
+static int l_cpu_item_cnt;
+static struct sd_sys *l_root_sys;
+
+/*
+ * External globals for system data
+ */
+struct sd_globals sd;
+
+/*
+ * Get root system
+ */
+struct sd_sys *sd_sys_root_get(void)
+{
+ return l_root_sys;
+}
+
+/*
+ * Get CPU type by it's ID
+ */
+struct sd_cpu_type *sd_cpu_type_by_id(const char *id)
+{
+ struct sd_cpu_type *type;
+ unsigned int i;
+
+ sd_cpu_type_iterate(type, i) {
+ if (strcasecmp(id, type->id) == 0)
+ return type;
+ }
+ return NULL;
+}
+
+/*
+ * Is CPU type selected?
+ */
+int sd_cpu_type_selected(struct sd_cpu_type *cpu_type)
+{
+ return l_cpu_type_selected_mask & cpu_type->idx;
+}
+
+/*
+ * Toggle selection of CPU type
+ */
+void sd_cpu_type_select_toggle(struct sd_cpu_type *cpu_type)
+{
+ if (l_cpu_type_selected_mask & cpu_type->idx)
+ l_cpu_type_selected_mask &= ~cpu_type->idx;
+ else
+ l_cpu_type_selected_mask |= cpu_type->idx;
+}
+
+/*
+ * Select exactly specified CPU type
+ */
+void sd_cpu_type_select(struct sd_cpu_type *cpu_type)
+{
+ l_cpu_type_selected_mask = cpu_type->idx;
+}
+
+/*
+ * Select all available CPU types
+ */
+void sd_cpu_type_select_all(void)
+{
+ l_cpu_type_selected_mask = (u32)-1;
+}
+
+/*
+ * Deselect all CPU types
+ */
+void sd_cpu_type_select_none(void)
+{
+ l_cpu_type_selected_mask = 0;
+}
+
+/*
+ * Setup CPU types specified on command line
+ */
+static void l_opts_cpu_types_init(void)
+{
+ struct sd_cpu_type *type;
+ unsigned int i;
+
+ if (!g.o.cpu_types.specified)
+ return;
+
+ sd_cpu_type_select_none();
+ for (i = 0; i < g.o.cpu_types.cnt; i++) {
+ type = sd_cpu_type_by_id(g.o.cpu_types.vec[i]);
+ if (!type)
+ ERR_EXIT("Invalid CPU type \"%s\"\n",
+ g.o.cpu_types.vec[i]);
+ sd_cpu_type_select_toggle(type);
+ }
+}
+
+/*
+ * Init CPU count for all CPU types
+ */
+static void l_cpu_types_init(void)
+{
+ struct sd_sys *sys = sd_sys_root_get();
+ struct sd_cpu_type *cpu_type;
+ unsigned int i;
+
+ sd_cpu_type_iterate(cpu_type, i) {
+ sd_cpu_type_select(cpu_type);
+ cpu_type->cpu_cnt = sd_sys_item_u64(sys, &sd_sys_item_cpu_cnt);
+ }
+ sd_cpu_type_select_all();
+ l_opts_cpu_types_init();
+}
+
+/*
+ * Update system data using the data gatherer
+ */
+void sd_update(void)
+{
+ sd.dg->update_sys();
+}
+
+/*
+ * Register a data gatherer
+ */
+void sd_dg_register(struct sd_dg *dg)
+{
+ struct timespec ts = {0, SD_DG_INIT_INTERVAL_MS * 1000000};
+ struct sd_sys_item *sys_item;
+ struct sd_cpu_item *cpu_item;
+ unsigned int i;
+
+ sd.dg = dg;
+
+ for (i = 0; dg->cpu_type_vec[i]; i++)
+ dg->cpu_type_vec[i]->idx = (1UL << i);
+ l_cpu_type_cnt = i;
+ sd_sys_item_iterate(sys_item, i)
+ l_sys_item_cnt++;
+ sd_cpu_item_iterate(cpu_item, i)
+ l_cpu_item_cnt++;
+
+ sd_update();
+ nanosleep(&ts, NULL);
+ sd_update();
+
+ l_cpu_types_init();
+}
+
+/*
+ * Get CPU from sys by ID
+ */
+struct sd_cpu *sd_cpu_get(struct sd_sys *sys, const char* id)
+{
+ struct sd_cpu *cpu;
+
+ list_iterate(cpu, &sys->cpu_list, list) {
+ if (strcmp(cpu->id, id) == 0)
+ return cpu;
+ }
+ return NULL;
+}
+
+/*
+ * Get CPU type by ID
+ */
+static struct sd_cpu_type *l_cpu_type_by_id(const char *id)
+{
+ struct sd_cpu_type **cpu_type_vec = sd.dg->cpu_type_vec;
+ int i;
+
+ for (i = 0; i < l_cpu_type_cnt; i++) {
+ if (strcmp(cpu_type_vec[i]->id, id) == 0)
+ return cpu_type_vec[i];
+ }
+ return NULL;
+}
+
+/*
+ * Allocate and initialize new CPU
+ */
+struct sd_cpu *sd_cpu_new(struct sd_sys *parent, const char *id,
+ const char *type, int cnt)
+{
+ struct sd_cpu *cpu;
+
+ cpu = ht_zalloc(sizeof(*cpu));
+ cpu->i.parent = parent;
+ strncpy(cpu->id, id, sizeof(cpu->id));
+ cpu->type = l_cpu_type_by_id(type);
+ cpu->d_cur = &cpu->d1;
+ cpu->cnt = cnt;
+
+ list_add_end(&cpu->list, &parent->cpu_list);
+
+ return cpu;
+}
+
+/*
+ * Get system by ID
+ */
+struct sd_sys *sd_sys_get(struct sd_sys *parent, const char* id)
+{
+ struct sd_sys *sys;
+
+ list_iterate(sys, &parent->child_list, list) {
+ if (strcmp(sys->id, id) == 0)
+ return sys;
+ }
+ return NULL;
+}
+
+/*
+ * Allocate and initialize new system
+ */
+struct sd_sys *sd_sys_new(struct sd_sys *parent, const char *id)
+{
+ struct sd_sys *sys_new;
+
+ sys_new = ht_zalloc(sizeof(*sys_new));
+ strncpy(sys_new->id, id, sizeof(sys_new->id));
+ list_init(&sys_new->child_list);
+ list_init(&sys_new->cpu_list);
+ list_init(&sys_new->list);
+
+ if (parent) {
+ sys_new->i.parent = parent;
+ parent->child_cnt++;
+ list_add_end(&sys_new->list, &parent->child_list);
+ }
+ return sys_new;
+}
+
+/*
+ * Free system
+ */
+static void sd_sys_free(struct sd_sys *sys)
+{
+ ht_free(sys);
+}
+
+/*
+ * Free CPU
+ */
+static void sd_cpu_free(struct sd_cpu *cpu)
+{
+ ht_free(cpu);
+}
+
+/*
+ * Start update cycle for CPU
+ */
+static void l_cpu_update_start(struct sd_cpu *cpu)
+{
+ struct sd_cpu_info *tmp;
+
+ cpu->i.active = 0;
+ if (!cpu->d_prev) {
+ cpu->d_prev = &cpu->d1;
+ cpu->d_cur = &cpu->d2;
+ } else {
+ tmp = cpu->d_prev;
+ cpu->d_prev = cpu->d_cur;
+ cpu->d_cur = tmp;
+ }
+}
+
+/*
+ * Start update cycle for system
+ */
+void sd_sys_update_start(struct sd_sys *sys)
+{
+ struct sd_sys *child;
+ struct sd_cpu *cpu;
+
+ sys->i.active = 0;
+ sys->child_cnt_active = 0;
+ sys->cpu_cnt_active = 0;
+
+ list_iterate(cpu, &sys->cpu_list, list)
+ l_cpu_update_start(cpu);
+ list_iterate(child, &sys->child_list, list)
+ sd_sys_update_start(child);
+}
+
+/*
+ * End update cycle for CPUs of a system
+ */
+static void l_cpu_update_end(struct sd_sys *sys)
+{
+ struct sd_cpu *cpu, *tmp;
+
+ /* Has system not lost any CPU? */
+ if (sys->cpu_cnt_active == sys->cpu_cnt)
+ return;
+
+ list_iterate_safe(cpu, &sys->cpu_list, list, tmp) {
+ if (!cpu->i.active) {
+ /* CPU has not been updated, remove it */
+ list_del(&cpu->list);
+ sd_cpu_free(cpu);
+ continue;
+ }
+ }
+}
+
+/*
+ * End update cycle for system
+ */
+static void l_sys_update_end(struct sd_sys *sys)
+{
+ struct sd_sys *child, *tmp;
+
+ if (sys->child_cnt_active == sys->child_cnt)
+ return;
+
+ l_cpu_update_end(sys);
+
+ list_iterate_safe(child, &sys->child_list, list, tmp) {
+ if (!child->i.active) {
+ /* child has not been updated, remove it */
+ list_del(&child->list);
+ sd_sys_free(child);
+ continue;
+ }
+ /* Recursively update child */
+ l_sys_update_end(child);
+ }
+ sys->child_cnt = sys->child_cnt_active;
+}
+
+/*
+ * End update cycle for system
+ */
+void sd_sys_update_end(struct sd_sys *sys, u64 update_time_us)
+{
+ sys->update_time_us = update_time_us;
+ l_sys_update_end(sys);
+}
+
+/*
+ * Is system item available?
+ */
+int sd_sys_item_available(struct sd_sys_item *item)
+{
+ struct sd_sys_item *ptr;
+ unsigned int i;
+
+ sd_sys_item_iterate(ptr, i) {
+ if (item == ptr)
+ return 1;
+ }
+ return 0;
+}
+
+/*
+ * Number of system items
+ */
+int sd_sys_item_cnt(void)
+{
+ return l_sys_item_cnt;
+}
+
+/*
+ * Is CPU item avaiable?
+ */
+int sd_cpu_item_available(struct sd_cpu_item *item)
+{
+ struct sd_cpu_item *ptr;
+ unsigned int i;
+
+ sd_cpu_item_iterate(ptr, i) {
+ if (item == ptr)
+ return 1;
+ }
+ return 0;
+}
+
+/*
+ * Number of CPU items
+ */
+int sd_cpu_item_cnt(void)
+{
+ return l_cpu_item_cnt;
+}
+
+/*
+ * Init system data module
+ */
+void sd_init(void)
+{
+ l_root_sys = sd_sys_new(NULL, "root");
+}
+
+/*
+ * CPU Types
+ */
+struct sd_cpu_type sd_cpu_type_ifl = {
+ .id = SD_CPU_TYPE_STR_IFL,
+ .desc = "Integrated Facility for Linux",
+ .hotkey = 'i',
+};
+
+struct sd_cpu_type sd_cpu_type_cp = {
+ .id = SD_CPU_TYPE_STR_CP,
+ .desc = "Central processor",
+ .hotkey = 'p',
+};
+
+struct sd_cpu_type sd_cpu_type_un = {
+ .id = SD_CPU_TYPE_STR_UN,
+ .desc = "Unspecified processor type",
+ .hotkey = 'u',
+};
diff --git a/hyptop/sd_cpu_items.c b/hyptop/sd_cpu_items.c
new file mode 100644
index 0000000..803a9b9
--- /dev/null
+++ b/hyptop/sd_cpu_items.c
@@ -0,0 +1,178 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Provide CPU Items
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include "sd.h"
+
+/*
+ * Return CPU type of "cpu"
+ */
+static char *l_cpu_type(struct sd_cpu_item *item, struct sd_cpu *cpu)
+{
+ (void) item;
+ return sd_cpu_type_str(cpu);
+}
+
+/*
+ * Return CPU state of "cpu"
+ */
+static char *l_cpu_state(struct sd_cpu_item *item, struct sd_cpu *cpu)
+{
+ (void) item;
+ return sd_cpu_state_str(sd_cpu_state(cpu));
+}
+
+/*
+ * value = (value_current - value_prev) / online_time_diff
+ */
+static double l_cpu_diff(struct sd_cpu_item *item, struct sd_cpu *cpu, int sign)
+{
+ u64 online_time_diff_us;
+ double factor, diff_us;
+
+ if (sd_cpu_state(cpu) == SD_CPU_STATE_STOPPED)
+ return 0;
+ if (!cpu->d_prev || !cpu->d_cur)
+ return 0;
+ if (!sd_cpu_type_selected(cpu->type))
+ return 0;
+ online_time_diff_us = l_sub_64(cpu->d_cur->online_time_us,
+ cpu->d_prev->online_time_us);
+ if (online_time_diff_us == 0)
+ return 0;
+
+ factor = ((double) online_time_diff_us) / 1000000;
+ if (sign)
+ diff_us = l_cpu_info_s64(cpu->d_cur, item->offset) -
+ l_cpu_info_s64(cpu->d_prev, item->offset);
+ else
+ diff_us = l_sub_64(l_cpu_info_u64(cpu->d_cur, item->offset),
+ l_cpu_info_u64(cpu->d_prev, item->offset));
+ diff_us /= factor;
+ return diff_us;
+}
+
+/*
+ * unsigned value = (value_current - value_prev) / online_time_diff
+ */
+static u64 l_cpu_diff_u64(struct sd_cpu_item *item, struct sd_cpu *cpu)
+{
+ return l_cpu_diff(item, cpu, 0);
+}
+
+/*
+ * signed value = (value_current - value_prev) / online_time_diff
+ */
+static s64 l_cpu_diff_s64(struct sd_cpu_item *item, struct sd_cpu *cpu)
+{
+ return l_cpu_diff(item, cpu, 1);
+}
+
+/*
+ * Return cpu item value
+ */
+static u64 l_cpu_item_64(struct sd_cpu_item *item, struct sd_cpu *cpu)
+{
+ if (sd_cpu_state(cpu) == SD_CPU_STATE_STOPPED)
+ return 0;
+ if (!cpu->d_cur)
+ return 0;
+ if (!sd_cpu_type_selected(cpu->type))
+ return 0;
+ return l_cpu_info_u64(cpu->d_cur, item->offset);
+}
+
+/*
+ * CPU item definitions
+ */
+struct sd_cpu_item sd_cpu_item_type = {
+ .table_col = TABLE_COL_STR('p', "type"),
+ .type = SD_TYPE_STR,
+ .desc = "CPU type",
+ .fn_str = l_cpu_type,
+};
+
+struct sd_cpu_item sd_cpu_item_state = {
+ .table_col = TABLE_COL_STR('a', "stat"),
+ .type = SD_TYPE_STR,
+ .desc = "CPU state",
+ .fn_str = l_cpu_state,
+};
+
+struct sd_cpu_item sd_cpu_item_cpu_diff = {
+ .table_col = TABLE_COL_TIME_DIFF_SUM(table_col_unit_perc, 'c', "cpu"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(cpu_time_us),
+ .desc = "CPU time per second",
+ .fn_u64 = l_cpu_diff_u64,
+};
+
+struct sd_cpu_item sd_cpu_item_mgm_diff = {
+ .table_col = TABLE_COL_TIME_DIFF_SUM(table_col_unit_perc, 'm', "mgm"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(mgm_time_us),
+ .desc = "Management time per second",
+ .fn_u64 = l_cpu_diff_u64,
+};
+
+struct sd_cpu_item sd_cpu_item_wait_diff = {
+ .table_col = TABLE_COL_TIME_DIFF_SUM(table_col_unit_perc, 'w', "wait"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(wait_time_us),
+ .desc = "Wait time per second",
+ .fn_u64 = l_cpu_diff_u64,
+};
+
+struct sd_cpu_item sd_cpu_item_steal_diff = {
+ .table_col = TABLE_COL_STIME_DIFF_SUM(table_col_unit_perc, 's',
+ "steal"),
+ .type = SD_TYPE_S64,
+ .offset = SD_CPU_INFO_OFFSET(steal_time_us),
+ .desc = "Steal time per second",
+ .fn_s64 = l_cpu_diff_s64,
+};
+
+struct sd_cpu_item sd_cpu_item_cpu = {
+ .table_col = TABLE_COL_TIME_SUM(table_col_unit_hm, 'C', "cpu+"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(cpu_time_us),
+ .desc = "Total CPU time",
+ .fn_u64 = l_cpu_item_64,
+};
+
+struct sd_cpu_item sd_cpu_item_mgm = {
+ .table_col = TABLE_COL_TIME_SUM(table_col_unit_hm, 'M', "mgm+"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(mgm_time_us),
+ .desc = "Total management time",
+ .fn_u64 = l_cpu_item_64,
+};
+
+struct sd_cpu_item sd_cpu_item_wait = {
+ .table_col = TABLE_COL_TIME_SUM(table_col_unit_hm, 'W', "wait+"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(wait_time_us),
+ .desc = "Total wait time",
+ .fn_u64 = l_cpu_item_64,
+};
+
+struct sd_cpu_item sd_cpu_item_steal = {
+ .table_col = TABLE_COL_STIME_SUM(table_col_unit_hm, 'S', "steal+"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(steal_time_us),
+ .desc = "Total steal time",
+ .fn_u64 = l_cpu_item_64,
+};
+
+struct sd_cpu_item sd_cpu_item_online = {
+ .table_col = TABLE_COL_TIME_MAX(table_col_unit_dhm, 'o', "online"),
+ .type = SD_TYPE_U64,
+ .offset = SD_CPU_INFO_OFFSET(online_time_us),
+ .desc = "Online time",
+ .fn_u64 = l_cpu_item_64,
+};
diff --git a/hyptop/sd_sys_items.c b/hyptop/sd_sys_items.c
new file mode 100644
index 0000000..046faf4
--- /dev/null
+++ b/hyptop/sd_sys_items.c
@@ -0,0 +1,325 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Provide System Items
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include "sd.h"
+
+/*
+ * Count CPUs of system according to active CPU types and requested CPU state
+ */
+static u64 l_sys_cpu_cnt_gen(struct sd_sys *sys, enum sd_cpu_state state,
+ int all)
+{
+ struct sd_cpu *cpu;
+ u32 cnt = 0;
+
+ sd_cpu_iterate(sys, cpu) {
+ if (!sd_cpu_type_selected(cpu->type))
+ continue;
+ if (all || sd_cpu_state(cpu) == state)
+ cnt += cpu->cnt;
+ }
+ return cnt;
+}
+
+/*
+ * Count all CPUs of system
+ */
+static u64 l_sys_cpu_cnt(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ (void) item;
+ return l_sys_cpu_cnt_gen(sys, SD_CPU_STATE_UNKNOWN, 1);
+}
+
+/*
+ * Count CPUs of system with state stopped
+ */
+static u64 l_sys_cpu_st_cnt(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ (void) item;
+
+ return l_sys_cpu_cnt_gen(sys, SD_CPU_STATE_STOPPED, 0);
+}
+
+/*
+ * Count CPUs of system with state operating
+ */
+static u64 l_sys_cpu_op_cnt(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ (void) item;
+
+ return l_sys_cpu_cnt_gen(sys, SD_CPU_STATE_OPERATING, 0);
+}
+
+/*
+ * Count CPUs of system with state deconfigured
+ */
+static u64 l_sys_cpu_dc_cnt(struct sd_sys_item *item,
+ struct sd_sys *sys)
+{
+ (void) item;
+
+ return l_sys_cpu_cnt_gen(sys, SD_CPU_STATE_DECONFIG, 0);
+}
+
+/*
+ * Get u64 system item value from "sys"
+ */
+static u64 l_sys_item_u64(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ switch (item->type) {
+ case SD_TYPE_U16:
+ return *(u16 *)(((char *) sys) + item->offset);
+ case SD_TYPE_U32:
+ return *(u32 *)(((char *) sys) + item->offset);
+ case SD_TYPE_U64:
+ return *(u64 *)(((char *) sys) + item->offset);
+ case SD_TYPE_S64:
+ case SD_TYPE_STR:
+ break;
+ }
+ assert(0);
+ return 0;
+}
+
+/*
+ * Calculate system item out of sum of CPU info
+ */
+static u64 l_sys_cpu_info_sum_u64(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ struct sd_cpu *cpu;
+ u64 rc = 0;
+
+ sd_cpu_iterate(sys, cpu) {
+ if (!sd_cpu_type_selected(cpu->type))
+ continue;
+ rc += l_cpu_info_u64(cpu->d_cur, item->offset);
+ }
+ return rc;
+}
+
+/*
+ * Calculate system item out of MAX of CPU info
+ */
+static u64 l_sys_cpu_info_max_u64(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ struct sd_cpu *cpu;
+ u64 rc = 0;
+
+ sd_cpu_iterate(sys, cpu) {
+ if (!sd_cpu_type_selected(cpu->type))
+ continue;
+ rc = MAX(rc, l_cpu_info_u64(cpu->d_cur, item->offset));
+ }
+ return rc;
+}
+
+/*
+ * value = (value_current - value_prev) / online_time_diff
+ */
+static double l_cpu_info_diff_u64(struct sd_sys_item *item, struct sd_cpu *cpu,
+ int sign)
+{
+ u64 online_time_diff_us;
+ double factor, diff_us;
+
+ if (!sd_cpu_type_selected(cpu->type))
+ return 0;
+ if (sd_cpu_state(cpu) == SD_CPU_STATE_STOPPED)
+ return 0;
+ online_time_diff_us = l_sub_64(cpu->d_cur->online_time_us,
+ cpu->d_prev->online_time_us);
+ if (online_time_diff_us == 0)
+ return 0;
+ if (sign) {
+ diff_us = l_cpu_info_s64(cpu->d_cur, item->offset) -
+ l_cpu_info_s64(cpu->d_prev, item->offset);
+ } else {
+ diff_us = l_sub_64(l_cpu_info_u64(cpu->d_cur, item->offset),
+ l_cpu_info_u64(cpu->d_prev, item->offset));
+ }
+ factor = ((double) online_time_diff_us) / 1000000;
+ diff_us /= factor;
+ return diff_us;
+}
+
+/*
+ * SUM over all CPUs: value = (value_current - value_prev) / online_time_diff
+ */
+static u64 l_sys_cpu_info_diff_u64(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ struct sd_cpu *cpu;
+ u64 rc = 0;
+
+ sd_cpu_iterate(sys, cpu) {
+ if (!cpu->d_prev || !cpu->d_cur)
+ return 0;
+ rc += l_cpu_info_diff_u64(item, cpu, 0);
+ }
+ return rc;
+}
+
+/*
+ * SUM over all CPUs: value = (value_current - value_prev) / online_time_diff
+ */
+static s64 l_sys_cpu_info_diff_s64(struct sd_sys_item *item, struct sd_sys *sys)
+{
+ struct sd_cpu *cpu;
+ s64 rc = 0;
+
+ sd_cpu_iterate(sys, cpu) {
+ if (!cpu->d_prev || !cpu->d_cur)
+ return 0;
+ rc += l_cpu_info_diff_u64(item, cpu, 1);
+ }
+ return rc;
+}
+
+/*
+ * System item definitions
+ */
+struct sd_sys_item sd_sys_item_cpu_cnt = {
+ .table_col = TABLE_COL_CNT_SUM('#', "#cpu"),
+ .type = SD_TYPE_U32,
+ .desc = "Number of CPUs",
+ .fn_u64 = l_sys_cpu_cnt,
+};
+
+struct sd_sys_item sd_sys_item_cpu_oper_cnt = {
+ .table_col = TABLE_COL_CNT_SUM('e', "#cpuope"),
+ .type = SD_TYPE_U32,
+ .desc = "Number of operating CPUs",
+ .fn_u64 = l_sys_cpu_op_cnt,
+};
+
+struct sd_sys_item sd_sys_item_cpu_stop_cnt = {
+ .table_col = TABLE_COL_CNT_SUM('p', "#cpusp"),
+ .type = SD_TYPE_U32,
+ .desc = "Number of stopped CPUs",
+ .fn_u64 = l_sys_cpu_st_cnt,
+};
+
+struct sd_sys_item sd_sys_item_cpu_deconf_cnt = {
+ .table_col = TABLE_COL_CNT_SUM('d', "#cpudc"),
+ .type = SD_TYPE_U32,
+ .desc = "Number of deconfigured CPUs",
+ .fn_u64 = l_sys_cpu_dc_cnt,
+};
+
+struct sd_sys_item sd_sys_item_cpu_diff = {
+ .table_col = TABLE_COL_TIME_DIFF_SUM(table_col_unit_perc, 'c', "cpu"),
+ .offset = SD_CPU_INFO_OFFSET(cpu_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "CPU time per second",
+ .fn_u64 = l_sys_cpu_info_diff_u64,
+};
+
+struct sd_sys_item sd_sys_item_mgm_diff = {
+ .table_col = TABLE_COL_TIME_DIFF_SUM(table_col_unit_perc, 'm', "mgm"),
+ .offset = SD_CPU_INFO_OFFSET(mgm_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "Management time per second",
+ .fn_u64 = l_sys_cpu_info_diff_u64,
+};
+
+struct sd_sys_item sd_sys_item_wait_diff = {
+ .table_col = TABLE_COL_TIME_DIFF_SUM(table_col_unit_perc, 'w', "wait"),
+ .offset = SD_CPU_INFO_OFFSET(wait_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "Wait time per second",
+ .fn_u64 = l_sys_cpu_info_diff_u64,
+};
+
+struct sd_sys_item sd_sys_item_steal_diff = {
+ .table_col = TABLE_COL_STIME_DIFF_SUM(table_col_unit_perc, 's',
+ "steal"),
+ .offset = SD_CPU_INFO_OFFSET(steal_time_us),
+ .type = SD_TYPE_S64,
+ .desc = "Steal time per second",
+ .fn_s64 = l_sys_cpu_info_diff_s64,
+};
+
+struct sd_sys_item sd_sys_item_cpu = {
+ .table_col = TABLE_COL_TIME_SUM(table_col_unit_hm, 'C', "cpu+"),
+ .offset = SD_CPU_INFO_OFFSET(cpu_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "Total CPU time",
+ .fn_u64 = l_sys_cpu_info_sum_u64,
+};
+
+struct sd_sys_item sd_sys_item_wait = {
+ .table_col = TABLE_COL_TIME_SUM(table_col_unit_hm, 'W', "wait+"),
+ .offset = SD_CPU_INFO_OFFSET(wait_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "Total wait time",
+ .fn_u64 = l_sys_cpu_info_sum_u64,
+};
+
+struct sd_sys_item sd_sys_item_mgm = {
+ .table_col = TABLE_COL_TIME_SUM(table_col_unit_hm, 'M', "mgm+"),
+ .offset = SD_CPU_INFO_OFFSET(mgm_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "Total management time",
+ .fn_u64 = l_sys_cpu_info_sum_u64,
+};
+
+struct sd_sys_item sd_sys_item_steal = {
+ .table_col = TABLE_COL_STIME_SUM(table_col_unit_hm, 'S', "steal+"),
+ .offset = SD_CPU_INFO_OFFSET(steal_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "Total steal time",
+ .fn_u64 = l_sys_cpu_info_sum_u64,
+};
+
+struct sd_sys_item sd_sys_item_online = {
+ .table_col = TABLE_COL_TIME_MAX(table_col_unit_dhm, 'o', "online"),
+ .offset = SD_CPU_INFO_OFFSET(online_time_us),
+ .type = SD_TYPE_U64,
+ .desc = "Online time",
+ .fn_u64 = l_sys_cpu_info_max_u64,
+};
+
+struct sd_sys_item sd_sys_item_mem_max = {
+ .table_col = TABLE_COL_MEM_SUM(table_col_unit_gib, 'a', "memmax"),
+ .offset = SD_SYSTEM_OFFSET(mem.max_kib),
+ .type = SD_TYPE_U64,
+ .desc = "Maximum memory",
+ .fn_u64 = l_sys_item_u64,
+};
+
+struct sd_sys_item sd_sys_item_mem_use = {
+ .table_col = TABLE_COL_MEM_SUM(table_col_unit_gib, 'u', "memuse"),
+ .offset = SD_SYSTEM_OFFSET(mem.use_kib),
+ .type = SD_TYPE_U64,
+ .desc = "Used memory",
+ .fn_u64 = l_sys_item_u64,
+};
+
+struct sd_sys_item sd_sys_item_weight_cur = {
+ .table_col = TABLE_COL_CNT_MAX('r', "wcur"),
+ .offset = SD_SYSTEM_OFFSET(weight.cur),
+ .type = SD_TYPE_U16,
+ .desc = "Current weight",
+ .fn_u64 = l_sys_item_u64,
+};
+
+struct sd_sys_item sd_sys_item_weight_min = {
+ .table_col = TABLE_COL_CNT_MAX('n', "wmin"),
+ .offset = SD_SYSTEM_OFFSET(weight.min),
+ .type = SD_TYPE_U16,
+ .desc = "Minimum weight",
+ .fn_u64 = l_sys_item_u64,
+};
+
+struct sd_sys_item sd_sys_item_weight_max = {
+ .table_col = TABLE_COL_CNT_MAX('x', "wmax"),
+ .offset = SD_SYSTEM_OFFSET(weight.max),
+ .type = SD_TYPE_U16,
+ .desc = "Maximum weight",
+ .fn_u64 = l_sys_item_u64,
+};
diff --git a/hyptop/table.c b/hyptop/table.c
new file mode 100644
index 0000000..352960f
--- /dev/null
+++ b/hyptop/table.c
@@ -0,0 +1,1231 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Table module: Provide line mode and curses base table
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ncurses.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include "table.h"
+#include "hyptop.h"
+#include "helper.h"
+
+#define L_ROWS_EXTRA 2 /* head + last */
+
+#define table_col_iterate(t, col, i) \
+ for (i = 0, col = t->col_vec[0]; col != NULL; col = t->col_vec[++i])
+
+/*
+ * Is row marked?
+ */
+static int l_row_is_marked(struct table *t, struct table_row *row)
+{
+ struct table_mark_key *key;
+
+ list_iterate(key, &t->mark_key_list, list) {
+ if (strcmp(row->entries[0].str, key->str) == 0)
+ return 1;
+ }
+ return 0;
+}
+
+/*
+ * Add mark key to table
+ */
+static void l_mark_key_add(struct table *t, char *str)
+{
+ struct table_mark_key *key;
+
+ key = ht_zalloc(sizeof(*key));
+ strncpy(key->str, str, sizeof(key->str));
+ list_add_end(&key->list, &t->mark_key_list);
+ t->mark_keys_cnt++;
+}
+
+/*
+ * Remove mark key from table
+ */
+static void l_mark_key_remove(struct table *t, char *str)
+{
+ struct table_mark_key *key;
+
+ list_iterate(key, &t->mark_key_list, list) {
+ if (strcmp(str, key->str) == 0) {
+ list_del(&key->list);
+ ht_free(key);
+ t->mark_keys_cnt--;
+ return;
+ }
+ }
+}
+
+/*
+ * Delete all mark keys from table
+ */
+void table_row_mark_del_all(struct table *t)
+{
+ struct table_mark_key *key, *tmp;
+ struct table_row *row;
+
+ list_iterate(row, &t->row_list, list)
+ row->marked = 0;
+ list_iterate_safe(key, &t->mark_key_list, list, tmp) {
+ list_del(&key->list);
+ ht_free(key);
+ }
+ t->mark_keys_cnt = 0;
+}
+
+/*
+ * Toggle mark for "row"
+ */
+void table_row_mark_toggle(struct table *t, struct table_row *row)
+{
+ if (row->marked) {
+ l_mark_key_remove(t, row->entries[0].str);
+ row->marked = 0;
+ t->row_cnt_marked--;
+ if (t->row_cnt_marked == 0)
+ t->mode_hide_unmarked = 0;
+ } else {
+ l_mark_key_add(t, row->entries[0].str);
+ row->marked = 1;
+ t->row_cnt_marked++;
+ }
+}
+
+/*
+ * Toggle mark by key
+ */
+void table_row_mark_toggle_by_key(struct table *t, const char *str)
+{
+ struct table_row *row;
+
+ list_iterate(row, &t->row_list, list) {
+ if (strcmp(str, row->entries[0].str) == 0)
+ table_row_mark_toggle(t, row);
+ }
+}
+
+/*
+ * Is column selected?
+ */
+static int l_col_selected(struct table *t, struct table_col *col)
+{
+ return t->col_selected == col;
+}
+
+/*
+ * Get number of rows for table
+ */
+static int l_row_cnt(struct table *t)
+{
+ return t->mode_hide_unmarked ? t->row_cnt_marked : t->row_cnt;
+}
+
+/*
+ * Get number of data rows that we can display on screen
+ */
+static int l_row_cnt_displ(struct table *t)
+{
+ return g.c.row_cnt - t->row_cnt_extra;
+}
+
+/*
+ * Alloc a new row for table
+ */
+struct table_row *table_row_alloc(struct table *t)
+{
+ struct table_row *table_row;
+
+ table_row = ht_zalloc(sizeof(*table_row));
+ table_row->entries = ht_zalloc(sizeof(*table_row->entries) *
+ t->col_cnt);
+ list_init(&table_row->list);
+ return table_row;
+}
+
+/*
+ * Free table row
+ */
+static void table_row_free(struct table_row *table_row)
+{
+ ht_free(table_row->entries);
+ ht_free(table_row);
+}
+
+/*
+ * Allocate and initialize a new table
+ */
+struct table *table_new(int extra_rows, int sorted, int first_bold,
+ int with_units)
+{
+ struct table *t = ht_zalloc(sizeof(*t));
+
+ list_init(&t->row_list);
+ list_init(&t->mark_key_list);
+ t->row_cnt_marked = 0;
+ if (with_units)
+ t->row_cnt_extra = extra_rows + L_ROWS_EXTRA + 1;
+ else
+ t->row_cnt_extra = extra_rows + L_ROWS_EXTRA;
+ t->attr_with_units = with_units;
+ t->attr_sorted_table = sorted;
+ t->attr_first_bold = first_bold;
+
+ return t;
+}
+
+/*
+ * Initialize headline for one column
+ */
+static void l_col_headline_init(struct table *t, struct table_col *col)
+{
+ char *ptr;
+
+ strcpy(col->p->head_first, col->head);
+ ptr = strchr(col->p->head_first, tolower(col->hotkey));
+ assert(ptr != NULL);
+ *ptr = 0;
+ col->p->head_char[0] = col->hotkey;
+ strcpy(col->p->head_last, ++ptr);
+ if (!t->attr_sorted_table) {
+ ht_str_to_upper(col->p->head_first);
+ ht_str_to_upper(col->p->head_last);
+ col->p->head_char[0] = toupper(col->p->head_char[0]);
+ }
+}
+
+/*
+ * Initialize the max width values for a column
+ */
+static void l_col_max_width_init(struct table *t, struct table_col *col)
+{
+ /* Units are displayed with brackets, therefore (+2) */
+ if (t->attr_with_units)
+ col->p->max_width = MAX(strlen(col->head),
+ strlen(col->unit->str) + 2);
+ else
+ col->p->max_width = strlen(col->head);
+}
+
+/*
+ * Add a new column to table
+ */
+void table_col_add(struct table *t, struct table_col *col)
+{
+ col->p = ht_zalloc(sizeof(*col->p));
+ col->p->col_nr = t->col_cnt;
+ col->p->enabled = 1;
+ t->col_cnt++;
+ t->col_vec = ht_realloc(t->col_vec, sizeof(void *) *
+ (t->col_cnt + 1));
+ t->col_vec[t->col_cnt - 1] = col;
+ t->col_vec[t->col_cnt] = NULL;
+ if (!t->col_selected && t->attr_sorted_table)
+ t->col_selected = col;
+ if (t->row_last)
+ table_row_free(t->row_last);
+ t->row_last = table_row_alloc(t);
+ l_col_headline_init(t, col);
+ l_col_max_width_init(t, col);
+}
+
+/*
+ * Initialize last row
+ */
+static void l_row_last_init(struct table *t)
+{
+ memset(t->row_last->entries, 0,
+ t->col_cnt * sizeof(struct table_entry));
+}
+
+/*
+ * Delete all rows of a table
+ */
+void table_row_del_all(struct table *t)
+{
+ struct table_row *row, *tmp;
+
+ list_iterate_safe(row, &t->row_list, list, tmp) {
+ list_del(&row->list);
+ table_row_free(row);
+ }
+ l_row_last_init(t);
+ t->row_cnt_marked = 0;
+ t->ready = 0;
+ t->row_cnt = 0;
+}
+
+/*
+ * Reset table
+ */
+void table_reset(struct table *t)
+{
+ table_row_mark_del_all(t);
+ table_row_del_all(t);
+ t->mode_sort_inverse = 0;
+ t->mode_select = 0;
+}
+
+/*
+ * Return true, if "e1" is less than "e2"
+ */
+static int l_entry_less_than(enum table_col_type type, struct table_entry *e1,
+ struct table_entry *e2)
+{
+ switch (type) {
+ case TABLE_COL_TYPE_U64:
+ return (e1->d.u64.v1 < e2->d.u64.v1);
+ case TABLE_COL_TYPE_S64:
+ return (e1->d.s64.v1 < e2->d.s64.v1);
+ case TABLE_COL_TYPE_STR:
+ return (strcmp(e1->str, e2->str) > 0);
+ }
+ return 0; /* Keep gcc quite */
+}
+
+/*
+ * Return true, if "row1" is less than "row2"
+ */
+static int l_row_less_than(struct table *t, struct table_row *row1,
+ struct table_row *row2)
+{
+ struct table_col *col = t->col_selected;
+ struct table_entry *e1 = &row1->entries[col->p->col_nr];
+ struct table_entry *e2 = &row2->entries[col->p->col_nr];
+
+ if ((t->mode_sort_inverse && !col->p->rsort) ||
+ (!t->mode_sort_inverse && col->p->rsort))
+ return !l_entry_less_than(col->type, e1, e2);
+ else
+ return l_entry_less_than(col->type, e1, e2);
+}
+
+/*
+ * Calculate: e1 = e1 + e2
+ */
+static void l_entry_sum(enum table_col_type type, struct table_entry *e1,
+ struct table_entry *e2)
+{
+ switch (type) {
+ case TABLE_COL_TYPE_U64:
+ e1->d.u64.v1 += e2->d.u64.v1;
+ return;
+ case TABLE_COL_TYPE_S64:
+ e1->d.s64.v1 += e2->d.s64.v1;
+ return;
+ default:
+ assert(0);
+ return;
+ }
+}
+
+/*
+ * Calculate: e1 = MAX(e1, e2)
+ */
+static void l_entry_max(enum table_col_type type, struct table_entry *e1,
+ struct table_entry *e2)
+{
+ switch (type) {
+ case TABLE_COL_TYPE_U64:
+ e1->d.u64.v1 = MAX(e1->d.u64.v1, e2->d.u64.v1);
+ return;
+ case TABLE_COL_TYPE_S64:
+ e1->d.s64.v1 = MAX(e1->d.s64.v1, e2->d.s64.v1);
+ return;
+ default:
+ assert(0);
+ return;
+ }
+}
+
+/*
+ * Aggregate "row" to "last row"
+ */
+static void l_row_last_agg(struct table *t, struct table_row *table_row)
+{
+ struct table_col *col;
+ int col_nr;
+
+ table_col_iterate(t, col, col_nr) {
+ struct table_entry *e_last = &t->row_last->entries[col_nr];
+ struct table_entry *e_new = &table_row->entries[col_nr];
+
+ switch (col->agg) {
+ case TABLE_COL_AGG_SUM:
+ l_entry_sum(col->type, e_last, e_new);
+ break;
+ case TABLE_COL_AGG_MAX:
+ l_entry_max(col->type, e_last, e_new);
+ break;
+ case TABLE_COL_AGG_NONE:
+ break;
+ }
+ }
+}
+
+/*
+ * Format row: Invoke unit callback and adjust max width of column
+ */
+static void l_row_format(struct table *t, struct table_row *row)
+{
+ unsigned int len, col_nr;
+ struct table_col *col;
+
+ table_col_iterate(t, col, col_nr) {
+ struct table_entry *e = &row->entries[col_nr];
+ if (col->agg == TABLE_COL_AGG_NONE && row == t->row_last)
+ len = 0;
+ else
+ len = col->unit->fn(col, e);
+ assert(len < TABLE_STR_MAX);
+ if (len > col->p->max_width)
+ col->p->max_width = len;
+ }
+}
+
+/*
+ * Calculate last row
+ */
+static void l_row_last_calc(struct table *t)
+{
+ struct table_row *row;
+
+ l_row_last_init(t);
+ list_iterate(row, &t->row_list, list) {
+ if (t->mode_hide_unmarked && !row->marked)
+ continue;
+ l_row_last_agg(t, row);
+ }
+ l_row_format(t, t->row_last);
+}
+
+/*
+ * Finish table after all rows have been added
+ */
+void table_finish(struct table *t)
+{
+ l_row_last_calc(t);
+ t->ready = 1;
+}
+
+/*
+ * Add new row to table
+ */
+void table_row_add(struct table *t, struct table_row *row)
+{
+ struct table_row *tmp;
+
+ l_row_format(t, row);
+
+ if (list_is_empty(&t->row_list) || !t->attr_sorted_table) {
+ list_add_end(&row->list, &t->row_list);
+ } else {
+ list_iterate(tmp, &t->row_list, list) {
+ if (l_row_less_than(t, tmp, row))
+ break;
+ }
+ list_add_end(&row->list, &tmp->list);
+ }
+ if (l_row_is_marked(t, row)) {
+ row->marked = 1;
+ t->row_cnt_marked++;
+ }
+ t->row_cnt++;
+}
+
+/*
+ * Rebuild table: Reformat all rows and adjust max width values
+ */
+void table_rebuild(struct table *t)
+{
+ struct table_col *col;
+ struct table_row *row;
+ unsigned int i;
+
+ table_col_iterate(t, col, i)
+ l_col_max_width_init(t, col);
+ list_iterate(row, &t->row_list, list)
+ l_row_format(t, row);
+ l_row_format(t, t->row_last);
+}
+
+/*
+ * Sort table (TODO: Use better sorting algorithm)
+ */
+static void l_table_sort(struct table *t)
+{
+ struct table_row *row_min;
+ struct table_row *row;
+ struct table_row *tmp;
+ struct list list;
+
+ list_init(&list);
+
+ /*
+ * Sort row list into temp list
+ */
+ while (!list_is_empty(&t->row_list)) {
+ row_min = NULL;
+
+ list_iterate(row, &t->row_list, list) {
+ if (row_min == NULL)
+ row_min = row;
+ else if (l_row_less_than(t, row, row_min))
+ row_min = row;
+ }
+ list_del(&row_min->list);
+ list_add(&row_min->list, &list);
+ }
+ /*
+ * Copy temp list to original list
+ */
+ list_iterate_safe(row, &list, list, tmp) {
+ list_del(&row->list);
+ list_add_end(&row->list, &t->row_list);
+ }
+}
+
+/*
+ * Adjust table values for select mode (e.g. for window resize or scrolling)
+ */
+static void l_adjust_values_select_mode(struct table *t)
+{
+ int row_cnt_displ = l_row_cnt_displ(t);
+ int row_cnt = l_row_cnt(t);
+
+ /* We went out of range with row selection */
+ if (t->row_nr_select >= row_cnt)
+ t->row_nr_select = row_cnt - 1;
+
+ /* Is selected row within visible area? */
+ if (t->row_nr_select < t->row_nr_begin) {
+ /* Selected row is above area: Scroll up */
+ t->row_nr_begin = t->row_nr_select;
+ } else if (t->row_nr_select - t->row_nr_begin >= row_cnt_displ) {
+ /* Selected row is below area: Scroll down */
+ t->row_nr_begin = MAX(t->row_nr_select - row_cnt_displ + 1, 0);
+ }
+}
+
+/*
+ * Adjust table values (e.g. for window resize or scrolling)
+ */
+static void l_adjust_values(struct table *t)
+{
+ int row_cnt_displ = l_row_cnt_displ(t);
+ int row_cnt = l_row_cnt(t);
+
+ if (t->mode_select)
+ l_adjust_values_select_mode(t);
+ /* If we do not use the whole screen, scroll up */
+ if (row_cnt - t->row_nr_begin < row_cnt_displ)
+ t->row_nr_begin = MAX(row_cnt - row_cnt_displ, 0);
+}
+
+/*
+ * Number of rows to be scrolled for page scroll
+ */
+static int l_scroll_page_row_cnt(struct table *t)
+{
+ /* We have two rows overlap for scrolling pages */
+ return l_row_cnt_displ(t) - 2;
+}
+
+/*
+ * Scroll table down
+ */
+void table_scroll_down(struct table *t, enum table_scroll_unit scroll_unit)
+{
+ switch (scroll_unit) {
+ case TABLE_SCROLL_LINE:
+ t->row_nr_begin++;
+ break;
+ case TABLE_SCROLL_PAGE:
+ t->row_nr_begin += l_scroll_page_row_cnt(t);
+ break;
+ case TABLE_SCROLL_LAST:
+ t->row_nr_begin = t->row_cnt;
+ break;
+ }
+}
+
+/*
+ * Scroll table up
+ */
+void table_scroll_up(struct table *t, enum table_scroll_unit scroll_unit)
+{
+ switch (scroll_unit) {
+ case TABLE_SCROLL_LINE:
+ t->row_nr_begin = MAX(t->row_nr_begin - 1, 0);
+ break;
+ case TABLE_SCROLL_PAGE:
+ t->row_nr_begin =
+ MAX(t->row_nr_begin - l_scroll_page_row_cnt(t), 0);
+ break;
+ case TABLE_SCROLL_LAST:
+ t->row_nr_begin = 0;
+ break;
+ }
+}
+
+/*
+ * Return selected row
+ */
+static struct table_row *l_selected_row(struct table *t)
+{
+ struct table_row *row;
+ int row_nr = 0;
+
+ list_iterate(row, &t->row_list, list) {
+ if (t->mode_hide_unmarked && !row->marked)
+ continue;
+ if (row_nr == t->row_nr_select)
+ return row;
+ row_nr++;
+ }
+ return NULL;
+}
+
+/*
+ * Toggle mark for selected row
+ */
+static void l_row_select_mark_toggle(struct table *t)
+{
+ struct table_row *row;
+
+ row = l_selected_row(t);
+ table_row_mark_toggle(t, row);
+ l_row_last_calc(t);
+}
+
+/*
+ * Switch select mode off
+ */
+static void l_select_mode_off(struct table *t)
+{
+ t->mode_select = 0;
+}
+
+/*
+ * Switch select mode on
+ */
+static void l_select_mode_on(struct table *t)
+{
+ t->mode_select = 1;
+ t->row_nr_select = t->row_nr_begin;
+}
+
+/*
+ * Get key for selected row
+ */
+void table_row_select_key_get(struct table *t, char str[TABLE_STR_MAX])
+{
+ struct table_row *row;
+
+ row = l_selected_row(t);
+ strncpy(str, row->entries[0].str, TABLE_STR_MAX);
+}
+
+/*
+ * Select row one page down
+ */
+void table_row_select_down(struct table *t, enum table_scroll_unit scroll_unit)
+{
+ switch (scroll_unit) {
+ case TABLE_SCROLL_LINE:
+ t->row_nr_select++;
+ break;
+ case TABLE_SCROLL_PAGE:
+ t->row_nr_select += g.c.row_cnt - t->row_cnt_extra;
+ break;
+ case TABLE_SCROLL_LAST:
+ t->row_nr_select = t->row_cnt;
+ break;
+ }
+}
+
+/*
+ * Select row one page up
+ */
+void table_row_select_up(struct table *t, enum table_scroll_unit scroll_unit)
+{
+ switch (scroll_unit) {
+ case TABLE_SCROLL_LINE:
+ t->row_nr_select = MAX(t->row_nr_select - 1, 0);
+ break;
+ case TABLE_SCROLL_PAGE:
+ t->row_nr_select = MAX(t->row_nr_begin -
+ (g.c.row_cnt - t->row_cnt_extra), 0);
+ break;
+ case TABLE_SCROLL_LAST:
+ t->row_nr_select = 0;
+ break;
+ }
+}
+
+/*
+ * Toggle "hide unmarked" mode
+ */
+static int l_mode_hide_unmarked_toggle(struct table *t)
+{
+ if (t->row_cnt_marked == 0)
+ return -ENODEV;
+ t->mode_hide_unmarked = t->mode_hide_unmarked ? 0 : 1;
+ t->row_nr_select = 0;
+ l_row_last_calc(t);
+ return 0;
+}
+
+/*
+ * Is it possible to scroll down the table?
+ */
+static int l_can_scroll_down(struct table *t)
+{
+ int row_cnt = t->mode_hide_unmarked ? t->row_cnt_marked : t->row_cnt;
+ int row_cnt_real = g.c.row_cnt - t->row_cnt_extra;
+
+ return (row_cnt - t->row_nr_begin > row_cnt_real);
+}
+
+/*
+ * Is it possible to scroll up the table?
+ */
+static int l_can_scroll_up(struct table *t)
+{
+ return (t->row_nr_begin > 0);
+}
+
+/*
+ * Update the status field
+ */
+static void l_status_update(struct table *t)
+{
+ struct table_entry *e_status = &t->row_last->entries[0];
+
+ if (g.o.batch_mode_specified)
+ return;
+
+ if (l_can_scroll_down(t) && l_can_scroll_up(t))
+ strcpy(e_status->str, "|");
+ else if (l_can_scroll_up(t))
+ strcpy(e_status->str, "^");
+ else if (l_can_scroll_down(t))
+ strcpy(e_status->str, "V");
+ else
+ strcpy(e_status->str, "=");
+
+ if (t->attr_sorted_table) {
+ strcat(e_status->str, ":");
+ if (t->mode_sort_inverse)
+ strcat(e_status->str, "^");
+ else
+ strcat(e_status->str, "V");
+ }
+ strcat(e_status->str, ":");
+ if (t->mode_select)
+ strcat(e_status->str, "S");
+ else
+ strcat(e_status->str, "N");
+}
+
+/*
+ * Print string with alignment
+ */
+static void l_str_print(struct table_col *col, const char *str)
+{
+ char unit[10];
+
+ if (col->align == TABLE_COL_ALIGN_LEFT)
+ sprintf(unit, "%%-%ds", col->p->max_width);
+ else
+ sprintf(unit, "%%%ds", col->p->max_width);
+ hyptop_printf(unit, str);
+}
+
+/*
+ * Print string for "col"
+ */
+static void l_col_print(struct table *t, struct table_col *col, const char *str)
+{
+ if (l_col_selected(t, col))
+ ht_underline_on();
+ if (col->p->col_nr == 0 && t->attr_first_bold)
+ ht_bold_on();
+
+ l_str_print(col, str);
+
+ if (l_col_selected(t, col))
+ ht_underline_off();
+ if (col->p->col_nr == 0 && t->attr_first_bold)
+ ht_bold_off();
+}
+
+/*
+ * Print status field
+ */
+static void l_status_print(struct table *t, const char *str)
+{
+ ht_bold_on();
+ l_str_print(t->col_vec[0], str);
+ ht_bold_off();
+}
+
+/*
+ * Print headline of column
+ */
+static void l_col_headline_print(struct table *t, struct table_col *col)
+{
+ unsigned int len = strlen(col->head);
+ char blank_str[TABLE_STR_MAX];
+ (void) t;
+
+ memset(blank_str, ' ', col->p->max_width - len);
+ blank_str[col->p->max_width - len] = 0;
+
+ if (l_col_selected(t, col))
+ ht_bold_on();
+ if (col->align == TABLE_COL_ALIGN_RIGHT)
+ hyptop_printf("%s", blank_str);
+ hyptop_printf("%s", col->p->head_first);
+ if (t->attr_sorted_table)
+ ht_underline_on();
+ hyptop_printf("%s", col->p->head_char);
+ if (t->attr_sorted_table)
+ ht_underline_off();
+ hyptop_printf("%s", col->p->head_last);
+ if (col->align == TABLE_COL_ALIGN_LEFT)
+ hyptop_printf("%s", blank_str);
+ if (l_col_selected(t, col))
+ ht_bold_off();
+
+}
+
+/*
+ * Print headline for table
+ */
+static void l_headline_print(struct table *t)
+{
+ struct table_col *col;
+ int col_nr, first = 1;
+
+ ht_reverse_on();
+ /* Print all column headlines */
+ table_col_iterate(t, col, col_nr) {
+ if (!col->p->enabled)
+ continue;
+ if (first)
+ first = 0;
+ else
+ hyptop_printf(" ");
+ l_col_headline_print(t, col);
+ }
+ /* This creates a black bar to the end of the line */
+ hyptop_print_seek_back(0);
+ ht_reverse_off();
+ hyptop_print_nl();
+}
+
+/*
+ * Print unit line for table
+ */
+static void l_unitline_print(struct table *t)
+{
+ struct table_col *col;
+ int col_nr, first = 1;
+ char unit_str[20];
+
+ if (!t->attr_with_units)
+ return;
+ ht_reverse_on();
+ /* Print all column units */
+ table_col_iterate(t, col, col_nr) {
+ if (!col->p->enabled)
+ continue;
+ if (first)
+ first = 0;
+ else
+ hyptop_printf(" ");
+ if (l_col_selected(t, col))
+ ht_bold_on();
+ snprintf(unit_str, sizeof(unit_str), "(%s)", col->unit->str);
+ l_str_print(col, unit_str);
+ if (l_col_selected(t, col))
+ ht_bold_off();
+ }
+ /* This creates a black bar to the end of the line */
+ hyptop_print_seek_back(0);
+ ht_reverse_off();
+ hyptop_print_nl();
+}
+
+/*
+ * Print one table row
+ */
+static void l_row_print(struct table *t, struct table_row *row)
+{
+ struct table_col *col;
+ int first = 1, col_nr;
+
+ table_col_iterate(t, col, col_nr) {
+ struct table_entry *e = &row->entries[col_nr];
+ if (!col->p->enabled)
+ continue;
+ if (!first)
+ hyptop_printf(" ");
+ else
+ first = 0;
+ if (row == t->row_last && col_nr == 0)
+ l_status_print(t, e->str);
+ else
+ l_col_print(t, col, e->str);
+ }
+}
+
+/*
+ * Print table under curses
+ */
+static void l_table_print_curses(struct table *t)
+{
+ struct table_row *row;
+ int row_nr = 0;
+
+ if (!t->ready)
+ return;
+ l_adjust_values(t);
+ l_status_update(t);
+ l_headline_print(t);
+ l_unitline_print(t);
+ list_iterate(row, &t->row_list, list) {
+ if (t->mode_hide_unmarked && !row->marked)
+ continue;
+ if (row_nr < t->row_nr_begin) {
+ row_nr++;
+ continue;
+ }
+ if (row_nr - t->row_nr_begin >= g.c.row_cnt - t->row_cnt_extra)
+ break;
+ if (t->mode_select && row_nr == t->row_nr_select)
+ ht_reverse_on();
+ if (row->marked)
+ ht_bold_on();
+ l_row_print(t, row);
+ if (t->mode_select && row_nr == t->row_nr_select) {
+#ifdef WITH_SCROLL_BAR
+ hyptop_print_seek_back(1);
+#else
+ hyptop_print_seek_back(0);
+#endif
+ ht_reverse_off();
+ }
+ if (row->marked)
+ ht_bold_off();
+ hyptop_print_nl();
+ row_nr++;
+ }
+ ht_reverse_on();
+ l_row_print(t, t->row_last);
+ hyptop_print_seek_back(0);
+ ht_reverse_off();
+#ifdef WITH_SCROLL_BAR
+ if (t->mode_hide_unmarked)
+ ht_print_scroll_bar(t->row_cnt_marked, t->row_nr_begin,
+ t->row_cnt_extra - 1, 1,
+ l_can_scroll_up(t),
+ l_can_scroll_down(t), 1);
+ else
+ ht_print_scroll_bar(t->row_cnt, t->row_nr_begin,
+ t->row_cnt_extra - 1, 1,
+ l_can_scroll_up(t),
+ l_can_scroll_down(t), 1);
+#endif
+}
+
+/*
+ * Print table under batch mode
+ */
+static void l_table_print_all(struct table *t)
+{
+ struct table_row *row;
+
+ l_headline_print(t);
+ l_unitline_print(t);
+ list_iterate(row, &t->row_list, list) {
+ l_row_print(t, row);
+ hyptop_print_nl();
+ }
+ l_row_print(t, t->row_last);
+}
+
+/*
+ * Print table to screen
+ */
+void table_print(struct table *t)
+{
+ if (g.o.batch_mode_specified)
+ l_table_print_all(t);
+ else
+ l_table_print_curses(t);
+}
+
+/*
+ * Return column by hotkey
+ */
+static struct table_col *l_col_by_hotkey(struct table *t, char hotkey)
+{
+ struct table_col *col;
+ int col_nr;
+
+ table_col_iterate(t, col, col_nr) {
+ if (col->hotkey == hotkey)
+ return col;
+ }
+ return NULL;
+}
+
+/*
+ * Select next unit for column with "hotkey"
+ */
+void table_col_unit_next(struct table *t, char hotkey)
+{
+ struct table_col *col;
+ int i;
+
+ col = l_col_by_hotkey(t, hotkey);
+ if (!col || !col->unit_fam)
+ assert(0);
+
+ for (i = 0; col->unit_fam[i] != NULL; i++) {
+ if (col->unit != col->unit_fam[i])
+ continue;
+
+ if (col->unit_fam[i + 1] == NULL)
+ col->unit = col->unit_fam[0];
+ else
+ col->unit = col->unit_fam[i + 1];
+ return;
+ }
+ assert(0);
+}
+
+/*
+ * Select previous unit for column with "hotkey"
+ */
+void table_col_unit_prev(struct table *t, char hotkey)
+{
+ struct table_col *col;
+ int i;
+
+ col = l_col_by_hotkey(t, hotkey);
+ if (!col || !col->unit_fam)
+ assert(0);
+
+ for (i = 0; col->unit_fam[i] != NULL; i++) {
+ if (col->unit != col->unit_fam[i])
+ continue;
+
+ if (i == 0) {
+ int j;
+
+ for (j = 0; col->unit_fam[j] != NULL; j++) {}
+ col->unit = col->unit_fam[j - 1];
+ } else {
+ col->unit = col->unit_fam[i - 1];
+ }
+ return;
+ }
+ assert(0);
+}
+
+/*
+ * Set unit for column
+ */
+int table_col_unit_set(struct table *t, char hotkey, const char *str)
+{
+ struct table_col *col;
+ int i;
+
+ col = l_col_by_hotkey(t, hotkey);
+ if (!col)
+ return -ENODEV;
+
+ for (i = 0; col->unit_fam[i] != NULL; i++) {
+ if (strcasecmp(col->unit_fam[i]->str, str) == 0) {
+ col->unit = col->unit_fam[i];
+ return 0;
+ }
+ }
+ return -EINVAL;
+}
+
+/*
+ * Select column by hotkey
+ */
+int table_col_select(struct table *t, char hotkey)
+{
+ struct table_col *col;
+
+ if (!t->attr_sorted_table)
+ assert(0);
+ col = l_col_by_hotkey(t, hotkey);
+ if (!col || !col->p->enabled)
+ return -ENODEV;
+ if (t->col_selected == col) {
+ t->mode_sort_inverse = t->mode_sort_inverse ? 0 : 1;
+ } else {
+ t->mode_sort_inverse = 0;
+ t->col_selected = col;
+ }
+ table_rebuild(t);
+ l_table_sort(t);
+ return 0;
+}
+
+/*
+ * Select next column
+ */
+void table_col_select_next(struct table *t)
+{
+ int i;
+
+ for (i = t->col_selected->p->col_nr + 1; i < t->col_cnt; i++) {
+ if (t->col_vec[i]->p->enabled)
+ goto found;
+ }
+ return;
+found:
+ t->col_selected = t->col_vec[i];
+ l_table_sort(t);
+}
+
+/*
+ * Select previous column
+ */
+void table_col_select_prev(struct table *t)
+{
+ int i;
+
+ for (i = t->col_selected->p->col_nr - 1; i >= 0; i--) {
+ if (t->col_vec[i]->p->enabled)
+ goto found;
+ }
+ return;
+found:
+ t->col_selected = t->col_vec[i];
+ l_table_sort(t);
+}
+
+/*
+ * Toggle enabled status for column
+ */
+void table_col_enable_toggle(struct table *t, char hotkey)
+{
+ struct table_col *col;
+
+ col = l_col_by_hotkey(t, hotkey);
+ if (!col || col->p->col_nr == 0)
+ return;
+ col->p->enabled = col->p->enabled ? 0 : 1;
+ if (col == t->col_selected)
+ t->col_selected = t->col_vec[0];
+}
+
+/*
+ * Process input for table
+ */
+void table_process_input(struct table *t, int c)
+{
+ switch (c) {
+ case '<':
+ if (t->attr_sorted_table)
+ table_col_select_prev(t);
+ break;
+ case '>':
+ if (t->attr_sorted_table)
+ table_col_select_next(t);
+ break;
+ case '.':
+ if (l_mode_hide_unmarked_toggle(t) == 0)
+ l_select_mode_off(t);
+ break;
+ case '+':
+ if (!t->attr_with_units)
+ break;
+ table_col_unit_next(t, t->col_selected->hotkey);
+ table_rebuild(t);
+ break;
+ case '-':
+ if (!t->attr_with_units)
+ break;
+ table_col_unit_prev(t, t->col_selected->hotkey);
+ table_rebuild(t);
+ break;
+ case 'G':
+ if (t->mode_select)
+ table_row_select_down(t, TABLE_SCROLL_LAST);
+ else
+ table_scroll_down(t, TABLE_SCROLL_LAST);
+ break;
+ case 'g':
+ if (t->mode_select)
+ table_row_select_up(t, TABLE_SCROLL_LAST);
+ else
+ table_scroll_up(t, TABLE_SCROLL_LAST);
+ break;
+ case KEY_NPAGE:
+ if (t->mode_select)
+ table_row_select_down(t, TABLE_SCROLL_PAGE);
+ else
+ table_scroll_down(t, TABLE_SCROLL_PAGE);
+ break;
+ case KEY_PPAGE:
+ if (t->mode_select)
+ table_row_select_up(t, TABLE_SCROLL_PAGE);
+ else
+ table_scroll_up(t, TABLE_SCROLL_PAGE);
+ break;
+ case 'j':
+ case KEY_DOWN:
+ if (t->mode_select)
+ table_row_select_down(t, TABLE_SCROLL_LINE);
+ else
+ table_scroll_down(t, TABLE_SCROLL_LINE);
+ break;
+ case 'k':
+ case KEY_UP:
+ if (t->mode_select)
+ table_row_select_up(t, TABLE_SCROLL_LINE);
+ else
+ table_scroll_up(t, TABLE_SCROLL_LINE);
+ break;
+ case ' ':
+ if (t->mode_select) {
+ l_row_select_mark_toggle(t);
+ } else {
+ table_row_mark_del_all(t);
+ t->mode_hide_unmarked = 0;
+ }
+ break;
+ case 'l':
+ case KEY_RIGHT:
+ if (!t->mode_select)
+ l_select_mode_on(t);
+ break;
+ case 'h':
+ case KEY_LEFT:
+ if (t->mode_select)
+ l_select_mode_off(t);
+ break;
+ default:
+ if (t->attr_sorted_table)
+ table_col_select(t, c);
+ }
+}
diff --git a/hyptop/table.h b/hyptop/table.h
new file mode 100644
index 0000000..c441245
--- /dev/null
+++ b/hyptop/table.h
@@ -0,0 +1,424 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Table module: Provide line mode and curses base table
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef TABLE_H
+#define TABLE_H
+
+#include <string.h>
+#include <assert.h>
+#include "list.h"
+#include "helper.h"
+
+#define TABLE_STR_MAX 64
+#define TABLE_HEADING_SIZE 20
+
+struct table_col;
+struct table_entry;
+
+/*
+ * Table Column Unit
+ */
+struct table_col_unit {
+ int (*fn)(struct table_col*, struct table_entry *);
+ const char *str;
+ char *desc;
+ char hotkey;
+};
+
+/* Predefined units */
+extern struct table_col_unit table_col_unit_str;
+extern struct table_col_unit table_col_unit_cnt;
+extern struct table_col_unit table_col_unit_kib;
+extern struct table_col_unit table_col_unit_mib;
+extern struct table_col_unit table_col_unit_gib;
+extern struct table_col_unit table_col_unit_us;
+extern struct table_col_unit table_col_unit_ms;
+extern struct table_col_unit table_col_unit_s;
+extern struct table_col_unit table_col_unit_hm;
+extern struct table_col_unit table_col_unit_dhm;
+extern struct table_col_unit table_col_unit_perc;
+extern struct table_col_unit table_col_unit_vis;
+
+/* Predefined families */
+extern struct table_col_unit *table_col_unit_fam_str[];
+extern struct table_col_unit *table_col_unit_fam_cnt[];
+extern struct table_col_unit *table_col_unit_fam_mem[];
+extern struct table_col_unit *table_col_unit_fam_time[];
+extern struct table_col_unit *table_col_unit_fam_time_diff[];
+extern struct table_col_unit *table_col_unit_fam_vis[];
+
+/*
+ * Table Column Type
+ */
+enum table_col_type {
+ TABLE_COL_TYPE_U64,
+ TABLE_COL_TYPE_S64,
+ TABLE_COL_TYPE_STR,
+};
+
+/*
+ * Table Column Alignment
+ */
+enum table_col_align {
+ TABLE_COL_ALIGN_LEFT,
+ TABLE_COL_ALIGN_RIGHT,
+};
+
+/*
+ * Table Column Aggregation
+ */
+enum table_col_agg {
+ TABLE_COL_AGG_SUM,
+ TABLE_COL_AGG_MAX,
+ TABLE_COL_AGG_NONE,
+};
+
+static inline const char *table_col_agg_str(enum table_col_agg agg)
+{
+ switch (agg) {
+ case TABLE_COL_AGG_SUM:
+ return "sum";
+ case TABLE_COL_AGG_MAX:
+ return "max";
+ case TABLE_COL_AGG_NONE:
+ return "none";
+ }
+ return NULL;
+}
+
+/*
+ * Table Column
+ */
+struct table_col_priv {
+ unsigned int max_width;
+ int col_nr;
+ int enabled;
+ char head_first[TABLE_HEADING_SIZE];
+ char head_char[2];
+ char head_last[TABLE_HEADING_SIZE];
+ int rsort;
+};
+
+/*
+ * Table Column Specification
+ */
+struct table_col_spec {
+ char hotkey;
+ char *unit_str;
+};
+
+/*
+ * Table Column
+ */
+struct table_col {
+ enum table_col_type type;
+ struct table_col_unit *unit;
+ struct table_col_unit **unit_fam;
+ enum table_col_align align;
+ enum table_col_agg agg;
+ char hotkey;
+ char head[TABLE_HEADING_SIZE];
+ struct table_col_priv *p;
+};
+
+static inline int table_col_enabled(struct table_col *col)
+{
+ return col->p->enabled;
+}
+
+/*
+ * Table Column Constructor Macros
+ */
+#define TABLE_COL_STR(l, h) \
+{ \
+ .type = TABLE_COL_TYPE_STR, \
+ .unit = &table_col_unit_str, \
+ .unit_fam = table_col_unit_fam_str, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_NONE, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_STR_LEFT(l, h) \
+{ \
+ .type = TABLE_COL_TYPE_STR, \
+ .unit = &table_col_unit_str, \
+ .unit_fam = table_col_unit_fam_str, \
+ .align = TABLE_COL_ALIGN_LEFT, \
+ .agg = TABLE_COL_AGG_NONE, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_CNT_SUM(l, h) \
+{ \
+ .type = TABLE_COL_TYPE_U64, \
+ .unit = &table_col_unit_cnt, \
+ .unit_fam = table_col_unit_fam_cnt, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_SUM, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_CNT_NONE(l, h) \
+{ \
+ .type = TABLE_COL_TYPE_U64, \
+ .unit = &table_col_unit_cnt, \
+ .unit_fam = table_col_unit_fam_cnt, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_NONE, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_CNT_MAX(l, h) \
+{ \
+ .type = TABLE_COL_TYPE_U64, \
+ .unit = &table_col_unit_cnt, \
+ .unit_fam = table_col_unit_fam_cnt, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_MAX, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_MEM_SUM(f, l, h) \
+{ \
+ .type = TABLE_COL_TYPE_U64, \
+ .unit = &f, \
+ .unit_fam = table_col_unit_fam_mem, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_SUM, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_TIME_SUM(f, l, h) \
+{ \
+ .type = TABLE_COL_TYPE_U64, \
+ .unit = &f, \
+ .unit_fam = table_col_unit_fam_time, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_SUM, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_TIME_DIFF_SUM(f, l, h) \
+{ \
+ .type = TABLE_COL_TYPE_U64, \
+ .unit = &f, \
+ .unit_fam = table_col_unit_fam_time_diff, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_SUM, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_STIME_SUM(f, l, h) \
+{ \
+ .type = TABLE_COL_TYPE_S64, \
+ .unit = &f, \
+ .unit_fam = table_col_unit_fam_time, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_SUM, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_STIME_DIFF_SUM(f, l, h) \
+{ \
+ .type = TABLE_COL_TYPE_S64, \
+ .unit = &f, \
+ .unit_fam = table_col_unit_fam_time_diff, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_SUM, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+#define TABLE_COL_TIME_MAX(f, l, h) \
+{ \
+ .type = TABLE_COL_TYPE_U64, \
+ .unit = &f, \
+ .unit_fam = table_col_unit_fam_time, \
+ .align = TABLE_COL_ALIGN_RIGHT, \
+ .agg = TABLE_COL_AGG_MAX, \
+ .hotkey = l, \
+ .head = h, \
+}
+
+/*
+ * Set reverse sort property for column
+ */
+static inline void table_col_rsort(struct table_col *col)
+{
+ col->p->rsort = 1;
+}
+
+/*
+ * Column member access macros
+ */
+#define table_col_hotkey(col) ((col)->hotkey)
+#define table_col_head(col) ((col)->head)
+#define table_col_unit_str(col) ((col)->unit->str)
+
+/*
+ * Table Entry
+ */
+struct table_entry {
+ union {
+ struct {
+ u64 v1;
+ u64 v2;
+ } u64;
+ struct {
+ s64 v1;
+ s64 v2;
+ } s64;
+ } d;
+ char str[TABLE_STR_MAX];
+};
+
+/*
+ * Table Row
+ */
+struct table_row {
+ struct list list;
+ int entry_count;
+ struct table_entry *entries;
+ int marked;
+};
+
+/*
+ * Table Mark Key
+ */
+struct table_mark_key {
+ struct list list;
+ char str[TABLE_STR_MAX];
+};
+
+/*
+ * Table
+ */
+struct table {
+ struct list row_list;
+ int col_cnt;
+ struct table_col **col_vec;
+ struct table_col *col_selected;
+ struct table_row *row_last;
+ int row_cnt;
+ int row_cnt_marked;
+ int row_cnt_extra;
+ int row_nr_begin;
+ int row_nr_select;
+ int ready;
+ struct list mark_key_list;
+ unsigned int mark_keys_cnt;
+ int attr_sorted_table;
+ int attr_first_bold;
+ int attr_with_units;
+ int mode_sort_inverse;
+ int mode_select;
+ int mode_hide_unmarked;
+};
+
+/*
+ * Return if we are in select mode
+ */
+static inline int table_mode_select(struct table *t)
+{
+ return t->mode_select;
+}
+
+/*
+ * Table croll units
+ */
+enum table_scroll_unit {
+ TABLE_SCROLL_LINE,
+ TABLE_SCROLL_PAGE,
+ TABLE_SCROLL_LAST,
+};
+
+/*
+ * Prototypes
+ */
+extern struct table *table_new(int extra_rows, int sorted, int first_bold,
+ int with_units);
+extern void table_reset(struct table *t);
+extern void table_rebuild(struct table *t);
+extern void table_finish(struct table *t);
+extern void table_print(struct table *t);
+extern void table_process_input(struct table *t, int c);
+
+extern void table_col_unit_next(struct table *t, char hotkey);
+extern void table_col_unit_prev(struct table *t, char hotkey);
+extern int table_col_unit_set(struct table *t, char hotkey, const char *unit);
+extern void table_col_add(struct table *t, struct table_col *col);
+extern int table_col_select(struct table *t, char hotkey);
+extern void table_col_select_next(struct table *t);
+extern void table_col_select_prev(struct table *t);
+extern void table_col_enable_toggle(struct table *t, char hotkey);
+
+extern void table_row_del_all(struct table *t);
+extern void table_row_add(struct table *t, struct table_row *row);
+extern void table_row_mark(struct table *t, struct table_row *row);
+extern void table_row_mark_del_all(struct table *t);
+extern void table_row_mark_toggle(struct table *t, struct table_row *row);
+extern void table_row_mark_toggle_by_key(struct table *t, const char *mark_key);
+extern void table_row_select_down(struct table *t, enum table_scroll_unit unit);
+extern void table_row_select_up(struct table *t, enum table_scroll_unit unit);
+extern void table_row_select_key_get(struct table *t, char str[TABLE_STR_MAX]);
+extern struct table_row *table_row_alloc(struct table *t);
+
+extern void table_scroll_down(struct table *t, enum table_scroll_unit unit);
+extern void table_scroll_up(struct table *t, enum table_scroll_unit unit);
+
+/*
+ * Entry add functions
+ */
+static inline void table_row_entry_u64_add(struct table_row *table_row,
+ struct table_col *table_col,
+ u64 value)
+{
+ table_row->entries[table_col->p->col_nr].d.u64.v1 = value;
+}
+
+static inline void table_row_entry_s64_add(struct table_row *table_row,
+ struct table_col *table_col,
+ s64 value)
+{
+ table_row->entries[table_col->p->col_nr].d.s64.v1 = value;
+}
+
+static inline void table_row_entry_u64_add_pair(struct table_row *table_row,
+ struct table_col *table_col,
+ u64 value1, u64 value2)
+{
+ table_row->entries[table_col->p->col_nr].d.u64.v1 = value1;
+ table_row->entries[table_col->p->col_nr].d.u64.v2 = value2;
+}
+
+static inline void table_row_entry_str_add(struct table_row *table_row,
+ struct table_col *table_col,
+ const char *str)
+{
+ assert(strlen(str) < TABLE_STR_MAX);
+ strcpy(table_row->entries[table_col->p->col_nr].str, str);
+}
+
+/*
+ * Interate over all mark keys
+ */
+#define table_iterate_mark_keys(t, key) \
+ list_iterate(key, &t->mark_key_list, list)
+
+#endif /* TABLE_H */
diff --git a/hyptop/table_col_unit.c b/hyptop/table_col_unit.c
new file mode 100644
index 0000000..a8f5851
--- /dev/null
+++ b/hyptop/table_col_unit.c
@@ -0,0 +1,369 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Table unit module: Provide different units for data
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <stdio.h>
+#include "table.h"
+
+#define L_VISUAL_ROW_CNT 45
+#define L_COL_FMT_STR_0 "%.0lf"
+#define L_COL_FMT_STR_2 "%.2lf"
+
+/*
+ * Helper: Divide value and format it
+ */
+static int l_unit_raw_div(struct table_col *col, struct table_entry *e,
+ unsigned int divisor, const char *fmt_str)
+{
+ double v1;
+
+ switch (col->type) {
+ case TABLE_COL_TYPE_U64:
+ v1 = ((double) e->d.u64.v1) / divisor;
+ break;
+ case TABLE_COL_TYPE_S64:
+ v1 = ((double) e->d.s64.v1) / divisor;
+ break;
+ default:
+ assert(0);
+ }
+ return snprintf(e->str, sizeof(e->str), fmt_str, v1);
+}
+
+/*
+ * Helper: Format value as is
+ */
+static int l_unit_raw(struct table_col *col, struct table_entry *e)
+{
+ switch (col->type) {
+ case TABLE_COL_TYPE_U64:
+ return snprintf(e->str, sizeof(e->str), "%llu", e->d.u64.v1);
+ case TABLE_COL_TYPE_S64:
+ return snprintf(e->str, sizeof(e->str), "%lld", e->d.s64.v1);
+ default:
+ assert(0);
+ return 0;
+ }
+}
+
+/*
+ * Format: String
+ */
+static int l_str(struct table_col *col, struct table_entry *e)
+{
+ (void) col;
+ return strlen(e->str);
+}
+
+struct table_col_unit table_col_unit_str = {
+ .fn = l_str,
+ .hotkey = 'S',
+ .str = "str",
+ .desc = "String",
+};
+
+/*
+ * Format: Count
+ */
+static int l_unit_cnt(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw(col, e);
+}
+
+struct table_col_unit table_col_unit_cnt = {
+ .fn = l_unit_cnt,
+ .hotkey = '#',
+ .str = "#",
+ .desc = "Count",
+};
+
+/*
+ * Format: Kibibytes
+ */
+static int l_unit_kib(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw(col, e);
+}
+
+struct table_col_unit table_col_unit_kib = {
+ .fn = l_unit_kib,
+ .hotkey = 'k',
+ .str = "KiB",
+ .desc = "Kibibyte (1.024 bytes)",
+};
+
+/*
+ * Format: Mebibytes
+ */
+static int l_unit_mib(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw_div(col, e, 1024, L_COL_FMT_STR_2);
+}
+
+struct table_col_unit table_col_unit_mib = {
+ .fn = l_unit_mib,
+ .hotkey = 'M',
+ .str = "MiB",
+ .desc = "Mebibyte (1.048.576 bytes)",
+};
+
+/*
+ * Format: Gibibytes
+ */
+static int l_unit_gib(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw_div(col, e, 1024 * 1024, L_COL_FMT_STR_2);
+}
+
+struct table_col_unit table_col_unit_gib = {
+ .fn = l_unit_gib,
+ .hotkey = 'g',
+ .str = "GiB",
+ .desc = "Gibibyte (1.073.741.824 bytes)",
+};
+
+/*
+ * Format: Microseconds
+ */
+static int l_unit_us(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw(col, e);
+}
+
+struct table_col_unit table_col_unit_us = {
+ .fn = l_unit_us,
+ .hotkey = 'u',
+ .str = "us",
+};
+
+/*
+ * Format: Milliseconds
+ */
+static int l_unit_ms(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw_div(col, e, 1000, L_COL_FMT_STR_2);
+}
+
+struct table_col_unit table_col_unit_ms = {
+ .fn = l_unit_ms,
+ .hotkey = 'm',
+ .str = "ms",
+};
+
+/*
+ * Format: Percent (Hundreds)
+ */
+static int l_unit_perc(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw_div(col, e, 10000, L_COL_FMT_STR_2);
+}
+
+struct table_col_unit table_col_unit_perc = {
+ .fn = l_unit_perc,
+ .hotkey = '%',
+ .str = "%",
+ .desc = "Percent",
+};
+
+/*
+ * Format: Seconds
+ */
+static int l_unit_s(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw_div(col, e, 1000000, L_COL_FMT_STR_2);
+}
+
+struct table_col_unit table_col_unit_s = {
+ .fn = l_unit_s,
+ .hotkey = 's',
+ .str = "s",
+ .desc = "Seconds",
+};
+
+/*
+ * Format: Minutes
+ */
+static int l_unit_m(struct table_col *col, struct table_entry *e)
+{
+ return l_unit_raw_div(col, e, 1000000 * 60, L_COL_FMT_STR_0);
+}
+
+struct table_col_unit table_col_unit_m = {
+ .fn = l_unit_m,
+ .hotkey = 'm',
+ .str = "m",
+ .desc = "Minutes",
+};
+
+/*
+ * Format: Hours:Minutes
+ */
+static int l_unit_hm_u64(char *str, u64 v1, int negative)
+{
+ u64 time_tmp, time_h, time_m;
+
+ time_tmp = v1 / (1000000 * 60);
+ time_h = time_tmp / 60;
+ time_m = time_tmp - time_h * 60;
+
+ if (negative)
+ return sprintf(str, "-%llu:%02llu", time_h, time_m);
+ else
+ return sprintf(str, "%llu:%02llu", time_h, time_m);
+}
+
+static int l_unit_hm(struct table_col *col, struct table_entry *e)
+{
+ switch (col->type) {
+ case TABLE_COL_TYPE_U64:
+ return l_unit_hm_u64(e->str, e->d.u64.v1, 0);
+ case TABLE_COL_TYPE_S64:
+ if (e->d.s64.v1 < 0)
+ return l_unit_hm_u64(e->str, -e->d.s64.v1, 1);
+ else
+ return l_unit_hm_u64(e->str, e->d.s64.v1, 0);
+ default:
+ assert(0);
+ return 0;
+ }
+}
+
+struct table_col_unit table_col_unit_hm = {
+ .fn = l_unit_hm,
+ .hotkey = 'H',
+ .str = "hm",
+ .desc = "Hours:Minutes",
+};
+
+/*
+ * Format: Days:Hours:Minutes
+ */
+static int l_unit_dhm_u64(char *str, u64 v1, int negative)
+{
+ u64 time_tmp, time_d, time_h, time_m;
+
+ time_tmp = v1 / (1000000 * 60);
+ time_d = time_tmp / (60 * 24);
+ time_h = time_tmp / 60 - time_d * 24;
+ time_m = time_tmp - time_h * 60 - time_d * 60 * 24;
+
+ if (negative)
+ return sprintf(str, "-%llu:%02llu:%02llu", time_d, time_h,
+ time_m);
+ else
+ return sprintf(str, "%llu:%02llu:%02llu", time_d, time_h,
+ time_m);
+}
+
+static int l_unit_dhm(struct table_col *col, struct table_entry *e)
+{
+ switch (col->type) {
+ case TABLE_COL_TYPE_U64:
+ return l_unit_dhm_u64(e->str, e->d.u64.v1, 0);
+ case TABLE_COL_TYPE_S64:
+ if (e->d.s64.v1 < 0)
+ return l_unit_dhm_u64(e->str, -e->d.s64.v1, 1);
+ else
+ return l_unit_dhm_u64(e->str, e->d.s64.v1, 0);
+ default:
+ assert(0);
+ return 0;
+ }
+}
+
+struct table_col_unit table_col_unit_dhm = {
+ .fn = l_unit_dhm,
+ .hotkey = 'D',
+ .str = "dhm",
+ .desc = "Days:Hours:Minutes",
+};
+
+/*
+ * Format: Visualization with bar chart
+ */
+static int l_unit_vis(struct table_col *col, struct table_entry *e)
+{
+ double val1_perc, val2_perc;
+ int val1_nr, val2_nr;
+ int i;
+
+ assert(col->type == TABLE_COL_TYPE_U64);
+
+ sprintf(e->str, "|");
+ val1_perc = e->d.u64.v1;
+ val1_perc /= 1000000;
+ val2_perc = e->d.u64.v2;
+ val2_perc /= 1000000;
+ val1_nr = (val1_perc * L_VISUAL_ROW_CNT) + 0.5;
+ val2_nr = (val2_perc * L_VISUAL_ROW_CNT) + 0.5;
+
+ if (val1_nr > L_VISUAL_ROW_CNT)
+ val1_nr = L_VISUAL_ROW_CNT;
+ if (val1_nr + val2_nr > L_VISUAL_ROW_CNT)
+ val2_nr = L_VISUAL_ROW_CNT - val1_nr;
+
+ for (i = 0; i < val1_nr; i++)
+ strcat(e->str, "#");
+ for (i = 0; i < val2_nr; i++)
+ strcat(e->str, "-");
+ for (i = 0; i < L_VISUAL_ROW_CNT - val1_nr - val2_nr; i++)
+ strcat(e->str, " ");
+ strcat(e->str, "|");
+
+ return strlen(e->str);
+}
+
+struct table_col_unit table_col_unit_vis = {
+ .fn = l_unit_vis,
+ .hotkey = 'v',
+ .str = "vis",
+ .desc = "Visualization with bar chart",
+};
+
+/*
+ * Families
+ */
+struct table_col_unit *table_col_unit_fam_str[] = {
+ &table_col_unit_str,
+ NULL,
+};
+
+struct table_col_unit *table_col_unit_fam_cnt[] = {
+ &table_col_unit_cnt,
+ NULL,
+};
+
+struct table_col_unit *table_col_unit_fam_mem[] = {
+ &table_col_unit_kib,
+ &table_col_unit_mib,
+ &table_col_unit_gib,
+ NULL,
+};
+
+struct table_col_unit *table_col_unit_fam_time_diff[] = {
+ &table_col_unit_us,
+ &table_col_unit_ms,
+ &table_col_unit_perc,
+ &table_col_unit_s,
+ NULL,
+};
+
+struct table_col_unit *table_col_unit_fam_time[] = {
+ &table_col_unit_us,
+ &table_col_unit_ms,
+ &table_col_unit_s,
+ &table_col_unit_m,
+ &table_col_unit_hm,
+ &table_col_unit_dhm,
+ NULL,
+};
+
+struct table_col_unit *table_col_unit_fam_vis[] = {
+ &table_col_unit_vis,
+ NULL,
+};
diff --git a/hyptop/tbox.c b/hyptop/tbox.c
new file mode 100644
index 0000000..82eda0c
--- /dev/null
+++ b/hyptop/tbox.c
@@ -0,0 +1,240 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Text box: Provide scrollable text window under curses.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <assert.h>
+#include <ncurses.h>
+#include "hyptop.h"
+#include "tbox.h"
+#include "helper.h"
+
+/*
+ * Delete one line
+ */
+static void l_line_free(struct tbox_line *line)
+{
+ ht_free(line->str);
+ ht_free(line);
+}
+
+/*
+ * Delete all lines
+ */
+void tbox_line_del_all(struct tbox *tb)
+{
+ struct tbox_line *line, *tmp;
+
+ list_iterate_safe(line, &tb->line_list, list, tmp) {
+ list_del(&line->list);
+ l_line_free(line);
+ }
+ tb->tbox_ready = 0;
+ tb->line_cnt = 0;
+}
+
+/*
+ * Finish text box after all lines have been added
+ */
+void tbox_finish(struct tbox *tb)
+{
+ tb->tbox_ready = 1;
+}
+
+/*
+ * Add one line to text box
+ */
+void tbox_line_add(struct tbox *tb, const char *str)
+{
+ struct tbox_line *line;
+
+ if (strlen(str) > TBOX_MAX_STR)
+ assert(0);
+ line = ht_zalloc(sizeof(*line));
+ line->str = ht_strdup(str);
+ if (list_is_empty(&tb->line_list))
+ list_add(&line->list, &tb->line_list);
+ else
+ list_add(&line->list, &tb->last_line->list);
+ tb->last_line = line;
+ tb->line_cnt++;
+}
+
+/*
+ * Adjust values, if we scrolled out of range
+ */
+static void l_adjust_values(struct tbox *tb)
+{
+ if (tb->line_cnt - tb->line_start < g.c.row_cnt)
+ tb->line_start = MAX(tb->line_cnt - g.c.row_cnt, 0);
+}
+
+/*
+ * Scroll text box down
+ */
+void tbox_scroll_down(struct tbox *tb, enum tbox_scroll_unit unit)
+{
+ switch (unit) {
+ case TBOX_SCROLL_LINE:
+ tb->line_start++;
+ break;
+ case TBOX_SCROLL_PAGE:
+ tb->line_start += (g.c.row_cnt - 2);
+ break;
+ case TBOX_SCROLL_LAST:
+ tb->line_start = tb->line_cnt;
+ break;
+ }
+}
+
+/*
+ * Scroll text box up
+ */
+void tbox_scroll_up(struct tbox *tb, enum tbox_scroll_unit unit)
+{
+ switch (unit) {
+ case TBOX_SCROLL_LINE:
+ tb->line_start = MAX(tb->line_start - 1, 0);
+ break;
+ case TBOX_SCROLL_PAGE:
+ tb->line_start = MAX(tb->line_start - (g.c.row_cnt - 2), 0);
+ break;
+ case TBOX_SCROLL_LAST:
+ tb->line_start = 0;
+ break;
+ }
+}
+
+/*
+ * Resize text box
+ */
+void tbox_term_resize(struct tbox *tb)
+{
+ l_adjust_values(tb);
+}
+
+/*
+ * Toggle bold curses format attribute
+ */
+static void l_bold_toggle(void)
+{
+ static int bold_on;
+
+ if (bold_on) {
+ ht_bold_off();
+ bold_on = 0;
+ } else {
+ ht_bold_on();
+ bold_on = 1;
+ }
+}
+
+/*
+ * Toggle underline curses format attribute
+ */
+static void l_underline_toggle(void)
+{
+ static int underline_on;
+
+ if (underline_on) {
+ ht_underline_off();
+ underline_on = 0;
+ } else {
+ ht_underline_on();
+ underline_on = 1;
+ }
+}
+
+/*
+ * Print one line with attributes (bold and underline)
+ */
+void l_print_line(const char *line)
+{
+ char line_cpy[TBOX_MAX_STR + 1];
+ char *ptr_old, *ptr;
+
+ strncpy(line_cpy, line, sizeof(line_cpy));
+ ptr_old = ptr = line_cpy;
+ do {
+ ptr = strchr(ptr, '\\');
+ if (ptr) {
+ *ptr = 0;
+ hyptop_printf("%s", ptr_old);
+ switch (ptr[1]) {
+ case 'B':
+ l_bold_toggle();
+ break;
+ case 'U':
+ l_underline_toggle();
+ break;
+ }
+ ptr += 2;
+ ptr_old = ptr;
+ } else {
+ hyptop_printf("%s", ptr_old);
+ return;
+ }
+ } while (*ptr);
+}
+
+#ifdef WITH_SCROLL_BAR
+static int l_can_scroll_down(struct tbox *tb)
+{
+ return (tb->line_cnt - tb->line_start > g.c.row_cnt);
+}
+
+static int l_can_scroll_up(struct tbox *tb)
+{
+ return (tb->line_start > 0);
+}
+#endif
+
+/*
+ * Print text box to screen
+ */
+void tbox_print(struct tbox *tb)
+{
+ int line_nr = 0, first = 1;
+ struct tbox_line *line;
+
+ if (!tb->tbox_ready)
+ return;
+
+ l_adjust_values(tb);
+ list_iterate(line, &tb->line_list, list) {
+ if (line_nr < tb->line_start) {
+ line_nr++;
+ continue;
+ }
+ /* Have we printed the whole visible screen ? */
+ if (line_nr - tb->line_start >= g.c.row_cnt)
+ break;
+ if (first)
+ first = 0;
+ else
+ hyptop_print_nl();
+ l_print_line(line->str);
+ line_nr++;
+ }
+#ifdef WITH_SCROLL_BAR
+ ht_print_scroll_bar(tb->line_cnt, tb->line_start, 0,
+ 0, l_can_scroll_up(tb), l_can_scroll_down(tb),
+ 0);
+#endif
+}
+
+/*
+ * Create new text box
+ */
+struct tbox *tbox_new(void)
+{
+ struct tbox *tb;
+
+ tb = ht_zalloc(sizeof(*tb));
+ list_init(&tb->line_list);
+ return tb;
+}
diff --git a/hyptop/tbox.h b/hyptop/tbox.h
new file mode 100644
index 0000000..60397f3
--- /dev/null
+++ b/hyptop/tbox.h
@@ -0,0 +1,52 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Text box: Provide scrollable text window under curses.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef TBOX_H
+#define TBOX_H
+
+#include "list.h"
+
+#define TBOX_MAX_STR 120
+
+struct tbox_line {
+ struct list list;
+ char *str;
+};
+
+struct tbox {
+ struct list line_list;
+ int line_cnt;
+ int line_start;
+ int tbox_ready;
+ struct tbox_line *last_line;
+};
+
+enum tbox_scroll_unit {
+ TBOX_SCROLL_LINE,
+ TBOX_SCROLL_PAGE,
+ TBOX_SCROLL_LAST,
+};
+
+struct tbox *tbox_new(void);
+void tbox_line_del_all(struct tbox *tb);
+void tbox_line_add(struct tbox *tb, const char *str);
+void tbox_finish(struct tbox *tb);
+void tbox_scroll_down(struct tbox *tb, enum tbox_scroll_unit);
+void tbox_scroll_up(struct tbox *tb, enum tbox_scroll_unit);
+void tbox_term_resize(struct tbox *tb);
+void tbox_print(struct tbox *tb);
+
+#define tbox_printf(tb, x...) \
+{ \
+ char line[TBOX_MAX_STR + 1]; \
+ sprintf(line, x); \
+ tbox_line_add(tb, line); \
+}
+
+#endif /* TBOX_H */
diff --git a/hyptop/win_cpu_types.c b/hyptop/win_cpu_types.c
new file mode 100644
index 0000000..7d3dff2
--- /dev/null
+++ b/hyptop/win_cpu_types.c
@@ -0,0 +1,248 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "cpu_types": Select CPU types used for CPU data calculation.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include "helper.h"
+#include "hyptop.h"
+#include "table.h"
+#include "win_cpu_types.h"
+#include "sd.h"
+#include "nav_desc.h"
+
+/*
+ * Globals for cpu_types window
+ */
+static struct table_col l_col_key = TABLE_COL_STR_LEFT('k', "k");
+static struct table_col l_col_select = TABLE_COL_STR_LEFT('s', "s");
+static struct table_col l_col_id = TABLE_COL_STR_LEFT('i', "id");
+static struct table_col l_col_desc = TABLE_COL_STR_LEFT('d', "description");
+
+/*
+ * Online help text for cpu_types window
+ */
+static const char l_help_str[] =
+"In the \"cpu_types\" window you can select the CPU types that are used for\n"
+"calculating CPU data. Toggle the selection of types either by pressing the\n"
+"corresponding hotkey or by selecting them in select mode using the SPACE bar.\n"
+"\n"
+"The table of the \"cpu_types\" window has the following columns:\n"
+" - K : Hotkey of CPU type\n"
+" - S : Shows if CPU type is selected\n"
+" - ID : Name of CPU type\n"
+" - DESC: Description of CPU type\n";
+
+/*
+ * Description of Navigation Keys (used for help window)
+ */
+static struct nav_desc *l_nav_desc_normal_vec[] = {
+ &nav_desc_select_mode_enter,
+ &nav_desc_marks_clear,
+ &nav_desc_win_leave_cpu_types,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_select_vec[] = {
+ &nav_desc_select_mode_leave,
+ &nav_desc_mark_toggle,
+ &nav_desc_win_leave_cpu_types_fast,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_general_vec[] = {
+ &nav_desc_toggle_mark_hotkey,
+ &nav_desc_scroll_up_line,
+ &nav_desc_scroll_down_line,
+ &nav_desc_scroll_up_page,
+ &nav_desc_scroll_down_page,
+ &nav_desc_scroll_up_head,
+ &nav_desc_scroll_down_tail,
+ &nav_desc_mark_toggle_view,
+ NULL,
+};
+
+/*
+ * Add a CPU type to the table
+ */
+static void l_add_cpu_type(struct win_cpu_types *win_cpu_types,
+ struct sd_cpu_type *cpu_type)
+{
+ char char_str[2], select_str[2];
+ struct table_row *table_row;
+
+ if (sd_cpu_type_selected(cpu_type))
+ sprintf(select_str, "*");
+ else
+ sprintf(select_str, " ");
+ sprintf(char_str, "%c", cpu_type->hotkey);
+
+ table_row = table_row_alloc(win_cpu_types->t);
+ table_row_entry_str_add(table_row, &l_col_select, select_str);
+ table_row_entry_str_add(table_row, &l_col_key, char_str);
+ table_row_entry_str_add(table_row, &l_col_id, cpu_type->id);
+ table_row_entry_str_add(table_row, &l_col_desc, cpu_type->desc);
+ table_row_add(win_cpu_types->t, table_row);
+ if (sd_cpu_type_selected(cpu_type))
+ table_row_mark_toggle(win_cpu_types->t, table_row);
+}
+
+/*
+ * Fill all available CPU types into table
+ */
+static void l_table_create(struct win_cpu_types *win_cpu_types)
+{
+ struct sd_cpu_type *cpu_type;
+ unsigned int i;
+
+ table_row_del_all(win_cpu_types->t);
+ table_row_mark_del_all(win_cpu_types->t);
+ sd_cpu_type_iterate(cpu_type, i)
+ l_add_cpu_type(win_cpu_types, cpu_type);
+ table_finish(win_cpu_types->t);
+}
+
+/*
+ * Toggle the cpu type specified by "key" in the system data module
+ */
+static void l_toggle_cpu_type(char key)
+{
+ struct sd_cpu_type *cpu_type;
+ unsigned int i;
+
+ sd_cpu_type_iterate(cpu_type, i) {
+ if (key == cpu_type->hotkey) {
+ sd_cpu_type_select_toggle(cpu_type);
+ return;
+ }
+ }
+}
+
+/*
+ * Process input for selection with SPACE key
+ */
+static void l_process_input_select_space(struct win_cpu_types *win_cpu_types)
+{
+ char cpu_type_key[TABLE_STR_MAX];
+
+ if (table_mode_select(win_cpu_types->t)) {
+ table_row_select_key_get(win_cpu_types->t, cpu_type_key);
+ l_toggle_cpu_type(cpu_type_key[0]);
+ } else {
+ struct table_mark_key *key;
+
+ table_iterate_mark_keys(win_cpu_types->t, key)
+ l_toggle_cpu_type(key->str[0]);
+ }
+}
+
+/*
+ * Process input for selection with hotkey
+ */
+static void l_process_input_select_key(struct win_cpu_types *win_cpu_types,
+ int c)
+{
+ char cpu_type_key[TABLE_STR_MAX];
+
+ sprintf(cpu_type_key, "%c", c);
+ table_row_mark_toggle_by_key(win_cpu_types->t, cpu_type_key);
+ l_toggle_cpu_type(cpu_type_key[0]);
+}
+
+/*
+ * Process input and switch window if necessary
+ */
+static enum hyptop_win_action l_process_input(struct hyptop_win *win, int c)
+{
+ struct win_cpu_types *win_cpu_types = (struct win_cpu_types *) win;
+
+ switch (c) {
+ case 't':
+ case 'q':
+ return win_back();
+ case KEY_RETURN:
+ case KEY_ENTER:
+ case 'h':
+ case KEY_LEFT:
+ if (!table_mode_select(win_cpu_types->t))
+ return win_back();
+ break;
+ case '?':
+ return win_switch(win_cpu_types->win_help);
+ case ' ':
+ l_process_input_select_space(win_cpu_types);
+ break;
+ case ERR:
+ return WIN_KEEP;
+ default:
+ l_process_input_select_key(win_cpu_types, c);
+ break;
+ }
+ table_process_input(win_cpu_types->t, c);
+ hyptop_update_term();
+ return WIN_KEEP;
+}
+
+/*
+ * Event loop: We stay in hyptop_process_input() until fields menu
+ * is left.
+ */
+static void l_run(struct hyptop_win *win)
+{
+ struct win_cpu_types *win_cpu_types = (struct win_cpu_types *) win;
+
+ table_reset(win_cpu_types->t);
+ while (1) {
+ hyptop_update_term();
+ if (hyptop_process_input() == WIN_SWITCH)
+ return;
+ }
+}
+
+/*
+ * Create table and print it to screen
+ */
+static void l_update_term(struct hyptop_win *win)
+{
+ struct win_cpu_types *win_cpu_types = (struct win_cpu_types *) win;
+
+ l_table_create(win_cpu_types);
+ hyptop_printf("Select Processor Types");
+ ht_print_help_icon();
+ hyptop_print_nl();
+
+ table_print(win_cpu_types->t);
+}
+
+/*
+ * Create new cpu_types window
+ */
+struct hyptop_win *win_cpu_types_new(void)
+{
+ struct win_cpu_types *win_cpu_types;
+
+ win_cpu_types = ht_zalloc(sizeof(*win_cpu_types));
+
+ win_cpu_types->win.process_input = l_process_input;
+ win_cpu_types->win.update_term = l_update_term;
+ win_cpu_types->win.run = l_run;
+ win_cpu_types->win.desc = l_help_str;
+ win_cpu_types->win.desc_normal_vec = l_nav_desc_normal_vec;
+ win_cpu_types->win.desc_select_vec = l_nav_desc_select_vec;
+ win_cpu_types->win.desc_general_vec = l_nav_desc_general_vec;
+ win_cpu_types->win.id = "cpu_types";
+
+ win_cpu_types->t = table_new(1, 0, 0, 0);
+ table_col_add(win_cpu_types->t, &l_col_key);
+ table_col_add(win_cpu_types->t, &l_col_select);
+ table_col_add(win_cpu_types->t, &l_col_id);
+ table_col_add(win_cpu_types->t, &l_col_desc);
+
+ win_cpu_types->win_help =
+ win_help_new((struct hyptop_win *) win_cpu_types);
+ l_table_create(win_cpu_types);
+ return (struct hyptop_win *) win_cpu_types;
+}
diff --git a/hyptop/win_cpu_types.h b/hyptop/win_cpu_types.h
new file mode 100644
index 0000000..b0f29a7
--- /dev/null
+++ b/hyptop/win_cpu_types.h
@@ -0,0 +1,26 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "cpu_types": Select CPU types used for CPU data calculation.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef WIN_CPU_TYPES_H
+#define WIN_CPU_TYPES_H
+
+#include "hyptop.h"
+#include "table.h"
+#include "win_help.h"
+
+struct win_cpu_types {
+ struct hyptop_win win;
+ struct table *t;
+ int in_select;
+ struct hyptop_win *win_help;
+};
+
+extern struct hyptop_win *win_cpu_types_new(void);
+
+#endif /* WIN_CPU_TYPES_H */
diff --git a/hyptop/win_fields.c b/hyptop/win_fields.c
new file mode 100644
index 0000000..8d5e233
--- /dev/null
+++ b/hyptop/win_fields.c
@@ -0,0 +1,272 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "fields": Select fields dialog.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include "helper.h"
+#include "hyptop.h"
+#include "table.h"
+#include "win_fields.h"
+
+
+/*
+ * Globals for fields window
+ */
+static struct table_col l_col_select = TABLE_COL_STR_LEFT('s', "s");
+static struct table_col l_col_id = TABLE_COL_STR_LEFT('i', "id");
+static struct table_col l_col_key = TABLE_COL_STR_LEFT('k', "k");
+static struct table_col l_col_unit = TABLE_COL_STR_LEFT('u', "unit");
+static struct table_col l_col_agg = TABLE_COL_STR_LEFT('a', "agg");
+static struct table_col l_col_desc = TABLE_COL_STR_LEFT('d', "description");
+
+/*
+ * Online help text for fields window
+ */
+static const char l_help_str[] =
+"In the \"fields\" window you can select fields and units. Toggle the selection\n"
+"of fields either by pressing the corresponding hotkey or by selecting them\n"
+"in select mode using the SPACE bar. The units can be changed by selecting a\n"
+"field in select mode and by pressing '+' or '-'.\n"
+"\n"
+"The table of the \"fields\" window has the following columns:\n"
+" - K : Hotkey of field\n"
+" - S : Shows if field is selected\n"
+" - ID : Name of field\n"
+" - UNIT: Current unit used for field\n"
+" - AGG : Aggregation used for last line of table\n"
+" - DESC: Description of field\n";
+
+/*
+ * Description of Navigation Keys (used for help window)
+ */
+static struct nav_desc *l_nav_desc_normal_vec[] = {
+ &nav_desc_select_mode_enter,
+ &nav_desc_marks_clear,
+ &nav_desc_win_leave_fields,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_select_vec[] = {
+ &nav_desc_select_mode_leave,
+ &nav_desc_mark_toggle,
+ &nav_desc_row_unit_increase,
+ &nav_desc_row_unit_decrease,
+ &nav_desc_win_leave_fields_fast,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_general_vec[] = {
+ &nav_desc_toggle_mark_hotkey,
+ &nav_desc_scroll_up_line,
+ &nav_desc_scroll_down_line,
+ &nav_desc_scroll_up_page,
+ &nav_desc_scroll_down_page,
+ &nav_desc_scroll_up_head,
+ &nav_desc_scroll_down_tail,
+ &nav_desc_mark_toggle_view,
+ NULL,
+};
+
+/*
+ * Add a field that is the column of the reference table to the table
+ */
+static void l_add_field(struct win_fields *win_fields, struct table_col *col,
+ const char *desc)
+{
+ char char_str[2], select_str[2];
+ struct table_row *table_row;
+
+ if (table_col_enabled(col))
+ sprintf(select_str, "*");
+ else
+ sprintf(select_str, " ");
+ sprintf(char_str, "%c", table_col_hotkey(col));
+
+ table_row = table_row_alloc(win_fields->t);
+ table_row_entry_str_add(table_row, &l_col_select, select_str);
+ table_row_entry_str_add(table_row, &l_col_key, char_str);
+ table_row_entry_str_add(table_row, &l_col_id, table_col_head(col));
+ table_row_entry_str_add(table_row, &l_col_unit,
+ table_col_unit_str(col));
+ table_row_entry_str_add(table_row, &l_col_agg,
+ table_col_agg_str(col->agg));
+ table_row_entry_str_add(table_row, &l_col_desc, desc);
+ table_row_add(win_fields->t, table_row);
+
+ if (table_col_enabled(col))
+ table_row_mark_toggle(win_fields->t, table_row);
+}
+
+/*
+ * Fill all field information into table
+ */
+static void l_table_create(struct win_fields *win_fields)
+{
+ unsigned int i;
+
+ table_row_del_all(win_fields->t);
+ table_row_mark_del_all(win_fields->t);
+ for (i = 0; win_fields->col_vec[i]; i++) {
+ l_add_field(win_fields, win_fields->col_vec[i],
+ win_fields->col_desc_vec[i]);
+ }
+ table_finish(win_fields->t);
+}
+
+/*
+ * Process input for selection with SPACE key
+ */
+static void l_process_input_select_space(struct win_fields *win_fields)
+{
+ char field_key[TABLE_STR_MAX];
+
+ if (table_mode_select(win_fields->t)) {
+ table_row_select_key_get(win_fields->t, field_key);
+ table_col_enable_toggle(win_fields->table, field_key[0]);
+ } else {
+ struct table_mark_key *key;
+ /* switch off all fields in reference table */
+ table_iterate_mark_keys(win_fields->t, key)
+ table_col_enable_toggle(win_fields->table,
+ key->str[0]);
+ }
+}
+
+/*
+ * Process input for selection with hotkey
+ */
+static void l_process_input_select_key(struct win_fields *win_fields, int c)
+{
+ char field_key[TABLE_STR_MAX];
+
+ sprintf(field_key, "%c", c);
+ table_row_mark_toggle_by_key(win_fields->t, field_key);
+ table_col_enable_toggle(win_fields->table, field_key[0]);
+}
+
+/*
+ * Process input for unit selection
+ */
+static void l_process_input_units(struct win_fields *win_fields, int c)
+{
+ char field_key[TABLE_STR_MAX];
+
+ if (!table_mode_select(win_fields->t))
+ return;
+ table_row_select_key_get(win_fields->t, field_key);
+ if (c == '+')
+ table_col_unit_next(win_fields->table, field_key[0]);
+ else
+ table_col_unit_prev(win_fields->table, field_key[0]);
+}
+
+/*
+ * Process input and switch window if necessary
+ */
+static enum hyptop_win_action l_process_input(struct hyptop_win *win, int c)
+{
+ struct win_fields *win_fields = (struct win_fields *) win;
+
+ switch (c) {
+ case 'f':
+ case 'q':
+ return win_back();
+ case KEY_RETURN:
+ case KEY_ENTER:
+ case 'h':
+ case KEY_LEFT:
+ if (!table_mode_select(win_fields->t))
+ return win_back();
+ break;
+ case '?':
+ return win_switch(win_fields->win_help);
+ case ' ':
+ l_process_input_select_space(win_fields);
+ break;
+ case '+':
+ case '-':
+ l_process_input_units(win_fields, c);
+ break;
+ case ERR:
+ return WIN_KEEP;
+ default:
+ l_process_input_select_key(win_fields, c);
+ break;
+ }
+ table_process_input(win_fields->t, c);
+ hyptop_update_term();
+ return WIN_KEEP;
+}
+
+/*
+ * Event loop: We stay in hyptop_process_input() until fields menu
+ * is left.
+ */
+static void l_run(struct hyptop_win *win)
+{
+ struct win_fields *win_fields = (struct win_fields *) win;
+
+ table_reset(win_fields->t);
+ while (1) {
+ hyptop_update_term();
+ if (hyptop_process_input() == WIN_SWITCH)
+ return;
+ }
+}
+
+/*
+ * Create table and print it to screen
+ */
+static void l_update_term(struct hyptop_win *win)
+{
+ struct win_fields *win_fields = (struct win_fields *) win;
+
+ l_table_create(win_fields);
+ hyptop_printf("Select Fields and Units");
+ ht_print_help_icon();
+ hyptop_print_nl();
+ table_print(win_fields->t);
+}
+
+/*
+ * Create new fields window
+ *
+ * - t...........: Reference table
+ * - col_vec.....: Table column vector for fields
+ * - col_desc_vec: Vector with descriptions for fields
+ */
+struct hyptop_win *win_fields_new(struct table *t, struct table_col **col_vec,
+ char **col_desc_vec)
+{
+ struct win_fields *win_fields;
+
+ win_fields = ht_zalloc(sizeof(*win_fields));
+
+ win_fields->win.process_input = l_process_input;
+ win_fields->win.update_term = l_update_term;
+ win_fields->win.run = l_run;
+ win_fields->win.desc = l_help_str;
+ win_fields->win.desc_normal_vec = l_nav_desc_normal_vec;
+ win_fields->win.desc_select_vec = l_nav_desc_select_vec;
+ win_fields->win.desc_general_vec = l_nav_desc_general_vec;
+ win_fields->win.id = "fields";
+
+ win_fields->t = table_new(1, 0, 0, 0);
+ table_col_add(win_fields->t, &l_col_key);
+ table_col_add(win_fields->t, &l_col_select);
+ table_col_add(win_fields->t, &l_col_id);
+ table_col_add(win_fields->t, &l_col_unit);
+ table_col_add(win_fields->t, &l_col_agg);
+ table_col_add(win_fields->t, &l_col_desc);
+ win_fields->col_desc_vec = col_desc_vec;
+ win_fields->col_vec = col_vec;
+ win_fields->table = t;
+ win_fields->win_help = win_help_new((struct hyptop_win *) win_fields);
+
+ l_table_create(win_fields);
+ return (struct hyptop_win *) win_fields;
+}
diff --git a/hyptop/win_fields.h b/hyptop/win_fields.h
new file mode 100644
index 0000000..b399203
--- /dev/null
+++ b/hyptop/win_fields.h
@@ -0,0 +1,31 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "fields": Select fields dialog.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef WIN_FIELDS_H
+#define WIN_FIELDS_H
+
+#include "table.h"
+#include "hyptop.h"
+#include "win_help.h"
+
+struct win_fields {
+ struct hyptop_win win;
+ struct table *t;
+ struct table *table;
+ struct table_col **col_vec;
+ char **col_desc_vec;
+ int mode_unit_change;
+ int in_select;
+ struct hyptop_win *win_help;
+};
+
+struct hyptop_win *win_fields_new(struct table *t, struct table_col **col_vec,
+ char **col_desc_vec);
+
+#endif /* WIN_FIELDS_H */
diff --git a/hyptop/win_help.c b/hyptop/win_help.c
new file mode 100644
index 0000000..f18d0bb
--- /dev/null
+++ b/hyptop/win_help.c
@@ -0,0 +1,122 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "help": Show online help text.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include "helper.h"
+#include "table.h"
+#include "hyptop.h"
+#include "win_help.h"
+#include "sd.h"
+
+/*
+ * Print help text to screen
+ */
+static void l_update_term(struct hyptop_win *win)
+{
+ struct win_help *win_help = (struct win_help *) win;
+ tbox_print(win_help->tb);
+}
+
+/*
+ * Process input and switch window if necessary
+ */
+static enum hyptop_win_action l_process_input(struct hyptop_win *win, int c)
+{
+ struct win_help *win_help = (struct win_help *) win;
+
+ switch (c) {
+ case 'h':
+ case KEY_RETURN:
+ case KEY_ENTER:
+ case KEY_LEFT:
+ case '?':
+ case 'q':
+ return win_back();
+ case 'G':
+ tbox_scroll_down(win_help->tb, TBOX_SCROLL_LAST);
+ break;
+ case 'g':
+ tbox_scroll_up(win_help->tb, TBOX_SCROLL_LAST);
+ break;
+ case KEY_NPAGE:
+ tbox_scroll_down(win_help->tb, TBOX_SCROLL_PAGE);
+ break;
+ case KEY_PPAGE:
+ tbox_scroll_up(win_help->tb, TBOX_SCROLL_PAGE);
+ break;
+ case 'k':
+ case KEY_UP:
+ tbox_scroll_up(win_help->tb, TBOX_SCROLL_LINE);
+ break;
+ case 'j':
+ case KEY_DOWN:
+ tbox_scroll_down(win_help->tb, TBOX_SCROLL_LINE);
+ break;
+ case ERR:
+ return WIN_KEEP;
+ default:
+ break;
+ }
+ hyptop_update_term();
+ return WIN_KEEP;
+}
+
+/*
+ * Event loop: wait for input and print help text
+ */
+static void l_run(struct hyptop_win *win)
+{
+ (void) win;
+
+ while (1) {
+ hyptop_update_term();
+ if (hyptop_process_input() == WIN_SWITCH)
+ return;
+ }
+}
+
+/*
+ * Add text to text box
+ */
+static void l_add_text(struct tbox *tb, const char *str)
+{
+ char *line, *line_end, *str_cpy;
+
+ str_cpy = line_end = ht_strdup(str);
+ for (line = str_cpy; line_end != NULL; line = line_end + 1) {
+ line_end = strchr(line, '\n');
+ if (line_end)
+ *line_end = 0;
+ tbox_line_add(tb, line);
+ }
+ ht_free(str_cpy);
+}
+
+/*
+ * Create new help window for "win" and init window description
+ */
+struct hyptop_win *win_help_new(struct hyptop_win *win)
+{
+ struct win_help *win_help;
+
+ win_help = ht_zalloc(sizeof(*win_help));
+
+ win_help->tb = tbox_new();
+ tbox_printf(win_help->tb, "\\BWindow: %s\\B", win->id);
+ tbox_printf(win_help->tb, " ");
+ l_add_text(win_help->tb, win->desc);
+ nav_desc_add(win_help->tb, win->desc_normal_vec, win->desc_select_vec,
+ win->desc_general_vec);
+ tbox_finish(win_help->tb);
+
+ win_help->win.process_input = l_process_input;
+ win_help->win.update_term = l_update_term;
+ win_help->win.run = l_run;
+
+ return (struct hyptop_win *) win_help;
+}
diff --git a/hyptop/win_help.h b/hyptop/win_help.h
new file mode 100644
index 0000000..5f4f45d
--- /dev/null
+++ b/hyptop/win_help.h
@@ -0,0 +1,23 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "help": Show online help text.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#ifndef WIN_HELP_H
+#define WIN_HELP_H
+
+#include "tbox.h"
+#include "hyptop.h"
+
+struct win_help {
+ struct hyptop_win win;
+ struct tbox *tb;
+};
+
+struct hyptop_win *win_help_new(struct hyptop_win *win);
+
+#endif /* WIN_HELP_H */
diff --git a/hyptop/win_sys.c b/hyptop/win_sys.c
new file mode 100644
index 0000000..2039c72
--- /dev/null
+++ b/hyptop/win_sys.c
@@ -0,0 +1,387 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "sys": Shows one system in more detail.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include <errno.h>
+#include "helper.h"
+#include "table.h"
+#include "hyptop.h"
+#include "sd.h"
+#include "win_fields.h"
+#include "win_help.h"
+#include "opts.h"
+
+/*
+ * Globals for sys_list window
+ */
+static char l_sys_id[SD_SYS_ID_SIZE]; /* System to show */
+static struct table_col l_cpu_col; /* CPU column */
+static struct table_col l_vis_col; /* Visual column */
+static struct table *l_t; /* Table */
+static int l_initialized; /* Win initialized ? */
+static struct hyptop_win *l_win_fields; /* Fields window */
+static struct hyptop_win *l_win_help; /* Help window */
+
+/* CPU column */
+static struct table_col l_cpu_col = {
+ .type = TABLE_COL_TYPE_U64,
+ .unit = &table_col_unit_cnt,
+ .unit_fam = table_col_unit_fam_cnt,
+ .align = TABLE_COL_ALIGN_LEFT,
+ .agg = TABLE_COL_AGG_NONE,
+ .hotkey = 'i',
+ .head = "cpuid",
+};
+
+/* Visual column */
+static struct table_col l_vis_col = {
+ .type = TABLE_COL_TYPE_U64,
+ .unit = &table_col_unit_vis,
+ .unit_fam = table_col_unit_fam_vis,
+ .align = TABLE_COL_ALIGN_LEFT,
+ .agg = TABLE_COL_AGG_NONE,
+ .hotkey = 'v',
+ .head = "visual",
+};
+
+/*
+ * Online help text for sys window
+ */
+static const char l_help_str[] =
+"The \"sys\" window displays CPU information about one selected system.\n"
+"Under z/VM you can only see aggregated CPU information and not information\n"
+"about single CPUs.\n"
+"\n"
+"Select a column by pressing the hotkey of the column. This key is underlined\n"
+"in the heading. The table is sorted according to the values in the selected\n"
+"column. If you press the hotkey again, the sort order is reversed.\n"
+"Alternatively you can select columns with the '<' and '>' keys.\n";
+
+/*
+ * Description of Navigation Keys (used for help window)
+ */
+static struct nav_desc *l_nav_desc_normal_vec[] = {
+ &nav_desc_select_mode_enter,
+ &nav_desc_marks_clear,
+ &nav_desc_win_leave_sys,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_select_vec[] = {
+ &nav_desc_select_mode_leave,
+ &nav_desc_mark_toggle,
+ &nav_desc_win_leave_sys_fast,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_general_vec[] = {
+ &nav_desc_win_enter_fields,
+ &nav_desc_win_enter_cpu_types,
+ &nav_desc_col_unit_increase,
+ &nav_desc_col_unit_decrease,
+ &nav_desc_select_col_next,
+ &nav_desc_select_col_prev,
+ &nav_desc_select_col_hotkey,
+ &nav_desc_scroll_up_line,
+ &nav_desc_scroll_down_line,
+ &nav_desc_scroll_up_page,
+ &nav_desc_scroll_down_page,
+ &nav_desc_scroll_up_head,
+ &nav_desc_scroll_down_tail,
+ &nav_desc_mark_toggle_view,
+ NULL,
+};
+
+/*
+ * Add CPU item to table row
+ */
+static void l_cpu_item_add(struct table_row *table_row, struct sd_cpu *cpu,
+ struct sd_cpu_item *item)
+{
+ switch (sd_cpu_item_type(item)) {
+ case SD_TYPE_U16:
+ case SD_TYPE_U32:
+ assert(0);
+ break;
+ case SD_TYPE_U64:
+ table_row_entry_u64_add(table_row,
+ sd_cpu_item_table_col(item),
+ sd_cpu_item_u64(item, cpu));
+ break;
+ case SD_TYPE_S64:
+ table_row_entry_s64_add(table_row,
+ sd_cpu_item_table_col(item),
+ sd_cpu_item_s64(item, cpu));
+ break;
+ case SD_TYPE_STR:
+ table_row_entry_str_add(table_row,
+ sd_cpu_item_table_col(item),
+ sd_cpu_item_str(item, cpu));
+ break;
+ }
+}
+
+/*
+ * Add visualization of CPU time to table row
+ */
+static void l_cpu_add_visual(struct table_row *table_row, struct sd_cpu *cpu)
+{
+ s64 steal_us;
+ u64 cpu_us;
+
+ cpu_us = sd_cpu_item_u64(&sd_cpu_item_cpu_diff, cpu) / sd_cpu_cnt(cpu);
+ steal_us = sd_cpu_item_s64(&sd_cpu_item_steal_diff, cpu) /
+ sd_cpu_cnt(cpu);
+ steal_us = MAX(steal_us, 0);
+ table_row_entry_u64_add_pair(table_row, &l_vis_col, cpu_us, steal_us);
+}
+
+/*
+ * Add CPU to table
+ */
+static void l_cpu_add(struct sd_cpu *cpu)
+{
+ struct table_row *table_row;
+ struct sd_cpu_item *item;
+ unsigned int cpu_id;
+ unsigned int i;
+
+ table_row = table_row_alloc(l_t);
+ cpu_id = atoi(sd_cpu_id(cpu));
+ table_row_entry_u64_add(table_row, &l_cpu_col, cpu_id);
+
+ sd_cpu_item_iterate(item, i)
+ l_cpu_item_add(table_row, cpu, item);
+ l_cpu_add_visual(table_row, cpu);
+ table_row_add(l_t, table_row);
+}
+
+/*
+ * Fill system CPU data into table
+ */
+static int l_table_create(void)
+{
+ struct sd_sys *parent;
+ struct sd_cpu *cpu;
+
+ parent = sd_sys_get(sd_sys_root_get(), l_sys_id);
+ if (!parent)
+ return -ENODEV;
+ table_row_del_all(l_t);
+ sd_cpu_iterate(parent, cpu)
+ l_cpu_add(cpu);
+ table_finish(l_t);
+ return 0;
+}
+
+/*
+ * Print table to screen
+ */
+static void l_table_update_term(struct hyptop_win *win)
+{
+ (void) win;
+
+ ht_print_head(l_sys_id);
+ table_print(l_t);
+}
+
+/*
+ * Process input and switch window if necessary
+ */
+static enum hyptop_win_action l_process_input(struct hyptop_win *win, int c)
+{
+ (void) win;
+
+ switch (c) {
+ case 't':
+ return win_switch(g.win_cpu_types);
+ case '?':
+ return win_switch(l_win_help);
+ case 'f':
+ return win_switch(l_win_fields);
+ case 'q':
+ return win_back();
+ case 'h':
+ case KEY_LEFT:
+ if (!(table_mode_select(l_t)))
+ return win_back();
+ break;
+ case ERR:
+ return WIN_KEEP;
+ }
+ table_process_input(l_t, c);
+ hyptop_update_term();
+ return WIN_KEEP;
+}
+
+/*
+ * Enable field and set unit
+ */
+static void l_field_set(struct table_col_spec *col_spec)
+{
+ table_col_enable_toggle(l_t, col_spec->hotkey);
+ if (!col_spec->unit_str)
+ return;
+ if (table_col_unit_set(l_t, col_spec->hotkey, col_spec->unit_str))
+ ERR_EXIT("Invalid unit \"%s\" for field \"%c\"\n",
+ col_spec->unit_str, col_spec->hotkey);
+}
+
+/*
+ * Enable field defined in "col_spec"
+ */
+static void l_field_enable(struct table_col_spec *col_spec)
+{
+ struct sd_cpu_item *item;
+ struct table_col *col;
+ unsigned int i;
+
+ if (table_col_hotkey(&l_vis_col) == col_spec->hotkey) {
+ l_field_set(col_spec);
+ return;
+ }
+ sd_cpu_item_iterate(item, i) {
+ col = sd_cpu_item_table_col(item);
+ if (table_col_hotkey(col) != col_spec->hotkey)
+ continue;
+ l_field_set(col_spec);
+ return;
+ }
+ ERR_EXIT("Unknown field \"%c\"\n", col_spec->hotkey);
+}
+
+/*
+ * Enable fields defined on command line
+ */
+static void l_fields_enable_cmdline(void)
+{
+ unsigned int i;
+
+ table_col_enable_toggle(l_t, table_col_hotkey(&l_vis_col));
+ for (i = 0; i < win_sys.opts.fields.cnt; i++)
+ l_field_enable(win_sys.opts.fields.vec[i]);
+}
+
+/*
+ * Enable fields like defined in data gatherer
+ */
+static void l_fields_enable_default(void)
+{
+ struct sd_cpu_item *item;
+ struct table_col *col;
+ unsigned int i;
+
+ sd_cpu_item_enable_iterate(item, i) {
+ col = sd_cpu_item_table_col(item);
+ table_col_enable_toggle(l_t, table_col_hotkey(col));
+ }
+}
+
+/*
+ * Event loop: Make regular updates of table
+ */
+static void l_run(struct hyptop_win *win)
+{
+ enum hyptop_win_action action;
+ (void) win;
+
+ /* Reformat table when entering window */
+ table_rebuild(l_t);
+ while (1) {
+ if (l_table_create()) {
+ if (g.o.batch_mode_specified)
+ ERR_EXIT("System \"%s\" not available.\n",
+ l_sys_id);
+ win_back();
+ return;
+ }
+ hyptop_update_term();
+ action = hyptop_process_input_timeout();
+ if (action == WIN_SWITCH)
+ return;
+
+ /* No updates in select mode */
+ if (!table_mode_select(l_t))
+ sd_update();
+ }
+}
+
+/*
+ * Define system for window
+ */
+void win_sys_set(const char *sys_id)
+{
+ if (l_initialized)
+ table_reset(l_t);
+ strncpy(l_sys_id, sys_id, sizeof(l_sys_id));
+}
+
+/*
+ * Initialize window
+ */
+void win_sys_init(void)
+{
+ struct table_col **col_vec;
+ struct sd_cpu_item *item;
+ struct table_col *col;
+ char **col_desc_vec;
+ unsigned int i, item_cnt;
+
+ /* Alloc table and add columns */
+ l_t = table_new(1, 1, 1, 1);
+ table_col_add(l_t, &l_cpu_col);
+ table_col_rsort(&l_cpu_col);
+
+ item_cnt = sd_cpu_item_cnt() + 2;
+ col_vec = ht_zalloc(sizeof(void *) * item_cnt);
+ col_desc_vec = ht_zalloc(sizeof(void *) * item_cnt);
+
+ sd_cpu_item_iterate(item, i) {
+ col = sd_cpu_item_table_col(item);
+ table_col_add(l_t, col);
+ table_col_enable_toggle(l_t, table_col_hotkey(col));
+ col_vec[i] = col;
+ col_desc_vec[i] = item->desc;
+ }
+ col_vec[i] = &l_vis_col;
+ col_desc_vec[i] = "Visualization of CPU time per second";
+ table_col_add(l_t, &l_vis_col);
+
+ /* Enable fields */
+ if (win_sys.opts.fields.specified)
+ l_fields_enable_cmdline();
+ else
+ l_fields_enable_default();
+
+ /* Select sort field */
+ if (win_sys.opts.sort_field_specified) {
+ for (i = 0; i < win_sys.opts.sort_field_specified; i++) {
+ if (table_col_select(l_t, win_sys.opts.sort_field))
+ ERR_EXIT("Sort field \"%c\" is not available\n",
+ win_sys.opts.sort_field);
+ }
+ }
+ /* Initialize help and fields window */
+ l_win_fields = win_fields_new(l_t, col_vec, col_desc_vec);
+ l_win_help = win_help_new(&win_sys);
+ l_initialized = 1;
+}
+
+/*
+ * hyptop window structure definition
+ */
+struct hyptop_win win_sys = {
+ .process_input = l_process_input,
+ .update_term = l_table_update_term,
+ .run = l_run,
+ .id = "sys",
+ .desc = l_help_str,
+ .desc_normal_vec = l_nav_desc_normal_vec,
+ .desc_select_vec = l_nav_desc_select_vec,
+ .desc_general_vec = l_nav_desc_general_vec,
+};
diff --git a/hyptop/win_sys_list.c b/hyptop/win_sys_list.c
new file mode 100644
index 0000000..79eb092
--- /dev/null
+++ b/hyptop/win_sys_list.c
@@ -0,0 +1,380 @@
+/*
+ * hyptop - Show hypervisor performance data on System z
+ *
+ * Window "sys_list":
+ * Shows a list of systems that the hypervisor is currently running.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
+ */
+
+#include "helper.h"
+#include "table.h"
+#include "hyptop.h"
+#include "win_fields.h"
+#include "win_help.h"
+#include "sd.h"
+#include "nav_desc.h"
+#include "opts.h"
+
+/*
+ * Globals for sys_list window
+ */
+static struct table *l_t; /* Table */
+static struct hyptop_win *l_win_fields; /* Fields Window */
+static struct hyptop_win *l_win_help; /* Herp Window */
+
+/* System column */
+static struct table_col l_col_sys = TABLE_COL_STR_LEFT('y', "system");
+
+/*
+ * Online help text for sys_list window
+ */
+static const char l_help_str[] =
+"The following windows can be accessed:\n"
+"\n"
+" +-----------+ RIGHT +----------+\n"
+" | | <----------------------> | |\n"
+" | | LEFT | |\n"
+" | | | |\n"
+" | sys_list | 't' +-----------+ | | 't' +-----------+\n"
+" | | <-------> | cpu_types | | sys | <-------> | cpu_types |\n"
+" | (start) | 't',LEFT +-----------+ | | 't',LEFT +-----------+\n"
+" | | | |\n"
+" | | 'f' +--------+ | | 'f' +--------+\n"
+" | | <-------> | fields | | | <-------> | fields |\n"
+" | | 'f',LEFT +--------+ | | 'f',LEFT +--------+\n"
+" +-----------+ +----------+\n"
+"\n"
+" * sys_list: Start window that shows a list of systems that the hypervisor\n"
+" is currently running.\n"
+" * sys: Shows one system in more detail.\n"
+" * cpu_types: Select CPU types that are used for calculating CPU data.\n"
+" * fields: Select fields and units for windows sys_list or sys.\n"
+"\n"
+"\\BNavigation\\B\n"
+"\n"
+"To navigate between the windows, use the arrow keys or 'hjkl'. The windows\n"
+"have two modes, \"normal mode\" and \"select mode\". When you start the "
+"program,\n"
+"the window is in normal mode where data is updated at regular intervals. Use\n"
+"the RIGHT arrow key to enter the select mode. In select mode you can select\n"
+"rows with with UP and DOWN arrow keys and mark them with the SPACE bar. From\n"
+"the \"sys_list\" window you can access the \"sys\" window in select mode\n"
+"with the arrow key RIGHT. Leave the select mode with the arrow key LEFT.\n"
+"If you are in normal mode, the arrow key LEFT goes to the previous window.\n"
+"You can scroll all windows using the arrow keys UP, DOWN, PAGEUP and\n"
+"PAGEDOWN. You can jump to the end of a window with 'G' and to the beginning\n"
+"with 'g'.\n"
+"\n"
+"Select a column by pressing the hotkey of the column. This key is underlined\n"
+"in the heading. The table is sorted according to the values in the selected\n"
+"column. If you press the hotkey again, the sort order is reversed.\n"
+"Alternatively you can select columns with the '<' and '>' keys.\n"
+"\n"
+"\\BTable layout\\B\n"
+"\n"
+"At the top left of the table the current time is shown. Then the CPU types\n"
+"with the physical CPU numbers that are used for CPU time calculation are\n"
+"displayed. The second row shows the units that are currently used for\n"
+"formatting the data. The last row shows the status display (see description\n"
+"below) and the aggregation of the the data columns. The last row aggregates\n"
+"all rows, not only the visible ones. If only the marked rows are shown\n"
+"(with '.') then only these rows are aggregated.\n"
+"\n"
+"\\BStatus display\\B\n"
+"\n"
+"At the left bottom of the screen a status display is shown.\n"
+"Example: \"V:V:N\"\n\n"
+"The first character shows, if the window can be scrolled:\n"
+" 'V': Window can be scrolled down\n"
+" '|': Window can be scrolled up/down\n"
+" '^': Window can be scrolled up\n"
+" '=': Window cannot be scrolled\n"
+"The second character shows the sort order for sorted tables:\n"
+" 'V': Higher values first\n"
+" '^': Lower values first\n"
+"The third character shows the current mode:\n"
+" 'N': Normal mode\n"
+" 'S': Select mode\n";
+
+/*
+ * Description of Navigation Keys (used for help window)
+ */
+static struct nav_desc *l_nav_desc_normal_vec[] = {
+ &nav_desc_select_mode_enter,
+ &nav_desc_marks_clear,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_select_vec[] = {
+ &nav_desc_select_mode_leave,
+ &nav_desc_win_enter_sys,
+ &nav_desc_mark_toggle,
+ NULL,
+};
+
+static struct nav_desc *l_nav_desc_general_vec[] = {
+ &nav_desc_win_enter_fields,
+ &nav_desc_win_enter_cpu_types,
+ &nav_desc_col_unit_increase,
+ &nav_desc_col_unit_decrease,
+ &nav_desc_select_col_next,
+ &nav_desc_select_col_prev,
+ &nav_desc_select_col_hotkey,
+ &nav_desc_scroll_up_line,
+ &nav_desc_scroll_down_line,
+ &nav_desc_scroll_up_page,
+ &nav_desc_scroll_down_page,
+ &nav_desc_scroll_up_head,
+ &nav_desc_scroll_down_tail,
+ &nav_desc_mark_toggle_view,
+ &nav_desc_quit,
+ NULL,
+};
+
+/*
+ * Add system item to table row
+ */
+static void l_sys_item_add(struct table_row *table_row, struct sd_sys *sys,
+ struct sd_sys_item *item)
+{
+ switch (sd_sys_item_type(item)) {
+ case SD_TYPE_U64:
+ case SD_TYPE_U32:
+ case SD_TYPE_U16:
+ table_row_entry_u64_add(table_row,
+ sd_sys_item_table_col(item),
+ sd_sys_item_u64(sys, item));
+ break;
+ case SD_TYPE_S64:
+ table_row_entry_s64_add(table_row,
+ sd_sys_item_table_col(item),
+ sd_sys_item_s64(sys, item));
+ break;
+ case SD_TYPE_STR:
+ table_row_entry_str_add(table_row,
+ sd_sys_item_table_col(item),
+ sd_sys_item_str(sys, item));
+ break;
+ }
+}
+
+/*
+ * Add system to table
+ */
+static void l_sys_add(struct sd_sys *sys)
+{
+ struct table_row *table_row;
+ struct sd_sys_item *item;
+ unsigned int i;
+
+ table_row = table_row_alloc(l_t);
+ table_row_entry_str_add(table_row, &l_col_sys, sd_sys_id(sys));
+
+ sd_sys_item_iterate(item, i)
+ l_sys_item_add(table_row, sys, item);
+ table_row_add(l_t, table_row);
+}
+
+/*
+ * Fill system data into table
+ */
+static void l_table_create(void)
+{
+ struct sd_sys *parent, *guest;
+
+ table_row_del_all(l_t);
+ parent = sd_sys_root_get();
+ sd_sys_iterate(parent, guest) {
+ if (!opts_sys_specified(&win_sys_list, sd_sys_id(guest)))
+ continue;
+ l_sys_add(guest);
+ }
+ table_finish(l_t);
+}
+
+/*
+ * Print table to screen
+ */
+static void l_table_update_term(struct hyptop_win *win)
+{
+ (void) win;
+
+ ht_print_head(NULL);
+ table_print(l_t);
+}
+
+/*
+ * Process input and switch window if necessary
+ */
+static enum hyptop_win_action l_process_input(struct hyptop_win *win, int c)
+{
+ char selected_sys[TABLE_STR_MAX];
+ (void) win;
+
+ switch (c) {
+ case 'f':
+ return win_switch(l_win_fields);
+ case 't':
+ return win_switch(g.win_cpu_types);
+ case '?':
+ return win_switch(l_win_help);
+ case 'q':
+ hyptop_exit(0);
+ case 'l':
+ case KEY_RIGHT:
+ if (!table_mode_select(l_t))
+ break;
+ table_row_select_key_get(l_t, selected_sys);
+ win_sys_set(selected_sys);
+ return win_switch(&win_sys);
+ case ERR:
+ break;
+ }
+ table_process_input(l_t, c);
+ hyptop_update_term();
+ return WIN_KEEP;
+}
+
+/*
+ * Enable field and set unit
+ */
+static void l_field_set(struct table_col_spec *col_spec)
+{
+ table_col_enable_toggle(l_t, col_spec->hotkey);
+ if (!col_spec->unit_str)
+ return;
+ if (table_col_unit_set(l_t, col_spec->hotkey, col_spec->unit_str))
+ ERR_EXIT("Invalid unit \"%s\" for field \"%c\"\n",
+ col_spec->unit_str, col_spec->hotkey);
+}
+
+/*
+ * Enable field defined in "col_spec"
+ */
+static void l_field_enable(struct table_col_spec *col_spec)
+{
+ struct sd_sys_item *item;
+ struct table_col *col;
+ unsigned int i;
+
+ sd_sys_item_iterate(item, i) {
+ col = sd_sys_item_table_col(item);
+ if (table_col_hotkey(col) != col_spec->hotkey)
+ continue;
+ l_field_set(col_spec);
+ return;
+ }
+ ERR_EXIT("Unknown field \"%c\"\n", col_spec->hotkey);
+}
+
+/*
+ * Enable fields defined on command line
+ */
+static void l_fields_enable_cmdline(void)
+{
+ unsigned int i;
+
+ for (i = 0; i < win_sys_list.opts.fields.cnt; i++)
+ l_field_enable(win_sys_list.opts.fields.vec[i]);
+}
+
+/*
+ * Enable fields like defined in data gatherer
+ */
+static void l_fields_enable_default(void)
+{
+ struct sd_sys_item *item;
+ struct table_col *col;
+ unsigned int i;
+
+ sd_sys_item_enable_iterate(item, i) {
+ col = sd_sys_item_table_col(item);
+ table_col_enable_toggle(l_t, table_col_hotkey(col));
+ }
+}
+
+/*
+ * Event loop: Make regular updates of table
+ */
+static void l_run(struct hyptop_win *win)
+{
+ enum hyptop_win_action action;
+ (void) win;
+
+ /* Reformat table when entering window */
+ table_rebuild(l_t);
+ while (1) {
+ l_table_create();
+ hyptop_update_term();
+ action = hyptop_process_input_timeout();
+ if (action == WIN_SWITCH)
+ return;
+ /* No updates in select mode */
+ if (!table_mode_select(l_t))
+ sd_update();
+ }
+}
+
+/*
+ * Initialize window
+ */
+void win_sys_list_init(void)
+{
+ struct table_col **col_vec;
+ struct sd_sys_item *item;
+ struct table_col *col;
+ char **col_desc_vec;
+ unsigned int i;
+ int item_cnt;
+
+ /* Alloc table and add columns */
+ l_t = table_new(1, 1, 1, 1);
+ table_col_add(l_t, &l_col_sys);
+
+ item_cnt = sd_sys_item_cnt() + 1;
+ col_vec = ht_zalloc(sizeof(void *) * item_cnt);
+ col_desc_vec = ht_zalloc(sizeof(void *) * item_cnt);
+
+ sd_sys_item_iterate(item, i) {
+ col = sd_sys_item_table_col(item);
+ table_col_add(l_t, col);
+ table_col_enable_toggle(l_t, table_col_hotkey(col));
+ col_vec[i] = col;
+ col_desc_vec[i] = item->desc;
+ }
+ /* Enable fields */
+ if (win_sys_list.opts.fields.specified)
+ l_fields_enable_cmdline();
+ else
+ l_fields_enable_default();
+
+ /* Select sort field */
+ if (win_sys_list.opts.sort_field_specified) {
+ for (i = 0; i < win_sys_list.opts.sort_field_specified; i++) {
+ if (table_col_select(l_t, win_sys_list.opts.sort_field))
+ ERR_EXIT("Sort field \"%c\" is not available\n",
+ win_sys_list.opts.sort_field);
+ }
+ } else {
+ table_col_select(l_t, sd_sys_item_cpu_diff.table_col.hotkey);
+ }
+ /* Initialize help and fields window */
+ l_win_help = win_help_new(&win_sys_list);
+ l_win_fields = win_fields_new(l_t, col_vec, col_desc_vec);
+}
+
+/*
+ * hyptop window structure definition
+ */
+struct hyptop_win win_sys_list = {
+ .process_input = l_process_input,
+ .update_term = l_table_update_term,
+ .run = l_run,
+ .id = "sys_list",
+ .desc = l_help_str,
+ .desc_normal_vec = l_nav_desc_normal_vec,
+ .desc_select_vec = l_nav_desc_select_vec,
+ .desc_general_vec = l_nav_desc_general_vec,
+};
--
1.7.3.5
Reference in New Issue Copy Permalink