[Crash-utility] [PATCH] New sbitmap command

Patch adds new 'sbitmap' command. This command dumps the contents of the sbitmap_queue structure and the used bits in the bitmap. Also, it shows the dump of a structure array associated with the sbitmap_queue. Signed-off-by: Sergey Samoylenko <s.samoylenko(a)yadro.com&gt; --- Makefile | 7 +- defs.h | 2 + global_data.c | 1 + help.c | 89 ++++++++ sbitmap.c | 591 ++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 688 insertions(+), 2 deletions(-) create mode 100644 sbitmap.c diff --git a/Makefile b/Makefile index ece1306..c116177 100644 --- a/Makefile +++ b/Makefile @@ -72,7 +72,7 @@ CFILES=main.c tools.c global_data.c memory.c filesys.c help.c task.c \ xen_hyper.c xen_hyper_command.c xen_hyper_global_data.c \ xen_hyper_dump_tables.c kvmdump.c qemu.c qemu-load.c sadump.c ipcs.c \ ramdump.c vmware_vmss.c vmware_guestdump.c \ - xen_dom0.c kaslr_helper.c + xen_dom0.c kaslr_helper.c sbitmap.c SOURCE_FILES=${CFILES} ${GENERIC_HFILES} ${MCORE_HFILES} \ ${REDHAT_CFILES} ${REDHAT_HFILES} ${UNWIND_HFILES} \ @@ -92,7 +92,7 @@ OBJECT_FILES=main.o tools.o global_data.o memory.o filesys.o help.o task.o \ xen_hyper.o xen_hyper_command.o xen_hyper_global_data.o \ xen_hyper_dump_tables.o kvmdump.o qemu.o qemu-load.o sadump.o ipcs.o \ ramdump.o vmware_vmss.o vmware_guestdump.o \ - xen_dom0.o kaslr_helper.o + xen_dom0.o kaslr_helper.o sbitmap.o MEMORY_DRIVER_FILES=memory_driver/Makefile memory_driver/crash.c memory_driver/README @@ -346,6 +346,9 @@ cmdline.o: ${GENERIC_HFILES} cmdline.c tools.o: ${GENERIC_HFILES} tools.c ${CC} -c ${CRASH_CFLAGS} tools.c ${WARNING_OPTIONS} ${WARNING_ERROR} +sbitmap.o: ${GENERIC_HFILES} sbitmap.c + ${CC} -c ${CRASH_CFLAGS} sbitmap.c ${WARNING_OPTIONS} ${WARNING_ERROR} + global_data.o: ${GENERIC_HFILES} global_data.c ${CC} -c ${CRASH_CFLAGS} global_data.c ${WARNING_OPTIONS} ${WARNING_ERROR} diff --git a/defs.h b/defs.h index eb1c71b..1fa5c21 100644 --- a/defs.h +++ b/defs.h @@ -4956,6 +4956,7 @@ void cmd_mach(void); /* main.c */ void cmd_help(void); /* help.c */ void cmd_test(void); /* test.c */ void cmd_ascii(void); /* tools.c */ +void cmd_sbitmap(void); /* sbitmap.c */ void cmd_bpf(void); /* bfp.c */ void cmd_set(void); /* tools.c */ void cmd_eval(void); /* tools.c */ @@ -5543,6 +5544,7 @@ void display_help_screen(char *); extern char *help_pointer[]; extern char *help_alias[]; extern char *help_ascii[]; +extern char *help_sbitmap[]; extern char *help_bpf[]; extern char *help_bt[]; extern char *help_btop[]; diff --git a/global_data.c b/global_data.c index a316d1c..55524e3 100644 --- a/global_data.c +++ b/global_data.c @@ -105,6 +105,7 @@ struct command_table_entry linux_command_table[] = { {"rd", cmd_rd, help_rd, MINIMAL}, {"repeat", cmd_repeat, help_repeat, 0}, {"runq", cmd_runq, help_runq, REFRESH_TASK_TABLE}, + {"sbitmap", cmd_sbitmap, help_sbitmap, 0}, {"search", cmd_search, help_search, 0}, {"set", cmd_set, help_set, REFRESH_TASK_TABLE | MINIMAL}, {"sig", cmd_sig, help_sig, REFRESH_TASK_TABLE}, diff --git a/help.c b/help.c index 6c262a3..b946745 100644 --- a/help.c +++ b/help.c @@ -967,6 +967,95 @@ char *help_ascii[] = { NULL }; +char *help_sbitmap[] = { +"sbitmap", +"sbitmap_queue struct contents", +"[-s struct[.member[,member]] -p address [-v]] address", +" This command dumps the contents of the sbitmap_queue structure and", +" the used bits in the bitmap. Also, it shows the dump of a structure", +" array associated with the sbitmap_queue.", +"", +" The arguments are as follows:", +"", +" -s struct - name of a C-code structure, that is stored in an array", +" sssociated with sbitmap_queue structure. Use the", +" \"struct.member\" format in order to display a particular", +" member of the structure. -s option requires -p option", +"", +" -p address - address of a structure array associated with sbitmap_queue", +" structure. The set bits in sbitmap are used for the index", +" in an associated array.", +"", +" -x - override default output format with hexadecimal format.", +"", +" -d - override default output format with decimal format.", +"", +" -v - By default, the sbitmap command shows only a used sbitmap", +" index and a structure address in the associated array.", +" This flag says to print of a formatted display of the", +" contents of a structure in an associated array. -v option", +" requires of -s.", +"", +"EXAMPLES", +"", +" Display the common sbitmap information:", +"", +" %s> sbitmap ffffffffc06b9420", +" depth = 256", +" busy = 15", +" cleared = 1", +" bits_per_word = 64", +" map_nr = 4", +" alloc_hint = {193, 78}", +" wake_batch = 8", +" wake_index = 0", +" ws_active = 0", +" ws = {", +" { .wait_cnt = 8, .wait = inactive },", +" { .wait_cnt = 8, .wait = inactive },", +" { .wait_cnt = 8, .wait = inactive },", +" { .wait_cnt = 8, .wait = inactive },", +" { .wait_cnt = 8, .wait = inactive },", +" { .wait_cnt = 8, .wait = inactive },", +" { .wait_cnt = 8, .wait = inactive },", +" { .wait_cnt = 8, .wait = inactive },", +" }", +" round_robin = 0", +" min_shallow_depth = 4294967295", +"", +" 00000000: 0000 0000 0000 0000 ffbf 0000 0000 0000", +" 00000010: 0000 0000 0000 0000 0000 0000 0000 0000", +"", +" Display the structure address is associated with sbitmap_queue:", +"", +" %s> sbitmap -s test_data -p ffff973422dac000 ffffffffc06b9420", +" 64: 0xffff973422dac200", +" 65: 0xffff973422dac208", +" 66: 0xffff973422dac210", +" ...", +"", +" Display a formatted content of a structures:", +"", +" %s> sbitmap -s test_data -p ffff973422dac000 -v ffffffffc06b9420", +" 64 (0xffff973422dac200):", +" struct test_data {", +" tag = 64,", +" cpu = 1", +" }", +" 65 (0xffff973422dac208):", +" struct test_data {", +" tag = 65,", +" cpu = 1", +" }", +" 66 (0xffff973422dac210):", +" struct test_data {", +" tag = 66,", +" cpu = 1", +" }", +" ...", +NULL +}; + char *help_quit[] = { "quit", "exit this session", diff --git a/sbitmap.c b/sbitmap.c new file mode 100644 index 0000000..71522f8 --- /dev/null +++ b/sbitmap.c @@ -0,0 +1,591 @@ +/* sbitmap.c - core analysis suite + * + * Copyright (C) 1999, 2000, 2001, 2002 Mission Critical Linux, Inc. + * Copyright (C) 2002-2020 David Anderson + * Copyright (C) 2002-2020 Red Hat, Inc. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include "defs.h" +#include <stdbool.h> + +#define SBQ_WAIT_QUEUES 8 + +static inline unsigned int __const_hweight8(unsigned long w) +{ + return + (!!((w) & (1ULL << 0))) + + (!!((w) & (1ULL << 1))) + + (!!((w) & (1ULL << 2))) + + (!!((w) & (1ULL << 3))) + + (!!((w) & (1ULL << 4))) + + (!!((w) & (1ULL << 5))) + + (!!((w) & (1ULL << 6))) + + (!!((w) & (1ULL << 7))); +} + +#define __const_hweight16(w) (__const_hweight8(w) + __const_hweight8((w) >> 8)) +#define __const_hweight32(w) (__const_hweight16(w) + __const_hweight16((w) >> 16)) +#define __const_hweight64(w) (__const_hweight32(w) + __const_hweight32((w) >> 32)) + +#define hweight32(w) __const_hweight32(w) +#define hweight64(w) __const_hweight64(w) + +#define BIT(nr) (1UL << (nr)) + +/* sbitmap and sbitmap_word structs context */ +struct sbitmap_context { + unsigned sb_depth; + unsigned sb_shift; + unsigned sb_map_nr; + ulong sb_map_addr; + unsigned sb_map_size; + + int w_depth_off; + int w_word_off; + int w_cleared_off; +}; + +/* sbitmap_queue struct context */ +struct sbitmap_queue_context { + ulong sb_addr; + ulong alloc_hint; + unsigned int wake_batch; + int wake_index; + ulong ws_addr; + int ws_active; + bool round_robin; + unsigned int min_shallow_depth; + +}; + +struct sbitmap_data { +#define SD_FLAG_STRUCT_NAME (VERBOSE << 1) +#define SD_FLAG_STRUCT_ADDR (VERBOSE << 2) +#define SD_FLAG_STRUCT_MEMBER (VERBOSE << 3) + ulong flags; + int radix; + /* sbitmap_queue info */ + ulong addr; + /* data array info */ + char *data_name; + ulong data_addr; + + struct sbitmap_queue_context sqc; + struct sbitmap_context sc; +}; + +static inline unsigned long min(unsigned long a, unsigned long b) +{ + return (a < b) ? a : b; +} + +static void __readmem(ulong addr, void *buffer, size_t size) +{ + ulong flag = FAULT_ON_ERROR; + + if (!readmem(addr, KVADDR, buffer, size, "__readmem", flag)) + error(FATAL, "failed read memory: 0x%x\n", addr); +} + +static ulong __read_ulong(ulong addr) +{ + ulong value; + + __readmem(addr, &value, sizeof(value)); + return value; +} + +static long __struct_size(char *name) +{ + long size; + + size = STRUCT_SIZE(name); + if (size < 0) + error(FATAL, "Invalid struct size: %s\n", name); + + return size; +} + +static long __member_offset(char *name, char *member) +{ + long offset; + + offset = MEMBER_OFFSET(name, member); + if (offset == INVALID_OFFSET) + offset = ANON_MEMBER_OFFSET(name, member); + if (offset == INVALID_OFFSET) + error(FATAL, "Can't get offset of '%s.%s'\n", name, member); + + return offset; +} + +static unsigned long __last_word_mask(unsigned long nbits) +{ + return ~0UL >> (-(nbits) & (BITS_PER_LONG - 1)); +} + +static unsigned long bitmap_hweight_long(unsigned long w) +{ + return sizeof(w) == 4 ? hweight32(w) : hweight64(w); +} + +static unsigned long bitmap_weight(unsigned long bitmap, unsigned int bits) +{ + unsigned long w = 0; + + w += bitmap_hweight_long(bitmap); + if (bits % BITS_PER_LONG) + w += bitmap_hweight_long(bitmap & __last_word_mask(bits)); + + return w; +} + +static unsigned int __sbitmap_weight(const struct sbitmap_context *sc, bool set) +{ + unsigned int weight = 0; + ulong addr = sc->sb_map_addr; + unsigned long depth, word, cleared; + int i; + + for (i = 0; i < sc->sb_map_nr; i++) { + depth = __read_ulong(addr + sc->w_depth_off); + + if (set) { + word = __read_ulong(addr + sc->w_word_off); + weight += bitmap_weight(word, depth); + } else { + cleared = __read_ulong(addr + sc->w_cleared_off); + weight += bitmap_weight(cleared, depth); + } + + addr += sc->sb_map_size; + } + + return weight; +} + +static unsigned int sbitmap_weight(const struct sbitmap_context *sc) +{ + return __sbitmap_weight(sc, true); +} + +static unsigned int sbitmap_cleared(const struct sbitmap_context *sc) +{ + return __sbitmap_weight(sc, false); +} + +static void sbitmap_queue_show(const struct sbitmap_queue_context *sqc, + const struct sbitmap_context *sc) +{ + int cpus = get_cpus_possible(); + int sbq_wait_state_size, wait_cnt_off, wait_off, list_head_off; + bool first; + int i; + + fprintf(fp, "depth = %u\n", sc->sb_depth); + fprintf(fp, "busy = %u\n", sbitmap_weight(sc) - sbitmap_cleared(sc)); + fprintf(fp, "cleared = %u\n", sbitmap_cleared(sc)); + fprintf(fp, "bits_per_word = %u\n", 1U << sc->sb_shift); + fprintf(fp, "map_nr = %u\n", sc->sb_map_nr); + + fputs("alloc_hint = {", fp); + first = true; + for (i = 0; i < cpus; i++) { + if (!first) + fprintf(fp, ", "); + first = false; + + ulong ptr = kt->__per_cpu_offset[i] + sqc->alloc_hint; + fprintf(fp, "%lu", __read_ulong(ptr)); + } + fputs("}\n", fp); + + fprintf(fp, "wake_batch = %u\n", sqc->wake_batch); + fprintf(fp, "wake_index = %d\n", sqc->wake_index); + fprintf(fp, "ws_active = %d\n", sqc->ws_active); + + sbq_wait_state_size = __struct_size("sbq_wait_state"); + wait_cnt_off = __member_offset("sbq_wait_state", "wait_cnt"); + wait_off = __member_offset("sbq_wait_state", "wait"); + list_head_off = __member_offset("wait_queue_head", "head"); + + fputs("ws = {\n", fp); + for (i = 0; i < SBQ_WAIT_QUEUES; i++) { + ulong ws_addr = sqc->ws_addr + (sbq_wait_state_size * i); + struct kernel_list_head lh; + ulong wait_cnt_addr, list_head_addr; + ulong wait_cnt; + + wait_cnt_addr = ws_addr + wait_cnt_off; + __readmem(wait_cnt_addr, &wait_cnt, sizeof(wait_cnt)); + + list_head_addr = ws_addr + wait_off + list_head_off; + __readmem(list_head_addr, &lh, sizeof(lh)); + + fprintf(fp, "\t{ .wait_cnt = %lu, .wait = %s },\n", + wait_cnt, (lh.next == lh.prev) ? "inactive" : "active"); + } + fputs("}\n", fp); + + fprintf(fp, "round_robin = %d\n", sqc->round_robin); + fprintf(fp, "min_shallow_depth = %u\n", sqc->min_shallow_depth); +} + +static void sbitmap_emit_byte(unsigned int offset, uint8_t byte) +{ + if ((offset &0xf) == 0) { + if (offset != 0) + fputc('\n', fp); + fprintf(fp, "%08x:", offset); + } + if ((offset & 0x1) == 0) + fputc(' ', fp); + fprintf(fp, "%02x", byte); +} + +static void sbitmap_bitmap_show(const struct sbitmap_context *sc) +{ + uint8_t byte = 0; + unsigned int byte_bits = 0; + unsigned int offset = 0; + int i; + + for (i = 0; i < sc->sb_map_nr; i++) { + ulong addr = sc->sb_map_addr + (sc->sb_map_size * i); + unsigned long word = __read_ulong(addr + sc->w_word_off); + unsigned long cleared = __read_ulong(addr + sc->w_cleared_off); + unsigned long word_bits = __read_ulong(addr + sc->w_depth_off); + + word &= ~cleared; + + while (word_bits > 0) { + unsigned int bits = min(8 - byte_bits, word_bits); + + byte |= (word & (BIT(bits) - 1)) << byte_bits; + byte_bits += bits; + if (byte_bits == 8) { + sbitmap_emit_byte(offset, byte); + byte = 0; + byte_bits = 0; + offset++; + } + word >>= bits; + word_bits -= bits; + } + + } + if (byte_bits) { + sbitmap_emit_byte(offset, byte); + offset++; + } + if (offset) + fputc('\n', fp); +} + +static void sbitmap_queue_dump(const struct sbitmap_data *sd) +{ + sbitmap_queue_show(&sd->sqc, &sd->sc); + fputc('\n', fp); + sbitmap_bitmap_show(&sd->sc); +} + +static unsigned long sbitmap_find_next_bit(unsigned long word, + unsigned long size, unsigned long offset) +{ + if (size > BITS_PER_LONG) + error(FATAL, "%s: word size isn't correct\n", __func__); + + for (; offset < size; offset++) + if (word & (1UL << offset)) + return offset; + + return size; +} + +typedef bool (*sb_for_each_fn)(unsigned int, void *); + +static void __sbitmap_for_each_set(const struct sbitmap_context *sc, + unsigned int start, sb_for_each_fn fn, void *data) +{ + unsigned int index; + unsigned int nr; + unsigned int scanned = 0; + + if (start >= sc->sb_map_nr) + start = 0; + + index = start >> sc->sb_shift; + nr = start & ((1U << sc->sb_shift) - 1U); + + while (scanned < sc->sb_depth) { + unsigned long w_addr = sc->sb_map_addr + (sc->sb_map_size * index); + + unsigned long w_depth = __read_ulong(w_addr + sc->w_depth_off); + unsigned long w_word = __read_ulong(w_addr + sc->w_word_off); + unsigned long w_cleared = __read_ulong(w_addr + sc->w_cleared_off); + + unsigned long word; + unsigned int depth = min(w_depth - nr, sc->sb_depth - scanned); + + scanned += depth; + word = w_word & ~w_cleared; + if (!word) + goto next; + + /* + * On the first iteration of the outer loop, we need to add the + * bit offset back to the size of the word for find_next_bit(). + * On all other iterations, nr is zero, so this is a noop. + */ + depth += nr; + while (1) { + nr = sbitmap_find_next_bit(word, depth, nr); + if (nr >= depth) + break; + if (!fn((index << sc->sb_shift) + nr, data)) + return; + + nr++; + } +next: + nr = 0; + if (++index >= sc->sb_map_nr) + index = 0; + } +} + +static void sbitmap_for_each_set(const struct sbitmap_context *sc, + sb_for_each_fn fn, void *data) +{ + __sbitmap_for_each_set(sc, 0, fn, data); +} + +static void sbitmap_dump_struct_members(const char *s, ulong addr, unsigned radix) +{ + int i, argc; + char *p1, *p2; + char *structname, *members; + char *arglist[MAXARGS]; + + structname = GETBUF(strlen(s) + 1); + members = GETBUF(strlen(s) + 1); + + strcpy(structname, s); + p1 = strstr(structname, ".") + 1; + + p2 = strstr(s, ".") + 1; + strcpy(members, p2); + replace_string(members, ",", ' '); + argc = parse_line(members, arglist); + + for (i = 0; i < argc; i++) { + *p1 = NULLCHAR; + strcat(structname, arglist[i]); + dump_struct_member(structname, addr, radix); + } + + FREEBUF(structname); + FREEBUF(members); +} + +struct data_info { + ulong addr; + int size; + char *name; + unsigned radix; + bool verbose; + bool members; +}; + +static bool sbitmap_data_print(unsigned int idx, void *data) +{ + const struct data_info *d = data; + ulong addr = d->addr + (d->size * idx); + + if (d->verbose) { + fprintf(fp, "%d (0x%08lx):\n", idx, addr); + if (d->members) + sbitmap_dump_struct_members(d->name, addr, d->radix); + else + dump_struct(d->name, addr, d->radix); + } else + fprintf(fp, "%d: 0x%08lx\n", idx, addr); + + return true; +} + +static char *__get_struct_name(const char *s) +{ + char *name, *p; + + name = GETBUF(strlen(s) + 1); + strcpy(name, s); + + p = strstr(name, "."); + *p = NULLCHAR; + + return name; +} + +static void sbitmap_data_dump(const struct sbitmap_data *sd) +{ + struct data_info d = {0}; + + d.addr = sd->data_addr; + d.name = sd->data_name; + d.radix = sd->radix; + d.verbose = !!(sd->flags & VERBOSE); + d.members = !!(sd->flags & SD_FLAG_STRUCT_MEMBER); + + if (d.members) { + char *name = __get_struct_name(d.name); + d.size = __struct_size(name); + FREEBUF(name); + } else + d.size = __struct_size(d.name); + + sbitmap_for_each_set(&sd->sc, sbitmap_data_print, &d); +} + +static void load_sbitmap_queue_context(ulong addr, struct sbitmap_queue_context *sqc) +{ + char *sb_q = "sbitmap_queue"; + + sqc->sb_addr = addr + __member_offset(sb_q, "sb"); + __readmem(addr + __member_offset(sb_q, "alloc_hint"), &sqc->alloc_hint, sizeof(sqc->alloc_hint)); + __readmem(addr + __member_offset(sb_q, "wake_batch"), &sqc->wake_batch, sizeof(sqc->wake_batch)); + __readmem(addr + __member_offset(sb_q, "wake_index"), &sqc->wake_index, sizeof(sqc->wake_index)); + __readmem(addr + __member_offset(sb_q, "ws"), &sqc->ws_addr, sizeof(sqc->ws_addr)); + __readmem(addr + __member_offset(sb_q, "ws_active"), &sqc->ws_active, sizeof(sqc->ws_active)); + __readmem(addr + __member_offset(sb_q, "round_robin"), &sqc->round_robin, sizeof(sqc->round_robin)); + __readmem(addr + __member_offset(sb_q, "min_shallow_depth"), &sqc->min_shallow_depth, sizeof(sqc->min_shallow_depth)); +} + +static void load_sbitmap_context(ulong addr, struct sbitmap_context *sc) +{ + char *sb = "sbitmap"; + char *map = "sbitmap_word"; + + __readmem(addr + __member_offset(sb, "depth"), &sc->sb_depth, sizeof(sc->sb_depth)); + __readmem(addr + __member_offset(sb, "shift"), &sc->sb_shift, sizeof(sc->sb_shift)); + __readmem(addr + __member_offset(sb, "map_nr"), &sc->sb_map_nr, sizeof(sc->sb_map_nr)); + __readmem(addr + __member_offset(sb, "map"), &sc->sb_map_addr, sizeof(sc->sb_map_addr)); + sc->sb_map_size = __struct_size(map); + sc->w_depth_off = __member_offset(map, "depth"); + sc->w_word_off = __member_offset(map, "word"); + sc->w_cleared_off = __member_offset(map, "cleared"); +} + +void cmd_sbitmap(void) +{ + struct sbitmap_data sd = {0}; + int c; + + while ((c = getopt(argcnt, args, "s:p:xdv")) != EOF) { + switch (c) { + case 's': + if (sd.flags & SD_FLAG_STRUCT_NAME) + error(FATAL, "-s option (%s) already entered\n", sd.data_name); + + sd.data_name = optarg; + sd.flags |= SD_FLAG_STRUCT_NAME; + + break; + + case 'p': + if (sd.flags & SD_FLAG_STRUCT_ADDR) + error(FATAL, "-m option (0x%lx) already entered\n", sd.data_addr); + else if (!IS_A_NUMBER(optarg)) + error(FATAL, "invalid -m option: %s\n", optarg); + + sd.data_addr = htol(optarg, FAULT_ON_ERROR, NULL); + if (!IS_KVADDR(sd.data_addr)) + error(FATAL, "invalid kernel virtual address: %s\n", optarg); + sd.flags |= SD_FLAG_STRUCT_ADDR; + + break; + + case 'v': + sd.flags |= VERBOSE; + break; + + case 'x': + if (sd.radix == 10) + error(FATAL, "-d and -x are mutually exclusive\n"); + sd.radix = 16; + break; + + case 'd': + if (sd.radix == 16) + error(FATAL, "-d and -x are mutually exclusive\n"); + sd.radix = 10; + break; + + default: + argerrs++; + break; + } + } + + if (argerrs) + cmd_usage(pc->curcmd, SYNOPSIS); + + if (!args[optind]) { + error(INFO, "command argument is required\n"); + cmd_usage(pc->curcmd, SYNOPSIS); + } else if (args[optind] && args[optind + 1]) { + error(INFO, "too many arguments\n"); + cmd_usage(pc->curcmd, SYNOPSIS); + } else if (!IS_A_NUMBER(args[optind])) { + error(FATAL, "invalid command argument: %s\n", args[optind]); + } + + sd.addr = htol(args[optind], FAULT_ON_ERROR, NULL); + if (!IS_KVADDR(sd.addr)) + error(FATAL, "invalid kernel virtual address: %s\n", args[optind]); + + if ((sd.flags & SD_FLAG_STRUCT_NAME) && !(sd.flags & SD_FLAG_STRUCT_ADDR)) { + error(INFO, "-s option requires -m option"); + cmd_usage(pc->curcmd, SYNOPSIS); + } else if ((sd.flags & SD_FLAG_STRUCT_ADDR) && !(sd.flags & SD_FLAG_STRUCT_NAME)) { + error(FATAL, "-m option is used with -s option only\n"); + cmd_usage(pc->curcmd, SYNOPSIS); + } + + if (sd.flags & SD_FLAG_STRUCT_NAME) { + bool error_flag = false; + + if (count_chars(sd.data_name, '.') > 0) + sd.flags |= SD_FLAG_STRUCT_MEMBER; + + if (sd.flags & SD_FLAG_STRUCT_MEMBER) { + char *data_name = __get_struct_name(sd.data_name); + if (!STRUCT_EXISTS(data_name)) + error_flag = true; + FREEBUF(data_name); + } else { + if (!STRUCT_EXISTS(sd.data_name)) + error_flag = true; + } + if (error_flag) + error(FATAL, "invalid data structure reference: %s\n", sd.data_name); + } + + load_sbitmap_queue_context(sd.addr, &sd.sqc); + load_sbitmap_context(sd.sqc.sb_addr, &sd.sc); + + if (sd.flags & SD_FLAG_STRUCT_NAME) + sbitmap_data_dump(&sd); + else + sbitmap_queue_dump(&sd); +} -- 2.25.1