/* help.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"

static void reshuffle_cmdlist(void);
static int sort_command_name(const void *, const void *);
static void display_commands(void);
static void display_copying_info(void);
static void display_warranty_info(void);
static void display_output_info(void);
static void display_input_info(void);
static void display_README(void);
static char *gnu_public_license[];
static char *gnu_public_license_v3[];
static char *version_info[];
static char *output_info[];
static char *input_info[];
static char *README[];
static void dump_registers(void);

#define GPLv2 2
#define GPLv3 3

#if defined(GDB_5_3) || defined(GDB_6_0) || defined(GDB_6_1)
static int GPL_version = GPLv2;
#else
static int GPL_version = GPLv3;
#endif

static 
char *program_usage_info[] = {
    "",
    "USAGE:",
    "",
    "  crash [OPTION]... NAMELIST MEMORY-IMAGE[@ADDRESS]	(dumpfile form)",
    "  crash [OPTION]... [NAMELIST]             		(live system form)",
    "",
    "OPTIONS:",
    "",
    "  NAMELIST",
    "    This is a pathname to an uncompressed kernel image (a vmlinux",
    "    file), or a Xen hypervisor image (a xen-syms file) which has",
    "    been compiled with the \"-g\" option.  If using the dumpfile form,",
    "    a vmlinux file may be compressed in either gzip or bzip2 formats.",
    "",
    "  MEMORY-IMAGE",
    "    A kernel core dump file created by the netdump, diskdump, LKCD",
    "    kdump, xendump or kvmdump facilities.",
    "",
    "    If a MEMORY-IMAGE argument is not entered, the session will be",
    "    invoked on the live system, which typically requires root privileges",
    "    because of the device file used to access system RAM.  By default, ",
    "    /dev/crash will be used if it exists.  If it does not exist, then ",
    "    /dev/mem will be used; but if the kernel has been configured with ",
    "    CONFIG_STRICT_DEVMEM, then /proc/kcore will be used.  It is permissible",
    "    to explicitly enter /dev/crash, /dev/mem or /proc/kcore.",
    "",
    "    An @ADDRESS value must be appended to the MEMORY-IMAGE if the dumpfile",
    "    is a raw RAM dumpfile that has no header information describing the file",
    "    contents.  Multiple MEMORY-IMAGE@ADDRESS ordered pairs may be entered,",
    "    with each dumpfile containing a contiguous block of RAM, where the ADDRESS",
    "    value is the physical start address of the block expressed in hexadecimal.",
    "    The physical address value(s) will be used to create a temporary ELF header",
    "    in /var/tmp, which will only exist during the crash session.  If a raw RAM",
    "    dumpfile represents a live memory source, such as that specified by the QEMU",
    "    mem-path argument of a memory-backend-file object, then \"live:\" must be",
    "    prepended to the MEMORY-IMAGE name.",
    "",
    "  mapfile",
    "    If the NAMELIST file is not the same kernel that is running",
    "    (live system form), or the kernel that was running when the system",
    "    crashed (dumpfile form), then the System.map file of the original ",
    "    kernel should be entered on the command line.",
    "",
    "  -h [option]",
    "  --help [option]",
    "    Without an option argument, display a crash usage help message.",
    "    If the option argument is a crash command name, the help page",
    "    for that command is displayed.  If it is the string \"input\", a",
    "    page describing the various crash command line input options is",
    "    displayed.  If it is the string \"output\", a page describing command",
    "    line output options is displayed.  If it is the string \"all\", then",
    "    all of the possible help messages are displayed.  After the help",
    "    message is displayed, crash exits.",
    "",
    "  -s     ",
    "    Silently proceed directly to the \"crash>\" prompt without displaying",
    "    any version, GPL, or crash initialization data during startup, and by",
    "    default, runtime command output is not passed to any scrolling command.",
    "",
    "  -i file",
    "    Execute the command(s) contained in \"file\" prior to displaying ",
    "    the \"crash>\" prompt for interactive user input.",
    "",
    "  -d num ",
    "    Set the internal debug level.  The higher the number, the more",
    "    debugging data will be printed when crash initializes and runs.",
    "",
    "  -S     ",
    "    Use /boot/System.map as the mapfile.",
    "",
    "  -e  vi | emacs",
    "    Set the readline(3) command  line editing mode to \"vi\" or \"emacs\".  ",
    "    The default editing mode is \"vi\".",
    "",
    "  -f     ",
    "    Force the usage of a compressed vmlinux file if its original",
    "    name does not start with \"vmlinux\".",
    "",
    "  -k     ",
    "    Indicate that the NAMELIST file is an LKCD \"Kerntypes\" debuginfo file.",
    "",
    "  -g [namelist]",
    "    Determine if a vmlinux or xen-syms namelist file contains debugging data.",
    "",
    "  -t     ",
    "    Display the system-crash timestamp and exit.",
    "",
    "  -L     ",
    "    Attempt to lock all of its virtual address space into memory by",
    "    calling mlockall(MCL_CURRENT|MCL_FUTURE) during initialization.",
    "    If the system call fails, an error message will be displayed,",
    "    but the session continues.",
    "",
    "  -c tty-device",
    "    Open the tty-device as the console used for debug messages.",
    "",
    "  -p page-size",
    "    If a processor's page size cannot be determined by the dumpfile, ",
    "    and the processor default cannot be used, use page-size.",
    "",
    "  -o filename",
    "    Only used with the MEMORY-IMAGE@ADDRESS format for raw RAM dumpfiles,",
    "    specifies a filename of a new ELF vmcore that will be created and used", 
    "    as the dumpfile.  It will be saved to allow future use as a standalone", 
    "    vmcore, replacing the original raw RAM dumpfile.",
    "",
    "  -m option=value",
    "  --machdep option=value",
    "    Pass an option and value pair to machine-dependent code.  These",
    "    architecture-specific option/pairs should only be required in",
    "    very rare circumstances:",
    "",
    "    X86_64:",
    "      phys_base=<physical-address>",
    "      irq_eframe_link=<value>",
    "      irq_stack_gap=<value>",
    "      max_physmem_bits=<value>",
    "      kernel_image_size=<value>",
    "      vm=orig       (pre-2.6.11 virtual memory address ranges)",
    "      vm=2.6.11     (2.6.11 and later virtual memory address ranges)",
    "      vm=xen        (Xen kernel virtual memory address ranges)",
    "      vm=xen-rhel4  (RHEL4 Xen kernel virtual address ranges)",
    "      vm=5level     (5-level page tables)",
    "      page_offset=<PAGE_OFFSET-value>",
    "    PPC64:",
    "      vm=orig",
    "      vm=2.6.14     (4-level page tables)",
    "    IA64:",
    "      phys_start=<physical-address>",
    "      init_stack_size=<size>",
    "      vm=4l         (4-level page tables)",
    "    ARM:",
    "      phys_base=<physical-address>",
    "    ARM64:",
    "      phys_offset=<physical-address>",
    "      kimage_voffset=<kimage_voffset-value>",
    "      max_physmem_bits=<value>",
    "      vabits_actual=<value>",
    "    X86:",
    "      page_offset=<CONFIG_PAGE_OFFSET-value>",
    "",
    "  -x     ",
    "    Automatically load extension modules from a particular directory.",
    "    The directory is determined by the following order of precedence:",
    "",
    "    (1) the directory specified in the CRASH_EXTENSIONS shell ",
    "        environment variable",
    "    (2) /usr/lib64/crash/extensions  (64-bit  architectures)",
    "    (3) /usr/lib/crash/extensions  (32-bit architectures)",
    "    (4) the ./extensions subdirectory of the current directory",
    "",
    "  --active",
    "    Track only the active task on each cpu.",
    "",
    "  --buildinfo",
    "    Display the crash binary's build date, the user ID of the builder,",
    "    the hostname of the machine where the build was done, the target", 
    "    architecture, the version number, and the compiler version.",
    "",
    "  --memory_module modname",
    "    Use the modname as an alternative kernel module to the crash.ko",
    "    module that creates the /dev/crash device.",
    "",
    "  --memory_device device",
    "    Use device as an alternative device to the /dev/crash, /dev/mem",
    "    or /proc/kcore devices.",
    "",
    "  --log dumpfile",
    "    Dump the contents of the kernel log buffer.  A kernel namelist",
    "    argument is not necessary, but the dumpfile must contain the",
    "    VMCOREINFO data taken from the original /proc/vmcore ELF header.",
    "    Note: this option is deprecated and will no longer work for",
    "    kernel(>=v5.10).",
    "",
    "  --no_kallsyms",
    "    Do not use kallsyms-generated symbol information contained within",
    "    kernel module object files.",
    "",
    "  --no_modules",
    "    Do not access or display any kernel module related information.",
    "",
    "  --no_ikconfig",
    "    Do not attempt to read configuration data that was built into",
    "    kernels configured with CONFIG_IKCONFIG.",
    "",
    "  --no_data_debug",
    "    Do not verify the validity of all structure member offsets and",
    "    structure sizes that it uses.",
    "",
    "  --no_kmem_cache",
    "    Do not initialize the kernel's slab cache infrastructure, and",
    "    commands that use kmem_cache-related data will not work.",
    "",
    "  --no_elf_notes",
    "    Do not use the registers from the ELF NT_PRSTATUS notes saved",
    "    in a compressed kdump header for backtraces.",
    "",
    "  --kmem_cache_delay",
    "    Delay the initialization of the kernel's slab cache infrastructure",
    "    until it is required by a run-time command.",
    "",
    "  --readnow",
    "    Pass this flag to the embedded gdb module, which will override",
    "    the two-stage strategy that it uses for reading symbol tables",
    "    from the NAMELIST.  If module symbol tables are loaded during",
    "    runtime with the \"mod\" command, the same override will occur.",
    "",
    "  --smp  ",
    "    Specify that the system being analyzed is an SMP kernel.",
    "",
    "  -v",
    "  --version",
    "    Display the version of the crash utility, the version of the",
    "    embedded gdb module, GPL information, and copyright notices.",
    "",
    "  --cpus number",
    "    Specify the number of cpus in the SMP system being analyzed.",
    "",
    "  --osrelease dumpfile",
    "    Display the OSRELEASE vmcoreinfo string from a kdump dumpfile",
    "    header.",
    "",
    "  --hyper",
    "    Force the session to be that of a Xen hypervisor.",
    "",
    "  --p2m_mfn pfn",
    "    When a Xen Hypervisor or its dom0 kernel crashes, the dumpfile",
    "    is typically analyzed with either the Xen hypervisor or the dom0",
    "    kernel.  It is also possible to analyze any of the guest domU",
    "    kernels if the pfn_to_mfn_list_list pfn value of the guest kernel",
    "    is passed on the command line along with its NAMELIST and the ",
    "    dumpfile.",
    "",
    "  --xen_phys_start physical-address",
    "    Supply the base physical address of the Xen hypervisor's text",
    "    and static data for older xendump dumpfiles that did not pass",
    "    that information in the dumpfile header.",
    "",
    "  --zero_excluded",
    "    If the makedumpfile(8) facility has filtered a compressed kdump",
    "    dumpfile to exclude various types of non-essential pages, or has",
    "    marked a compressed or ELF kdump dumpfile as incomplete due to",
    "    an ENOSPC or other error during its creation, any attempt to",
    "    read missing pages will fail.  With this flag, reads from any",
    "    of those pages will return zero-filled memory.",
    "",
    "  --no_panic",
    "    Do not attempt to find the task that was running when the kernel",
    "    crashed.  Set the initial context to that of the \"swapper\"  task",
    "    on cpu 0.",
    "",
    "  --more ",
    "    Use /bin/more as the command output scroller, overriding the",
    "    default of /usr/bin/less and any settings in either ./.crashrc",
    "    or $HOME/.crashrc.",
    "",
    "  --less ",
    "    Use /usr/bin/less as the command output scroller, overriding any",
    "    settings in either ./.crashrc or $HOME/.crashrc.",
    "",
    "  --CRASHPAGER",
    "    Use the output paging command defined in the CRASHPAGER shell",
    "    environment variable, overriding any settings in either ./.crashrc ",
    "    or $HOME/.crashrc.",
    "",
    "  --no_scroll",
    "    Do not pass run-time command output to any scrolling command.",
    "",
    "  --no_strip",
    "    Do not strip cloned kernel text symbol names.",
    "",
    "  --no_crashrc",
    "    Do not execute the commands in either $HOME/.crashrc or ./.crashrc.",
    "",
    "  --mod directory",
    "    When loading the debuginfo data of kernel modules with the \"mod -S\"",
    "    command, search for their object files in directory instead of in ",
    "    the standard location.",
    "",
    "  --src directory",
    "    Search for the kernel source code in directory instead of in the",
    "    standard location that is compiled into the debuginfo data.",
    "",
    "  --reloc size",
    "    When analyzing live x86 kernels configured with a CONFIG_PHYSICAL_START ",
    "    value that is larger than its CONFIG_PHYSICAL_ALIGN value, then it will",
    "    be necessary to enter a relocation size equal to the difference between",
    "    the two values.",
    "",
    "  --hash count",
    "    Set the number of internal hash queue heads used for list gathering",
    "    and verification.  The default count is 32768.",
    "",
    "  --kaslr offset | auto",
    "    If x86, x86_64, s390x or loongarch64 kernel was configured with",
    "    CONFIG_RANDOMIZE_BASE, the offset value is equal to the difference",
    "    between the symbol values compiled into the vmlinux file and their",
    "    relocated KASLR value.  If set to auto, the KASLR offset value will",
    "    be automatically calculated.",
    "",
    "  --minimal",
    "    Bring up a session that is restricted to the log, dis, rd, sym,",
    "    eval, set and exit commands.  This option may provide a way to",
    "    extract some minimal/quick information from a corrupted or truncated",
    "    dumpfile, or in situations where one of the several kernel subsystem ",
    "    initialization routines would abort the crash session.",
    "",
    "  --kvmhost [32|64]",
    "    When examining an x86 KVM guest dumpfile, this option specifies",
    "    that the KVM host that created the dumpfile was an x86 (32-bit)",
    "    or an x86_64 (64-bit) machine, overriding the automatically",
    "    determined value.",
    "",
    "  --kvmio <size>",
    "    override the automatically-calculated KVM guest I/O hole size.",
    "",
    "  --offline [show|hide]",
    "    Show or hide command output that is associated with offline cpus,",
    "    overriding any settings in either ./.crashrc or $HOME/.crashrc.",
    "",
    "FILES:",
    "",
    "  .crashrc",
    "    Initialization commands.  The file can be located in the user's",
    "    HOME directory and/or the current directory.  Commands found in",
    "    the .crashrc file in the HOME directory are executed before",
    "    those in the current directory's .crashrc file.",
    "",
    "ENVIRONMENT VARIABLES:",
    "",
    "  EDITOR ",
    "    Command input is read using readline(3).  If EDITOR is set to",
    "    emacs or vi then suitable keybindings are used.  If EDITOR is",
    "    not set, then vi is used.  This can be overridden by \"set vi\" or",
    "    \"set emacs\" commands located in a .crashrc file, or by entering",
    "    \"-e emacs\" on the crash command line.",
    "",
    "  CRASHPAGER",
    "    If CRASHPAGER is set, its value is used as the name of the program",
    "    to which command output will be sent.  If not, then command output",
    "    output is sent to \"/usr/bin/less -E -X\" by default.",
    "",
    "  CRASH_MODULE_PATH",
    "    Specifies an alternative directory tree to search for kernel",
    "    module object files.",
    "",
    "  CRASH_EXTENSIONS",
    "    Specifies a directory containing extension modules that will be",
    "    loaded automatically if the -x command line option is used.",
    "",
    NULL
};

void
program_usage(int form)
{
	if (form == SHORT_FORM) {
		fprintf(fp, "\nUsage:\n\n");
		fprintf(fp, "%s\n%s\n", program_usage_info[3], 
			program_usage_info[4]);
		fprintf(fp, "\nEnter \"%s -h\" for details.\n",
			pc->program_name);
		clean_exit(1);
	} else {
		FILE *scroll;
		char *scroll_command;
		char **p;

		if ((scroll_command = setup_scroll_command()) &&
		    (scroll = popen(scroll_command, "w")))
			fp = scroll;
		else
			scroll = NULL;

		for (p = program_usage_info; *p; p++) {
			fprintf(fp, *p, pc->program_name);
			fprintf(fp, "\n");
		}
		fflush(fp);

		if (scroll)
			pclose(scroll);

		clean_exit(0);
	}
}


/*
 *  Get an updated count of commands for subsequent help menu display,
 *  reshuffling the deck if this is the first time or if something's changed.
 */
void
help_init(void)
{
        struct command_table_entry *cp;
	struct extension_table *ext;

	for (pc->ncmds = 0, cp = pc->cmd_table; cp->name; cp++) {
		if (!(cp->flags & HIDDEN_COMMAND))
                	pc->ncmds++;
	}

        for (ext = extension_table; ext; ext = ext->next) {
		for (cp = ext->command_table; cp->name; cp++) {
			if (!(cp->flags & (CLEANUP|HIDDEN_COMMAND)))
				pc->ncmds++;
		}
	}

        if (!pc->cmdlist) {
		pc->cmdlistsz = pc->ncmds;        
        	if ((pc->cmdlist = (char **)
                	malloc(sizeof(char *) * pc->cmdlistsz)) == NULL)
                        	error(FATAL,
                                    	"cannot malloc command list space\n");
	} else if (pc->ncmds > pc->cmdlistsz) {
		pc->cmdlistsz = pc->ncmds;
		if ((pc->cmdlist = (char **)realloc(pc->cmdlist,
                	sizeof(char *) * pc->cmdlistsz)) == NULL)
				error(FATAL, 
					"cannot realloc command list space\n");
	}

	reshuffle_cmdlist();
}

/*
 *  If the command list is modified during runtime, re-shuffle the list
 *  for proper help menu display.
 */
static void
reshuffle_cmdlist(void)
{
	int i, cnt;
        struct command_table_entry *cp;
	struct extension_table *ext;

	for (i = 0; i < pc->cmdlistsz; i++) 
		pc->cmdlist[i] = NULL;

        for (cnt = 0, cp = pc->cmd_table; cp->name; cp++) {
		if (!(cp->flags & HIDDEN_COMMAND))
                	pc->cmdlist[cnt++] = cp->name;
	}

        for (ext = extension_table; ext; ext = ext->next) {
                for (cp = ext->command_table; cp->name; cp++) {
			if (!(cp->flags & (CLEANUP|HIDDEN_COMMAND)))
				pc->cmdlist[cnt++] = cp->name;
		}
        }

	if (cnt > pc->cmdlistsz)
		error(FATAL, "help table malfunction!\n");

        qsort((void *)pc->cmdlist, (size_t)cnt,
                sizeof(char *), sort_command_name);
}


/*
 *  The help list is in alphabetical order, with exception of the "q" command,
 *  which has historically always been the last command in the list.
 */

static int
sort_command_name(const void *name1, const void *name2)
{
	char **s1, **s2;

	s1 = (char **)name1;
	s2 = (char **)name2;

	if (STREQ(*s1, "q"))  
		return 1;

	return strcmp(*s1, *s2);
}


/*
 *  Get help for a command, to dump an internal table, or the GNU public
 *  license copying/warranty information.
 */
void
cmd_help(void)
{
	int c;
	int oflag;

	oflag = 0;

        while ((c = getopt(argcnt, args, 
	        "efNDdmM:ngcaBbHhkKsvVoptTzLOr")) != EOF) {
                switch(c)
                {
		case 'e':
			dump_extension_table(VERBOSE);
			return;

		case 'f':
			dump_filesys_table(VERBOSE);
			return;

		case 'n':
		case 'D':
			dumpfile_memory(DUMPFILE_MEM_DUMP);
			return;

		case 'd':
			dump_dev_table();
			return;

		case 'M':
			dump_machdep_table(stol(optarg, FAULT_ON_ERROR, NULL));
			return;
		case 'm':
			dump_machdep_table(0);
			return;

		case 'g':
			dump_gdb_data();
			return;

		case 'N':
			dump_net_table();
			return;

		case 'a':
			dump_alias_data();
			return;

		case 'b':
			dump_shared_bufs();
			return;

		case 'B':
			dump_build_data();
			return;

		case 'c':
			dump_numargs_cache();
			return;

		case 'H':
			dump_hash_table(VERBOSE);
			return;

		case 'h':
			dump_hash_table(!VERBOSE);
 			return;

		case 'k':
			dump_kernel_table(!VERBOSE);
			return;

		case 'K':
			dump_kernel_table(VERBOSE);
			return;

		case 's':
			dump_symbol_table();
			return;

		case 'V':
			dump_vm_table(VERBOSE);
			return;

		case 'v':
			dump_vm_table(!VERBOSE);
			return;

		case 'O':
			dump_offset_table(NULL, TRUE);
			return;

		case 'o':
			oflag = TRUE;
			break;

		case 'T':
			dump_task_table(VERBOSE);
			return;

		case 't':
			dump_task_table(!VERBOSE);
			return;

		case 'p':
			dump_program_context();
			return;

		case 'z':
			fprintf(fp, "help options:\n");
			fprintf(fp, " -a - alias data\n");
			fprintf(fp, " -b - shared buffer data\n");
			fprintf(fp, " -B - build data\n");
			fprintf(fp, " -c - numargs cache\n");
			fprintf(fp, " -d - device table\n");
			fprintf(fp, " -D - dumpfile contents/statistics\n");
			fprintf(fp, " -e - extension table data\n");
			fprintf(fp, " -f - filesys table\n");
			fprintf(fp, " -g - gdb data\n");
			fprintf(fp, " -h - hash_table data\n");
			fprintf(fp, " -H - hash_table data (verbose)\n");
			fprintf(fp, " -k - kernel_table\n");
			fprintf(fp, " -K - kernel_table (verbose)\n");
			fprintf(fp, " -L - LKCD page cache environment\n");
			fprintf(fp, " -M <num> machine specific\n");
			fprintf(fp, " -m - machdep_table\n");
			fprintf(fp, " -N - net_table\n");
			fprintf(fp, " -n - dumpfile contents/statistics\n");
			fprintf(fp, " -o - offset_table and size_table\n");
			fprintf(fp, " -p - program_context\n");
			fprintf(fp, " -r - dump registers from dumpfile header\n");
			fprintf(fp, " -s - symbol table data\n");
			fprintf(fp, " -t - task_table\n");
			fprintf(fp, " -T - task_table plus context_array\n");
			fprintf(fp, " -v - vm_table\n");
			fprintf(fp, " -V - vm_table (verbose)\n");
			fprintf(fp, " -z - help options\n");
			return;

		case 'L':
			dumpfile_memory(DUMPFILE_ENVIRONMENT);
			return;

		case 'r':
			dump_registers();
			return;

                default:  
			argerrs++;
                        break;
                }
        }

        if (argerrs)
                cmd_usage(pc->curcmd, COMPLETE_HELP);

	if (!args[optind]) {
		if (oflag) 
			dump_offset_table(NULL, FALSE);
		else 
			display_help_screen("");
		return;
	}

        do {
		if (oflag) 
			dump_offset_table(args[optind], FALSE);
		else	
        		cmd_usage(args[optind], COMPLETE_HELP|MUST_HELP);
		optind++;
        } while (args[optind]);
}

static void
dump_registers(void)
{
	if (pc->flags2 & QEMU_MEM_DUMP_ELF) {
		dump_registers_for_qemu_mem_dump();
		return;
	} else if (DISKDUMP_DUMPFILE()) {
		dump_registers_for_compressed_kdump();
		return;
	} else if (NETDUMP_DUMPFILE() || KDUMP_DUMPFILE()) {
		dump_registers_for_elf_dumpfiles();
		return;
	} else if (VMSS_DUMPFILE()) {
		dump_registers_for_vmss_dump();
		return;
	}

	error(FATAL, "-r option not supported on %s\n",
		ACTIVE() ? "a live system" : "this dumpfile type");
}

/*
 *  Format and display the help menu.
 */

void
display_help_screen(char *indent)
{
        int i, j, rows;
	char **namep;

	help_init();

	fprintf(fp, "\n%s", indent);

        rows = (pc->ncmds + (HELP_COLUMNS-1)) / HELP_COLUMNS;

        for (i = 0; i < rows; i++) {
                namep = &pc->cmdlist[i];
                for (j = 0; j < HELP_COLUMNS; j++) {
                        fprintf(fp,"%-15s", *namep);
                        namep += rows;
                        if ((namep - pc->cmdlist) >= pc->ncmds)
                                break;
                }
                fprintf(fp,"\n%s", indent);
        }

        fprintf(fp, "\n%s%s version: %-6s   gdb version: %s\n", indent,
		pc->program_name, pc->program_version, pc->gdb_version); 
	fprintf(fp,
		"%sFor help on any command above, enter \"help <command>\".\n",
		indent);
	fprintf(fp, "%sFor help on input options, enter \"help input\".\n",
		indent);
	fprintf(fp, "%sFor help on output options, enter \"help output\".\n",
		indent);
#ifdef NO_LONGER_TRUE
	fprintf(fp, "%sFor the most recent version: "
		    "http://www.missioncriticallinux.com/download\n\n", indent);
#else
	fprintf(fp, "\n");
#endif
}

/*
 *  Used for generating HTML pages, dump the commands in the order
 *  they would be seen on the help menu, i.e., from left-to-right, row-by-row.
 *  Line ends are signaled with a "BREAK" string.
 */
static void
display_commands(void)
{
        int i, j, rows;
	char **namep;

	help_init();
        rows = (pc->ncmds + (HELP_COLUMNS-1)) / HELP_COLUMNS;

        for (i = 0; i < rows; i++) {
                namep = &pc->cmdlist[i];
                for (j = 0; j < HELP_COLUMNS; j++) {
                        fprintf(fp,"%s\n", *namep);
                        namep += rows;
                        if ((namep - pc->cmdlist) >= pc->ncmds) {
                                fprintf(fp, "BREAK\n");
                                break;
                        }
                }
        }
}


/*
 *  Help data for a command must be formatted using the following template:
 
"command-name",
"command description line", 
"argument-usage line",
"description...",
"description...",
"description...",
NULL,
 
 *  The first line is concatenated with the second line, and will follow the
 *  help command's "NAME" header.
 *  The first and third lines will also be concatenated, and will follow the
 *  help command's "SYNOPSIS" header.  If the command has no arguments, enter
 *  a string consisting of a space, i.e., " ".
 *  The fourth and subsequent lines will follow the help command's "DESCRIPTION"
 *  header.
 *
 *  The program name can be referenced by using the %%s format.  The final
 *  entry in each command's help data string list must be a NULL.
 */


char *help_foreach[] = {
"foreach",
"display command data for multiple tasks in the system",
"[[pid | taskp | name | state | [kernel | user | gleader]] ...]\n"
"          command [flag] [argument]",
"  This command allows for an examination of various kernel data associated",
"  with any, or all, tasks in the system, without having to set the context",
"  to each targeted task.\n",
"      pid  perform the command(s) on this PID.",
"    taskp  perform the command(s) on task referenced by this hexadecimal", 
"           task_struct pointer.",
"     name  perform the command(s) on all tasks with this name.  If the",
"           task name can be confused with a foreach command name, then",
"           precede the name string with a \"\\\".  If the name string is",
"           enclosed within \"'\" characters, then the encompassed string",
"           must be a POSIX extended regular expression that will be used",
"           to match task names.",
"     user  perform the command(s) on all user (non-kernel) threads.",
"  gleader  perform the command(s) on all user (non-kernel) thread group leaders.",
"   kernel  perform the command(s) on all kernel threads.",
"   active  perform the command(s) on the active thread on each CPU.",
"    state  perform the command(s) on all tasks in the specified state, which",
"           may be one of: RU, IN, UN, ST, ZO, TR, SW, DE, WA, PA, ID or NE.\n",
"  If none of the task-identifying arguments above are entered, the command",
"  will be performed on all tasks.\n",
"  command  select one or more of the following commands to be run on the tasks",
"           selected, or on all tasks:\n",
"              bt  run the \"bt\" command  (optional flags: -r -t -l -e -R -f -F",
"                  -o -s -x -d)",
"              vm  run the \"vm\" command  (optional flags: -p -v -m -R -d -x)",
"            task  run the \"task\" command  (optional flags: -R -d -x)",
"           files  run the \"files\" command  (optional flag: -c -R)",
"             net  run the \"net\" command  (optional flags: -s -S -R -d -x)",
"             set  run the \"set\" command",
"              ps  run the \"ps\" command  (optional flags: -G -s -p -c -t -l -a",
"                  -g -r -y)",
"             sig  run the \"sig\" command (optional flag: -g)",
"            vtop  run the \"vtop\" command  (optional flags: -c -u -k)\n",
"     flag  Pass this optional flag to the command selected.",
" argument  Pass this argument to the command selected.",
" ",
"  A header containing the PID, task address, cpu and command name will be",
"  pre-pended before the command output for each selected task.  Consult the",
"  help page of each of the command types above for details.",
"\nEXAMPLES",
"  Display the stack traces for all tasks:\n",
"    %s> foreach bt",
"    PID: 4752   TASK: c7680000  CPU: 1   COMMAND: \"xterm\"",
"     #0 [c7681edc] schedule at c01135f6",
"        (void)",
"     #1 [c7681f34] schedule_timeout at c01131ff",
"        (24)",
"     #2 [c7681f64] do_select at c0132838",
"        (5, c7681fa4, c7681fa0)",
"     #3 [c7681fbc] sys_select at c0132dad",
"        (5, 8070300, 8070380, 0, 0)",
"     #4 [bffffb0c] system_call at c0109944",
"        EAX: 0000008e  EBX: 00000005  ECX: 08070300  EDX: 08070380 ",
"        DS:  002b      ESI: 00000000  ES:  002b      EDI: 00000000 ",
"        SS:  002b      ESP: bffffadc  EBP: bffffb0c ",
"        CS:  0023      EIP: 402259ee  ERR: 0000008e  EFLAGS: 00000246 ",
"    ",
"    PID: 557    TASK: c5600000  CPU: 0   COMMAND: \"nfsd\"",
"     #0 [c5601f38] schedule at c01135f6",
"        (void)",
"     #1 [c5601f90] schedule_timeout at c01131ff",
"        (c5600000)",
"     #2 [c5601fb8] svc_recv at c805363a",
"        (c0096f40, c5602800, 7fffffff, 100, c65c9f1c)",
"     #3 [c5601fec] (nfsd module) at c806e303",
"        (c5602800, c5602800, c0096f40, 6c6e0002, 50)",
"     #4 [c65c9f24] kernel_thread at c010834f",
"        (0, 0, ext2_file_inode_operations)",
"    ",
"    PID: 824    TASK: c7c84000  CPU: 0   COMMAND: \"mingetty\"",
"    ...\n",
"  Display the task_struct structure for each \"bash\" command:\n",
"    %s> foreach bash task",
"    ...\n",
"  Display the open files for all tasks:\n",
"    %s> foreach files",
"    ...\n",
"  Display the state of tasks whose name contains a match to \"event.*\":\n",
"    %s> foreach 'event.*' task -R state",
"    PID: 99     TASK: ffff8804750d5500  CPU: 0   COMMAND: \"events/0\"",
"      state = 1,",
"    ",
"    PID: 100    TASK: ffff8804750d4ac0  CPU: 1   COMMAND: \"events/1\"",
"      state = 1,",
"    ",
"    PID: 101    TASK: ffff8804750d4080  CPU: 2   COMMAND: \"events/2\"",
"      state = 1,",
"    ...\n",
"  Display the stack traces for all blocked (TASK_UNINTERRUPTIBLE) tasks:\n",
"    %s> foreach UN bt",
"    PID: 428    TASK: ffff880036b6c560  CPU: 1   COMMAND: \"jbd2/dm-1-8\"",
"     #0 [ffff880035779a70] __schedule at ffffffff815df272",
"     #1 [ffff880035779b08] schedule at ffffffff815dfacf",
"     #2 [ffff880035779b18] io_schedule at ffffffff815dfb7f",
"     #3 [ffff880035779b38] sleep_on_page at ffffffff81119a4e",
"     #4 [ffff880035779b48] __wait_on_bit at ffffffff815e039f",
"     #5 [ffff880035779b98] wait_on_page_bit at ffffffff81119bb8",
"     #6 [ffff880035779be8] filemap_fdatawait_range at ffffffff81119ccc",
"     #7 [ffff880035779cd8] filemap_fdatawait at ffffffff81119d8b",
"     #8 [ffff880035779ce8] jbd2_journal_commit_transaction at ffffffff8123a99c",
"     #9 [ffff880035779e58] kjournald2 at ffffffff8123ee7b",
"    #10 [ffff880035779ee8] kthread at ffffffff8108fb9c",
"    #11 [ffff880035779f48] kernel_thread_helper at ffffffff815ebaf4",
"    ...\n",
NULL
};

char *help_ascii[] = {
"ascii",
"translate a hexadecimal string to ASCII",
"value ...",
"  Translates 32-bit or 64-bit hexadecimal values to ASCII.  If no argument",
"  is entered, an ASCII chart is displayed.",
"\nEXAMPLES",
"  Translate the hexadecimal value of 0x62696c2f7273752f to ASCII:",
"\n    %s> ascii 62696c2f7273752f",
"    62696c2f7273752f: /usr/lib",
"\n  Display an ASCII chart:",
"\n    %s> ascii",
" ",  
"          0    1   2   3   4   5   6   7",
"        +-------------------------------",
"      0 | NUL DLE  SP  0   @   P   '   p",
"      1 | SOH DC1  !   1   A   Q   a   q",
"      2 | STX DC2  \"   2   B   R   b   r",
"      3 | ETX DC3  #   3   C   S   c   s",
"      4 | EOT DC4  $   4   D   T   d   t",
"      5 | ENQ NAK  \%   5   E   U   e   u",
"      6 | ACK SYN  &   6   F   V   f   v",
"      7 | BEL ETB  `   7   G   W   g   w",
"      8 |  BS CAN  (   8   H   X   h   x",
"      9 |  HT  EM  )   9   I   Y   i   y",
"      A |  LF SUB  *   :   J   Z   j   z",
"      B |  VT ESC  +   ;   K   [   k   {",
"      C |  FF  FS  ,   <   L   \\   l   |",
"      D |  CR  GS  _   =   M   ]   m   }",
"      E |  SO  RS  .   >   N   ^   n   ~",
"      F |  SI  US  /   ?   O   -   o  DEL",
NULL
};

char *help_sbitmapq[] = {
"sbitmapq",
"sbitmap_queue struct contents",
"[-s struct[.member[,member]] -a address [-p] [-v]] -[x|d] address",
"  The 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",
"              associated with sbitmap_queue structure. Use the",
"              \"struct.member\" format in order to display a particular",
"              member of the structure. -s option requires -a option",
"  -a 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.",
"          -p  associated with sbitmap_queue array contains the points of",
"              structure.",
"          -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 a formatted display of the",
"              contents of a structure in an associated array. -v option",
"              requires of -s.",
"",
"EXAMPLES",
"",
"  All examples are shown on the base of Linux Target system with iSCSI",
"  transport.",
"",
"  Display the common sbitmap information for target session:",
"",
"    %s> struct -oh se_session 0xc0000000e118c760 | grep sbitmap_queue",
"      [c0000000e118c808] struct sbitmap_queue sess_tag_pool;",
"    %s>",
"    %s> sbitmapq c0000000e118c808",
"    depth = 136",
"    busy = 4",
"    cleared = 26",
"    bits_per_word = 32",
"    map_nr = 5",
"    alloc_hint = {74, 36, 123, 101}",
"    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 0030 0000 0000 0000",
"    00000010: 00",
"",
"  Display the addresses of structure are associated with",
"  sbitmap_queue (for iscsi it is 'iscsi_cmd' structure):",
"",
"    %s> struct se_session 0xc0000000e118c760 | grep sess_cmd_map",
"      sess_cmd_map = 0xc0000000671c0000,",
"    %s>",
"    %s> sbitmapq -s iscsi_cmd -a 0xc0000000671c0000 c0000000e118c808",
"    76: 0xc0000000671d5600",
"    77: 0xc0000000671d5a80",
"",
"  Dump of formatted content of structures:",
"",
"    %s> sbitmapq -s iscsi_cmd -a 0xc0000000671c0000 -v c0000000e118c808",
"    76 (0xc0000000671d5600):",
"    struct iscsi_cmd {",
"      dataout_timer_flags = 0,",
"      dataout_timeout_retries = 0 '\\000',",
"      error_recovery_count = 0 '\\000',",
"      deferred_i_state = ISTATE_NO_STATE,",
"      i_state = ISTATE_SENT_STATUS,",
"      ...",
"      first_data_sg = 0xc0000000e306b080,",
"      first_data_sg_off = 0,",
"      kmapped_nents = 1,",
"      sense_reason = 0",
"    }",
"    77 (0xc0000000671d5a80):",
"    struct iscsi_cmd {",
"      dataout_timer_flags = 0,",
"      dataout_timeout_retries = 0 '\\000',",
"      error_recovery_count = 0 '\\000',",
"      deferred_i_state = ISTATE_NO_STATE,",
"      i_state = ISTATE_NEW_CMD,",
"      ...",
"      first_data_sg = 0x0,",
"      first_data_sg_off = 0,",
"      kmapped_nents = 0,",
"      sense_reason = 0",
"    }",
NULL
};

char *help_quit[] = {
"quit",
"exit this session",
" ",
"  Bail out of the current %s session.",
"\nNOTE",
"  This command is equivalent to the \"exit\" command.",
NULL
};

char *help_exit[] = {
"exit",
"exit this session",
" ",
"  Bail out of the current %s session.",
"\nNOTE",
"  This command is equivalent to the \"q\" command.",
NULL            
};

char *help_help[] = { 
"help",
"get help",
"[command | all] [-<option>]",
"  When entered with no argument, a list of all currently available %s",
"  commands is listed.  If a name of a %s command is entered, a man-like",
"  page for the command is displayed.  If \"all\" is entered, help pages",
"  for all commands will be displayed.  If neither of the above is entered,",
"  the argument string will be passed on to the gdb help command.",
" ",
"  A number of internal debug, statistical, and other dumpfile related",
"  data is available with the following options:",
" ",
"    -a - alias data",
"    -b - shared buffer data",
"    -B - build data",
"    -c - numargs cache",
"    -d - device table",
"    -D - dumpfile contents/statistics",
"    -e - extension table data",
"    -f - filesys table",
"    -g - gdb data",
"    -h - hash_table data",
"    -H - hash_table data (verbose)",
"    -k - kernel_table",
"    -K - kernel_table (verbose)",
"    -L - LKCD page cache environment",
"    -M <num> machine specific",
"    -m - machdep_table",
"    -N - net_table",
"    -n - dumpfile contents/statistics",
"    -o - offset_table and size_table",
"    -p - program_context",
"    -r - dump registers from dumpfile header",
"    -s - symbol table data",
"    -t - task_table",
"    -T - task_table plus context_array",
"    -v - vm_table",
"    -V - vm_table (verbose)",
"    -z - help options",
NULL               
};

char *help_set[] = {
"set",
"set a process context or internal %s variable",
"[[-a] [pid | taskp] | [-c cpu] | -p] | [%s_variable [setting]] | -v",
"  This command either sets a new context, or gets the current context for",
"  display.  The context can be set by the use of:\n",
"      pid  a process PID.",
"    taskp  a hexadecimal task_struct pointer.",
"       -a  sets the pid or task as the active task on its cpu (dumpfiles only).",
"   -c cpu  sets the context to the active task on a cpu (dumpfiles only).",
"       -p  sets the context to the panic task, or back to the %s task on",
"           a live system.",
"       -v  display the current state of internal %s variables.",
"",
"  If no argument is entered, the current context is displayed.  The context",
"  consists of the PID, the task pointer, the CPU, and task state.  The task",
"  state shows the bits found in both the task_struct state and exit_state",
"  fields.",
"  ",
"  This command may also be used to set internal %s variables.  If no value",
"  argument is entered, the current value of the %s variable is shown.  These",
"  are the %s variables, acceptable arguments, and purpose:\n",
"          scroll  on | off     controls output scrolling.",
"          scroll  less         /usr/bin/less as the output scrolling program.",
"          scroll  more         /bin/more as the output scrolling program.",
"          scroll  CRASHPAGER   use CRASHPAGER environment variable as the",
"                               output scrolling program.",
"           radix  10 | 16      sets output radix to 10 or 16.",
"         refresh  on | off     controls internal task list refresh.",
"       print_max  number       set maximum number of array elements to print.",
"     print_array  on | off     if on, set gdb's printing of arrays to \"pretty\"",
"                               format, with one line per element.",
"         console  device-name  sets debug console device.",
"           debug  number       sets %s debug level.",
"            core  on | off     if on, drops core when the next error message",
"                               is displayed.",
"            hash  on | off     controls internal list verification.",
"          silent  on | off     turns off initialization messages; turns off",
"                               %s prompt during input file execution. ",
"                               (scrolling is turned off if silent is on)",
"            edit  vi | emacs   set line editing mode (from .%src file only).",
"        namelist  filename     name of kernel (from .%src file only).",
"   zero_excluded  on | off     controls whether excluded pages, or pages that",
"                               are missing from an incomplete dumpfile, should", 
"                               return zero-filled memory when read.",
"       null-stop  on | off     if on, gdb's printing of character arrays will",
"                               stop at the first NULL encountered.", 
"             gdb  on | off     if on, the %s session will be run in a mode",
"                               where all commands will be passed directly to",
"                               gdb, and the command prompt will change to ",
"                               \"gdb>\"; when running in this mode, native %s",
"                               commands may be executed by preceding them with",
"                               the \"crash\" directive.",
"           scope  text-addr    sets the text scope for viewing the definition",
"                               of data structures; the \"text-addr\" argument",
"                               must be a kernel or module text address, which", 
"                               may be expressed symbolically or as a hexadecimal",
"                               value; set scope 0 to un-set.",
"         offline  show | hide  show or hide command output that is associated",
"                               with offline cpus.",
"         redzone  on | off     if on, CONFIG_SLUB object addresses displayed by",
"                               the kmem command will point to the SLAB_RED_ZONE",
"                               padding inserted at the beginning of the object.", 
"   error  default | redirect | filename   set the destination of error messages.",
"                               \"default\": error messages are always displayed",
"                                 on the console; if the output of a command is",
"                                 piped to an external command or redirected",
"                                 to a file, the error messages are also sent",
"                                 to the pipe or file.",
"                               \"redirect\": if the output of a command is piped",
"                                 to an external command or redirected to a file,",
"                                 error messages are only sent to the pipe or",
"                                 file; otherwise they are displayed on the",
"                                 console.",
"                               \"filename\": error messages are only sent to the",
"                                 specified filename; they are not displayed on",
"                                 the console and are not sent to a pipe or file.",
" ",
"  Internal variables may be set in four manners:\n",
"    1. entering the set command in $HOME/.%src.",
"    2. entering the set command in .%src in the current directory.",
"    3. executing an input file containing the set command.",
"    4. during runtime with this command.\n",
"  During initialization, $HOME/.%src is read first, followed by the",
"  .%src file in the current directory.  Set commands in the .%src file",
"  in the current directory override those in $HOME/.%src.  Set commands ",
"  entered with this command or by runtime input file override those",
"  defined in either .%src file.  Multiple set command arguments or argument",
"  pairs may be entered in one command line.",
"\nEXAMPLES",
"  Set the current context to task c2fe8000:\n",
"    %s> set c2fe8000",
"         PID: 15917",
"     COMMAND: \"bash\"",
"        TASK: c2fe8000  ",
"         CPU: 0",
"       STATE: TASK_INTERRUPTIBLE\n",
"  Set the context back to the panicking task:\n",
"    %s> set -p",
"         PID: 698",
"     COMMAND: \"gen12\"",
"        TASK: f9d78000",
"         CPU: 2",
"       STATE: TASK_RUNNING (PANIC)\n",
"  Turn off output scrolling:\n",
"    %s> set scroll off",
"    scroll: off (/usr/bin/less)",
" ",
"  Show the current state of %s internal variables:\n", 
"    %s> set -v",
"            scroll: on (/usr/bin/less)",
"             radix: 10 (decimal)",
"           refresh: on",
"         print_max: 256",
"       print_array: off",
"           console: /dev/pts/2",
"             debug: 0",
"              core: off",
"              hash: on",
"            silent: off",
"              edit: vi",
"          namelist: vmlinux",
"     zero_excluded: off",
"         null-stop: on",
"               gdb: off",
"             scope: (not set)",
"           offline: show",
"           redzone: on",
"             error: default",
" ",
"  Show the current context:\n",
"    %s> set",
"         PID: 1525",
"     COMMAND: \"bash\"",
"        TASK: c1ede000",
"         CPU: 0",
"       STATE: TASK_INTERRUPTIBLE\n",
NULL               
};

char *help_p[] = {
"p",
"print the value of an expression",
"[-x|-d][-u] [expression | symbol[:cpuspec]]",
"  This command passes its arguments on to gdb \"print\" command for evaluation.",
"",
"    expression  an expression to be evaluated.",
"        symbol  a kernel symbol.",
"      :cpuspec  CPU specification for a per-cpu symbol:",
"                  :             CPU of the currently selected task.",
"                  :a[ll]        all CPUs.",
"                  :#[-#][,...]  CPU list(s), e.g. \"1,3,5\", \"1-3\",",
"                                or \"1,3,5-7,10\".",
"            -x  override default output format with hexadecimal format.",
"            -d  override default output format with decimal format.",
"            -u  the expression evaluates to a user address reference.", 
"",
"  The default output format is decimal, but that can be changed at any time",
"  with the two built-in aliases \"hex\" and \"dec\".  Alternatively, there",
"  are two other built-in aliases, \"px\" and \"pd\", which force the command",
"  output to be displayed in hexadecimal or decimal, without changing the",
"  default mode. ",
"\nEXAMPLES",
"  Print the contents of jiffies:\n",
"    %s> p jiffies",
"    jiffies = $6 = 166532620",
"    %s> px jiffies",
"    jiffies = $7 = 0x9ed174b",
"    %s> pd jiffies",
"    jiffies = $8 = 166533160",
" ",
"  Print the contents of the vm_area_struct \"init_mm\":\n", 
"    %s> p init_mm",
"    init_mm = $5 = {",
"      mmap = 0xc022d540, ",
"      mmap_avl = 0x0, ",
"      mmap_cache = 0x0, ",
"      pgd = 0xc0101000, ",
"      count = {",
"        counter = 0x6",
"      }, ",
"      map_count = 0x1, ",
"      mmap_sem = {",
"        count = {",
"          counter = 0x1",
"        }, ",
"        waking = 0x0, ",
"        wait = 0x0",
"      }, ",
"      context = 0x0, ",
"      start_code = 0xc0000000, ",
"      end_code = 0xc022b4c8, ",
"      start_data = 0x0, ",
"      end_data = 0xc0250388, ",
"      start_brk = 0x0, ",
"      brk = 0xc02928d8, ",
"      start_stack = 0x0, ",
"      arg_start = 0x0, ",
"      arg_end = 0x0, ",
"      env_start = 0x0, ",
"      env_end = 0x0, ",
"      rss = 0x0, ",
"      total_vm = 0x0, ",
"      locked_vm = 0x0, ",
"      def_flags = 0x0, ",
"      cpu_vm_mask = 0x0, ",
"      swap_cnt = 0x0, ",
"      swap_address = 0x0, ",
"      segments = 0x0",
"    }",
"",
"  If a per-cpu symbol is entered as a argument, its data type",
"  and all of its per-cpu addresses are displayed:",
" ",
"    %s> p irq_stat",
"    PER-CPU DATA TYPE:",
"      irq_cpustat_t irq_stat;",
"    PER-CPU ADDRESSES:",
"      [0]: ffff88021e211540",
"      [1]: ffff88021e251540",
"      [2]: ffff88021e291540",
"      [3]: ffff88021e2d1540",
" ",
"  To display the contents a per-cpu symbol for CPU 1, append",
"  a cpu-specifier:",
" ",
"    %s> p irq_stat:1",
"    per_cpu(irq_stat, 1) = $29 = {",
"      __softirq_pending = 0, ",
"      __nmi_count = 209034, ",
"      apic_timer_irqs = 597509876, ",
"      irq_spurious_count = 0, ",
"      icr_read_retry_count = 2, ",
"      x86_platform_ipis = 0, ",
"      apic_perf_irqs = 209034, ",
"      apic_irq_work_irqs = 0, ",
"      irq_resched_count = 264922233, ",
"      irq_call_count = 7036692, ",
"      irq_tlb_count = 4750442, ",
"      irq_thermal_count = 0, ",
"      irq_threshold_count = 0",
"    }",
" ",
NULL               
};

char *help_ps[] = {
"ps",
"display process status information",
"[-k|-u|-G|-y policy] [-s] [-p|-c|-t|-[l|m][-C cpu]|-a|-g|-r|-S|-A|-H]\n     [pid | task | command] ...",
"  This command displays process status for selected, or all, processes" ,
"  in the system.  If no arguments are entered, the process data is",
"  is displayed for all processes.  Specific processes may be selected",
"  by using the following identifier formats:\n",
"       pid  a process PID.",
"      task  a hexadecimal task_struct pointer.",
"   command  a command name.  If a command name is made up of letters that",
"            are all numerical values, precede the name string with a \"\\\".",
"            If the command string is enclosed within \"'\" characters, then",
"            the encompassed string must be a POSIX extended regular expression",
"            that will be used to match task names.",
" ",
"  The process list may be further restricted by the following options:\n",
"        -k  restrict the output to only kernel threads.",
"        -u  restrict the output to only user tasks.",
"        -G  display only the thread group leader in a thread group.",
" -y policy  restrict the output to tasks having a specified scheduling policy",
"            expressed by its integer value or by its (case-insensitive) name;",
"            multiple policies may be entered in a comma-separated list:",
"              0 or NORMAL",
"              1 or FIFO",
"              2 or RR",
"              3 or BATCH",
"              4 or ISO",
"              5 or IDLE",
"              6 or DEADLINE",
" ",
"  The process identifier types may be mixed.  For each task, the following",
"  items are displayed:",
" ",
"    1. the process PID.",
"    2. the parent process PID.",
"    3. the CPU number that the task ran on last.",
"    4. the task_struct address or the kernel stack pointer of the process.",
"       (see -s option below)",
"    5. the task state (RU, IN, UN, ZO, ST, TR, DE, SW, WA, PA, ID, NE).",
"    6. the percentage of physical memory being used by this task.",
"    7. the virtual address size of this task in kilobytes.",
"    8. the resident set size of this task in kilobytes.",
"    9. the command name.",
" ",
"  The default output shows the task_struct address of each process under a",
"  column titled \"TASK\".  This can be changed to show the kernel stack ",
"  pointer under a column titled \"KSTACKP\".",
" ",
"       -s  replace the TASK column with the KSTACKP column.",
" ",
"  On SMP machines, the active task on each CPU will be highlighted by an",
"  angle bracket (\">\") preceding its information.  If the crash variable",
"  \"offline\" is set to \"hide\", the active task on an offline CPU will",
"  be highlighted by a \"-\" preceding its information.",
" ",
"  Alternatively, information regarding parent-child relationships,",
"  per-task time usage data, argument/environment data, thread groups,",
"  or resource limits may be displayed:",
" ",
"       -p  display the parental hierarchy of selected, or all, tasks.",  
"       -c  display the children of selected, or all, tasks.",
"       -t  display the task run time, start time, and cumulative user",
"           and system times.",
"       -l  display the task's last-run timestamp value, using either the",
"           task_struct's last_run value, the task_struct's timestamp value",
"           or the task_struct's sched_entity last_arrival value, whichever",
"           applies, of selected, or all, tasks; the list is sorted with the",
"           most recently-run task (with the largest timestamp) shown first,",
"           followed by the task's current state.",
"       -m  similar to -l, but the timestamp value is translated into days,",
"           hours, minutes, seconds, and milliseconds since the task was",
"           last run on a cpu.",
"  -C cpus  only usable with the -l or -m options, dump the timestamp data",
"           in per-cpu blocks, where the cpu[s] can be specified as \"1,3,5\",",
"           \"1-3\", \"1,3,5-7,10\", \"all\", or \"a\" (shortcut for \"all\").",
"       -a  display the command line arguments and environment strings of",
"           selected, or all, user-mode tasks.",
"       -g  display tasks by thread group, of selected, or all, tasks.",
"       -r  display resource limits (rlimits) of selected, or all, tasks.",
"       -S  display a summary consisting of the number of tasks in a task state.",
"       -A  display only the active task on each cpu.",
"       -H  display no header line.",
"\nEXAMPLES",
"  Show the process status of all current tasks:\n",
"    %s> ps",
"       PID    PPID  CPU   TASK    ST  %MEM   VSZ   RSS  COMM",
"    >     0      0   3  c024c000  RU   0.0     0     0  [swapper]",
"    >     0      0   0  c0dce000  RU   0.0     0     0  [swapper]",
"          0      0   1  c0fa8000  RU   0.0     0     0  [swapper]",
"    >     0      0   2  c009a000  RU   0.0     0     0  [swapper]",
"          1      0   1  c0098000  IN   0.0  1096   476  init",
"          2      1   1  c0090000  IN   0.0     0     0  [kflushd]",
"          3      1   1  c000e000  IN   0.0     0     0  [kpiod]",
"          4      1   3  c000c000  IN   0.0     0     0  [kswapd]",
"          5      1   1  c0008000  IN   0.0     0     0  [mdrecoveryd]",
"        253      1   2  fbc4c000  IN   0.0  1088   376  portmap",
"        268      1   2  fbc82000  IN   0.1  1232   504  ypbind",
"        274    268   2  fa984000  IN   0.1  1260   556  ypbind",
"        321      1   1  fabf6000  IN   0.1  1264   608  syslogd",
"        332      1   1  fa9be000  RU   0.1  1364   736  klogd",
"        346      1   2  fae88000  IN   0.0  1112   472  atd",
"        360      1   2  faeb2000  IN   0.1  1284   592  crond",
"        378      1   2  fafd6000  IN   0.1  1236   560  inetd",
"        392      1   0  fb710000  IN   0.1  2264  1468  named",
"        406      1   3  fb768000  IN   0.1  1284   560  lpd",
"        423      1   1  fb8ac000  IN   0.1  1128   528  rpc.statd",
"        434      1   2  fb75a000  IN   0.0  1072   376  rpc.rquotad",
"        445      1   2  fb4a4000  IN   0.0  1132   456  rpc.mountd",
"        460      1   1  fa938000  IN   0.0     0     0  [nfsd]",
"        461      1   1  faa86000  IN   0.0     0     0  [nfsd]",
"        462      1   0  fac48000  IN   0.0     0     0  [nfsd]",
"        463      1   0  fb4ca000  IN   0.0     0     0  [nfsd]",
"        464      1   0  fb4c8000  IN   0.0     0     0  [nfsd]",
"        465      1   2  fba6e000  IN   0.0     0     0  [nfsd]",
"        466      1   1  fba6c000  IN   0.0     0     0  [nfsd]",
"        467      1   2  fac04000  IN   0.0     0     0  [nfsd]",
"        468    461   2  fa93a000  IN   0.0     0     0  [lockd]",
"        469    468   2  fa93e000  IN   0.0     0     0  [rpciod]",
"        486      1   0  fab54000  IN   0.1  1596   880  amd",
"        523      1   2  fa84e000  IN   0.1  1884  1128  sendmail",
"        538      1   0  fa82c000  IN   0.0  1112   416  gpm",
"        552      1   3  fa70a000  IN   0.1  2384  1220  httpd",
"        556    552   3  fa776000  IN   0.1  2572  1352  httpd",
"        557    552   2  faba4000  IN   0.1  2572  1352  httpd",
"        558    552   1  fa802000  IN   0.1  2572  1352  httpd",
"        559    552   3  fa6ee000  IN   0.1  2572  1352  httpd",
"        560    552   3  fa700000  IN   0.1  2572  1352  httpd",
"        561    552   0  fa6f0000  IN   0.1  2572  1352  httpd",
"        562    552   3  fa6ea000  IN   0.1  2572  1352  httpd",
"        563    552   0  fa67c000  IN   0.1  2572  1352  httpd",
"        564    552   3  fa674000  IN   0.1  2572  1352  httpd",
"        565    552   3  fa66a000  IN   0.1  2572  1352  httpd",
"        582      1   2  fa402000  IN   0.2  2968  1916  xfs",
"        633      1   2  fa1ec000  IN   0.2  5512  2248  innd",
"        636      1   3  fa088000  IN   0.1  2536   804  actived",
"        676      1   0  fa840000  IN   0.0  1060   384  mingetty",
"        677      1   1  fa590000  IN   0.0  1060   384  mingetty",
"        678      1   2  fa3b8000  IN   0.0  1060   384  mingetty",
"        679      1   0  fa5b8000  IN   0.0  1060   384  mingetty",
"        680      1   1  fa3a4000  IN   0.0  1060   384  mingetty",
"        681      1   2  fa30a000  IN   0.0  1060   384  mingetty",
"        683      1   3  fa5d8000  IN   0.0  1052   280  update",
"        686    378   1  fa3aa000  IN   0.1  2320  1136  in.rlogind",
"        687    686   2  f9e52000  IN   0.1  2136  1000  login",
"        688    687   0  f9dec000  IN   0.1  1732   976  bash",
"    >   700    688   1  f9d62000  RU   0.0  1048   256  gen12",
" ",
"  Display the parental hierarchy of the \"%s\" process on a live system:\n",
"    %s> ps -p 4249",
"    PID: 0      TASK: c0252000  CPU: 0   COMMAND: \"swapper\"",
"     PID: 1      TASK: c009a000  CPU: 1   COMMAND: \"init\"",
"      PID: 632    TASK: c73b6000  CPU: 1   COMMAND: \"prefdm\"",
"       PID: 637    TASK: c5a4a000  CPU: 1   COMMAND: \"prefdm\"",
"        PID: 649    TASK: c179a000  CPU: 0   COMMAND: \"kwm\"",
"         PID: 683    TASK: c1164000  CPU: 0   COMMAND: \"kfm\"",
"          PID: 1186   TASK: c165a000  CPU: 0   COMMAND: \"xterm\"",
"           PID: 1188   TASK: c705e000  CPU: 1   COMMAND: \"bash\"",
"            PID: 4249   TASK: c6b9a000  CPU: 0   COMMAND: \"crash\"",
" ",
"  Display all children of the \"kwm\" window manager:\n",
"    %s> ps -c kwm",
"      PID: 649    TASK: c179a000  CPU: 0   COMMAND: \"kwm\"",
"      PID: 682    TASK: c2d58000  CPU: 1   COMMAND: \"kwmsound\"",
"      PID: 683    TASK: c1164000  CPU: 1   COMMAND: \"kfm\"",
"      PID: 685    TASK: c053c000  CPU: 0   COMMAND: \"krootwm\"",
"      PID: 686    TASK: c13fa000  CPU: 0   COMMAND: \"kpanel\"",
"      PID: 687    TASK: c13f0000  CPU: 1   COMMAND: \"kbgndwm\"",
" ",
"  Display all threads in a firefox session:\n",
"    %s> ps firefox",
"       PID    PPID  CPU       TASK        ST  %MEM     VSZ    RSS  COMM",
"      21273  21256   6  ffff81003ec15080  IN  46.3 1138276 484364  firefox",
"      21276  21256   6  ffff81003f49e7e0  IN  46.3 1138276 484364  firefox",
"      21280  21256   0  ffff81003ec1d7e0  IN  46.3 1138276 484364  firefox",
"      21286  21256   6  ffff81000b0d1820  IN  46.3 1138276 484364  firefox",
"      21287  21256   2  ffff81000b0d10c0  IN  46.3 1138276 484364  firefox",
"      26975  21256   5  ffff81003b5c1820  IN  46.3 1138276 484364  firefox",
"      26976  21256   5  ffff810023232820  IN  46.3 1138276 484364  firefox",
"      26977  21256   4  ffff810021a11820  IN  46.3 1138276 484364  firefox",
"      26978  21256   5  ffff810003159040  IN  46.3 1138276 484364  firefox",
"      26979  21256   5  ffff81003a058820  IN  46.3 1138276 484364  firefox",
" ",
"  Display only the thread group leader in the firefox session:\n",
"    %s> ps -G firefox",
"       PID    PPID  CPU       TASK        ST  %MEM     VSZ    RSS  COMM",
"      21273  21256   0  ffff81003ec15080  IN  46.3 1138276 484364  firefox",
" ",
"  Show the time usage data for pid 10318:\n",
"    %s> ps -t 10318",
"    PID: 10318  TASK: f7b85550  CPU: 5   COMMAND: \"bash\"",
"        RUN TIME: 1 days, 01:35:32",
"      START TIME: 5209",
"           UTIME: 95",
"           STIME: 57",
" ",
"  Show the process status of PID 1, task f9dec000, and all nfsd tasks:\n",
"    %s> ps 1 f9dec000 nfsd",
"       PID    PPID  CPU   TASK    ST  %MEM   VSZ   RSS  COMM",
"          1      0   1  c0098000  IN   0.0  1096   476  init",
"        688    687   0  f9dec000  IN   0.1  1732   976  bash",
"        460      1   1  fa938000  IN   0.0     0     0  [nfsd]",
"        461      1   1  faa86000  IN   0.0     0     0  [nfsd]",
"        462      1   0  fac48000  IN   0.0     0     0  [nfsd]",
"        463      1   0  fb4ca000  IN   0.0     0     0  [nfsd]",
"        464      1   0  fb4c8000  IN   0.0     0     0  [nfsd]",
"        465      1   2  fba6e000  IN   0.0     0     0  [nfsd]",
"        466      1   1  fba6c000  IN   0.0     0     0  [nfsd]",
"        467      1   2  fac04000  IN   0.0     0     0  [nfsd]",
" ",
"  Show all kernel threads:\n",
"    %s> ps -k",
"       PID    PPID  CPU   TASK    ST  %MEM   VSZ   RSS  COMM",
"          0      0   1  c0fac000  RU   0.0     0     0  [swapper]",
"          0      0   0  c0252000  RU   0.0     0     0  [swapper]",
"          2      1   1  c0fa0000  IN   0.0     0     0  [kflushd]",
"          3      1   1  c03de000  IN   0.0     0     0  [kpiod]",
"          4      1   1  c03dc000  IN   0.0     0     0  [kswapd]",
"          5      1   0  c0092000  IN   0.0     0     0  [mdrecoveryd]",
"        336      1   0  c4a9a000  IN   0.0     0     0  [rpciod]",
"        337      1   0  c4830000  IN   0.0     0     0  [lockd]",
"        487      1   1  c4ba6000  IN   0.0     0     0  [nfsd]",
"        488      1   0  c18c6000  IN   0.0     0     0  [nfsd]",
"        489      1   0  c0cac000  IN   0.0     0     0  [nfsd]",
"        490      1   0  c056a000  IN   0.0     0     0  [nfsd]",
"        491      1   0  c0860000  IN   0.0     0     0  [nfsd]",
"        492      1   1  c0254000  IN   0.0     0     0  [nfsd]",
"        493      1   0  c0a86000  IN   0.0     0     0  [nfsd]",
"        494      1   0  c0968000  IN   0.0     0     0  [nfsd]",
" ",
"  Display a summary consisting of the number of tasks in a task state:\n",
"    %s> ps -S",
"      RU: 5",
"      IN: 259",
"      UN: 31",
"      ZO: 1",
" ",
"  Display only the active task, on each cpu:\n",
"    %s> ps -A",
"        PID    PPID  CPU       TASK        ST  %MEM    VSZ    RSS  COMM",
"     >    10      2   1  ffff880212969710  IN   0.0      0      0   [migration/1]",
"     >     0      0   3  ffff884026d43520  RU   0.0      0      0   [swapper]",
"     >  6582      1   2  ffff880f49c52040  RU   0.0 42202472  33368  oracle",
"     >  9497      1   0  ffff880549ec2ab0  RU   0.0 42314692 138664  oracle",
" ",
"  Show all tasks sorted by their task_struct's last_run, timestamp, or", 
"  sched_entity last_arrival timestamp value, whichever applies:\n",
"    %s> ps -l",
"    [20811245123] [IN] PID: 37    TASK: f7153030  CPU: 2  COMMAND: \"events/2\"",
"    [20811229959] [IN] PID: 1756  TASK: f2a5a570  CPU: 2  COMMAND: \"ntpd\"",
"    [20800696644] [IN] PID: 1456  TASK: f2b1f030  CPU: 4  COMMAND: \"irqbalance\"",
"    [20617047229] [IN] PID: 2324  TASK: f57f9570  CPU: 5  COMMAND: \"flush-253:0\"",
"    [20617029209] [IN] PID: 49    TASK: f7167030  CPU: 4  COMMAND: \"bdi-default\"",
"    [20438025365] [IN] PID: 345   TASK: f55c7ab0  CPU: 3  COMMAND: \"mpt_poll_0\"",
"    [20103026046] [IN] PID: 728   TASK: f72ba570  CPU: 3  COMMAND: \"edac-poller\"",
"    [20000189409] [IN] PID: 35    TASK: f7153ab0  CPU: 0  COMMAND: \"events/0\"",
"    [20000179905] [IN] PID: 48    TASK: f7167570  CPU: 0  COMMAND: \"sync_supers\"",
"    [19997120354] [IN] PID: 36    TASK: f7153570  CPU: 1  COMMAND: \"events/1\"",
"    [19991059209] [IN] PID: 38    TASK: f715fab0  CPU: 3  COMMAND: \"events/3\"",
"    [19988091608] [IN] PID: 39    TASK: f715f570  CPU: 4  COMMAND: \"events/4\"",
"    [19985076530] [IN] PID: 40    TASK: f715f030  CPU: 5  COMMAND: \"events/5\"",
"    [19982019106] [IN] PID: 41    TASK: f7161ab0  CPU: 6  COMMAND: \"events/6\"",
"    [19982016294] [IN] PID: 29    TASK: f7109ab0  CPU: 6  COMMAND: \"ksoftirqd/6\"",
"    [19838402345] [RU] PID: 2331  TASK: f297f570  CPU: 7  COMMAND: \"bash\"",
"    [19837129436] [IN] PID: 2326  TASK: f2ad5030  CPU: 6  COMMAND: \"sshd\"",
"    [19289476417] [IN] PID: 1772  TASK: f5665570  CPU: 5  COMMAND: \"sendmail\"",
"    ...\n",
"  Show the most-recently run tasks on cpu 0 using both the -l and the -m",
"  options:\n",
"    %s> ps -m -C0",
"    CPU: 0",
"    [ 0 00:00:00.003] [RU] PID: 1205 TASK: dee03f20 CPU: 0 COMMAND: \"insmod\"",
"    [ 0 00:00:00.006] [RU] PID: 770  TASK: df9e9940 CPU: 0 COMMAND: \"rsyslogd\"",
"    [ 0 00:00:00.009] [IN] PID: 603  TASK: df9bcbc0 CPU: 0 COMMAND: \"udevd\"",
"    [ 0 00:00:00.010] [IN] PID: 348  TASK: df9ecbc0 CPU: 0 COMMAND: \"udevd\"",
"    [ 0 00:00:00.013] [IN] PID: 934  TASK: df9171a0 CPU: 0 COMMAND: \"hald\"",
"    [ 0 00:00:00.023] [IN] PID: 6    TASK: df443f20 CPU: 0 COMMAND: \"events/0\"",
"    [ 0 00:00:00.029] [IN] PID: 15   TASK: df46b280 CPU: 0 COMMAND: \"kblockd/0\"",
"    [ 0 00:00:00.101] [IN] PID: 1168 TASK: dee01940 CPU: 0 COMMAND: \"bash\"",
"    [ 0 00:00:01.404] [IN] PID: 272  TASK: dfa48ca0 CPU: 0 COMMAND: \"flush-8:0\"",
"    ...",
" ",
"    %s> ps -l -C0",
"    CPU: 0",
"    [137146164748] [RU] PID: 1205 TASK: dee03f20 CPU: 0 COMMAND: \"insmod\"",
"    [137142534372] [RU] PID: 770  TASK: df9e9940 CPU: 0 COMMAND: \"rsyslogd\"",
"    [137140168469] [IN] PID: 603  TASK: df9bcbc0 CPU: 0 COMMAND: \"udevd\"",
"    [137138826427] [IN] PID: 348  TASK: df9ecbc0 CPU: 0 COMMAND: \"udevd\"",
"    [137135214599] [IN] PID: 934  TASK: df9171a0 CPU: 0 COMMAND: \"hald\"",
"    [137125651275] [IN] PID: 6    TASK: df443f20 CPU: 0 COMMAND: \"events/0\"",
"    [137119564815] [IN] PID: 15   TASK: df46b280 CPU: 0 COMMAND: \"kblockd/0\"",
"    [137047715027] [IN] PID: 1168 TASK: dee01940 CPU: 0 COMMAND: \"bash\"",
"    [135744209052] [IN] PID: 272  TASK: dfa48ca0 CPU: 0 COMMAND: \"flush-8:0\"",
"    ... ",

" ",
"  Show the kernel stack pointer of each user task:\n",
"    %s> ps -us",
"       PID    PPID  CPU  KSTACKP  ST  %MEM   VSZ   RSS  COMM",
"          1      0   0  c009bedc  IN   0.0  1096    52  init",
"        239      1   0  c15e7ed8  IN   0.2  1332   224  pump",
"        280      1   1  c7cbdedc  IN   0.2  1092   208  portmap",
"        295      1   0  c7481edc  IN   0.0  1232     0  ypbind",
"        301    295   0  c7c7bf28  IN   0.1  1260   124  ypbind",
"        376      1   1  c5053f28  IN   0.0  1316    40  automount",
"        381      1   0  c34ddf28  IN   0.2  1316   224  automount",
"        391      1   1  c2777f28  IN   0.2  1316   224  automount",
"    ...",
" ",
"  Display the argument and environment data for the automount task:\n",
"    %s> ps -a automount",
"    PID: 3948   TASK: f722ee30  CPU: 0   COMMAND: \"automount\"",
"    ARG: /usr/sbin/automount --timeout=60 /net program /etc/auto.net",
"    ENV: SELINUX_INIT=YES",
"         CONSOLE=/dev/console",
"         TERM=linux",
"         INIT_VERSION=sysvinit-2.85",
"         PATH=/sbin:/usr/sbin:/bin:/usr/bin",
"         LC_MESSAGES=en_US",
"         RUNLEVEL=3",
"         runlevel=3",
"         PWD=/",
"         LANG=ja_JP.UTF-8",
"         PREVLEVEL=N",
"         previous=N",
"         HOME=/",
"         SHLVL=2",
"         _=/usr/sbin/automount",
" ",
"  Display the tasks in the thread group containing task c20ab0b0:\n",
"    %s> ps -g c20ab0b0",
"    PID: 6425   TASK: f72f50b0  CPU: 0   COMMAND: \"firefox-bin\"",
"      PID: 6516   TASK: f71bf1b0  CPU: 0   COMMAND: \"firefox-bin\"",
"      PID: 6518   TASK: d394b930  CPU: 0   COMMAND: \"firefox-bin\"",
"      PID: 6520   TASK: c20aa030  CPU: 0   COMMAND: \"firefox-bin\"",
"      PID: 6523   TASK: c20ab0b0  CPU: 0   COMMAND: \"firefox-bin\"",
"      PID: 6614   TASK: f1f181b0  CPU: 0   COMMAND: \"firefox-bin\"",
" ",   
"  Display the tasks in the thread group for each instance of the",
"  program named \"multi-thread\":\n",
"    %s> ps -g multi-thread",
"    PID: 2522   TASK: 1003f0dc7f0       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2523   TASK: 10037b13030       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2524   TASK: 1003e064030       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2525   TASK: 1003e13a7f0       CPU: 1   COMMAND: \"multi-thread\"",
"    ",
"    PID: 2526   TASK: 1002f82b7f0       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2527   TASK: 1003e1737f0       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2528   TASK: 10035b4b7f0       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2529   TASK: 1003f0c37f0       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2530   TASK: 10035597030       CPU: 1   COMMAND: \"multi-thread\"",
"      PID: 2531   TASK: 100184be7f0       CPU: 1   COMMAND: \"multi-thread\"",
" ",
"  Display the resource limits of \"bash\" task 13896:\n",
"    %s> ps -r 13896",
"    PID: 13896  TASK: cf402000  CPU: 0   COMMAND: \"bash\"",
"       RLIMIT     CURRENT       MAXIMUM",
"          CPU   (unlimited)   (unlimited)",
"        FSIZE   (unlimited)   (unlimited)",
"         DATA   (unlimited)   (unlimited)",
"        STACK    10485760     (unlimited)",
"         CORE   (unlimited)   (unlimited)",
"          RSS   (unlimited)   (unlimited)",
"        NPROC      4091          4091",
"       NOFILE      1024          1024",
"      MEMLOCK      4096          4096",
"           AS   (unlimited)   (unlimited)",
"        LOCKS   (unlimited)   (unlimited)",
" ",
"  Search for task names matching a POSIX regular expression:\n",
"     %s> ps 'migration*'",
"        PID    PPID  CPU       TASK        ST  %MEM    VSZ    RSS  COMM",
"           8      2   0  ffff8802128a2e20  IN   0.0      0      0  [migration/0]",
"          10      2   1  ffff880212969710  IN   0.0      0      0  [migration/1]",
"          15      2   2  ffff880212989710  IN   0.0      0      0  [migration/2]",
"          20      2   3  ffff8802129a9710  IN   0.0      0      0  [migration/3]",
NULL               
};

char *help_rd[] = {
"rd",
"read memory",
"[-adDsSupxmfNR][-8|-16|-32|-64][-o offs][-e addr][-r file][address|symbol]\n"
"     [count]",
"  This command displays the contents of memory, with the output formatted",
"  in several different manners.  The starting address may be entered either",
"  symbolically or by address.  The default output size is the size of a long",
"  data type, and the default output format is hexadecimal.  When hexadecimal",
"  output is used, the output will be accompanied by an ASCII translation.\n",
"       -p  address argument is a physical address.",
"       -u  address argument is a user virtual address; only required on",
"           processors with common user and kernel virtual address spaces.",
"       -m  address argument is a xen host machine address.",
"       -f  address argument is a dumpfile offset.",
"       -d  display output in signed decimal format (default is hexadecimal).",
"       -D  display output in unsigned decimal format (default is hexadecimal).",
"       -s  displays output symbolically when appropriate.",
"    -S[S]  displays output symbolically when appropriate; if the memory",
"           contents reference a slab cache object, the name of the slab cache",
"           will be displayed in brackets.  If -S is entered twice, and the",
"           memory contents reference a slab cache object, both the memory",
"           contents and the name of the slab cache will be displayed in",
"           brackets.",
"       -x  do not display ASCII translation at end of each line.",
#ifdef NOTDEF
"    -o       Shows offset value from the starting address.",
#endif
"       -8  display output in 8-bit values.",
"      -16  display output in 16-bit values.",
"      -32  display output in 32-bit values (default on 32-bit machines).",
"      -64  display output in 64-bit values (default on 64-bit machines).",
"       -a  display output in ASCII characters if the memory contains printable",
"           ASCII characters; if no count argument is entered, stop at the first",
"           non-printable character.",
"       -N  display output in network byte order (only valid for 16- and 32-bit",
"           values)",
"       -R  display memory in reverse order; memory will be displayed up to and",
"           including the address argument, requiring the count argument to be",
"           greater than 1 in order to display memory before the specified",
"           address.",
"  -o offs  offset the starting address by offs.",
"  -e addr  display memory until reaching specified ending hexadecimal address.",
"  -r file  dumps raw data to the specified output file; the number of bytes that",
"           are copied to the file must be specified either by a count argument",
"           or by the -e option.",
"  address  starting hexadecimal address:",
"             1  the default presumes a kernel virtual address.",
"             2. -p specifies a physical address.",
"             3. -u specifies a user virtual address, but is only necessary on",
"                processors with common user and kernel virtual address spaces.",
"   symbol  symbol of starting address to read.",
"    count  number of memory locations to display; if entered, it must be the",
"           last argument on the command line; if not entered, the count defaults",
"           to 1, or unlimited for -a; when used with the -r option, it is the",
"           number of bytes to be written to the file.",
"\nEXAMPLES",
"  Display the kernel's version string:\n",
"    %s> rd -a linux_banner",
"    c082a020:  Linux version 2.6.32-119.el6.i686 (mockbuild@hs20-bc2-4.buil",
"    c082a05c:  d.redhat.com) (gcc version 4.4.4 20100726 (Red Hat 4.4.4-13)",  
"    c082a098:   (GCC) ) #1 SMP Tue Mar 1 18:16:57 EST 2011",
"",
"  Display the same block of memory, first without symbols, again",
"  with symbols, and then with symbols and slab cache references:\n",
"    %s> rd f6e31f70 28",
"    f6e31f70:  f6e31f6c f779c180 c04a4032 00a9dd40   l.....y.2@J.@...",
"    f6e31f80:  00000fff c0472da0 f6e31fa4 f779c180   .....-G.......y.",
"    f6e31f90:  fffffff7 00a9b70f f6e31000 c04731ee   .............1G.",
"    f6e31fa0:  f6e31fa4 00000000 00000000 00000000   ................",
"    f6e31fb0:  00000000 00a9dd40 c0404f17 00000000   ....@....O@.....",
"    f6e31fc0:  00a9dd40 00000fff 00a9dd40 00a9b70f   @.......@.......",
"    f6e31fd0:  bf9e2718 ffffffda c040007b 0000007b   .'......{.@.{...",
"    %s> rd -s f6e31f70 28",
"    f6e31f70:  f6e31f6c f779c180 kmsg_read 00a9dd40 ",
"    f6e31f80:  00000fff vfs_read+159 f6e31fa4 f779c180 ",
"    f6e31f90:  fffffff7 00a9b70f f6e31000 sys_read+60 ",
"    f6e31fa0:  f6e31fa4 00000000 00000000 00000000 ",
"    f6e31fb0:  00000000 00a9dd40 syscall_call+7 00000000 ",
"    f6e31fc0:  00a9dd40 00000fff 00a9dd40 00a9b70f ",
"    f6e31fd0:  bf9e2718 ffffffda startup_32+123 0000007b ",
"    %s> rd -S f6e31f70 28",
"    f6e31f70:  [size-4096] [filp]   kmsg_read 00a9dd40 ",
"    f6e31f80:  00000fff vfs_read+159 [size-4096] [filp]   ",
"    f6e31f90:  fffffff7 00a9b70f [size-4096] sys_read+60 ",
"    f6e31fa0:  [size-4096] 00000000 00000000 00000000 ",
"    f6e31fb0:  00000000 00a9dd40 syscall_call+7 00000000 ",
"    f6e31fc0:  00a9dd40 00000fff 00a9dd40 00a9b70f ",
"    f6e31fd0:  bf9e2718 ffffffda startup_32+123 0000007b ",
"    %s> rd -SS f6e31f70 28",
"    f6e31f70:  [f6e31f6c:size-4096] [f779c180:filp] kmsg_read 00a9dd40 ",
"    f6e31f80:  00000fff vfs_read+159 [f6e31fa4:size-4096] [f779c180:filp] ",
"    f6e31f90:  fffffff7 00a9b70f [f6e31000:size-4096] sys_read+60 ",
"    f6e31fa0:  [f6e31fa4:size-4096] 00000000 00000000 00000000 ",
"    f6e31fb0:  00000000 00a9dd40 syscall_call+7 00000000 ",
"    f6e31fc0:  00a9dd40 00000fff 00a9dd40 00a9b70f ",
"    f6e31fd0:  bf9e2718 ffffffda startup_32+123 0000007b ",
"",
"  Read jiffies in hexadecimal and decimal format:\n",
"    %s> rd jiffies",
"    c0213ae0:  0008cc3a                              :...\n",
"    %s> rd -d jiffies",
"    c0213ae0:        577376\n",
"  Access the same memory in different sizes:\n",
"    %s> rd -64 kernel_version",
"    c0226a6c:  35312d352e322e32                    2.2.5-15\n",
"    %s> rd -32 kernel_version 2",
"    c0226a6c:  2e322e32 35312d35                     2.2.5-15\n",
"    %s> rd -16 kernel_version 4",
"    c0226a6c:  2e32 2e32 2d35 3531                       2.2.5-15\n",
"    %s> rd -8 kernel_version 8 ",
"    c0226a6c:  32 2e 32 2e 35 2d 31 35                           2.2.5-15",
"\n  Read the range of memory from c009bf2c to c009bf60:\n",
"    %s> rd c009bf2c -e c009bf60",
"    c009bf2c:  c009bf64 c01328c3 c009bf64 c0132838   d....(..d...8(..",
"    c009bf3c:  0000002a 00000004 c57d77e8 00000104   *........w}.....",
"    c009bf4c:  0000000b c009a000 7fffffff 00000000   ................",
"    c009bf5c:  00000000                              ....",
NULL               
};

char *help_wr[] = {
"wr",
"write memory",
"[-u|-k|-p] [-8|-16|-32|-64] [address|symbol] value",
"  This command modifies the contents of memory.  The starting address may be",
"  entered either symbolically or by address.  The default modification size ",
"  is the size of a long data type.  Write permission must exist on the",
"  /dev/mem.  When writing to memory on a live system, this command should ",
"  obviously be used with great care.\n",
"       -u  address argument is a user virtual address.",
"       -k  address argument is a kernel virtual address.",
"       -p  address argument is a physical address.",
"       -8  write data in an 8-bit value.",
"      -16  write data in a 16-bit value.",
"      -32  write data in a 32-bit values (default on 32-bit machines).",
"      -64  write data in a 64-bit values (default on 64-bit machines).",
"  address  address to write.  The address is considered virtual unless the",
"           -p option is used.  If a virtual address is specified, the",
"           -u or -k options are necessary only if the address space cannot", 
"           be determined from the address value itself.  If a user virtual",  
"           address is specified, the address space of the current context",
"           implied.  The address must be expressed in hexadecimal format.",
"   symbol  symbol of starting address to write.",
"    value  the value of the data to write.",
"\nEXAMPLES",
"  Turn on a debug flag:\n",
"    %s> wr my_debug_flag 1",
NULL               
};

char *help_bt[] = {
"bt",
"backtrace",
"[-a|-c cpu(s)|-g|-r|-t|-T|-l|-e|-E|-f|-F|-o|-O|-v|-p] [-R ref] [-s [-x|d]]"
"\n     [-I ip] [-S sp] [-n idle] [pid | task]",
"  Display a kernel stack backtrace.  If no arguments are given, the stack",
"  trace of the current context will be displayed.\n",
"       -a  displays the stack traces of the active task on each CPU.",
"           (only applicable to crash dumps)",
"       -A  same as -a, but also displays vector registers (S390X only).",
"  -n idle  filter the stack of idle tasks (x86_64, arm64).",
"           (only applicable to crash dumps)",
"       -p  display the stack trace of the panic task only.",
"           (only applicable to crash dumps)",
"   -c cpu  display the stack trace of the active task on one or more CPUs,",
"           which can be specified using the format \"3\", \"1,8,9\", \"1-23\",",
"           or \"1,8,9-14\". (only applicable to crash dumps)",
#ifdef GDB_5_3
"       -g  use gdb stack trace code. (alpha only)",
#else
"       -g  displays the stack traces of all threads in the thread group of",
#endif
"           the target task; the thread group leader will be displayed first.",
"       -r  display raw stack data, consisting of a memory dump of the two",
"           pages of memory containing the task_union structure.",
"       -t  display all text symbols found from the last known stack location",
"           to the top of the stack. (helpful if the back trace fails)",
"       -T  display all text symbols found from just above the task_struct or",
"           thread_info to the top of the stack. (helpful if the back trace",
"           fails or the -t option starts too high in the process stack).",
"       -l  show file and line number of each stack trace text location.",
"       -e  search the stack for possible kernel and user mode exception frames.",
"       -E  search the IRQ stacks (x86, x86_64, arm64, riscv64 and ppc64), and",
"           the exception stacks (x86_64) for possible exception frames; all",
"           other arguments except for -c will be ignored since this is not a",
"           context-sensitive operation.",
"       -f  display all stack data contained in a frame; this option can be",
"           used to determine the arguments passed to each function; on ia64,",
"           the argument register contents are dumped.",
"    -F[F]  similar to -f, except that the stack data is displayed symbolically",
"           when appropriate; if the stack data references a slab cache object,",
"           the name of the slab cache will be displayed in brackets; on ia64,",
"           the substitution is done to the argument register contents.  If -F",
"           is entered twice, and the stack data references a slab cache object,",
"           both the address and the name of the slab cache will be displayed",
"           in brackets.",
"       -v  check the kernel stack of all tasks for evidence of stack overflows.",
"           It does so by verifying the thread_info.task pointer, ensuring that",
"           the thread_info.cpu is a valid cpu number, and checking the end of ",
"           the stack for the STACK_END_MAGIC value.",
"       -o  arm64: use optional backtrace method; not supported on Linux 4.14 or",
"           later kernels.",
"           x86: use old backtrace method, permissible only on kernels that were",
"           compiled without the -fomit-frame_pointer.",
"           x86_64: use old backtrace method, which dumps potentially stale",
"           kernel text return addresses found on the stack.",
"       -O  arm64: use optional backtrace method by default; subsequent usage",
"           of this option toggles the backtrace method.",
"           x86: use old backtrace method by default, permissible only on kernels",
"           that were compiled without the -fomit-frame_pointer; subsequent usage",
"           of this option toggles the backtrace method.",
"           x86_64: use old backtrace method by default; subsequent usage of this",
"           option toggles the backtrace method.",  
"   -R ref  display stack trace only if there is a reference to this symbol",
"           or text address.",
"       -s  display the symbol name plus its offset.", 
"       -x  when displaying a symbol offset with the -s option, override the",
"           default output format with hexadecimal format.",
"       -d  when displaying a symbol offset with the -s option, override the",
"           default output format with decimal format.",
"    -I ip  use ip as the starting text location.",
"    -S sp  use sp as the starting stack frame address.",
"      pid  displays the stack trace(s) of this pid.",
"    taskp  displays the stack trace the the task referenced by this hexadecimal",
"           task_struct pointer.\n",
"  Multiple pid and taskp arguments may be specified.\n",
"  Note that all examples below are for x86 only.  The output format will differ",
"  for other architectures.  x86 backtraces from kernels that were compiled",
"  with the --fomit-frame-pointer CFLAG occasionally will drop stack frames,",
"  or display a stale frame reference.  When in doubt as to the accuracy of a",
"  backtrace, the -t or -T options may help fill in the blanks.\n",
"EXAMPLES",
"  Display the stack trace of the active task(s) when the kernel panicked:\n",
"    %s> bt -a",
"    PID: 286    TASK: c0b3a000  CPU: 0   COMMAND: \"in.rlogind\"",
"    #0 [c0b3be90] crash_save_current_state at c011aed0",
"    #1 [c0b3bea4] panic at c011367c",
"    #2 [c0b3bee8] tulip_interrupt at c01bc820",
"    #3 [c0b3bf08] handle_IRQ_event at c010a551",
"    #4 [c0b3bf2c] do_8259A_IRQ at c010a319",
"    #5 [c0b3bf3c] do_IRQ at c010a653",
"    #6 [c0b3bfbc] ret_from_intr at c0109634",
"       EAX: 00000000  EBX: c0e68280  ECX: 00000000  EDX: 00000004  EBP: c0b3bfbc",
"       DS:  0018      ESI: 00000004  ES:  0018      EDI: c0e68284 ",
"       CS:  0010      EIP: c012f803  ERR: ffffff09  EFLAGS: 00000246 ",
"    #7 [c0b3bfbc] sys_select at c012f803",
"    #8 [c0b3bfc0] system_call at c0109598",
"       EAX: 0000008e  EBX: 00000004  ECX: bfffc9a0  EDX: 00000000 ",
"       DS:  002b      ESI: bfffc8a0  ES:  002b      EDI: 00000000 ",
"       SS:  002b      ESP: bfffc82c  EBP: bfffd224 ",
"       CS:  0023      EIP: 400d032e  ERR: 0000008e  EFLAGS: 00000246  ",
" ",
"  Display the stack trace of the active task(s) when the kernel panicked,",
"  and filter out the stack of the idle tasks:",
" ",
"    %s> bt -a -n idle",
"    ...",
"    PID: 0      TASK: ffff889ff8c35a00  CPU: 11  COMMAND: \"swapper/11\"",
" ",
"    PID: 0      TASK: ffff889ff8c3c380  CPU: 12  COMMAND: \"swapper/12\"",
" ",
"    PID: 150773  TASK: ffff889fe85a1680  CPU: 13  COMMAND: \"bash\"",
"    #0 [ffffc9000d35bcd0] machine_kexec at ffffffff8105a407",
"    #1 [ffffc9000d35bd28] __crash_kexec at ffffffff8113033d",
"    #2 [ffffc9000d35bdf0] panic at ffffffff81081930",
"    #3 [ffffc9000d35be70] sysrq_handle_crash at ffffffff814e38d1",
"    #4 [ffffc9000d35be78] __handle_sysrq.cold.12 at ffffffff814e4175",
"    #5 [ffffc9000d35bea8] write_sysrq_trigger at ffffffff814e404b",
"    #6 [ffffc9000d35beb8] proc_reg_write at ffffffff81330d86",
"    #7 [ffffc9000d35bed0] vfs_write at ffffffff812a72d5",
"    #8 [ffffc9000d35bf00] ksys_write at ffffffff812a7579",
"    #9 [ffffc9000d35bf38] do_syscall_64 at ffffffff81004259",
"       RIP: 00007fa7abcdc274  RSP: 00007fffa731f678  RFLAGS: 00000246",
"       RAX: ffffffffffffffda  RBX: 0000000000000002  RCX: 00007fa7abcdc274",
"       RDX: 0000000000000002  RSI: 0000563ca51ee6d0  RDI: 0000000000000001",
"       RBP: 0000563ca51ee6d0   R8: 000000000000000a   R9: 00007fa7abd6be80",
"       R10: 000000000000000a  R11: 0000000000000246  R12: 00007fa7abdad760",
"       R13: 0000000000000002  R14: 00007fa7abda8760  R15: 0000000000000002",
"       ORIG_RAX: 0000000000000001  CS: 0033  SS: 002b",
"    ...",
"\n  Display the stack trace of the active task on CPU 0 and 1:\n",
"    %s> bt -c 0,1",
"    PID: 0      TASK: ffffffff81a8d020  CPU: 0   COMMAND: \"swapper\"",
"     #0 [ffff880002207e90] crash_nmi_callback at ffffffff8102fee6",
"     #1 [ffff880002207ea0] notifier_call_chain at ffffffff8152d525",
"     #2 [ffff880002207ee0] atomic_notifier_call_chain at ffffffff8152d58a",
"     #3 [ffff880002207ef0] notify_die at ffffffff810a155e",
"     #4 [ffff880002207f20] do_nmi at ffffffff8152b1eb",
"     #5 [ffff880002207f50] nmi at ffffffff8152aab0",
"        [exception RIP: native_safe_halt+0xb]",
"        RIP: ffffffff8103eacb  RSP: ffffffff81a01ea8  RFLAGS: 00000296",
"        RAX: 0000000000000000  RBX: 0000000000000000  RCX: 0000000000000000",
"        RDX: 0000000000000000  RSI: 0000000000000001  RDI: ffffffff81de5228",
"        RBP: ffffffff81a01ea8   R8: 0000000000000000   R9: 0000000000000000",
"        R10: 0012099429a6bea3  R11: 0000000000000000  R12: ffffffff81c066c0",
"        R13: 0000000000000000  R14: ffffffffffffffff  R15: ffffffff81de1000",
"        ORIG_RAX: ffffffffffffffff  CS: 0010  SS: 0018",
"    --- <NMI exception stack> ---",
"     #6 [ffffffff81a01ea8] native_safe_halt at ffffffff8103eacb",
"     #7 [ffffffff81a01eb0] default_idle at ffffffff810167bd",
"     #8 [ffffffff81a01ed0] cpu_idle at ffffffff81009fc6",
" ",
"    PID: 38     TASK: ffff88003eaae040  CPU: 1   COMMAND: \"khungtaskd\"",
"     #0 [ffff88003ad97ce8] machine_kexec at ffffffff81038f3b",
"     #1 [ffff88003ad97d48] crash_kexec at ffffffff810c5da2",
"     #2 [ffff88003ad97e18] panic at ffffffff8152721a",
"     #3 [ffff88003ad97e98] watchdog at ffffffff810e6346",
"     #4 [ffff88003ad97ee8] kthread at ffffffff8109af06",
"     #5 [ffff88003ad97f48] kernel_thread at ffffffff8100c20a",
"\n  Display the stack traces of task f2814000 and PID 1592:\n",
"    %s> bt f2814000 1592",
"    PID: 1018   TASK: f2814000  CPU: 1   COMMAND: \"java\"",
"     #0 [f2815db4] schedule at c011af85",
"     #1 [f2815de4] __down at c010600f",
"     #2 [f2815e14] __down_failed at c01061b3",
"     #3 [f2815e24] stext_lock (via drain_cpu_caches) at c025fa55",
"     #4 [f2815ec8] kmem_cache_shrink_nr at c013a53e",
"     #5 [f2815ed8] do_try_to_free_pages at c013f402",
"     #6 [f2815f04] try_to_free_pages at c013f8d2",
"     #7 [f2815f1c] _wrapped_alloc_pages at c01406bd",
"     #8 [f2815f40] __alloc_pages at c014079d",
"     #9 [f2815f60] __get_free_pages at c014083e",
"    #10 [f2815f68] do_fork at c011cebb",
"    #11 [f2815fa4] sys_clone at c0105ceb",
"    #12 [f2815fc0] system_call at c010740c",
"        EAX: 00000078  EBX: 00000f21  ECX: bc1ffbd8  EDX: bc1ffbe0",
"        DS:  002b      ESI: 00000000  ES:  002b      EDI: bc1ffd04",
"        SS:  002b      ESP: 0807316c  EBP: 080731bc",
"        CS:  0023      EIP: 4012881e  ERR: 00000078  EFLAGS: 00000296",
" ",
"    PID: 1592   TASK: c0cec000  CPU: 3   COMMAND: \"httpd\"",
"     #0 [c0ceded4] schedule at c011af85",
"     #1 [c0cedf04] pipe_wait at c0153083",
"     #2 [c0cedf58] pipe_read at c015317f",
"     #3 [c0cedf7c] sys_read at c0148be6",
"     #4 [c0cedfc0] system_call at c010740c",
"        EAX: 00000003  EBX: 00000004  ECX: bffed4a3  EDX: 00000001 ",
"        DS:  002b      ESI: 00000001  ES:  002b      EDI: bffed4a3 ",
"        SS:  002b      ESP: bffed458  EBP: bffed488 ",
"        CS:  0023      EIP: 4024f1d4  ERR: 00000003  EFLAGS: 00000286 ",
" ",
"  In order to examine each stack frame's contents use the bt -f option.",
"  From the extra frame data that is displayed, the arguments passed to each",
"  function can be determined.  Re-examining the PID 1592 trace above:",
" ",
"    %s> bt -f 1592",
"    PID: 1592   TASK: c0cec000  CPU: 3   COMMAND: \"httpd\"",
"     #0 [c0ceded4] schedule at c011af85",
"        [RA: c0153088  SP: c0ceded4  FP: c0cedf04  SIZE: 52]",
"        c0ceded4: c0cedf00  c0cec000  ce1a6000  00000003  ",
"        c0cedee4: c0cec000  f26152c0  cfafc8c0  c0cec000  ",
"        c0cedef4: ef70a0a0  c0cec000  c0cedf28  c0cedf54  ",
"        c0cedf04: c0153088  ",
"     #1 [c0cedf04] pipe_wait at c0153083",
"        [RA: c0153184  SP: c0cedf08  FP: c0cedf58  SIZE: 84]",
"        c0cedf08: 00000000  c0cec000  00000000  00000000  ",
"        c0cedf18: 00000000  c0a41fa0  c011d38b  c0394120  ",
"        c0cedf28: 00000000  c0cec000  ceeebf30  ce4adf30  ",
"        c0cedf38: 00000000  d4b60ce0  00000000  c0cedf58  ",
"        c0cedf48: e204f820  ef70a040  00000001  c0cedf78  ",
"        c0cedf58: c0153184  ",
"     #2 [c0cedf58] pipe_read at c015317f",
"        [RA: c0148be8  SP: c0cedf5c  FP: c0cedf7c  SIZE: 36]",
"        c0cedf5c: ef70a040  c0cec000  00000000  00000000  ",
"        c0cedf6c: 00000001  f27ae680  ffffffea  c0cedfbc  ",
"        c0cedf7c: c0148be8  ",
"     #3 [c0cedf7c] sys_read at c0148be6",
"        [RA: c0107413  SP: c0cedf80  FP: c0cedfc0  SIZE: 68]",
"        c0cedf80: f27ae680  bffed4a3  00000001  f27ae6a0  ",
"        c0cedf90: 40160370  24000000  4019ba28  00000000  ",
"        c0cedfa0: 00000000  fffffffe  bffba207  fffffffe  ",
"        c0cedfb0: c0cec000  00000001  bffed4a3  bffed488  ",
"        c0cedfc0: c0107413  ",
"     #4 [c0cedfc0] system_call at c010740c",
"        EAX: 00000003  EBX: 00000004  ECX: bffed4a3  EDX: 00000001 ",
"        DS:  002b      ESI: 00000001  ES:  002b      EDI: bffed4a3 ",
"        SS:  002b      ESP: bffed458  EBP: bffed488 ",
"        CS:  0023      EIP: 4024f1d4  ERR: 00000003  EFLAGS: 00000286 ",
"        [RA: 4024f1d4  SP: c0cedfc4  FP: c0cedffc  SIZE: 60]",
"        c0cedfc4: 00000004  bffed4a3  00000001  00000001  ",
"        c0cedfd4: bffed4a3  bffed488  00000003  0000002b  ",
"        c0cedfe4: 0000002b  00000003  4024f1d4  00000023  ",
"        c0cedff4: 00000286  bffed458  0000002b  ",
" ",
"    Typically the arguments passed to a function will be the last values",
"    that were pushed onto the stack by the next higher-numbered function, i.e.,", 
"    the lowest stack addresses in the frame above the called function's",
"    stack frame.  That can be verified by disassembling the calling function.",
"    For example, the arguments passed from sys_read() to pipe_read() above",
"    are the file pointer, the user buffer address, the count, and a pointer",
"    to the file structure's f_pos field.  Looking at the frame #3 data for",
"    sys_read(), the last four items pushed onto the stack (lowest addresses)",
"    are f27ae680, bffed4a3, 00000001, and f27ae6a0 -- which are the 4 arguments",
"    above, in that order.  Note that the first (highest address) stack content",
"    in frame #2 data for pipe_read() is c0148be8, which is the return address",
"    back to sys_read(). ",
" ",
"  Dump the text symbols found in the current context's stack:\n",
"    %s> bt -t",
"    PID: 1357   TASK: c1aa0000  CPU: 0   COMMAND: \"lockd\"",
"          START: schedule at c01190e0",
"      [c1aa1f28] dput at c0157dbc",
"      [c1aa1f4c] schedule_timeout at c0124cd4",
"      [c1aa1f78] svc_recv at cb22c4d8 [sunrpc]",
"      [c1aa1f98] put_files_struct at c011eb21",
"      [c1aa1fcc] nlmclnt_proc at cb237bef [lockd]",
"      [c1aa1ff0] kernel_thread at c0105826",
"      [c1aa1ff8] nlmclnt_proc at cb237a60 [lockd]",
" ",
"  Search the current stack for possible exception frames:\n",
"    %s> bt -e",
"    PID: 286    TASK: c0b3a000  CPU: 0   COMMAND: \"in.rlogind\"",
"    ",
"     KERNEL-MODE EXCEPTION FRAME AT c0b3bf44:",
"       EAX: 00000000  EBX: c0e68280  ECX: 00000000  EDX: 00000004  EBP: c0b3bfbc",
"       DS:  0018      ESI: 00000004  ES:  0018      EDI: c0e68284 ",
"       CS:  0010      EIP: c012f803  ERR: ffffff09  EFLAGS: 00000246 ",
"    ",
"     USER-MODE EXCEPTION FRAME AT c0b3bfc4:",
"       EAX: 0000008e  EBX: 00000004  ECX: bfffc9a0  EDX: 00000000 ",
"       DS:  002b      ESI: bfffc8a0  ES:  002b      EDI: 00000000 ",
"       SS:  002b      ESP: bfffc82c  EBP: bfffd224 ",
"       CS:  0023      EIP: 400d032e  ERR: 0000008e  EFLAGS: 00000246 ",
" ",
"  Display the back trace from a dumpfile that resulted from the execution",
"  of the %s utility's \"sys -panic\" command:\n",
"   %s> bt",
"   PID: 12523  TASK: c610c000  CPU: 0   COMMAND: \"crash\"",
"    #0 [c610de64] die at c01076ec",
"    #1 [c610de74] do_invalid_op at c01079bc",
"    #2 [c610df2c] error_code (via invalid_op) at c0107256",
"       EAX: 0000001d  EBX: c024a4c0  ECX: c02f13c4  EDX: 000026f6  EBP: c610c000",
"       DS:  0018      ESI: 401de2e0  ES:  0018      EDI: c610c000",
"       CS:  0010      EIP: c011bbb4  ERR: ffffffff  EFLAGS: 00010296",
"    #3 [c610df68] panic at c011bbb4",
"    #4 [c610df78] do_exit at c011f1fe",
"    #5 [c610dfc0] system_call at c0107154",
"       EAX: 00000001  EBX: 00000000  ECX: 00001000  EDX: 401df154",
"       DS:  002b      ESI: 401de2e0  ES:  002b      EDI: 00000000",
"       SS:  002b      ESP: bffebf0c  EBP: bffebf38",
"       CS:  0023      EIP: 40163afd  ERR: 00000001  EFLAGS: 00000246",
" ",
"  Display the back trace from a dumpfile that resulted from an attempt to",
"  insmod the sample \"crash.c\" kernel module that comes as part of the",
"  Red Hat netdump package:\n",
"   %s> bt",
"   PID: 1696   TASK: c74de000  CPU: 0   COMMAND: \"insmod\"",
"    #0 [c74dfdcc] die at c01076ec",
"    #1 [c74dfddc] do_page_fault at c0117bbc",
"    #2 [c74dfee0] error_code (via page_fault) at c0107256",
"       EAX: 00000013  EBX: cb297000  ECX: 00000000  EDX: c5962000  EBP: c74dff28",
"       DS:  0018      ESI: 00000000  ES:  0018      EDI: 00000000",
"       CS:  0010      EIP: cb297076  ERR: ffffffff  EFLAGS: 00010282",
"    #3 [c74dff1c] crash_init at cb297076 [crash]",
"    #4 [c74dff2c] sys_init_module at c011d233",
"    #5 [c74dffc0] system_call at c0107154",
"       EAX: 00000080  EBX: 08060528  ECX: 08076450  EDX: 0000000a",
"       DS:  002b      ESI: 0804b305  ES:  002b      EDI: 08074ed0",
"       SS:  002b      ESP: bffe9a90  EBP: bffe9ac8",
"       CS:  0023      EIP: 4012066e  ERR: 00000080  EFLAGS: 00000246",
" ",
"  Display the symbol name plus its offset in each frame, overriding",
"  the current output format with hexadecimal:\n",
"    %s> bt -sx",
"    PID: 1499   TASK: ffff88006af43cc0  CPU: 2   COMMAND: \"su\"",
"     #0 [ffff8800664a1c90] machine_kexec+0x167 at ffffffff810327b7",
"     #1 [ffff8800664a1ce0] crash_kexec+0x60 at ffffffff810a9ec0",
"     #2 [ffff8800664a1db0] oops_end+0xb0 at ffffffff81504160",
"     #3 [ffff8800664a1dd0] general_protection+0x25 at ffffffff81503435",
"        [exception RIP: kmem_cache_alloc+120]",
"        RIP: ffffffff8113cf88  RSP: ffff8800664a1e88  RFLAGS: 00010086",
"        RAX: 0000000000000000  RBX: ff88006ef56840ff  RCX: ffffffff8114e9e4",
"        RDX: 0000000000000000  RSI: 00000000000080d0  RDI: ffffffff81796020",
"        RBP: ffffffff81796020   R8: ffff88000a3137a0   R9: 0000000000000000",
"        R10: ffff88007ac97300  R11: 0000000000000400  R12: 00000000000080d0",
"        R13: 0000000000000292  R14: 00000000000080d0  R15: 00000000000000c0",
"        ORIG_RAX: ffffffffffffffff  CS: 0010  SS: 0018",
"     #4 [ffff8800664a1ed0] get_empty_filp+0x74 at ffffffff8114e9e4",
"     #5 [ffff8800664a1ef0] sock_alloc_fd+0x23 at ffffffff8142f553",
"     #6 [ffff8800664a1f10] sock_map_fd+0x23 at ffffffff8142f693",
"     #7 [ffff8800664a1f50] sys_socket+0x43 at ffffffff814302a3",
"     #8 [ffff8800664a1f80] system_call_fastpath+0x16 at ffffffff81013042",
"        RIP: 00007f5720b368e7  RSP: 00007fff52b629a8  RFLAGS: 00010206",
"        RAX: 0000000000000029  RBX: ffffffff81013042  RCX: 0000000000000000",
"        RDX: 0000000000000009  RSI: 0000000000000003  RDI: 0000000000000010",
"        RBP: 000000000066f320   R8: 0000000000000001   R9: 0000000000000000",
"        R10: 0000000000000000  R11: 0000000000000202  R12: ffff88007ac97300",
"        R13: 0000000000000000  R14: 00007f571e104a80  R15: 00007f571e305048",
"        ORIG_RAX: 0000000000000029  CS: 0033  SS: 002b",
"",
"  The following three examples show the difference in the display of",
"  the same stack frame's contents using -f, -F, and -FF:",
"  ",
"    %s> bt -f",
"    ...",
"     #4 [ffff810072b47f10] vfs_write at ffffffff800789d8",
"        ffff810072b47f18: ffff81007e020380 ffff81007e2c2880 ",
"        ffff810072b47f28: 0000000000000002 fffffffffffffff7 ",
"        ffff810072b47f38: 00002b141825d000 ffffffff80078f75 ",
"     #5 [ffff810072b47f40] sys_write at ffffffff80078f75",
"    ...",
"    %s> bt -F",
"    ...",
"     #4 [ffff810072b47f10] vfs_write at ffffffff800789d8",
"        ffff810072b47f18: [files_cache]    [filp]           ",
"        ffff810072b47f28: 0000000000000002 fffffffffffffff7 ",
"        ffff810072b47f38: 00002b141825d000 sys_write+69   ",
"     #5 [ffff810072b47f40] sys_write at ffffffff80078f75",
"    ...",
"    %s> bt -FF",
"    ...",
"     #4 [ffff810072b47f10] vfs_write at ffffffff800789d8",
"        ffff810072b47f18: [ffff81007e020380:files_cache] [ffff81007e2c2880:filp]",
"        ffff810072b47f28: 0000000000000002 fffffffffffffff7 ",
"        ffff810072b47f38: 00002b141825d000 sys_write+69  ",
"     #5 [ffff810072b47f40] sys_write at ffffffff80078f75",
"    ...",
"",
"  Check the kernel stack of all tasks for evidence of a stack overflow:\n",
"    %s> bt -v",
"    PID: 5823   TASK: ffff88102aae0040  CPU: 1   COMMAND: \"flush-253:0\"",
"    possible stack overflow: thread_info.task: 102efb5adc0 != ffff88102aae0040",
"    possible stack overflow: 40ffffffff != STACK_END_MAGIC",
NULL               
};

char *help_btop[] = {
"btop",
"bytes to page",
"address ...",
"  This command translates a hexadecimal address to its page number.",
"\nEXAMPLES",
"    %s> btop 512a000",
"    512a000: 512a",
NULL               
};

char *help_extend[] = {
"extend",
"extend the %s command set",  
"[shared-object ...] | [-u [shared-object ...]] | -s",
"  This command dynamically loads or unloads %s extension shared object",
"  libraries:\n",
"    shared-object     load the specified shared object file; more than one",
"                      one object file may be entered.",
"    -u shared-object  unload the specified shared object file; if no file",
"                      arguments are specified, unload all objects.", 
"    -s                show all available shared object files.",
"\n  If the shared-object filename is not expressed with a fully-qualified",
"  pathname, the following directories will be searched in the order shown,",
"  and the first instance of the file that is found will be selected:\n",
"     1. the current working directory",
"     2. the directory specified in the CRASH_EXTENSIONS environment variable",
"     3. /usr/lib64/crash/extensions (64-bit architectures)",
"     4. /usr/lib/crash/extensions", 
"     5. the ./extensions subdirectory of the current directory",
"\n  If no arguments are entered, the current set of shared object files and ",
"  a list of their commands will be displayed.  The registered commands",
"  contained in each shared object file will appear automatically in the ",
"  \"help\" command screen.",
"\n  An example of a shared object prototype file, and how to compile it",
"  into a shared object, is appended below.",
"\nEXAMPLES",
"  Load two shared object files:\n",
"    %s> extend extlib1.so extlib2.so",
"    ./extlib1.so: shared object loaded",
"    ./extlib2.so: shared object loaded",
"\n  Display the current set of shared object files and their commands:\n",
"    %s> extend",
"    SHARED OBJECT  COMMANDS",
"    ./extlib1.so   echo util bin",
"    ./extlib2.so   smp show",
"\n  Unload one of the shared object files:\n",
"    %s> extend -u extlib1.so",
"    ./extlib1.so: shared object unloaded",
"\n  Unload all currently-loaded object files:\n",
"    %s> extend -u",
"    ./extlib2.so: shared object unloaded",
"\nCREATING A SHARED OBJECT",
"  The extend command loads shared object files using dlopen(3), which in",
"  turn calls the shared object's constructor function.  The shared object's",
"  constructor function should register its command set by calling ",
"  register_extension(), passing it a pointer to an array of one or more",
"  structures of the following type:",
" ",
"    struct command_table_entry {",
"            char *name;",
"            cmd_func_t func;",
"            char **help_data,",
"            ulong flags;",
"    };",
" ",
"  Each command_table_entry structure contains the ASCII name of a command,",
"  the command's function address, a pointer to an array of help data strings,",
"  and a flags field.  The help_data field is optional; if it is non-NULL, it",
"  should point to an array of character strings used by the \"help\"",
"  command, and during command failures.  The flags field currently has two",
"  available bit settings, REFRESH_TASK_TABLE, which should be set if it is ",
"  preferable to reload the current set of running processes just prior to ",
"  executing the command (on a live system) and MINIMAL, which should be ",
"  set if the command should be available in minimal mode.  Terminate the array",
"  of command_table_entry structures with an entry with a NULL command name.  ",
" ",
"  Below is an example shared object file consisting of just one command, ",
"  called \"echo\", which simply echoes back all arguments passed to it.",
"  Note the comments contained within it for further details.  Cut and paste",
"  the following output into a file, and call it, for example, \"echo.c\".",
"  Then compiled in either of two manners.  Either manually like so:",
" ",
" gcc -shared -rdynamic -o echo.so echo.c -fPIC -D<machine-type> $(TARGET_CFLAGS)",
" ",
"  where <machine-type> must be one of the MACHINE_TYPE #define's in defs.h,",
"  and where $(TARGET_CFLAGS) is the same as it is declared in the top-level",
"  Makefile after a build is completed.  Or alternatively, the \"echo.c\" file",
"  can be copied into the \"extensions\" subdirectory, and compiled automatically",
"  like so:",
" ",
"  make extensions",
" ",
"  The echo.so file may be dynamically linked into %s during runtime, or",
"  during initialization by putting \"extend echo.so\" into a .%src file",
"  located in the current directory, or in the user's $HOME directory.",
"  ",
"---------------------------------- cut here ----------------------------------",
" ",
"#include \"defs.h\"      /* From the crash source top-level directory */",
"",
"void echo_init(void);    /* constructor function */",
"void echo_fini(void);    /* destructor function (optional) */",
"",
"void cmd_echo(void);     /* Declare the commands and their help data. */",
"char *help_echo[];",
"",
"static struct command_table_entry command_table[] = {",
"        { \"echo\", cmd_echo, help_echo, 0},          /* One or more commands, */",
"        { NULL },                                     /* terminated by NULL, */",
"};",
"",
"",
"void __attribute__((constructor))",
"echo_init(void) /* Register the command set. */",
"{ ",
"        register_extension(command_table);",
"}",
" ",
"/* ",
" *  This function is called if the shared object is unloaded. ",
" *  If desired, perform any cleanups here. ",
" */",
"void __attribute__((destructor))",
"echo_fini(void) { }",
"",
"",
"/* ",
" *  Arguments are passed to the command functions in the global args[argcnt]",
" *  array.  See getopt(3) for info on dash arguments.  Check out defs.h and",
" *  other %s commands for usage of the myriad of utility routines available",
" *  to accomplish what your task.",
" */",
"void",
"cmd_echo(void)",
"{",
"        int c;",
"",
"        while ((c = getopt(argcnt, args, \"\")) != EOF) {",
"                switch(c)",
"                {",
"                default:",
"                        argerrs++;",
"                        break;",
"                }",
"        }",
"",
"        if (argerrs)",
"                cmd_usage(pc->curcmd, SYNOPSIS);",
"",
"        while (args[optind]) ",
"                fprintf(fp, \"%%s \", args[optind++]);",
"",
"        fprintf(fp, \"\\n\");",
"}",
"",
"/* ",  
" *  The optional help data is simply an array of strings in a defined format.",
" *  For example, the \"help echo\" command will use the help_echo[] string",
" *  array below to create a help page that looks like this:",
" * ",
" *    NAME",
" *      echo - echoes back its arguments",
" *",
" *    SYNOPSIS",
" *      echo arg ...",
" *",
" *    DESCRIPTION",
" *      This command simply echoes back its arguments.",
" *",
" *    EXAMPLE",
" *      Echo back all command arguments:",
" *",
" *        crash> echo hello, world",
" *        hello, world",
" *",
" */",
" ",
"char *help_echo[] = {",
"        \"echo\",                        /* command name */",
"        \"echoes back its arguments\",   /* short description */",
"        \"arg ...\",                     /* argument synopsis, or \" \" if none */",
" ",
"        \"  This command simply echoes back its arguments.\",",
"        \"\\nEXAMPLE\",",
"        \"  Echo back all command arguments:\\n\",",
"        \"    %s> echo hello, world\",",
"        \"    hello, world\",",
"        NULL",
"};",
"",
NULL               
};

char *help_mach[] = {
"mach",
"machine specific data",    
"[-m | -c -[xd] | -o]",
"  This command displays data specific to a machine type.\n",
"    -m  Display the physical memory map (x86, x86_64 and ia64 only).",
"    -c  Display each cpu's cpuinfo structure (x86, x86_64 and ia64 only).",
"        Display each cpu's x8664_pda structure (x86_64 only),", 
"        Display the hwrpb_struct, and each cpu's percpu_struct (alpha only).",
"    -x  override default output format with hexadecimal format.",
"    -d  override default output format with decimal format.",
"    -o  Display the OPAL console log (ppc64 only).",
"\nEXAMPLES", 
"    %s> mach",
"           MACHINE TYPE: i686",
"            MEMORY SIZE: 512 MB",
"                   CPUS: 2",
"             HYPERVISOR: KVM",
"        PROCESSOR SPEED: 1993 Mhz",
"                     HZ: 100",
"              PAGE SIZE: 4096",
// "          L1 CACHE SIZE: 32",
"    KERNEL VIRTUAL BASE: c0000000",
"    KERNEL VMALLOC BASE: e0800000",
"      KERNEL STACK SIZE: 8192",
" ",
"  Display the system physical memory map:\n",
"    %s> mach -m",
"          PHYSICAL ADDRESS RANGE         TYPE",
"    0000000000000000 - 00000000000a0000  E820_RAM",
"    00000000000f0000 - 0000000000100000  E820_RESERVED",
"    0000000000100000 - 000000001ff75000  E820_RAM",
"    000000001ff75000 - 000000001ff77000  E820_NVS",
"    000000001ff77000 - 000000001ff98000  E820_ACPI",
"    000000001ff98000 - 0000000020000000  E820_RESERVED",
"    00000000fec00000 - 00000000fec90000  E820_RESERVED",
"    00000000fee00000 - 00000000fee10000  E820_RESERVED",
"    00000000ffb00000 - 0000000100000000  E820_RESERVED",
" ",
"  Display the OPAL console log:\n",
"    %s> mach -o",
"    [   65.219056911,5] SkiBoot skiboot-5.4.0-218-ge0225cc-df9a248 starting...",
"    [   65.219065872,5] initial console log level: memory 7, driver 5",
"    [   65.219068917,6] CPU: P8 generation processor(max 8 threads/core)",
"    [   65.219071681,7] CPU: Boot CPU PIR is 0x0060 PVR is 0x004d0200",
"    [   65.219074685,7] CPU: Initial max PIR set to 0x1fff",
"    [   65.219607955,5] FDT: Parsing fdt @0xff00000",
"    [  494.026291523,7] BT: seq 0x25 netfn 0x0a cmd 0x48: Message sent to host",
"    [  494.027636927,7] BT: seq 0x25 netfn 0x0a cmd 0x48: IPMI MSG done",
NULL               
};

char *help_bpf[] = {
"bpf",
"extended Berkeley Packet Filter (eBPF)",
"[[-p ID | -P] [-tTj]] [[-m ID] | -M] [-s] [-xd]",
" ",
"  This command provides information on currently-loaded eBPF programs and maps.",
"  With no arguments, basic information about each loaded eBPF program and map",
"  is displayed.  For each eBPF program, its ID number, the addresses of its ",
"  bpf_prog and bpf_prog_aux data structures, its type, tag, and the IDs of the",
"  eBPF maps that it uses are displayed.  For each eBPF map, its ID number, the",
"  address of its bpf_map data structure, its type, and the hexadecimal value of",
"  its map_flags are displayed.",
" ",
"    -p ID  displays the basic information specific to the program ID, plus the",
"           size in bytes of its translated bytecode, the size in bytes of its",
"           jited code, the number of bytes locked into memory, the time that",
"           the program was loaded, whether it is GPL compatible, its name",
"           string, and its UID.",
"    -P     same as -p, but displays the basic and extra data for all programs.",
"    -m ID  displays the basic information specific to the map ID, plus the", 
"           size in bytes of its key and value, the maximum number of key-value",
"           pairs that can be stored within the map, the number of bytes locked",
"           into memory, its name string, and its UID.",
"    -M     same as -m, but displays the basic and extra data for all maps.",    
"    -t     translate the bytecode of the specified program ID.",
"    -T     same as -t, but also dump the bytecode of each instruction.",
"    -j     disassemble the jited code of the specified program ID.",
"    -s     with -p or -P, dump the bpf_prog and bpf_prog_aux data structures.",
"           with -m or -M, dump the bpf_map structure.", 
"    -x     with -s, override default output format with hexadecimal format.",
"    -d     with -s, override default output format with decimal format.",
" ",
"EXAMPLES",
"  Display all loaded eBPF programs and maps:\n",
"  %s> bpf",
"   ID     BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG        USED_MAPS",
"   13 ffffbc00c06d1000 ffff9ff260f0c400  CGROUP_SKB   7be49e3934a125ba   13,14",
"   14 ffffbc00c0761000 ffff9ff260f0f600  CGROUP_SKB   2a142ef67aaad174   13,14",
"   15 ffffbc00c001d000 ffff9ff2618f9e00  CGROUP_SKB   7be49e3934a125ba   15,16",
"   16 ffffbc00c06c9000 ffff9ff2618f9400  CGROUP_SKB   2a142ef67aaad174   15,16",
"   19 ffffbc00c0d39000 ffff9ff2610fa000  CGROUP_SKB   7be49e3934a125ba   19,20",
"   20 ffffbc00c0d41000 ffff9ff2610f8e00  CGROUP_SKB   2a142ef67aaad174   19,20",
"   30 ffffbc00c065f000 ffff9ff1b64de200    KPROBE     69fed6de18629d7a    32",
"   31 ffffbc00c065b000 ffff9ff1b64df200    KPROBE     69fed6de18629d7a    37",
"   32 ffffbc00c0733000 ffff9ff1b64dc600    KPROBE     69fed6de18629d7a    38",
"   33 ffffbc00c0735000 ffff9ff1b64dca00    KPROBE     69fed6de18629d7a    39",
"   34 ffffbc00c0737000 ffff9ff1b64dfc00    KPROBE     4abbddae72a6ee17 33,36,34",
"   36 ffffbc00c0839000 ffff9ff1b64dd000    KPROBE     da4fc6a3f41761a2    32",
"   41 ffffbc00c07ec000 ffff9ff207b70400  TRACEPOINT   e2094f9f46284bf6   55,54",
"   44 ffffbc00c07ee000 ffff9ff1b64dc800  PERF_EVENT   19578a12836c4115    62",
"   46 ffffbc00c07f0000 ffff9ff207b70400 SOCKET_FILTER 1fcfc04afd689133    64",
"  ",
"   ID     BPF_MAP       BPF_MAP_TYPE   MAP_FLAGS",
"   13 ffff9ff260f0ec00    LPM_TRIE      00000001",
"   14 ffff9ff260f0de00    LPM_TRIE      00000001",
"   15 ffff9ff2618fbe00    LPM_TRIE      00000001",
"   16 ffff9ff2618fb800    LPM_TRIE      00000001",
"   19 ffff9ff2610faa00    LPM_TRIE      00000001",
"   20 ffff9ff2610fb800    LPM_TRIE      00000001",
"   32 ffff9ff260d74000      HASH        00000000",
"   33 ffff9ff260d76400    LRU_HASH      00000000",
"   34 ffff9ff260d70000    LRU_HASH      00000002",
"   35 ffff9ff260d73800    LRU_HASH      00000004",
"   36 ffff9ff1b4f44000  ARRAY_OF_MAPS   00000000",
"   37 ffff9ff260d77c00   PERCPU_HASH    00000000",
"   38 ffff9ff260d70800      HASH        00000001",
"   39 ffff9ff260d76c00   PERCPU_HASH    00000001",
"   54 ffff9ff260dd2c00      HASH        00000000",
"   55 ffff9ff260dd1400      HASH        00000000",
"   62 ffff9ff1ae784000      HASH        00000000",
"   64 ffff9ff1aea15000      ARRAY       00000000",
" ",
"  Display additional data about program ID 20:\n",
"  %s> bpf -p 20",
"   ID     BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG        USED_MAPS",
"   20 ffffbc00c0d41000 ffff9ff2610f8e00  CGROUP_SKB   2a142ef67aaad174   19,20",   
"      XLATED: 296  JITED: 229  MEMLOCK: 4096",
"      LOAD_TIME: Fri Apr 20 19:39:21 2018",
"      GPL_COMPATIBLE: yes  UID: 0",
" ",
"  Display additional data about map ID 34:\n",
"  %s> bpf -m 34",
"   ID     BPF_MAP       BPF_MAP_TYPE   MAP_FLAGS",
"   34  ffff9ff260d70000    LRU_HASH      00000000",
"       KEY_SIZE: 4  VALUE_SIZE: 8  MAX_ENTRIES: 10000  MEMLOCK: 1953792",
"       NAME: \"lru_hash_map\"  UID: 0",
"",
"  Disassemble the jited program of program ID 20:\n",
"  %s> bpf -p 20 -j",
"  ID     BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG        USED_MAPS",
"  20 ffffbc00c0d41000 ffff9ff2610f8e00  CGROUP_SKB   2a142ef67aaad174   19,20",   
"     XLATED: 296  JITED: 229  MEMLOCK: 4096",
"     LOAD_TIME: Fri Apr 20 19:39:21 2018",
"     GPL_COMPATIBLE: yes  UID: 0",
" ",
"   0xffffffffc06887a2:  push   \%rbp ",
"   0xffffffffc06887a3:  mov    \%rsp,\%rbp ",
"   0xffffffffc06887a6:  sub    $0x40,\%rsp ",
"   0xffffffffc06887ad:  sub    $0x28,\%rbp ",
"   0xffffffffc06887b1:  mov    \%rbx,0x0(\%rbp) ",
"   0xffffffffc06887b5:  mov    \%r13,0x8(\%rbp) ",
"   0xffffffffc06887b9:  mov    \%r14,0x10(\%rbp) ",
"   0xffffffffc06887bd:  mov    \%r15,0x18(\%rbp) ",
"   0xffffffffc06887c1:  xor    \%eax,\%eax ",
"   0xffffffffc06887c3:  mov    \%rax,0x20(\%rbp) ",
"   0xffffffffc06887c7:  mov    \%rdi,\%rbx ",
"   0xffffffffc06887ca:  movzwq 0xc0(\%rbx),\%r13 ",
"   0xffffffffc06887d2:  xor    \%r14d,\%r14d ",
"   0xffffffffc06887d5:  cmp    $0x8,\%r13 ",
"   0xffffffffc06887d9:  jne    0xffffffffc068881b ",
"   0xffffffffc06887db:  mov    \%rbx,\%rdi ",
"   0xffffffffc06887de:  mov    $0xc,\%esi ",
"   0xffffffffc06887e3:  mov    \%rbp,\%rdx ",
"   0xffffffffc06887e6:  add    $0xfffffffffffffffc,\%rdx ",
"   0xffffffffc06887ea:  mov    $0x4,\%ecx ",
"   0xffffffffc06887ef:  callq  0xffffffffb0865340 <bpf_skb_load_bytes>",
"   0xffffffffc06887f4:  movabs $0xffff9ff2610faa00,\%rdi ",
"   0xffffffffc06887fe:  mov    \%rbp,\%rsi ",
"   0xffffffffc0688801:  add    $0xfffffffffffffff8,\%rsi ",
"   0xffffffffc0688805:  movl   $0x20,0x0(\%rsi) ",
"   0xffffffffc068880c:  callq  0xffffffffb01fcba0 <bpf_map_lookup_elem>",
"   0xffffffffc0688811:  cmp    $0x0,\%rax ",
"   0xffffffffc0688815:  je     0xffffffffc068881b ",
"   0xffffffffc0688817:  or     $0x2,\%r14d ",
"   0xffffffffc068881b:  cmp    $0xdd86,\%r13 ",
"   0xffffffffc0688822:  jne    0xffffffffc0688864 ",
"   0xffffffffc0688824:  mov    \%rbx,\%rdi ",
"   0xffffffffc0688827:  mov    $0x8,\%esi ",
"   0xffffffffc068882c:  mov    \%rbp,\%rdx ",
"   0xffffffffc068882f:  add    $0xfffffffffffffff0,\%rdx ",
"   0xffffffffc0688833:  mov    $0x10,\%ecx ",
"   0xffffffffc0688838:  callq  0xffffffffb0865340 <bpf_skb_load_bytes>",
"   0xffffffffc068883d:  movabs $0xffff9ff2610fb800,\%rdi ",
"   0xffffffffc0688847:  mov    \%rbp,\%rsi ",
"   0xffffffffc068884a:  add    $0xffffffffffffffec,\%rsi ",
"   0xffffffffc068884e:  movl   $0x80,0x0(\%rsi) ",
"   0xffffffffc0688855:  callq  0xffffffffb01fcba0 <bpf_map_lookup_elem>",
"   0xffffffffc068885a:  cmp    $0x0,\%rax ",
"   0xffffffffc068885e:  je     0xffffffffc0688864 ",
"   0xffffffffc0688860:  or     $0x2,\%r14d ",
"   0xffffffffc0688864:  mov    $0x1,\%eax ",
"   0xffffffffc0688869:  cmp    $0x2,\%r14 ",
"   0xffffffffc068886d:  jne    0xffffffffc0688871 ",
"   0xffffffffc068886f:  xor    \%eax,\%eax ",
"   0xffffffffc0688871:  mov    0x0(\%rbp),\%rbx ",
"   0xffffffffc0688875:  mov    0x8(\%rbp),\%r13 ",
"   0xffffffffc0688879:  mov    0x10(\%rbp),\%r14 ",
"   0xffffffffc068887d:  mov    0x18(\%rbp),\%r15 ",
"   0xffffffffc0688881:  add    $0x28,\%rbp ",
"   0xffffffffc0688885:  leaveq  ",
"   0xffffffffc0688886:  retq ",
" ",
"  Translate each bytecode instruction of program ID 13:\n",
"  %s> bpf -p 13 -t",
"   ID      BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG       USED_MAPS",
"   13 ffffbc00c06d1000 ffff9ff260f0c400  CGROUP_SKB   7be49e3934a125ba   13,14",
"      XLATED: 296  JITED: 229  MEMLOCK: 4096",
"      LOAD_TIME: Fri Apr 20 19:39:11 2018",
"      GPL_COMPATIBLE: yes  UID: 0",
" ",
"    0: (bf) r6 = r1",
"    1: (69) r7 = *(u16 *)(r6 +192)",
"    2: (b4) (u32) r8 = (u32) 0",
"    3: (55) if r7 != 0x8 goto pc+14",
"    4: (bf) r1 = r6",
"    5: (b4) (u32) r2 = (u32) 16",
"    6: (bf) r3 = r10",
"    7: (07) r3 += -4",
"    8: (b4) (u32) r4 = (u32) 4",
"    9: (85) call bpf_skb_load_bytes#6793152",
"   10: (18) r1 = map[id:13]",
"   12: (bf) r2 = r10",
"   13: (07) r2 += -8",
"   14: (62) *(u32 *)(r2 +0) = 32",
"   15: (85) call bpf_map_lookup_elem#73760",
"   16: (15) if r0 == 0x0 goto pc+1",
"   17: (44) (u32) r8 |= (u32) 2",
"   18: (55) if r7 != 0xdd86 goto pc+14",
"   19: (bf) r1 = r6",
"   20: (b4) (u32) r2 = (u32) 24",
"   21: (bf) r3 = r10",
"   22: (07) r3 += -16",
"   23: (b4) (u32) r4 = (u32) 16",
"   24: (85) call bpf_skb_load_bytes#6793152",
"   25: (18) r1 = map[id:14]",
"   27: (bf) r2 = r10",
"   28: (07) r2 += -20",
"   29: (62) *(u32 *)(r2 +0) = 128",
"   30: (85) call bpf_map_lookup_elem#73760",
"   31: (15) if r0 == 0x0 goto pc+1",
"   32: (44) (u32) r8 |= (u32) 2",
"   33: (b7) r0 = 1",
"   34: (55) if r8 != 0x2 goto pc+1",
"   35: (b7) r0 = 0",
"   36: (95) exit",
" ",
"  Translate, and then dump each bytecode instruction of program ID 13:\n",
"  %s> bpf -p 13 -T",
"   ID      BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG       USED_MAPS",
"   13 ffffbc00c06d1000 ffff9ff260f0c400  CGROUP_SKB   7be49e3934a125ba   13,14",
"      XLATED: 296  JITED: 229  MEMLOCK: 4096",
"      LOAD_TIME: Fri Apr 20 19:39:11 2018",
"      GPL_COMPATIBLE: yes  UID: 0",
" ",
"    0: (bf) r6 = r1",
"        bf 16 00 00 00 00 00 00",
"    1: (69) r7 = *(u16 *)(r6 +192)",
"        69 67 c0 00 00 00 00 00",
"    2: (b4) (u32) r8 = (u32) 0",
"        b4 08 00 00 00 00 00 00",
"    3: (55) if r7 != 0x8 goto pc+14",
"        55 07 0e 00 08 00 00 00",
"    4: (bf) r1 = r6",
"        bf 61 00 00 00 00 00 00",
"    5: (b4) (u32) r2 = (u32) 16",
"        b4 02 00 00 10 00 00 00",
"    6: (bf) r3 = r10",
"        bf a3 00 00 00 00 00 00",
"    7: (07) r3 += -4",
"        07 03 00 00 fc ff ff ff",
"    8: (b4) (u32) r4 = (u32) 4",
"        b4 04 00 00 04 00 00 00",
"    9: (85) call bpf_skb_load_bytes#6793152",
"        85 00 00 00 c0 a7 67 00",
"   10: (18) r1 = map[id:13]",
"        18 01 00 00 00 7a 96 61 00 00 00 00 b2 9d ff ff",
"   12: (bf) r2 = r10",
"        bf a2 00 00 00 00 00 00",
"   13: (07) r2 += -8",
"        07 02 00 00 f8 ff ff ff",
"   14: (62) *(u32 *)(r2 +0) = 32",
"        62 02 00 00 20 00 00 00",
"   15: (85) call bpf_map_lookup_elem#73760",
"        85 00 00 00 20 20 01 00",
"   16: (15) if r0 == 0x0 goto pc+1",
"        15 00 01 00 00 00 00 00",
"   17: (44) (u32) r8 |= (u32) 2",
"        44 08 00 00 02 00 00 00",
"   18: (55) if r7 != 0xdd86 goto pc+14",
"        55 07 0e 00 86 dd 00 00",
"   19: (bf) r1 = r6",
"        bf 61 00 00 00 00 00 00",
"   20: (b4) (u32) r2 = (u32) 24",
"        b4 02 00 00 18 00 00 00",
"   21: (bf) r3 = r10",
"        bf a3 00 00 00 00 00 00",
"   22: (07) r3 += -16",
"        07 03 00 00 f0 ff ff ff",
"   23: (b4) (u32) r4 = (u32) 16",
"        b4 04 00 00 10 00 00 00",
"   24: (85) call bpf_skb_load_bytes#6793152",
"        85 00 00 00 c0 a7 67 00",
"   25: (18) r1 = map[id:14]",
"        18 01 00 00 00 68 96 61 00 00 00 00 b2 9d ff ff",
"   27: (bf) r2 = r10",
"        bf a2 00 00 00 00 00 00",
"   28: (07) r2 += -20",
"        07 02 00 00 ec ff ff ff",
"   29: (62) *(u32 *)(r2 +0) = 128",
"        62 02 00 00 80 00 00 00",
"   30: (85) call bpf_map_lookup_elem#73760",
"        85 00 00 00 20 20 01 00",
"   31: (15) if r0 == 0x0 goto pc+1",
"        15 00 01 00 00 00 00 00",
"   32: (44) (u32) r8 |= (u32) 2",
"        44 08 00 00 02 00 00 00",
"   33: (b7) r0 = 1",
"        b7 00 00 00 01 00 00 00",
"   34: (55) if r8 != 0x2 goto pc+1",
"        55 08 01 00 02 00 00 00",
"   35: (b7) r0 = 0",
"        b7 00 00 00 00 00 00 00",
"   36: (95) exit",
"        95 00 00 00 00 00 00 00",
" ",
"  Display the bpf_map data structure for map ID 13:\n",
"  %s> bpf -m 13 -s",
"   ID      BPF_MAP       BPF_MAP_TYPE   MAP_FLAGS",
"   13  ffff9ff260f0ec00    LPM_TRIE      00000001",
"       KEY_SIZE: 8  VALUE_SIZE: 8  MAX_ENTRIES: 1  MEMLOCK: 4096",
"       NAME: (unused)  UID: 0",
" ",
"  struct bpf_map {",
"    ops = 0xffffffffb0e36720, ",
"    inner_map_meta = 0x0, ",
"    security = 0xffff9ff26873a158, ",
"    map_type = BPF_MAP_TYPE_LPM_TRIE, ",
"    key_size = 8, ",
"    value_size = 8, ",
"    max_entries = 1, ",
"    map_flags = 1, ",
"    pages = 1, ",
"    id = 13, ",
"    numa_node = -1, ",
"    unpriv_array = false, ",
"    user = 0xffffffffb14578a0, ",
"    refcnt = {",
"      counter = 3",
"    }, ",
"    usercnt = {",
"      counter = 1",
"    }, ",
"    work = {",
"      data = {",
"        counter = 0",
"      }, ",
"      entry = {",
"        next = 0x0, ",
"        prev = 0x0",
"      }, ",
"      func = 0x0, ",
"      lockdep_map = {",
"        key = 0x0, ",
"        class_cache = {0x0, 0x0}, ",
"        name = 0x0, ",
"        cpu = 0, ",
"        ip = 0",
"      }",
"    }, ",
"    name = \"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"",
"  }",
" ",
"  Display the bpf_prog and bpf_prog_aux structures for program ID 13:\n",
"  %s> bpf -p 13 -s",
"   ID      BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG       USED_MAPS",
"   13  ffffbc00c06d1000 ffff9ff260f0c400  CGROUP_SKB   7be49e3934a125ba   13,14",
"       XLATED: 296  JITED: 229  MEMLOCK: 4096",
"       LOAD_TIME: Fri Apr 20 19:39:10 2018",
"       GPL_COMPATIBLE: yes  UID: 0",
" ",
"   struct bpf_prog {",
"     pages = 1, ",
"     jited = 1, ",
"     jit_requested = 1, ",
"     locked = 1, ",
"     gpl_compatible = 1, ",
"     cb_access = 0, ",
"     dst_needed = 0, ",
"     blinded = 0, ",
"     is_func = 0, ",
"     kprobe_override = 0, ",
"     type = BPF_PROG_TYPE_CGROUP_SKB, ",
"     len = 37, ",
"     jited_len = 229, ",
"     tag = \"{\\344\\236\\071\\064\\241\%\\272\", ",
"     aux = ffff9ff260f0c400,",
"     orig_prog = 0x0, ",
"     bpf_func = 0xffffffffc0218a59, ",
"     {",
"       insns = 0xffffb0cf406d1030, ",
"       insnsi = 0xffffb0cf406d1030",
"     }",
"   }",
"   ",
"   struct bpf_prog_aux {",
"     refcnt = {",
"       counter = 2",
"     }, ",
"     used_map_cnt = 2, ",
"     max_ctx_offset = 20, ",
"     stack_depth = 20, ",
"     id = 13, ",
"     func_cnt = 0, ",
"     offload_requested = false, ",
"     func = 0x0, ",
"     jit_data = 0x0, ",
"     ksym_tnode = {",
"       node = {{",
"           __rb_parent_color = 18446635988194065457, ",
"           rb_right = 0x0, ",
"           rb_left = 0x0",
"         }, {",
"           __rb_parent_color = 18446635988194065481, ",
"           rb_right = 0x0, ",
"           rb_left = 0x0",
"         }}",
"     }, ",
"     ksym_lnode = {",
"       next = 0xffff9db261966460, ",
"       prev = 0xffffffffb85d1150",
"     }, ",
"     ops = 0xffffffffb7f09060, ",
"     used_maps = 0xffff9db261e03600, ",
"     prog = 0xffffb0cf406d1000, ",
"     user = 0xffffffffb84578a0, ",
"     load_time = 23962237943, ",
"     name = \"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\",",
"     security = 0xffff9db266f9cf50, ",
"     offload = 0x0, ",
"     {",
"       work = {",
"         data = {",
"           counter = 0",
"         }, ",
"         entry = {",
"           next = 0x0, ",
"           prev = 0x0",
"         }, ",
"         func = 0x0, ",
"         lockdep_map = {",
"           key = 0x0, ",
"           class_cache = {0x0, 0x0}, ",
"           name = 0x0, ",
"           cpu = 0, ",
"           ip = 0",
"         }",
"       }, ",
"       rcu = {",
"         next = 0x0, ",
"         func = 0x0",
"       }",
"     }",
"   }",
" ",
"  Display the extra data about all programs:\n",
"  %s> bpf -P",
"   ID     BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG        USED_MAPS",
"   13 ffffbc00c06d1000 ffff9ff260f0c400  CGROUP_SKB   7be49e3934a125ba   13,14",
"      XLATED: 296  JITED: 229  MEMLOCK: 4096",
"      LOAD_TIME: Fri Apr 20 19:39:10 2018",
"      GPL_COMPATIBLE: yes  UID: 0",
"  ",
"   ID     BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG        USED_MAPS",
"   14 ffffbc00c0761000 ffff9ff260f0f600  CGROUP_SKB   2a142ef67aaad174   13,14",
"      XLATED: 296  JITED: 229  MEMLOCK: 4096",
"      LOAD_TIME: Fri Apr 20 19:39:10 2018",
"      GPL_COMPATIBLE: yes  UID: 0",
"  ",
"   ID     BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG        USED_MAPS",
"   15 ffffbc00c001d000 ffff9ff2618f9e00  CGROUP_SKB   7be49e3934a125ba   15,16",
"      XLATED: 296  JITED: 229  MEMLOCK: 4096",
"      LOAD_TIME: Fri Apr 20 19:39:11 2018",
"      GPL_COMPATIBLE: yes  UID: 0",
" ",
"  ...",
" ",
"   ID     BPF_PROG       BPF_PROG_AUX   BPF_PROG_TYPE       TAG        USED_MAPS",
"   75 ffffbc00c0ed1000 ffff9ff2429c6400    KPROBE     da4fc6a3f41761a2    107",    
"      XLATED: 5168  JITED: 2828  MEMLOCK: 8192",
"      LOAD_TIME: Fri Apr 27 14:54:40 2018",
"      GPL_COMPATIBLE: yes  UID: 0",
" ",
"  Display the extra data for all maps:\n",
"  %s> bpf -M",
"   ID      BPF_MAP       BPF_MAP_TYPE   MAP_FLAGS",
"   13  ffff9ff260f0ec00    LPM_TRIE      00000001 ",
"       KEY_SIZE: 8  VALUE_SIZE: 8  MAX_ENTRIES: 1  MEMLOCK: 4096",
"       NAME: (unused)  UID: 0",
" ",
"   ID      BPF_MAP       BPF_MAP_TYPE   MAP_FLAGS",
"   14  ffff9ff260f0de00    LPM_TRIE      00000001 ",
"       KEY_SIZE: 20  VALUE_SIZE: 8  MAX_ENTRIES: 1  MEMLOCK: 4096",
"       NAME: (unused)  UID: 0",
" ",
"  ...",
" ",
"   ID      BPF_MAP       BPF_MAP_TYPE   MAP_FLAGS",
"  108  ffff9ff1aeab9400    LRU_HASH      00000000 ",
"       KEY_SIZE: 4  VALUE_SIZE: 8  MAX_ENTRIES: 1000  MEMLOCK: 147456",
"       NAME: \"lru_hash_lookup\"  UID: 0",
" ",
"  To display all possible information that this command offers about",
"  all programs and maps, enter:\n",
"  %s> bpf -PM -jTs",
NULL
}; 

char *help_map[] = {
"map",
"store KVM dumpfile memory map data",    
"[-a][-f [filename]]",
"  The layout of KVM guest dumpfiles created with \"virsh dump\" does not allow",
"  the crash utility to access the system's memory in a random access manner.",
"  Therefore, during crash session initialization, a potentially time-consuming",
"  dumpfile scan procedure is required to create a physical-memory-to-file-offset",
"  map for use during the session.",
" ",  
"  This command may be used to append the memory map data to the dumpfile or",
"  to store it in a permanent file.  After this has been done, subsequent crash",
"  sessions using the dumpfile will no longer require the scan procedure:",
" ", 
"    -a  Append the memory map to the end of the KVM dumpfile.",
"    -f  Create a memory map file.  If no filename argument is entered, the",
"        filename will consist of the dumpfile name with \".map\" appended,",
"        and will be located in the same directory as the dumpfile; it will",
"        be recognized and used automatically during subsequent %s sessions.",
"        However, if a \"filename\" argument is entered, and the default location",
"        and naming convention are not used, then the new memory map file will",
"        have to be added to the %s command line during invocation.",
"\nEXAMPLES", 
"    %s> map",
"    MAP FILE IN USE: vmcore.map",
"    %s> map -a",
"    MAP FILE APPENDED TO: vmcore",
"    %s> map -f",
"    MAP FILE CREATED: vmcore.map",
"    %s> map -f /tmp/vmcore.map",
"    MAP FILE CREATED: /tmp/vmcore.map",
NULL
};

char *help_timer[] = {
"timer",
"timer queue data",
"[-r][-C cpu]",
"  This command displays the timer queue entries, both old- and new-style,",
"  in chronological order.  In the case of the old-style timers, the",
"  timer_table array index is shown; in the case of the new-style timers, ",
"  the timer_list address is shown.  On later kernels, the timer data is",
"  per-cpu.\n",
"    -r  Display hrtimer timer queue entries, both old- and new-style, in",
"        chronological order.  In the case of the old-style hrtimers, the",
"        expiration time is a single value; in the new-style hrtimers, the",
"        expiration time is a range.",
" -C cpu Restrict the output to one or more CPUs, where multiple cpu[s] can", 
"        be specified, for example, as \"1,3,5\", \"1-3\", or \"1,3,5-7,10\".",
"\nEXAMPLES",
" Display the timer queue on an SMP system:\n",
"    %s> timer",
"    JIFFIES",
"    4296291038",
"    ...",
"    TIMER_BASES[1][BASE_STD]: ffff9801aba5aa00",
"      EXPIRES        TTE         TIMER_LIST     FUNCTION",
"      4296282997    -8041  ffff9801aba55ce0  ffffffff83a3bda0  <mce_timer_fn>",
"      4296283104    -7934  ffff97fd84bd35e0  ffffffff83ac6b70  <delayed_work_timer_fn>",
"      4296291061       23  ffffa6b283967de0  ffffffff83b29880  <process_timeout>",
"      4296291112       74  ffff9800c9b62ad8  ffffffff83e6b550  <cursor_timer_handler>",
"      4296291345      307  ffff980186d5ef88  ffffffff84146b80  <tcp_keepalive_timer>",
"      4296291484      446  ffff9801a7c54740  ffffffff84147f50  <tcp_write_timer>",
"      4296291997      959  ffffffffc073f880  ffffffff83ac6b70  <delayed_work_timer_fn>",
"      4296296213     5175  ffffa6b28339be18  ffffffff83b29880  <process_timeout>",
"      4296304383    13345  ffff980194ca72a8  ffffffff8412e4e0  <tw_timer_handler>",
"      4296305724    14686  ffff980194ca6918  ffffffff8412e4e0  <tw_timer_handler>",
"      4296306036    14998  ffff980194ca6d58  ffffffff8412e4e0  <tw_timer_handler>",
"      4296306883    15845  ffff980194ca7e58  ffffffff8412e4e0  <tw_timer_handler>",
"      4296307588    16550  ffff9801aaa27e58  ffffffff8412e4e0  <tw_timer_handler>",
"      4296307625    16587  ffff980194ca6a28  ffffffff8412e4e0  <tw_timer_handler>",
"      4296313542    22504  ffff980194ca7c38  ffffffff8412e4e0  <tw_timer_handler>",
"      4296317680    26642  ffff9800c9149c58  ffffffff840da870  <neigh_timer_handler>",
"      4296317744    26706  ffff9801a5354468  ffffffff83ac6b70  <delayed_work_timer_fn>",
"      4296343322    52284  ffff980194ca63c8  ffffffff8412e4e0  <tw_timer_handler>",
"      4296343581    52543  ffff980194ca7088  ffffffff8412e4e0  <tw_timer_handler>",
"      4296343597    52559  ffff9801aaa274c8  ffffffff8412e4e0  <tw_timer_handler>",
"      4296714205   423167  ffffffff84caf3c0  ffffffff83ac6b70  <delayed_work_timer_fn>",
"    TIMER_BASES[1][BASE_DEF]: ffff9801aba5bc80",
"      EXPIRES        TTE         TIMER_LIST     FUNCTION",
"      4296291264      226  ffffffff855eb238  ffffffff83c08fb0  <writeout_period>",
"      4296319997    28959  ffffffffc06ede40  ffffffff83ac6b70  <delayed_work_timer_fn>",
"      4296506084   215046  ffff9801aba629c8  ffffffff83ac5ea0  <idle_worker_timeout>",
"    ...",
" ",
"  Display a new-style hrtimer queue:\n",
"    %s> timer -r",
"    ...",
"    CPU: 2  HRTIMER_CPU_BASE: ffff9801aba9cf00",
"      CLOCK: 0  HRTIMER_CLOCK_BASE: ffff9801aba9cf40  [ktime_get]",
"         CURRENT",
"      1623742000000",
"       SOFTEXPIRES      EXPIRES         TTE         HRTIMER           FUNCTION",
"      1623741000000  1623741000000    -1000000  ffff9801aba9d540  ffffffff83b3c8e0  <tick_sched_timer>",
"      1624024000000  1624024000000   282000000  ffff9801aba9d720  ffffffff83b7e7a0  <watchdog_timer_fn>",
"      1626000939806  1626010929804  2268929804  ffffa6b28399fa40  ffffffff83b2c1e0  <hrtimer_wakeup>",
"      1627576915615  1627576915615  3834915615  ffff9801a5727978  ffffffff83b365c0  <posix_timer_fn>",
"      1627637194488  1627647194487  3905194487  ffffa6b283977db0  ffffffff83b2c1e0  <hrtimer_wakeup>",
"      1629937423000  1629937423000  6195423000  ffff9801a9af2900  ffffffff83cf3d30  <timerfd_tmrproc>",
" ",
"      CLOCK: 1  HRTIMER_CLOCK_BASE: ffff9801aba9cf80  [ktime_get_real]",
"            CURRENT",
"      1558362388334558243",
"          SOFTEXPIRES            EXPIRES             TTE           HRTIMER           FUNCTION",
"      1558362389331238000  1558362389331288000      996729757  ffffa6b28574bcf0  ffffffff83b2c1e0  <hrtimer_wakeup>",
"      1558364372000000000  1558364372000000000  1983665441757  ffff9801a3513278  ffffffff83b365c0  <posix_timer_fn>",
" ",
"      CLOCK: 2  HRTIMER_CLOCK_BASE: ffff9801aba9cfc0  [ktime_get_boottime]",
"      (empty)",
"    ...",
" ",
NULL               
};



char *help_runq[] = {
"runq",
"run queue",
"[-t] [-T] [-m] [-g] [-c cpu(s)]",
"  With no argument, this command displays the tasks on the run queues",
"  of each cpu.",
" ",
"     -t  Display the timestamp information of each cpu's runqueue, which is the",
"         rq.clock, rq.most_recent_timestamp or rq.timestamp_last_tick value,",
"         whichever applies; following each cpu timestamp is the last_run or ",
"         timestamp value of the active task on that cpu, whichever applies, ",
"         along with the task identification.",
"     -T  Display the time lag of each CPU relative to the most recent runqueue",
"         timestamp.",
"     -m  Display the amount of time that the active task on each cpu has been",
"         running, expressed in a format consisting of days, hours, minutes, ",
"         seconds and milliseconds.",
"     -g  Display tasks hierarchically by task_group.  The task_group line shows",
"         the task_group address, the cfs_rq or rt_rq address, the task_group",
"         name (if any), and whether the task_group is throttled.",
" -c cpu  restrict the output to the run queue data of one or more CPUs,",
"         which can be specified using the format \"3\", \"1,8,9\", \"1-23\",",
"         or \"1,8,9-14\".",
"\nEXAMPLES",
" Display the tasks on an O(1) scheduler run queue:\n",
"    %s> runq",
"    CPU 0 RUNQUEUE: ffff880001cdb460",
"      CURRENT: PID: 2739   TASK: ffff8800320fa7e0  COMMAND: \"bash\"",
"      ACTIVE PRIO_ARRAY: ffff880001cdb4d8",
"         [115] PID: 2739   TASK: ffff8800320fa7e0  COMMAND: \"bash\"",
"               PID: 1776   TASK: ffff88003217d820  COMMAND: \"syslogd\"",
"      EXPIRED PRIO_ARRAY: ffff880001cdbdb8",
"         [no tasks queued]",
"    ",
"    CPU 1 RUNQUEUE: ffff880001ce3460",
"      CURRENT: PID: 1779   TASK: ffff88003207a860  COMMAND: \"klogd\"",
"      ACTIVE PRIO_ARRAY: ffff880001ce34d8",
"         [115] PID: 1779   TASK: ffff88003207a860  COMMAND: \"klogd\"",
"      EXPIRED PRIO_ARRAY: ffff880001ce3db8",
"         [no tasks queued]",
" ",
" Display the tasks on a CFS run queue:\n",
"    %s> runq",
"    CPU 0 RUNQUEUE: ffff8800090436c0",
"      CURRENT: PID: 588    TASK: ffff88007e4877a0  COMMAND: \"udevd\"",
"      RT PRIO_ARRAY: ffff8800090437c8",
"         [no tasks queued]",
"      CFS RB_ROOT: ffff880009043740",
"         [118] PID: 2110   TASK: ffff88007d470860  COMMAND: \"check-cdrom.sh\"",
"         [118] PID: 2109   TASK: ffff88007f1247a0  COMMAND: \"check-cdrom.sh\"",
"         [118] PID: 2114   TASK: ffff88007f20e080  COMMAND: \"udevd\"",
"    ",
"    CPU 1 RUNQUEUE: ffff88000905b6c0",
"      CURRENT: PID: 2113   TASK: ffff88007e8ac140  COMMAND: \"udevd\"",
"      RT PRIO_ARRAY: ffff88000905b7c8",
"         [no tasks queued]",
"      CFS RB_ROOT: ffff88000905b740",
"         [118] PID: 2092   TASK: ffff88007d7a4760  COMMAND: \"MAKEDEV\"",
"         [118] PID: 1983   TASK: ffff88007e59f140  COMMAND: \"udevd\"",
"         [118] PID: 2064   TASK: ffff88007e40f7a0  COMMAND: \"udevd\"",
"         [115] PID: 2111   TASK: ffff88007e4278a0  COMMAND: \"kthreadd\"",
" ",
" Display run queue timestamp data:\n",
"    %s> runq -t ",
"    CPU 0: 2680990637359",
"           2680986653330  PID: 28228  TASK: ffff880037ca2ac0  COMMAND: \"loop\"",
"    CPU 1: 2680940618478",
"           2680940618478  PID: 28167  TASK: ffff880078130040  COMMAND: \"bash\"",
"    CPU 2: 2680990763425",
"           2680986785772  PID: 28227  TASK: ffff8800787780c0  COMMAND: \"loop\"",
"    CPU 3: 2680990954469",
"           2680986059540  PID: 28226  TASK: ffff880078778b00  COMMAND: \"loop\"",
" ",
" Display the amount of time the active task on each cpu has been running:\n",
"    %s> runq -m",
"     CPU 0: [0 00:00:00.014]  PID: 5275  TASK: f5dbcaa0  COMMAND: \"sh\"",
"     CPU 1: [0 00:00:00.002]  PID: 5203  TASK: f5c7baa0  COMMAND: \"cat\"",
"     CPU 2: [0 00:00:00.014]  PID: 7971  TASK: f5c6c550  COMMAND: \"khelper\"",
"     CPU 3: [0 00:00:00.002]  PID: 0     TASK: f4ccd000  COMMAND: \"swapper\"",
" ",
" Display tasks hierarchically by task_group:\n",
"  %s> runq -g ",
"  CPU 0",
"    CURRENT: PID: 14734  TASK: ffff88010626f500  COMMAND: \"sh\"",
"    ROOT_TASK_GROUP: ffffffff81ed93e0  RT_RQ: ffff880028216808",
"       [  0] TASK_GROUP: ffff88022c6bbc00 RT_RQ: ffff880139fc9800 (THROTTLED)",
"            [  0] PID: 14750  TASK: ffff88013a4dd540  COMMAND: \"rtloop99\"",
"            [  1] PID: 14748  TASK: ffff88013bbca040  COMMAND: \"rtloop98\"",
"            [  1] TASK_GROUP: ffff88012b0fb400 RT_RQ: ffff880089029000 ",
"                  [  1] PID: 14752  TASK: ffff880088abf500  COMMAND: \"rtloop98\"",
"            [ 54] PID: 14749  TASK: ffff880037a4e080  COMMAND: \"rtloop45\"",
"            [ 98] PID: 14746  TASK: ffff88012678c080  COMMAND: \"rtloop1\"",
"    ROOT_TASK_GROUP: ffffffff81ed93e0  CFS_RQ: ffff8800282166e8",
"       [120] PID: 14740  TASK: ffff88013b1e6080  COMMAND: \"sh\"",
"       [120] PID: 14738  TASK: ffff88012678d540  COMMAND: \"sh\"",
"       [120] PID: 14734  TASK: ffff88010626f500  COMMAND: \"sh\" [CURRENT]",
"       TASK_GROUP: ffff884052bc9800 CFS_RQ: ffff8831e4a1b000 (THROTTLED)",
"          [120] PID: 14732  TASK: ffff88013bbcb500  COMMAND: \"sh\"",
"          [120] PID: 14728  TASK: ffff8800b3496080  COMMAND: \"sh\"",
"          [120] PID: 14730  TASK: ffff880037833540  COMMAND: \"sh\"",
"       TASK_GROUP: ffff884058f1d000 CFS_RQ: ffff88120a101600 (THROTTLED)",
"          [120] PID: 14726  TASK: ffff880138d42aa0  COMMAND: \"sh\"",
"  ...",
" ",
" Display tasks hierarchically by task_group for cpu 3 only:\n",
"  %s> runq -g -c3",
"  CPU 3",
"    CURRENT: PID: 2948   TASK: ffff88022af2a100  COMMAND: \"bash\"",
"    INIT_TASK_GROUP: ffffffff81e1a780  RT_RQ: ffff880028216148",
"       [no tasks queued]",
"    INIT_TASK_GROUP: ffffffff81e1a780  CFS_RQ: ffff880028216028",
"       [120] PID: 2948   TASK: ffff88022af2a100  COMMAND: \"bash\" [CURRENT]",
"       TASK_GROUP: ffff88012b880800  CFS_RQ: ffff88012c5d1000  <libvirt>",
"          TASK_GROUP: ffff88012c078000  CFS_RQ: ffff88012c663e00  <qemu>",
"             TASK_GROUP: ffff88022c7f4c00  CFS_RQ: ffff88012bb56000  <guest2>",
"                TASK_GROUP: ffff88022b621400  CFS_RQ: ffff88012b012000  <vcpu0>",
"                   [120] PID: 3248   TASK: ffff88012a9d4100  COMMAND: \"qemu-kvm\"",
NULL               
};


char *help_repeat[] = {
"repeat",
"repeat a command",
"[-seconds] command",
"  This command repeats a command indefinitely, optionally delaying a given",
"  number of seconds between each command execution.\n",
"    -seconds   The number of seconds to delay between command executions.",
"               This option must precede the command name to be executed.",
" ",
"  Command execution may be stopped with CTRL-C, or if scrolling is in effect,",
"  by entering \"q\".  This command is meant for use on a live system; it is",
"  hard to conceive of a reason to use it when debugging a crash dump.",
"\nEXAMPLES",
"  Display the value of jiffies once per second:\n",
"    %s> repeat -1 p jiffies",
"    jiffies = $1 = 155551079",
"    jiffies = $2 = 155551180",
"    jiffies = $3 = 155551281",
"    jiffies = $4 = 155551382",
"    jiffies = $5 = 155551483",
"    jiffies = $6 = 155551584",
"    jiffies = $7 = 155551685",
"    jiffies = $8 = 155551786",
"    jiffies = $9 = 155551887",
"    jiffies = $10 = 155551988",
"    jiffies = $11 = 155552089",
"    jiffies = $12 = 155552190",
"    jiffies = $13 = 155552291",
"    jiffies = $14 = 155552392",
"    jiffies = $15 = 155552493",
"    jiffies = $16 = 155552594",
"    jiffies = $17 = 155552695",
"    jiffies = $18 = 155552796",
"    ...",
NULL               
};


char *help_pte[] = {
"pte",
"translate a page table entry",
"contents ...",
"  This command translates the hexadecimal contents of a PTE into its physical",
"  page address and page bit settings.  If the PTE references a swap location,",
"  the swap device and offset are displayed.",
"\nEXAMPLES\n",
"    %s> pte d8e067",
"     PTE    PHYSICAL  FLAGS",
"    d8e067   d8e000   (PRESENT|RW|USER|ACCESSED|DIRTY)",
" ",
"    %s> pte 13f600",
"     PTE      SWAP     OFFSET",
"    13f600  /dev/hda2   5104",
NULL               
};


char *help_swap[] = {
"swap",
"swap device information",
" ",
"  This command displays information for each configured swap device.",
"\nEXAMPLE",
"  %s> swap",
"  SWAP_INFO_STRUCT    TYPE       SIZE       USED    PCT  PRI  FILENAME",
"  ffff880153d45f40  PARTITION  7192568k   1200580k  16%   -1  /dev/dm-1",
NULL               
};



char *help_dev[] = {
"dev",
"device data",
"[-i | -p | -d | -D ] [-V | -v index [file]]",
"  If no argument is entered, this command dumps character and block",
"  device data.\n",
"    -i  display I/O port usage; on 2.4 kernels, also display I/O memory usage.",
"    -p  display PCI device data.",
"    -d  display disk I/O statistics:",
"         TOTAL: total number of allocated in-progress I/O requests",
"          SYNC: I/O requests that are synchronous",
"         ASYNC: I/O requests that are asynchronous",
"          READ: I/O requests that are reads (older kernels)",
"         WRITE: I/O requests that are writes (older kernels)",
"           DRV: I/O requests that are in-flight in the device driver.",
"                If the device driver uses blk-mq interface, this field",
"                shows N/A(MQ).  If not available, this column is not shown.",
"    -D  same as -d, but filter out disks with no in-progress I/O requests.",
" ",
"  If the dumpfile contains device dumps:",
"        -V  display an indexed list of all device dumps present in the vmcore,",
"            showing their file offset, size and name.", 
"  -v index  select and display one device dump based upon an index value",
"            shown by the -V option, shown in a default human-readable format;",
"            alternatively, the \"rd -f\" option along with its various format",
"            options may be used to further tailor the output.",
"      file  only used with -v, copy the device dump data to a file.",

"\nEXAMPLES",
"  Display character and block device data:\n",
"    %s> dev",
"    CHRDEV    NAME              CDEV    OPERATIONS",
"       1      mem             f79b83c0  memory_fops",
"       4      /dev/vc/0       c07bc560  console_fops",
"       4      tty             f7af5004  tty_fops",
"       4      ttyS            f7b02204  tty_fops",
"       5      /dev/tty        c07bc440  tty_fops",
"       5      /dev/console    c07bc4a0  console_fops",
"       5      /dev/ptmx       c07bc500  ptmx_fops",
"       6      lp              c5797e40  lp_fops",
"       7      vcs             f7b03d40  vcs_fops",
"      10      misc            f7f68640  misc_fops",
"      13      input           f79b8840  input_fops",
"      21      sg              f7f12840  sg_fops",
"      29      fb              f7f8c640  fb_fops",
"     128      ptm             f7b02604  tty_fops",
"     136      pts             f7b02404  tty_fops",
"     162      raw             c0693e40  raw_fops",
"     180      usb             f79b8bc0  usb_fops",
"     189      usb_device      c06a0300  usbfs_device_file_operations",
"     216      rfcomm          f5961a04  tty_fops",
"     254      pcmcia          f79b82c0  ds_fops",
"    ",
"    BLKDEV    NAME             GENDISK  OPERATIONS",
"       1      ramdisk         f7b23480  rd_bd_op",
"       8      sd              f7cab280  sd_fops",
"       9      md              f7829b80  md_fops",
"      11      sr              f75c24c0  sr_bdops",
"      65      sd               (none)  ",
"      66      sd               (none)  ",
"      67      sd               (none)  ",
"      68      sd               (none)  ",
"      69      sd               (none)  ",
"      70      sd               (none)  ",
"      71      sd               (none)  ",
"     128      sd               (none)  ",
"     129      sd               (none)  ",
"     130      sd               (none)  ",
"     131      sd               (none)  ",
"     132      sd               (none)  ",
"     133      sd               (none)  ",
"     134      sd               (none)  ",
"     135      sd               (none)  ",
"     253      device-mapper   c57a0ac0  dm_blk_dops",
"     254      mdp              (none)  ",

"\n  Display PCI data:\n",
"    %s> dev -p",
"    PCI_DEV  BU:SL.FN CLASS: VENDOR-DEVICE",
"    c00051c0 00:00.0  Host bridge: Intel 440BX - 82443BX Host",
"    c0005250 00:01.0  PCI bridge: Intel 440BX - 82443BX AGP",
"    c00052e0 00:07.0  ISA bridge: Intel 82371AB PIIX4 ISA",
"    c0005370 00:07.1  IDE interface: Intel 82371AB PIIX4 IDE",
"    c0005400 00:07.2  USB Controller: Intel 82371AB PIIX4 USB",
"    c0005490 00:07.3  Bridge: Intel 82371AB PIIX4 ACPI",
"    c0005520 00:11.0  Ethernet controller: 3Com 3C905B 100bTX",
"    c00055b0 00:13.0  PCI bridge: DEC DC21152",
"    c0005640 01:00.0  VGA compatible controller: NVidia [PCI_DEVICE 28]",
"    c00056d0 02:0a.0  SCSI storage controller: Adaptec AIC-7890/1",
"    c0005760 02:0e.0  SCSI storage controller: Adaptec AIC-7880U",

"\n  Display I/O port and I/O memory usage:\n",
"    %s> dev -i",
"    RESOURCE    RANGE    NAME",
"    c03036d4  0000-ffff  PCI IO",
"    c0302594  0000-001f  dma1",
"    c03025b0  0020-003f  pic1",
"    c03025cc  0040-005f  timer",
"    c03025e8  0060-006f  keyboard",
"    c0302604  0080-008f  dma page reg",
"    c0302620  00a0-00bf  pic2",
"    c030263c  00c0-00df  dma2",
"    c0302658  00f0-00ff  fpu",
"    c122ff20  0170-0177  ide1",
"    c122f240  0213-0213  isapnp read",
"    c122ff40  02f8-02ff  serial(auto)",
"    c122ff00  0376-0376  ide1",
"    c03186e8  03c0-03df  vga+",
"    c122ff60  03f8-03ff  serial(auto)",
"    c123851c  0800-083f  Intel Corporation 82371AB PIIX4 ACPI",
"    c1238538  0840-085f  Intel Corporation 82371AB PIIX4 ACPI",
"    c122f220  0a79-0a79  isapnp write",
"    c122f200  0cf8-0cff  PCI conf1",
"    c1238858  dc00-dc7f  3Com Corporation 3c905B 100BaseTX [Cyclone]",
"    c122fc00  dc00-dc7f  00:11.0",
"    c12380c8  dce0-dcff  Intel Corporation 82371AB PIIX4 USB",
"    c1238d1c  e000-efff  PCI Bus #02",
"    c1237858  e800-e8ff  Adaptec AIC-7880U",
"    c1237458  ec00-ecff  Adaptec AHA-2940U2/W / 7890",
"    c1239cc8  ffa0-ffaf  Intel Corporation 82371AB PIIX4 IDE",
"    ",
"    RESOURCE        RANGE        NAME",
"    c03036f0  00000000-ffffffff  PCI mem",
"    c0004000  00000000-0009ffff  System RAM",
"    c03026ac  000a0000-000bffff  Video RAM area",
"    c03026fc  000c0000-000c7fff  Video ROM",
"    c0302718  000c9800-000cdfff  Extension ROM",
"    c0302734  000ce000-000ce7ff  Extension ROM",
"    c0302750  000ce800-000cffff  Extension ROM",
"    c03026e0  000f0000-000fffff  System ROM",
"    c0004040  00100000-07ffdfff  System RAM",
"    c0302674  00100000-0028682b  Kernel code",
"    c0302690  0028682c-0031c63f  Kernel data",
"    c0004060  07ffe000-07ffffff  reserved",
"    c1239058  ec000000-efffffff  Intel Corporation 440BX/ZX - 82443BX/ZX Host",
"                                 bridge",
"    c1238d54  f1000000-f1ffffff  PCI Bus #02",
"    c1239554  f2000000-f5ffffff  PCI Bus #01",
"    c1237074  f4000000-f5ffffff  nVidia Corporation Riva TnT2 [NV5]",
"    c1238d38  fa000000-fbffffff  PCI Bus #02",
"    c1237874  faffe000-faffefff  Adaptec AIC-7880U",
"    c127ec40  faffe000-faffefff  aic7xxx",
"    c1237474  fafff000-faffffff  Adaptec AHA-2940U2/W / 7890",
"    c127eec0  fafff000-faffffff  aic7xxx",
"    c1239538  fc000000-fdffffff  PCI Bus #01",
"    c1237058  fc000000-fcffffff  nVidia Corporation Riva TnT2 [NV5]",
"    c1238874  fe000000-fe00007f  3Com Corporation 3c905B 100BaseTX [Cyclone]",
"    c0004080  fec00000-fec0ffff  reserved",
"    c00040a0  fee00000-fee0ffff  reserved",
"    c00040c0  ffe00000-ffffffff  reserved",
"\n  Display disk I/O statistics:\n",
"    %s> dev -d",
"    MAJOR GENDISK            NAME     REQUEST_QUEUE      TOTAL  READ WRITE   DRV",
"        2 ffff81012d8a5000   fd0      ffff81012dc053c0      12     0    12     0",
"       22 ffff81012dc6b000   hdc      ffff81012d8ae340       2     2     0     0",
"        8 ffff81012dd71000   sda      ffff81012d8af040       6     0     6     6",
"        8 ffff81012dc77000   sdb      ffff81012d8b5740       0     0     0     0",
"        8 ffff81012d8d0c00   sdc      ffff81012d8ae9c0       0     0     0     0",

"\n  Display the available device dumps:\n",
"    %s> dev -V",
"    INDEX  OFFSET             SIZE             NAME",
"      0    0x240              33558464         cxgb4_0000:02:00.4",
"      1    0x2001240          33558464         cxgb4_0000:03:00.4",

"\n  Extract a specified device dump to file:\n",
"    %s> dev -v 0 device_dump_0.bin",
"    DEVICE: cxgb4_0000:02:00.4",
"    33558464 bytes copied from 0x240 to device_dump_0.bin",

"\n  Format and display a device's dump data to the screen using the \"rd\" command:\n",
"    %s> rd -f 0x240 -32 8",
"    240:  040b69e2 00000038 000e0001 00675fd4   .i..8........_g.",
"    250:  00000000 21600047 00000000 00000000   ....G.`!........",

"\n  Display a device's dump data to the screen using the default format:\n",
"    %s> dev -v 1",
"    DEVICE: cxgb4_0000:03:00.4",
"             2001240:  00000038040b69e2 00af985c000e0001   .i..8.......\\...",
"             2001250:  2150004700000000 0000000000000000   ....G.P!........",
"             2001260:  0000000000000000 0000000000000000   ................",
"             2001270:  0000000000000000 0002fccc00000001   ................",
"             2001280:  00000000000027b0 0000000000000000   .'..............",
"    ...",


NULL               
};



char *help_search[] = {
"search",
"search memory",
"[-s start] [ -[kKV] | -u | -p | -t | -T ] [-e end | -l length] [-m mask]\n"
"         [-x count] -[cwh] [value | (expression) | symbol | string] ...",
"  This command searches for a given value within a range of user virtual, kernel",
"  virtual, or physical memory space.  If no end nor length value is entered, ",
"  then the search stops at the end of user virtual, kernel virtual, or physical",
"  address space, whichever is appropriate.",
" ",
"  An optional mask value may be entered to mask off \"don't care\" bits.\n",
"    -s start  Start the search at this hexadecimal user or kernel virtual ",
"              address, physical address, or kernel symbol.  The start address",
"              must be appropriate for the memory type specified; if no memory",
"              type is specified, the default is kernel virtual address space.",
"          -k  If no start address is specified, start the search at the base",
"              of kernel virtual address space.  This option is the default.",
"          -K  Same as -k, except that mapped kernel virtual memory that was",
"              allocated by vmalloc(), module memory, or virtual mem_map regions",
"              will not be searched.", 
"          -V  Same as -k, except that unity-mapped kernel virtual memory and",
"              mapped kernel-text/static-data (x86_64 and ia64) will not be",
"              searched.",
"          -u  If no start address is specified, start the search at the base",
"              of the current context's user virtual address space.  If a start",
"              address is specified, then this option specifies that the start",
"              address is a user virtual address.",
"          -p  If no start address is specified, start the search at the base",
"              of physical address space.  If a start address is specified,",
"              then this option specifies that the start address is a physical ",
"              address.",
"          -t  Search only the kernel stack pages of every task.  If one or more",
"              matches are found in a task's kernel stack, precede the output",
"              with a task-identifying header.",
"          -T  Same as -t, except only the active task(s) are considered.",
"      -e end  Stop the search at this hexadecimal user or kernel virtual",
"              address, kernel symbol, or physical address.  The end address",
"              must be appropriate for the memory type specified.",
"   -l length  Length in bytes of address range to search.",
"     -m mask  Ignore the bits that are set in the hexadecimal mask value.",
"          -c  Search for character string values instead of unsigned longs.  If",
"              the string contains any space(s), it must be encompassed by double",
"              quotes.",
"          -w  Search for unsigned hexadecimal ints instead of unsigned longs.",
"              This is only meaningful on 64-bit systems in order to search both",
"              the upper and lower 32-bits of each 64-bit long for the value.",
"          -h  Search for unsigned hexadecimal shorts instead of unsigned longs.",
"    -x count  Display the memory contents before and after any found value.  The",
"              before and after memory context will consist of \"count\" memory",
"              items of the same size as the \"value\" argument.  This option is",
"              not applicable with the -c option.",
"       value  Search for this hexadecimal long, unless modified by the -c, -w, ",
"              or -h options.",
"(expression)  Search for the value of this expression; the expression value must",
"              not overflow the designated size when -h or -w are used; not",
"              applicable when used with the -c option.",
"      symbol  Search for this symbol value; the symbol value must not overflow",
"              the designated size when -h or -w are used; not applicable when ",
"              used with the -c option.",
"      string  Search for character string values; if the string contains any ",
"              space(s), it must be encompassed by double quotes; only applicable",
"              with the -c option.",
" ",
"  If -k, -K, -V, -u, -p or -t are not used, then the search defaults to kernel",
"  virtual address space.  The starting address must be long-word aligned. ",
"  Address ranges that start in user space and end in kernel space are not",
"  accepted.",
"\nEXAMPLES",
"  Search the current context's address space for all instances of 0xdeadbeef:",
"\n    %s> search -u deadbeef",
"    81aba5c: deadbeef",
"    81abaa8: deadbeef",
"    bfffc698: deadbeef",
"    bffff390: deadbeef",
"\n  Search all kernel memory above the kernel text space for all instances",
"  of 0xabcd occurring in the lower 16-bits of each 32-bit word: \n",
"    %s> search -s _etext -m ffff0000 abcd",
"    c071481c: abcd",
"    c0c2b0fc: 804abcd",
"    c0cf5e74: 7489abcd",
"    c17c0b44: c012abcd",
"    c1dac730: 3dbeabcd",
"    c226d0e8: ffffabcd",
"    c23ed5dc: abcd",
"    c3022544: 3dbeabcd",
"    c3069b58: 3dbeabcd",
"    c3e86e84: aabcd",
"    c3e88ed0: aabcd",
"    c3e8ee5c: aabcd",
"    c3e9df50: aabcd",
"    c3e9e930: aabcd",
"    c440a778: 804abcd",
"    c486eb44: 3dbeabcd",
"    c578f0fc: 804abcd",
"    c6394f90: 8ababcd",
"    c65219f0: 3abcd",
"    c661399c: abcd",
"    c68514ac: 8abcd",
"    c7e036bc: 3dbeabcd",
"    c7e12568: 5abcd",
"    c7e1256c: 5abcd",
"\n  Search the 4K page at c532c000 for all instances of 0xffffffff:\n",
"    %s> search -s c532c000 -l 4096 ffffffff",
"    c532c33c: ffffffff",
"    c532c3fc: ffffffff",
"\n  Search the static kernel data area for all instances of c2d400eb:\n",
"    %s> search -s _etext -e _edata c2d400eb",
"    c022b550: c2d400eb",
"    c022b590: c2d400eb",
"    c022b670: c2d400eb",
"    c022b6e0: c2d400eb",
"    c022b7b0: c2d400eb",
"    c022b7e0: c2d400eb",
"    c022b8b0: c2d400eb",
"\n  Search physical memory for all instances of 0xbabe occurring in the",
"  upper 16 bits of each 32-bit word:\n",
"    %s> search -p babe0000 -m ffff",
"    2a1dc4: babe671e",
"    2b6928: babe3de1",
"    2f99ac: babe0d54",
"    31843c: babe70b9",
"    3ba920: babeb5d7",
"    413ce4: babe7540",
"    482747c: babe2600",
"    48579a4: babe2600",
"    4864a68: babe2600",
"    ...",
"\n  Search physical memory for all instances of 0xbabe occurring in the",
"  upper 16 bits of each 32-bit word on a 64-bit system:\n",
"    %s> search -p babe0000 -m ffff -w",
"    102e248: babe1174",
"    11d2f90: babe813d",
"    122d3ad70: babe6b27",
"    124d8cd30: babe3dc8",
"    124d8eefc: babef981",
"    124d8f060: babe3dc8",
"    124d8f17c: babefc81",
"    ...",
"\n  Search kernel memory for all instances of 32-bit value 0xbabe1174",
"  on a 64-bit system:\n",
"    %s> search -k -w babe1174",
"    ffff88000102e248: babe1174",
"    ffffffff8102e248: babe1174",
"\n  Search kernel memory for two strings:\n",
"    %s> search -k -c \"can\'t allocate memory\" \"Failure to\"",
"    ffff8800013ddec1: can\'t allocate memory for key lists..<3>%%s %%s: error con",
"    ffff8801258be748: Failure to install fence: %%d..<3>[drm:%%s] *ERROR* Failed",
"    ffff880125f07ec9: can\'t allocate memory..<3>ACPI: Invalid data..Too many d",
"    ffffffff813ddec1: can\'t allocate memory for key lists..<3>%%s %%s: error con",
"\n  Search the kernel stacks of all tasks for those that contain the inode",
"  address ffff81002c0a3050:\n",
"    %s> search -t ffff81002c0a3050",
"    PID: 4876   TASK: ffff81003e9f5860  CPU: 7   COMMAND: \"automount\"",
"    ffff8100288fbe98: ffff81002c0a3050",
"    ",
"    PID: 4880   TASK: ffff81003ce967a0  CPU: 0   COMMAND: \"automount\"",
"    ffff81002c0fbdd8: ffff81002c0a3050",
"    ffff81002c0fbe78: ffff81002c0a3050",
"\n  When a kernel symbol or an (expression) is used an argument, both the",
"  resultant value and the input string are displayed:\n",
"    %s> search anon_inode_inode (__down_interruptible+191)",
"    ffff81000222a728: ffffffff80493d60 (anon_inode_inode)",
"    ffff810005a1e918: ffffffff800649d6 (__down_interruptible+191)",
"    ffff810005a1e9d0: ffffffff800649d6 (__down_interruptible+191)",
"    ffff810005a1eb48: ffffffff800649d6 (__down_interruptible+191)",
"    ffff81000b409c60: ffffffff80493d60 (anon_inode_inode)",
"    ffff81000c155b98: ffffffff80493d60 (anon_inode_inode)",
"    ffff8100194fac70: ffffffff80493d60 (anon_inode_inode)",
"    ffff81001daa1008: ffffffff80493d60 (anon_inode_inode)",
"    ffff810028b95830: ffffffff800649d6 (__down_interruptible+191)",
"    ffff81002cea0c70: ffffffff80493d60 (anon_inode_inode)",
"    ffff810031327268: ffffffff80493d60 (anon_inode_inode)",
"    ffff810031327270: ffffffff800649d6 (__down_interruptible+191)",
"    ffff810034b1ccd0: ffffffff800649d6 (__down_interruptible+191)",
"    ffff8100399565a8: ffffffff80493d60 (anon_inode_inode)",
"    ffff81003a278cd0: ffffffff800649d6 (__down_interruptible+191)",
"    ffff81003cc23e08: ffffffff800649d6 (__down_interruptible+191)",
NULL               
};


char *help_irq[] = {
"irq",
"IRQ data",
"[[[index ...] | -u ] | -d | -b | -a | -s [-c cpu]]",
"  This command collaborates the data in an irq_desc_t, along with its",
"  associated hw_interrupt_type and irqaction structure data, into a",
"  consolidated per-IRQ display.  For kernel versions 2.6.37 and later",
"  the display consists of the irq_desc/irq_data address, its irqaction",
"  address(es), and the irqaction name strings.  Alternatively, the", 
"  intel interrupt descriptor table, bottom half data, cpu affinity for",
"  in-use irqs, or kernel irq stats may be displayed.  If no index value",
"  argument(s) nor any options are entered, the IRQ data for all IRQs will",
"  be displayed.\n",
"    index   a valid IRQ index.",
"       -u   dump data for in-use IRQs only.",
"       -d   dump the intel interrupt descriptor table.",
"       -b   dump bottom half data.",
"       -a   dump cpu affinity for in-use IRQs.",
"       -s   dump the kernel irq stats; if no cpu specified with -c, the",
"            irq stats of all cpus will be displayed.",
"   -c cpu   only usable with the -s option, dump the irq stats of the ",
"            specified cpu[s]; cpu can be specified as \"1,3,5\", \"1-3\",",
"            \"1,3,5-7,10\", \"all\", or \"a\" (shortcut for \"all\").",
"\nEXAMPLES",
"  Display the relevant data for IRQ 18 from a pre-2.6.37 kernel:\n", 
"    %s> irq 18",
"        IRQ: 18",
"     STATUS: 0 ",
"    HANDLER: c02301e0  <ioapic_level_irq_type>",
"             typename: c01f9e0c  \"IO-APIC-level\"",
"              startup: c0110234  <unmask_IO_APIC_irq>",
"             shutdown: c01101cc  <mask_IO_APIC_irq>",
"               handle: c0110518  <do_level_ioapic_IRQ>",
"               enable: c0110234  <unmask_IO_APIC_irq>",
"              disable: c01101cc  <mask_IO_APIC_irq>",
"     ACTION: c009c6b0",
"              handler: c01ce818  <do_aic7xxx_isr>",
"                flags: 4000000  (SA_SHIRQ)",
"                 mask: 0",
"                 name: c0217780  \"aic7xxx\"",
"               dev_id: c0090078",
"                 next: c009c770",
"     ACTION: c009c770",
"              handler: c01ce818  <do_aic7xxx_isr>",
"                flags: 4000000  (SA_SHIRQ)",
"                 mask: 0",
"                 name: c0217780  \"aic7xxx\"",
"               dev_id: c0091078",
"                 next: 0",
"      DEPTH: 0\n",
"  Display the relevant data for IRQ 21 from a 2.6.37 kernel:\n", 
"    %s> irq 21",
"     IRQ   IRQ_DESC/_DATA      IRQACTION      NAME",
"     21   ffff88003787f780  ffff8800379a8b40  \"ehci_hcd:usb2\"",
"                            ffff8800379cbac0  \"uhci_hcd:usb5\"",
"                            ffff8800379cb140  \"uhci_hcd:usb7\"",
" ",
"  Display the intel interrupt descriptor table entries:\n",
"    %s> irq -d",
"      [0] divide_error",
"      [1] debug",
"      [2] nmi",
"      [3] int3",
"      [4] overflow",
"      [5] bounds",
"      [6] invalid_op",
"      [7] device_not_available",
"      [8] double_fault",
"      [9] coprocessor_segment_overrun",
"     [10] invalid_TSS",
"     [11] segment_not_present",
"     [12] stack_segment",
"     [13] general_protection",
"     [14] page_fault",
"     [15] spurious_interrupt_bug",
"     [16] coprocessor_error",
"     [17] alignment_check",
"     [18] ignore_int",
"     [19] ignore_int",
"     [20] ignore_int",
"     [21] ignore_int",
"    ...\n",
"    [250] IRQ0xda_interrupt",
"    [251] IRQ0xdb_interrupt",
"    [252] IRQ0xdc_interrupt",
"    [253] IRQ0xdd_interrupt",
"    [254] IRQ0xde_interrupt",
"    [255] spurious_interrupt\n",
"  Display the bottom half data:\n",
"    %s> irq -b",
"    SOFTIRQ_VEC      ACTION     ",
"        [0]     ffffffff81068f60  <tasklet_hi_action> ",
"        [1]     ffffffff81071b80  <run_timer_softirq> ",
"        [2]     ffffffff813e6f30  <net_tx_action> ",
"        [3]     ffffffff813ee370  <net_rx_action> ",
"        [4]     ffffffff81211a60  <blk_done_softirq> ",
"        [5]     ffffffff812122f0  <blk_iopoll_softirq> ",
"        [6]     ffffffff81069090  <tasklet_action> ",
"        [7]     ffffffff81058830  <run_rebalance_domains> ",
"        [8]     ffffffff81087f00  <run_hrtimer_softirq> ",
"        [9]     ffffffff810ca7a0  <rcu_process_callbacks> \n",
"  Display the cpu affinity for in-use IRQs:\n",
"    %s> irq -a",
"    IRQ NAME                 AFFINITY",
"      0 timer                0-23",
"      1 i8042                0-23",
"      8 rtc0                 0-23",
"      9 acpi                 0-23",
"     16 ehci_hcd:usb2,uhci_hcd:usb3,uhci_hcd:usb6 0,6,18",
"     17 uhci_hcd:usb4,uhci_hcd:usb7 0-23",
"     18 ehci_hcd:usb1,uhci_hcd:usb5,uhci_hcd:usb8,ioc0 0,11,23",
"     24 dmar0                0",
"     35 pciehp               0-23",
"     36 pciehp               0-23",
"     37 pciehp               0-23",
"     38 pciehp               0-23",
"     39 megasas              0-5,12-17",
"     40 lpfc:sp              0-5,12-17",
"     41 lpfc:fp              0,6-11,18-23",
"     42 lpfc:sp              0,6-11,18-23",
"     43 lpfc:fp              0,6-11,18-23",
"    ...\n",
"     80 ioat-msix            0-23",
"     81 ioat-msix            0-23",
"     82 ioat-msix            0-23",
"     83 ioat-msix            0-23",
"     84 ioat-msix            0-23",
"     85 ioat-msix            0-23",
"     86 ioat-msix            0-23",
"     87 ioat-msix            0-23",
"     88 eth4                 0,17\n",
"  Display the kernel irq stats:\n",
"    %s>irq -c 0,2 -s",
"               CPU0       CPU2 ",
"      0: 2068161471          0 IR-IO-APIC-edge     timer",
"      1:          9          0 IR-IO-APIC-edge     i8042",
"      8:          1          0 IR-IO-APIC-edge     rtc0",
"      9:          0          0 IR-IO-APIC-fasteoi  acpi",
"     16:         36          0 IR-IO-APIC-fasteoi  ehci_hcd:usb2",
"    ...\n",
"     85:          3          0 IR-PCI-MSI-edge     ioat-msix",
"     86:          3          0 IR-PCI-MSI-edge     ioat-msix",
"     87:          3          0 IR-PCI-MSI-edge     ioat-msix",
"     88:         24        295 IR-PCI-MSI-edge     eth4",
NULL               
};


char *help_ipcs[] = {
"ipcs",                            
"System V IPC facilities",  
"[-smMq] [-n pid|task] [id | addr]",
 
"  This command provides information on the System V IPC facilities.  With no",
"  arguments, the command will display kernel usage of all three facilities.",
"  ",
"       -s  show semaphore arrays.",
"       -m  show shared memory segments.",
"       -M  show shared memory segments with additional details.",
"       -q  show message queues.",
"       id  show the data associated with this resource ID.",
"     addr  show the data associated with this virtual address of a",
"           shmid_kernel, sem_array or msq_queue.",
"",
"  For kernels supporting namespaces, the -n option may be used to",
"  display the IPC facilities with respect to the namespace of a",
"  specified task:\n",
"  -n pid   a process PID.",
"  -n task  a hexadecimal task_struct pointer.",
"\nEXAMPLES",
"  Display all IPC facilities:\n",
"    %s> ipcs",
"    SHMID_KERNEL     KEY      SHMID      UID   PERMS BYTES      NATTCH STATUS",
"    ffff880473a28310 00000000 0          0     666   90000      1       ",
"    ffff880473a28490 00000001 32769      0     666   90000      1       ",
"    ffff880473a28250 00000002 65538      0     666   90000      1       ",
"    ",
"    SEM_ARRAY        KEY      SEMID      UID   PERMS NSEMS     ",
"    ffff88047200f9d0 00000000 0          0     600   1         ",
"    ffff88046f826910 00000000 32769      0     600   1         ",
"    ",
"    MSG_QUEUE        KEY      MSQID      UID   PERMS USED-BYTES   MESSAGES",
"    ffff8100036bb8d0 000079d7 0          3369  666   16640        104",         
"    ffff8100036bb3d0 000079d8 32769      3369  666   12960        81",          
"    ffff810026d751d0 000079d9 65538      3369  666   10880        68",
"    ",
"  Display shared memory usage with detailed information:\n",
"    %s> ipcs -M",
"    SHMID_KERNEL     KEY      SHMID      UID   PERMS BYTES      NATTCH STATUS",
"    ffff880473a28310 00000000 0          0     666   90000      1       ",
"    PAGES ALLOCATED/RESIDENT/SWAPPED: 22/1/0",
"    INODE: ffff88047239cd98",
"    ",
"    SHMID_KERNEL     KEY      SHMID      UID   PERMS BYTES      NATTCH STATUS",
"    ffff880473a28490 00000001 32769      0     666   90000      1       ",
"    PAGES ALLOCATED/RESIDENT/SWAPPED: 22/1/0",
"    INODE: ffff88047239c118",
"    ",
"    SHMID_KERNEL     KEY      SHMID      UID   PERMS BYTES      NATTCH STATUS",
"    ffff880473a28250 00000002 65538      0     666   90000      1       ",
"    PAGES ALLOCATED/RESIDENT/SWAPPED: 22/1/0",
"    INODE: ffff880470503758",
"    ",
"  Display the shared memory data associated with shmid_kernel ffff880473a28250:\n",
"    %s> ipcs -M ffff880473a28250",
"    SHMID_KERNEL     KEY      SHMID      UID   PERMS BYTES      NATTCH STATUS",
"    ffff880473a28250 00000002 65538      0     666   90000      1       ",
"    PAGES ALLOCATED/RESIDENT/SWAPPED: 22/1/0",
"    INODE: ffff880470503758",
NULL
};

char *help_cpu[] = {
"cpu",
"set context to the active task on a cpu",
"[cpu]",
"  This command sets the current context to the active task on a cpu.  If no",
"  argument is given, the current context is displayed.\n",
"    cpu   a valid cpu number\n",
"  This command is not allowable on live systems.",
"\nEXAMPLES",
"    %s> cpu 1",
"         PID: 286",
"     COMMAND: \"in.rlogind\"",
"        TASK: c0b3a000 ",
"         CPU: 1 ",
"       STATE: TASK_RUNNING (ACTIVE)",
NULL               
};


char *help_sys[] = {
"sys",
"system data",
"[-c [name|number]] [-t] [-i] config",
"  This command displays system-specific data.  If no arguments are entered,\n"
"  the same system data shown during %s invocation is shown.\n",
"    -c [name|number]  If no name or number argument is entered, dump all",
"                      sys_call_table entries.  If a name string is entered,",
"                      search the table for all entries containing the string.",
"                      If a number is entered, the table entry associated with",
"                      that number is displayed.  If the current output radix",
"                      has been set to 16, the system call numbers will be ",
"                      displayed in hexadecimal.",
"    config            If the kernel was configured with CONFIG_IKCONFIG, then",
"                      dump the in-kernel configuration data.",
"    -t                Display kernel taint information.  If the \"tainted_mask\"",
"                      symbol exists, show its hexadecimal value and translate",
"                      each bit set to the symbolic letter of the taint type.",
"                      On older kernels with the \"tainted\" symbol, only its",
"                      hexadecimal value is shown.  The relevant kernel sources",
"                      should be consulted for the meaning of the letter(s) or",
"                      hexadecimal bit value(s).",
"    -panic            Panic a live system.  Requires write permission to", 
"                      /dev/mem.  Results in the %s context causing an",
"                      \"Attempted to kill the idle task!\" panic.  (The dump",
"                      will indicate that the %s context has a PID of 0).",
"    -i                Dump the DMI string data if available in the kernel.",

"\nEXAMPLES",
"  Display essential system information:\n",
"    %s> sys",
"          KERNEL: vmlinux.4",
"        DUMPFILE: lcore.cr.4",
"            CPUS: 4",
"            DATE: Mon Oct 11 18:48:55 1999",
"          UPTIME: 10 days, 14:14:39",
"    LOAD AVERAGE: 0.74, 0.23, 0.08",
"           TASKS: 77",
"        NODENAME: test.mclinux.com",
"         RELEASE: 2.2.5-15smp",
"         VERSION: #24 SMP Mon Oct 11 17:41:40 CDT 1999",
"         MACHINE: i686  (500 MHz)",
"          MEMORY: 1 GB",
"\n  Dump the system configuration data (if CONFIG_IKCONFIG):\n",
"    %s> sys config",
"    #",
"    # Automatically generated make config: don't edit",
"    # Linux kernel version: 2.6.16",
"    # Mon Apr 10 07:58:06 2006",
"    #",
"    CONFIG_X86_64=y",
"    CONFIG_64BIT=y",
"    CONFIG_X86=y",
"    CONFIG_SEMAPHORE_SLEEPERS=y",
"    CONFIG_MMU=y",
"    CONFIG_RWSEM_GENERIC_SPINLOCK=y",
"    CONFIG_GENERIC_CALIBRATE_DELAY=y",
"    CONFIG_X86_CMPXCHG=y",
"    CONFIG_EARLY_PRINTK=y",
"    CONFIG_GENERIC_ISA_DMA=y",
"    CONFIG_GENERIC_IOMAP=y",
"    CONFIG_ARCH_MAY_HAVE_PC_FDC=y",
"    CONFIG_DMI=y",
"    ...",
"\n  Display the kernel taint information, in this case where both the",
"  TAINT_WARN and TAINT_PROPRIETARY_MODULE bits have been set:\n",
"    %s> sys -t",
"    TAINTED_MASK: 201  PW",
"\n  Dump the system call table:\n",
"    %s> sys -c",
"    NUM  SYSTEM CALL                FILE AND LINE NUMBER",
"      0  sys_ni_syscall             ../kernel/sys.c: 48",
"      1  sys_exit                   ../kernel/exit.c: 404",
"      2  sys_fork                   ../arch/i386/kernel/process.c: 771",
"      3  sys_read                   ../fs/read_write.c: 117",
"      4  sys_write                  ../fs/read_write.c: 146",
"      5  sys_open                   ../fs/open.c: 754",
"      6  sys_close                  ../fs/open.c: 839",
"      7  sys_waitpid                ../kernel/exit.c: 503",
"      8  sys_creat                  ../fs/open.c: 789",
"      9  sys_link                   ../fs/namei.c: 1213",
"     10  sys_unlink                 ../fs/namei.c: 1074",
"     11  sys_execve                 ../arch/i386/kernel/process.c: 806",
"    ...",
"\n  Find the system call number of the select system call:\n",
"    %s> sys -c select",
"    NUM  SYSTEM CALL                FILE AND LINE NUMBER",
"     65  sys_select                 ../fs/select.c: 259",
" ",
"    If the current output radix has been set to 16, the system call numbers",
"    will be displayed in hexadecimal.",
"\n  Dump the DMI string data:\n",
"    %s> sys -i",
"            DMI_BIOS_VENDOR: LENOVO",
"           DMI_BIOS_VERSION: G4ET37WW (1.12 )",
"              DMI_BIOS_DATE: 05/29/2012",
"             DMI_SYS_VENDOR: LENOVO",
"           DMI_PRODUCT_NAME: 2429BQ1",
"        DMI_PRODUCT_VERSION: ThinkPad T530",
"         DMI_PRODUCT_SERIAL: R9R91HZ",
"           DMI_PRODUCT_UUID: 568DFA01-5180-11CB-B851-BD06085ADDB0",
"           DMI_BOARD_VENDOR: LENOVO",
"             DMI_BOARD_NAME: 2429BQ1",
"          DMI_BOARD_VERSION: Not Available",
"           DMI_BOARD_SERIAL: 1ZLV127F17M",
"        DMI_BOARD_ASSET_TAG: Not Available",
"         DMI_CHASSIS_VENDOR: LENOVO",
"           DMI_CHASSIS_TYPE: 10",
"        DMI_CHASSIS_VERSION: Not Available",
"         DMI_CHASSIS_SERIAL: R9R91HZ",
"      DMI_CHASSIS_ASSET_TAG: RH0004111",
NULL               
};

char *help_log[] = {
"log",
"dump system message buffer",
"[-TtdmascR]",
"  This command dumps the kernel log_buf contents in chronological order.  The",
"  command supports the older log_buf formats, which may or may not contain a",
"  timestamp inserted prior to each message, as well as the newer variable-length", 
"  record format, where the timestamp is contained in each log entry's header.",
"  ",
"    -T  Display the message text with human readable timestamp.",
"        (Be aware that the timestamp could be inaccurate!  The timestamp is",
"         from local_clock(), which is different from the elapsed wall time.)",
"    -t  Display the message text without the timestamp; only applicable to the",
"        variable-length record format.",
"    -d  Display the dictionary of key/value pair properties that are optionally",
"        appended to a message by the kernel's dev_printk() function; only",
"        applicable to the variable-length record format.",
"    -m  Display the message log level in brackets preceding each message.  For",
"        the variable-length record format, the level will be displayed in ",
"        hexadecimal.  In older kernels, by default, the facility/flag bits",
"        will be stripped to only show the level, but if needed, can still be",
"        shown with 'set debug 1'.",
"    -a  Dump the audit logs remaining in kernel audit buffers that have not",
"        been copied out to the user-space audit daemon.",
"    -s  Dump the printk logs remaining in kernel safe per-CPU buffers that",
"        have not been flushed out to log_buf.",
"    -c  Display the caller id field that identifies either the thread id or",
"        the CPU id (if in CPU context) that called printk(), if available.",
"        Generally available on Linux 5.1 to 5.9 kernels configured with",
"        CONFIG_PRINTK_CALLER or Linux 5.10 and later kernels.",
"    -R  Display the message text with human readable Rust symbol name if any,",
"        otherwise still print the original message text.",
" ",
"\nEXAMPLES",
"  Dump the kernel message buffer:\n",
"    %s> log",
"    Linux version 2.2.5-15smp (root@mclinux1) (gcc version egcs-2.91.66 19990",
"    314/Linux (egcs-1.1.2 release)) #1 SMP Thu Aug 26 11:04:37 EDT 1999",
"    Intel MultiProcessor Specification v1.4",
"        Virtual Wire compatibility mode.",
"    OEM ID: DELL     Product ID: WS 410       APIC at: 0xFEE00000",
"    Processor #0 Pentium(tm) Pro APIC version 17",
"    Processor #1 Pentium(tm) Pro APIC version 17",
"    I/O APIC #2 Version 17 at 0xFEC00000.",
"    Processors: 2",
"    mapped APIC to ffffe000 (fee00000)",
"    mapped IOAPIC to ffffd000 (fec00000)",
"    Detected 447696347 Hz processor.",
"    Console: colour VGA+ 80x25",
"    Calibrating delay loop... 445.64 BogoMIPS",
"    ...",
"      8K byte-wide RAM 5:3 Rx:Tx split, autoselect/Autonegotiate interface.",
"      MII transceiver found at address 24, status 782d.",
"      Enabling bus-master transmits and whole-frame receives.",
"    Installing knfsd (copyright (C) 1996 okir@monad.swb.de).",
"    nfsd_init: initialized fhcache, entries=256",
"    ...",
" ",
"  Do the same thing, but also show the log level preceding each message:\n",
"    %s> log -m",
"    <4>Linux version 2.2.5-15smp (root@mclinux1) (gcc version egcs-2.91.66 19990",
"    314/Linux (egcs-1.1.2 release)) #1 SMP Thu Aug 26 11:04:37 EDT 1999",
"    <4>Intel MultiProcessor Specification v1.4",
"    <4>    Virtual Wire compatibility mode.",
"    <4>OEM ID: DELL     Product ID: WS 410       APIC at: 0xFEE00000",
"    <4>Processor #0 Pentium(tm) Pro APIC version 17",
"    <4>Processor #1 Pentium(tm) Pro APIC version 17",
"    <4>I/O APIC #2 Version 17 at 0xFEC00000.",
"    <4>Processors: 2",
"    <4>mapped APIC to ffffe000 (fee00000)",
"    <4>mapped IOAPIC to ffffd000 (fec00000)",
"    <4>Detected 447696347 Hz processor.",
"    <4>Console: colour VGA+ 80x25",
"    <4>Calibrating delay loop... 445.64 BogoMIPS",
"    ...",
"    <6>  8K byte-wide RAM 5:3 Rx:Tx split, autoselect/Autonegotiate interface.",
"    <6>  MII transceiver found at address 24, status 782d.",
"    <6>  Enabling bus-master transmits and whole-frame receives.",
"    <6>Installing knfsd (copyright (C) 1996 okir@monad.swb.de).",
"    <7>nfsd_init: initialized fhcache, entries=256",
"    ... ",
" ",
"  On a system with the variable-length record format, and whose log_buf has been",
"  filled and wrapped around, display the log with timestamp data:\n",
"    %s> log",
"    [    0.467730] pci 0000:ff:02.0: [8086:2c10] type 00 class 0x060000",
"    [    0.467749] pci 0000:ff:02.1: [8086:2c11] type 00 class 0x060000",
"    [    0.467769] pci 0000:ff:02.4: [8086:2c14] type 00 class 0x060000",
"    [    0.467788] pci 0000:ff:02.5: [8086:2c15] type 00 class 0x060000",
"    [    0.467809] pci 0000:ff:03.0: [8086:2c18] type 00 class 0x060000",
"    [    0.467828] pci 0000:ff:03.1: [8086:2c19] type 00 class 0x060000",
"    ...",
" ",
"  Display the same message text as above, without the timestamp data:\n",
"    %s> log -t",
"    pci 0000:ff:02.0: [8086:2c10] type 00 class 0x060000",
"    pci 0000:ff:02.1: [8086:2c11] type 00 class 0x060000",
"    pci 0000:ff:02.4: [8086:2c14] type 00 class 0x060000",
"    pci 0000:ff:02.5: [8086:2c15] type 00 class 0x060000",
"    pci 0000:ff:03.0: [8086:2c18] type 00 class 0x060000",
"    pci 0000:ff:03.1: [8086:2c19] type 00 class 0x060000",
"    ...",
" ",
"  Display the same message text as above, with appended dictionary data:\n",
"    %s> log -td",
"    pci 0000:ff:02.0: [8086:2c10] type 00 class 0x060000",
"    SUBSYSTEM=pci",
"    DEVICE=+pci:0000:ff:02.0",
"    pci 0000:ff:02.1: [8086:2c11] type 00 class 0x060000",
"    SUBSYSTEM=pci",
"    DEVICE=+pci:0000:ff:02.1",
"    pci 0000:ff:02.4: [8086:2c14] type 00 class 0x060000",
"    SUBSYSTEM=pci",
"    DEVICE=+pci:0000:ff:02.4",
"    pci 0000:ff:02.5: [8086:2c15] type 00 class 0x060000",
"    SUBSYSTEM=pci",
"    DEVICE=+pci:0000:ff:02.5",
"    pci 0000:ff:03.0: [8086:2c18] type 00 class 0x060000",
"    SUBSYSTEM=pci",
"    DEVICE=+pci:0000:ff:03.0",
"    pci 0000:ff:03.1: [8086:2c19] type 00 class 0x060000",
"    SUBSYSTEM=pci",
"    DEVICE=+pci:0000:ff:03.1",
"    ...",
" ",
"  Dump the kernel audit logs:\n",
"    %s> log -a",
"    type=1320 audit(1489384479.809:4342):",
"    type=1300 audit(1489384479.809:4343): arch=c000003e syscall=0 success=yes ",
"    exit=0 a0=4 a1=7f84154a2000 a2=400 a3=22 items=0 ppid=2560 pid=2591 auid=0 ",
"    uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=ttyS0 ses=1 ",
"    comm=\"pidof\" exe=\"/usr/sbin/killall5\" ",
"    subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 key=(null)",
"    type=1320 audit(1489384479.809:4343):",
"    type=1300 audit(1489384479.809:4344): arch=c000003e syscall=3 success=yes ",
"    exit=0 a0=4 a1=1 a2=8 a3=0 items=0 ppid=2560 pid=2591 auid=0 uid=0 gid=0 ",
"    euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=ttyS0 ses=1 comm=\"pidof\" ",
"    exe=\"/usr/sbin/killall5\" ",
"    subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 key=(null)",
"    type=1320 audit(1489384479.809:4344):",
"    type=1300 audit(1489384479.809:4345): arch=c000003e syscall=11 ",
"    success=yes exit=0 a0=7f84154a2000 a1=1000 a2=0 a3=0 items=0 ppid=2560 ",
"    pid=2591 auid=0 uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 ",
"    tty=ttyS0 ses=1 comm=\"pidof\" exe=\"/usr/sbin/killall5\" ",
"    subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 key=(null)",
"    type=1320 audit(1489384479.809:4345):",
"    type=1300 audit(1489384479.809:4346): arch=c000003e syscall=2 success=yes ",
"    exit=4 a0=7ffcfd20f5a0 a1=0 a2=1b6 a3=24 items=1 ppid=2560 pid=2591 auid=0",
"    uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=ttyS0 ses=1 ",
"    comm=\"pidof\" exe=\"/usr/sbin/killall5\" ",
"    subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 key=(null)",
"    type=1307 audit(1489384479.809:4346):  cwd=\"/proc\"",
"    ...",
" ",
"  Display the message text with human readable timestamp:\n",
"    %s> log -T",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x0000000000000000-0x000000000009fbff] usable",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x000000000009fc00-0x000000000009ffff] reserved",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x00000000000f0000-0x00000000000fffff] reserved",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x0000000000100000-0x00000000dffeffff] usable",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x00000000dfff0000-0x00000000dfffffff] ACPI data",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x00000000fec00000-0x00000000fec00fff] reserved",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x00000000fee00000-0x00000000fee00fff] reserved",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x00000000fffc0000-0x00000000ffffffff] reserved",
"    [Sat Apr  4 07:41:09 2020] BIOS-e820: [mem 0x0000000100000000-0x000000011fffffff] usable",
"    [Sat Apr  4 07:41:09 2020] NX (Execute Disable) protection: active",
"    [Sat Apr  4 07:41:09 2020] SMBIOS 2.5 present.",
"    [Sat Apr  4 07:41:09 2020] DMI: innotek GmbH VirtualBox/VirtualBox, BIOS VirtualBox 12/01/2006",
"    [Sat Apr  4 07:41:09 2020] Hypervisor detected: KVM",
"    [Sat Apr  4 07:41:09 2020] kvm-clock: Using msrs 4b564d01 and 4b564d00",
"    [Sat Apr  4 07:41:09 2020] kvm-clock: cpu 0, msr 6de01001, primary cpu clock",
"    [Sat Apr  4 07:41:09 2020] kvm-clock: using sched offset of 11838753697 cycles",
"    [Sat Apr  4 07:41:09 2020] clocksource: kvm-clock: mask: 0xffffffffffffffff max_cycles: 0x1cd42e4dffb, max_idle_ns: 881590591483 ns",
"    [Sat Apr  4 07:41:09 2020] e820: update [mem 0x00000000-0x00000fff] usable ==> reserved",
"    [Sat Apr  4 07:41:09 2020] e820: remove [mem 0x000a0000-0x000fffff] usable",
"    [Sat Apr  4 07:41:09 2020] last_pfn = 0x120000 max_arch_pfn = 0x400000000",
"    [Sat Apr  4 07:41:09 2020] MTRR default type: uncachable",
"    [Sat Apr  4 07:41:09 2020] MTRR variable ranges disabled:",
"    ...",
" ",
"  On a system which has printk_safe_seq_buf buffer,",
"  display its unflushed log with buffer name:\n",
"    %s> log",
"    ...",
"    [nmi_print_seq] Uhhuh. NMI received for unknown reason 30 on CPU 0.",
"    [nmi_print_seq] Do you have a strange power saving mode enabled?",
"    [nmi_print_seq] Dazed and confused, but trying to continue",
" ",
"  Dump the printk safe buffers:\n",
"    %s> log -s",
"    PRINTK_SAFE_SEQ_BUF: nmi_print_seq",
"    CPU: 0  ADDR: ffff8ca4fbc19ce0 LEN: 150  MESSAGE_LOST: 0",
"      Uhhuh. NMI received for unknown reason 20 on CPU 0.",
"      Do you have a strange power saving mode enabled?",
"      Dazed and confused, but trying to continue",
"    ...",
"    PRINTK_SAFE_SEQ_BUF: safe_print_seq",
"    CPU: 0  ADDR: ffff8ca4fbc1ad00 LEN: 0  MESSAGE_LOST: 0",
"      (empty)",
"    ...",
" ",
"  Display the caller id that identifies the thread id of the task (begins",
"  with 'T') or the processor id (begins with 'C' for in CPU context) that",
"  called printk(), if available.\n",
"    %s> log -c",
"    ...",
"    [    0.014179] [     T1] Secure boot disabled",
"    [    0.014179] [    T29] RAMDISK: [mem 0x3cf4f000-0x437bbfff]",
"    [    0.198789] [     C0] DMAR: DRHD: handling fault status reg 3",
"    ...",
" ",
"  Display the message text with human readable Rust symbol name if any,",
"  otherwise still print the original message text.\n",
"    %s> log -R",
"    ...",
"    [ 2174.289360] Tainted: [S]=CPU_OUT_OF_SPEC, [O]=OOT_MODULE, [E]=UNSIGNED_MODULE",
"    [ 2174.297322] Hardware name: Intel Corporation S2600CWR/S2600CWR, BIOS SE5C610.86B.01.01.0018.072020161249 07/20/2016",
"    [ 2174.308966] Call Trace:",
"    [ 2174.311693]  <TASK>",
"    [ 2174.314033]  dump_stack_lvl+0x5d/0x80",
"    [ 2174.318125]  panic+0x156/0x32a",
"    [ 2174.321539]  rust_panic::area_in_hp+0xf7/0x120 [rust_panic]",
"    [ 2174.329700]  ? console_unlock+0x9c/0x140",
"    [ 2174.334080]  ? irq_work_queue+0x2d/0x50",
"    [ 2174.338352]  ? __pfx_init_module+0x10/0x10 [rust_panic]",
"    [ 2174.344183]  <rust_panic::HelloPanic>::step_two+0x20/0xe0 [rust_panic]",
"    [ 2174.353698]  ? _printk+0x6b/0x90",
"    [ 2174.357303]  init_module+0x57/0xff0 [rust_panic]",
"    [ 2174.362456]  ? __pfx_init_module+0x10/0x10 [rust_panic]",
"    ...",

NULL               
};

char *help_whatis[] = {
"whatis",
"search symbol table for data or type information",
"[[-o] [struct | union | typedef | symbol]] | \n         [[-r [size|range]] [-m member]]",
"  This command displays the definition of structures, unions, typedefs or",
"  text/data symbols:\n",
"    struct  a structure name. The output is the same as if the \"struct\"",
"            command was used.",
"     union  a union name. The output is the same as if the \"union\" command",
"            was used.", 
"        -o  display the offsets of structure/union members.",
"   typedef  a typedef name. If the typedef translates to a structure or union",
"            the output is the same as if the \"struct\" or \"union\" command",
"            was used. If the typedef is a primitive datatype, the one-line",
"            declaration is displayed.",
"    symbol  a kernel symbol.  ",
"",
"  Alternatively, a search can be made for data structures of a given size or",
"  size range, that contain a member of a given type, or contain a pointer to",
"  given type.  The -r and -m options may be used alone or in conjunction with",
"  one another:\n",
"   -r size  search for structures of this exact size.",
"  -r range  search for structures of a range of sizes, expressed as \"low-high\".",
" -m member  search for structures that contain a member of this data type, or",
"            that contain a pointer to this data type; if a structure contains ",
"            another structure, the members of the embedded structure will also",
"            be subject to the search. The member argument may also be expressed",
"            as a substring of a member's data type.", 
"\nEXAMPLES",
"   Display the definition of a linux_binfmt structure:\n", 
"    %s> whatis linux_binfmt",
"    struct linux_binfmt {",
"        struct list_head lh;",
"        struct module *module;",
"        int (*load_binary)(struct linux_binprm *);",
"        int (*load_shlib)(struct file *);",
"        int (*core_dump)(struct coredump_params *);",
"        unsigned long min_coredump;",
"    }",
"    SIZE: 56",
"",
"   Display the same structure with member offsets:\n", 
"    %s> whatis -o linux_binfmt",
"    struct linux_binfmt {",
"       [0] struct list_head lh;",
"      [16] struct module *module;",
"      [24] int (*load_binary)(struct linux_binprm *);",
"      [32] int (*load_shlib)(struct file *);",
"      [40] int (*core_dump)(struct coredump_params *);",
"      [48] unsigned long min_coredump;",
"    }",
"    SIZE: 56",
"",
"  Since a kmem_bufctl_t is typedef'd to be a kmem_bufctl_s structure, the",
"  output of the following two commands is identical:\n",
"    %s> whatis kmem_bufctl_s",
"    struct kmem_bufctl_s {",
"      union {",
"        struct kmem_bufctl_s  *buf_nextp;",
"        kmem_slab_t *buf_slabp;",
"        void *buf_objp;",
"      } u;",
"    };",
"    ",
"    %s> whatis kmem_bufctl_t",
"    struct kmem_bufctl_s {",
"      union {",
"        struct kmem_bufctl_s *buf_nextp;",
"        kmem_slab_t *buf_slabp;",
"        void *buf_objp;",
"      } u;",
"    };",
"    SIZE: 4  (0x4)",
"    ",
"  Display the type data of sys_read() and jiffies text and data symbols:\n", 
"    %s> whatis sys_read",
"    ssize_t sys_read(unsigned int, char *, size_t);",
" ",
"    %s> whatis jiffies",
"    long unsigned int jiffies;\n",
"  Display definition of a kdev_t typedef:\n",
"    %s> whatis kdev_t",
"    typedef short unsigned int kdev_t;",
"    SIZE: 2  (0x2)\n",
"  Display all structures which have a size of 192 bytes:\n",
"    %s> whatis -r 192",
"    SIZE  TYPE",
"     192  _intel_private",
"     192  blkcg_gq",
"     192  clock_event_device",
"     192  cper_sec_proc_generic",
"     192  dentry",
"     192  dst_ops",
"     192  ehci_itd",
"     192  ethtool_rxnfc",
"     192  fb_ops",
"     192  file_lock",
"     192  inode_operations",
"     192  input_device_id",
"     192  ip_vs_stats",
"     192  numa_group",
"     192  parallel_data",
"     192  pcie_port_service_driver",
"     192  pebs_record_hsw",
"     192  pnp_driver",
"     192  regmap_config",
"     192  sched_entity",
"     192  tcp_timewait_sock",
"     192  timerfd_ctx",
"     192  tpm_vendor_specific",
"     192  urb",
"",
"  Display all structures that contain members that point to ",
"  an mm_struct:\n",
"    %s> whatis -m mm_struct",
"    SIZE  TYPE",
"      16  tlb_state",
"      24  flush_tlb_info",
"      24  ftrace_raw_xen_mmu_pgd",
"      24  futex_key",
"      24  map_info",
"      32  ftrace_raw_xen_mmu_alloc_ptpage",
"      32  ftrace_raw_xen_mmu_pte_clear",
"      40  ftrace_raw_xen_mmu_flush_tlb_others",
"      40  ftrace_raw_xen_mmu_ptep_modify_prot",
"      40  ftrace_raw_xen_mmu_set_pte_at",
"      40  mm_slot",
"      64  mm_walk",
"      64  rmap_item",
"     104  userfaultfd_ctx",
"     128  mmu_gather",
"     216  vm_area_struct",
"     256  linux_binprm",
"    2616  rq",
"    2936  task_struct",
"",
"  Display all structures sized from 256 to 512 bytes that",
"  contain members that point to a task_struct:\n",
"    %s> whatis -r 256-512 -m task_struct",
"    SIZE  TYPE",
"     256  file",
"     256  od_cpu_dbs_info_s",
"     264  srcu_notifier_head",
"     272  protection_domain",
"     288  clk_notifier",
"     288  fsnotify_group",
"     296  quota_info",
"     312  tty_port",
"     320  workqueue_struct",
"     344  trace_array",
"     344  uart_state",
"     352  cpufreq_policy",
"     352  elf_thread_core_info",
"     376  perf_event_context",
"     384  rcu_data",
"     400  cgroup",
"     408  subsys_private",
"     424  hvc_struct",
"     496  psmouse",
NULL               
};


char *help_mount[] = {
"mount",
"mounted filesystem data",
"[-f][-i] [-n pid|task] [mount|vfsmount|superblock|dev|dir|dentry|inode]",
"  This command displays basic information about the currently-mounted",
"  filesystems.  The per-filesystem dirty inode list or list of open",
"  files for the filesystem may also be displayed.\n",
"     -f  dump dentries and inodes for open files in each filesystem; only",
"         supported on kernels prior to Linux 3.13.",
"     -i  dump all dirty inodes associated with each filesystem; only",
"         supported on kernels prior to Linux 2.6.32.\n",
"  For kernels supporting namespaces, the -n option may be used to",
"  display the mounted filesystems with respect to the namespace of a",
"  specified task:\n",
"     -n pid   a process PID.",
"     -n task  a hexadecimal task_struct pointer.\n",
"  Specific filesystems may be selected using the following forms:\n",
"    vfsmount  hexadecimal address of a filesystem vfsmount structure.",
"       mount  hexadecimal address of a filesystem mount structure (Linux 3.3",
"              and later).",
"  superblock  hexadecimal address of a filesystem super_block structure.",
"         dev  device name of a filesystem.",
"         dir  directory where a filesystem is mounted.",
"      dentry  hexadecimal address of an open dentry of a filesystem.",
"       inode  hexadecimal address of an open inode of a filesystem.",
" ",
"  The first column of the command output displays the filesystem's vfsmount",
"  structure address for kernels prior to Linux 3.3.  For Linux 3.3 and later",
"  kernels, the first column displays the filesystem's mount structure address,",
"  which contains an embedded vfsmount structure.",
"\nEXAMPLES",
"  Display mounted filesystem data:\n",
"    %s> mount",
"    VFSMOUNT SUPERBLK TYPE   DEVNAME   DIRNAME",
"    c0089ea0 c0088a00 ext2   /dev/root /    ",
"    c0089cf0 c0088c00 proc   /proc     /proc",
"    c0089e10 c0088800 ext2   /dev/sda5 /boot",
"    c0089d80 c0088600 ext2   /dev/sda6 /usr",
"    c0089f30 c0088400 devpts none      /dev/pts",
"    c3f4b010 c0088200 ext2   /dev/sda1 /home",
" ",
"  On Linux 3.3 and later kernels, the filesystem's mount structure address",
"  is shown:\n",
"    %s> mount",
"         MOUNT           SUPERBLK     TYPE   DEVNAME   DIRNAME",
"    ffff880212fb8200 ffff880212fc0800 rootfs rootfs    /   ",      
"    ffff88020ffbea00 ffff880212fc2000 proc   proc      proc",     
"    ffff880211db7f00 ffff88020e01a800 sysfs  sysfs     /sys",     
"    ffff88020ffe1300 ffff880212a40000 devtmpfs devtmpfs /dev",     
"    ffff88020ff15000 ffff880212bbc800 devpts devpts    /dev/pts",  
"    ffff88020e542800 ffff88020e62b800 tmpfs  tmpfs     /dev/shm",  
"    ...",
" ",
"  Display the open files associated with each mounted filesystem:\n",
"    %s> mount -f",
"    VFSMOUNT SUPERBLK TYPE   DEVNAME   DIRNAME",
"    c7fb2b80 c7fb3200 ext2   /dev/root /",
"    OPEN FILES:",
"     DENTRY    INODE    TYPE  PATH",
"    c6d02200  c6d0f7a0  REG   usr/X11R6/lib/libX11.so.6.1",
"    c6d02100  c6d0f9e0  REG   usr/X11R6/lib/libXext.so.6.3",
"    c6d02000  c6d0fc20  REG   usr/X11R6/lib/libICE.so.6.3",
"    c6d02680  c6d0f320  REG   usr/X11R6/bin/xfs",
"    c7106580  c70c5440  CHR   dev/psaux",
"    ...",
" ",
"  Display the dirty inodes associated with each mounted filesystem:\n",
"    %s> mount -i",
"    VFSMOUNT SUPERBLK TYPE   DEVNAME   DIRNAME",
"    c0089ea0 c0088a00 ext2   /dev/root /",
"    DIRTY INODES",
"    c7ad4008",
"    c2233438",
"    c72c4008",
"    c7d6b548",
"    c3af1a98",
"    c7d6b768",
"    c3c4e228",
"    ...",
" ",
"  Display the mounted filesystem containing inode c5000aa8:\n",
"    %s> mount c5000aa8",
"    VFSMOUNT SUPERBLK TYPE   DEVNAME   DIRNAME",
"    c0089f30 c0088600 ext2   /dev/sda6 /usr ",               
" ",
"  Display the mounted filesystem containing inode ffff8801f4245e40:\n",
"    %s> mount ffff8801f4245e40",
"         MOUNT           SUPERBLK     TYPE   DEVNAME  DIRNAME",
"    ffff88020ffbea00 ffff880212fc2000 proc   proc     /proc",     
" ",
NULL               
};


char *help_alias[] = {
"alias",
"command aliases",
"[alias] [command string]",
"  This command creates an alias for a given command string.  If no arguments",
"  are entered, the current list of aliases are displayed.  If one argument is",
"  entered, the command string for that alias, if any, is displayed.\n",
"           alias  the single word to be used as an alias",
"  command string  the word(s) that will be substituted for the alias\n",
"  Aliases may be created in four manners:\n",
"    1. entering the alias in $HOME/.%src.",
"    2. entering the alias in .%src in the current directory.",
"    3. executing an input file containing the alias command.",
"    4. during runtime with this command.\n",
"  During initialization, $HOME/.%src is read first, followed by the",
"  .%src file in the current directory.  Aliases in the .%src file",
"  in the current directory override those in $HOME/.%src.  Aliases ",
"  entered with this command or by runtime input file override those",
"  defined in either .%src file.  Aliases may be deleted by entering an",
"  empty string for the second argument.  If redirection characters are to",
"  be part of the command string, the command string must be enclosed by",
"  quotation marks.\n",
"  Note that there are a number of helpful built-in aliases -- see the ",
"  first example below.",
"\nEXAMPLES",
"  Display the currently-defined aliases, which in this example, only",
"  consist of the built-in aliases:\n",
"    %s> alias",
"    ORIGIN   ALIAS    COMMAND",
"    builtin  man      help ",
"    builtin  ?        help ",
"    builtin  quit     q",
"    builtin  sf       set scroll off", 
"    builtin  sn       set scroll on", 
"    builtin  hex      set radix 16",
"    builtin  dec      set radix 10",
"    builtin  g        gdb",
"    builtin  px       p -x",
"    builtin  pd       p -d",
"    builtin  for      foreach", 
"    builtin  size     *",
"    builtin  dmesg    log",
"    builtin  lsmod    mod",
"    builtin  last     ps -l",
" ",
"  Create a new alias to be added to the list:\n",
"    %s> alias kp kmem -p",
"    ORIGIN   ALIAS    COMMAND",
"    runtime  kp       kmem -p\n",
"  Create an alias with redirection characters:\n",
"    %s> alias ksd \"kmem -p | grep slab | grep DMA\"",
"    ORIGIN   ALIAS    COMMAND",
"    runtime  ksd      kmem -p | grep slab | grep DMA\n",
"  Remove an alias:\n",
"    %s> alias kp \"\"",
"    alias deleted: kp",
NULL               
};

char *help_pointer[] = {
"*",
"pointer-to short-cut",
"(struct or union command arguments)",
"  This command is a short-cut command that replaces the requirement to enter",
"  \"struct\" or \"union\" command names.  For details on the arguments to",
"  those commands, enter \"help struct\" or \"help union\".",
"\nEXAMPLES",
"  Dump the page structure at address c02943c0:",
" ",
"    %s> *page c02943c0",
"    struct page {",
"      next = 0xc0fae740, ",
"      prev = 0xc0018fb0, ",
"      inode = 0x0, ",
"      offset = 0x3f000, ",
"      next_hash = 0xc02d6310, ",
"      count = {",
"        counter = 0x1",
"      }, ",
"      flags = 0x310, ",
"      wait = 0xc02943d8, ",
"      pprev_hash = 0x0, ",
"      buffers = 0x0",
"    }",

NULL               
};


char *help_vtop[] = {
"vtop",
"virtual to physical",
"[-c [pid | taskp]] [-u|-k] address ...",
"  This command translates a user or kernel virtual address to its physical",
"  address.  Also displayed is the PTE translation, the vm_area_struct data",
"  for user virtual addresses, the mem_map page data associated with the",
"  physical page, and the swap location or file location if the page is",
"  not mapped.  The -u and -k options specify that the address is a user",
"  or kernel virtual address; -u and -k are not necessary on processors whose",
"  virtual addresses self-define themselves as user or kernel.  User addresses",
"  are translated with respect to the current context unless the -c option",
"  is used.  Kernel virtual addresses are translated using the swapper_pg_dir",
"  as the base page directory unless the -c option is used.",
" ",
"   -u                 The address is a user virtual address; only required",
"                      on processors with overlapping user and kernel virtual",
"                      address spaces.",
"   -k                 The address is a kernel virtual address; only required",
"                      on processors with overlapping user and kernel virtual",
"                      address spaces.",
"   -c [pid | taskp]   Translate the virtual address from the page directory",
"                      of the specified PID or hexadecimal task_struct pointer.",
"                      However, if this command is invoked from \"foreach vtop\",",
"                      the pid or taskp argument should NOT be entered; the",
"                      address will be translated using the page directory of",
"                      each task specified by \"foreach\".",
"   address            A hexadecimal user or kernel virtual address.",
"\nEXAMPLES",
"  Translate user virtual address 80b4000:\n",
"    %s> vtop 80b4000",
"    VIRTUAL   PHYSICAL",
"    80b4000   660f000",
"    ",
"    PAGE DIRECTORY: c37f0000",
"      PGD: c37f0080 => e0d067",
"      PMD: c37f0080 => e0d067",
"      PTE: c0e0d2d0 => 660f067",
"     PAGE: 660f000",
" ",
"      PTE    PHYSICAL  FLAGS",
"    660f067   660f000  (PRESENT|RW|USER|ACCESSED|DIRTY)",
"    ",
"      VMA      START      END      FLAGS  FILE",
"    c773daa0   80b4000   810c000    77",
"    ",
"      PAGE    PHYSICAL   INODE     OFFSET  CNT FLAGS",
"    c0393258   660f000         0     17000  1  uptodate",
"    ",
"  Translate kernel virtual address c806e000, first using swapper_pg_dir",
"  as the page directory base, and secondly, using the page table base",
"  of PID 1359:\n",
"    %s> vtop c806e000",
"    VIRTUAL   PHYSICAL",
"    c806e000  2216000",
"    ",
"    PAGE DIRECTORY: c0101000",
"      PGD: c0101c80 => 94063",
"      PMD: c0101c80 => 94063",
"      PTE: c00941b8 => 2216063",
"     PAGE: 2216000",
" ",
"      PTE    PHYSICAL  FLAGS",
"    2216063   2216000  (PRESENT|RW|ACCESSED|DIRTY)",
"    ",
"      PAGE    PHYSICAL   INODE     OFFSET  CNT FLAGS",
"    c02e9370   2216000         0         0  1  ",
"    ",
"    %s> vtop -c 1359 c806e000",
"    VIRTUAL   PHYSICAL",
"    c806e000  2216000",
"    ",
"    PAGE DIRECTORY: c5caf000",
"      PGD: c5cafc80 => 94063",
"      PMD: c5cafc80 => 94063",
"      PTE: c00941b8 => 2216063",
"     PAGE: 2216000",
"    ",
"      PTE    PHYSICAL  FLAGS",
"    2216063   2216000  (PRESENT|RW|ACCESSED|DIRTY)",
" ",
"      PAGE    PHYSICAL   INODE     OFFSET  CNT FLAGS",
"    c02e9370   2216000         0         0  1  ",
"    ",
"  Determine swap location of user virtual address 40104000:\n",
"    %s> vtop 40104000",
"    VIRTUAL   PHYSICAL",
"    40104000  (not mapped)",
"    ",
"    PAGE DIRECTORY: c40d8000",
"      PGD: c40d8400 => 6bbe067",
"      PMD: c40d8400 => 6bbe067",
"      PTE: c6bbe410 => 58bc00  ",
" ",
"     PTE      SWAP     OFFSET",
"    58bc00  /dev/sda8   22716",
"    ",
"      VMA      START      END     FLAGS  FILE",
"    c7200ae0  40104000  40b08000    73   ",
" ",
"    SWAP: /dev/sda8  OFFSET: 22716",
NULL               
};


char *help_vm[] = { 
"vm",
"virtual memory",
"[-p | -P vma | -M mm | -v | -m | -x | -d | [-R reference] [pid | task]]"
"\n     [-f vm_flags]",
"  This command displays basic virtual memory information of a context,",
"  consisting of a pointer to its mm_struct and page directory, its RSS and ",
"  total virtual memory size; and a list of pointers to each vm_area_struct,",
"  its starting and ending address, vm_flags value, and file pathname.  If no",
"  arguments are entered, the current context is used.  Additionally, the -p ",
"  option translates each virtual page of each VM area to its physical address.",
"  The -R option, typically invoked from \"foreach vm\", searches for references",
"  to a supplied number, address, or filename argument, and prints only the",
"  essential information leading up to and including the reference.  ",
"  Alternatively, the -m or -v options may be used to dump the task's mm_struct",
"  or all of its vm_area_structs respectively.  The -p, -v, -m, -R and -f",
"  options are all mutually exclusive.\n",
"            -p  translate each virtual page to its physical address, or if", 
"                the page is not mapped, its swap device and offset, or",
"                filename and offset.",
"        -P vma  similar to -p, but only translate the pages belonging to the",
"                specified VM area of a context.",
"         -M mm  if the mm_struct address has been removed from the task_struct",
"                of an exiting task, the virtual memory data cannot be displayed.",
"                However, if the address can be determined from the kernel stack,",
"                it can be entered manually in order to try to resurrect the",
"                virtual memory data of the task.",
"                NOTE: this option is only used when the task's mm_struct is NULL.",
"  -R reference  search for references to this number or filename.",
"            -m  dump the mm_struct associated with the task.",
"            -v  dump all of the vm_area_structs associated with the task.",
"            -x  override the default output format for the -m or -v options",
"                with hexadecimal format.",
"            -d  override the default output format for the -m or -v options", 
"                with decimal format.",
"   -f vm_flags  translate the bits of a FLAGS (vm_flags) value.", 
"           pid  a process PID.",
"          task  a hexadecimal task_struct pointer.",
"\nEXAMPLES",
"  Display the virtual memory data of the current context:\n",
"    %s> vm",
"    PID: 30986  TASK: c0440000  CPU: 0   COMMAND: \"bash\"",
"       MM       PGD       RSS    TOTAL_VM",
"    c303fe20  c4789000    88k      1728k",
"      VMA      START      END     FLAGS  FILE",
"    c0d1f540   8048000   80ad000  1875   /bin/bash",
"    c0d1f400   80ad000   80b3000  1873   /bin/bash",
"    c0d1f880   80b3000   80ec000    77",
"    c0d1f0c0  40000000  40012000   875   /lib/ld-2.1.1.so",
"    c0d1f700  40012000  40013000   873   /lib/ld-2.1.1.so",
"    c0d1fe00  40013000  40014000    77",
"    c0d1f580  40014000  40016000    73",
"    c0d1f280  4001a000  4004b000    75   /usr/lib/libncurses.so.4.2",
"    c0d1f100  4004b000  40054000    73   /usr/lib/libncurses.so.4.2",
"    c0d1f600  40054000  40057000    73",
"    c0d1f9c0  40057000  40059000    75   /lib/libdl-2.1.1.so",
"    c0d1f800  40059000  4005a000    73   /lib/libdl-2.1.1.so",
"    c0d1fd00  4005a000  40140000    75   /lib/libc-2.1.1.so",
"    c0d1fe40  40140000  40145000    73   /lib/libc-2.1.1.so",
"    c0d1f780  40145000  40148000    73",
"    c0d1f140  40148000  40150000    75   /lib/libnss_files-2.1.1.so",
"    c0d1fa80  40150000  40151000    73   /lib/libnss_files-2.1.1.so",
"    c0d1fb00  40151000  4015a000    75   /lib/libnss_nisplus-2.1.1.so",
"    c5f754e0  4015a000  4015b000    73   /lib/libnss_nisplus-2.1.1.so",
"    c0d1fec0  4015b000  4016d000    75   /lib/libnsl-2.1.1.so",
"    c5f75460  4016d000  4016e000    73   /lib/libnsl-2.1.1.so",
"    c5f75420  4016e000  40170000    73",
"    c5f753e0  40170000  40178000    75   /lib/libnss_nis-2.1.1.so",
"    c5f753a0  40178000  40179000    73   /lib/libnss_nis-2.1.1.so",
"    c0d1f240  bfffc000  c0000000   177\n",
"  Display the virtual memory data along with page translations for PID 386:",
"\n    %s> vm -p 386",
"    PID: 386    TASK: c11cc000  CPU: 0   COMMAND: \"atd\"",
"       MM       PGD       RSS    TOTAL_VM",
"    c7e30560  c10e5000    104k     1112k",
"      VMA      START      END     FLAGS  FILE",
"    c0fbe6a0   8048000   804b000  1875   /usr/sbin/atd",
"     VIRTUAL  PHYSICAL",
"     8048000  20e1000",
"     8049000  17c6000",
"     804a000  1f6f000",
"      VMA      START      END     FLAGS  FILE",
"    c61e0ba0   804b000   804d000  1873   /usr/sbin/atd",
"     VIRTUAL  PHYSICAL",
"     804b000  254d000",
"     804c000  6a9c000",
"      VMA      START      END     FLAGS  FILE",
"    c61e04e0   804d000   8050000    77   ",
"     VIRTUAL  PHYSICAL",
"     804d000  219d000",
"     804e000  2617000",
"     804f000  SWAP: /dev/sda8  OFFSET: 24225",
"      VMA      START      END     FLAGS  FILE",
"    c61e0720  40000000  40012000   875   /lib/ld-2.1.1.so",
"     VIRTUAL  PHYSICAL",
"    40000000  FILE: /lib/ld-2.1.1.so  OFFSET: 0",
"    40001000  FILE: /lib/ld-2.1.1.so  OFFSET: 1000",
"    40002000  FILE: /lib/ld-2.1.1.so  OFFSET: 2000",
"    40003000  FILE: /lib/ld-2.1.1.so  OFFSET: 3000",
"    40004000  FILE: /lib/ld-2.1.1.so  OFFSET: 4000",
"    40005000  FILE: /lib/ld-2.1.1.so  OFFSET: 5000",
"    ...",
" ",
"  Although the -R option is typically invoked from \"foreach vm\", it can be",
"  executed directly.  This example displays all VM areas with vm_flags of 75:\n",
"    %s> vm -R 75",
"    PID: 694    TASK: c0c76000  CPU: 1   COMMAND: \"crash\"",
"       MM       PGD      RSS    TOTAL_VM",
"    c6c43110  c0fe9000  8932k    10720k ",
"      VMA       START      END   FLAGS  FILE",
"    c322c0d0  40019000  4004a000    75  /usr/lib/libncurses.so.4.2",
"    c67537c0  40056000  40071000    75  /lib/libm-2.1.1.so",
"    c6753d00  40072000  40074000    75  /lib/libdl-2.1.1.so",
"    c6753540  40075000  40081000    75  /usr/lib/libz.so.1.1.3",
"    c6753740  40085000  4016b000    75  /lib/libc-2.1.1.so",
" ",
"  One reason to use -R directly is to pare down the output associated with",
"  the -p option on a task with a huge address space.  This example displays",
"  the page data associated with virtual address 40121000:\n",
"    %s> vm -R 40121000",
"    PID: 694    TASK: c0c76000  CPU: 0   COMMAND: \"crash\"",
"       MM       PGD      RSS    TOTAL_VM",
"    c6c43110  c0fe9000  8928k    10720k ",
"      VMA       START      END   FLAGS  FILE",
"    c6753740  40085000  4016b000    75  /lib/libc-2.1.1.so",
"    VIRTUAL   PHYSICAL",
"    40121000  FILE: /lib/libc-2.1.1.so  OFFSET: 9c000",
" ",
"  Display the mm_struct for PID 4777:",
"\n    %s> vm -m 4777",
"    PID: 4777   TASK: c0896000  CPU: 0   COMMAND: \"bash\"",
"    struct mm_struct {",
"      mmap = 0xc6caa1c0, ",
"      mmap_avl = 0x0, ",
"      mmap_cache = 0xc6caabc0, ",
"      pgd = 0xc100a000, ",
"      count = {",
"        counter = 0x1",
"      }, ",
"      map_count = 0x14, ",
"      mmap_sem = {",
"        count = {",
"          counter = 0x1",
"        }, ",
"        waking = 0x0, ",
"        wait = 0x0",
"      }, ",
"      context = 0x0, ",
"      start_code = 0x8048000, ",
"      end_code = 0x809c6f7, ",
"      start_data = 0x0, ",
"      end_data = 0x80a2090, ",
"      start_brk = 0x80a5420, ",
"      brk = 0x80b9000, ",
"      start_stack = 0xbffff9d0, ",
"      arg_start = 0xbffffad1, ",
"      arg_end = 0xbffffad7, ",
"      env_start = 0xbffffad7, ",
"      env_end = 0xbffffff2, ",
"      rss = 0xf6, ",
"      total_vm = 0x1a3, ",
"      locked_vm = 0x0, ",
"      def_flags = 0x0, ",
"      cpu_vm_mask = 0x0, ",
"      swap_cnt = 0x23d,",
"      swap_address = 0x0, ",
"      segments = 0x0",
"    }",
" ",
"  Display all of the vm_area_structs for task c47d4000:",
"\n    %s> vm -v c47d4000",
"    PID: 4971   TASK: c47d4000  CPU: 1   COMMAND: \"login\"",
"    struct vm_area_struct {",
"      vm_mm = 0xc4b0d200, ",
"      vm_start = 0x8048000, ",
"      vm_end = 0x804d000, ",
"      vm_next = 0xc3e3abd0, ",
"      vm_page_prot = {",
"        pgprot = 0x25",
"      }, ",
"      vm_flags = 0x1875, ",
"      vm_avl_height = 0x1, ",
"      vm_avl_left = 0x0, ",
"      vm_avl_right = 0x0, ",
"      vm_next_share = 0x0, ",
"      vm_pprev_share = 0xc3e3abf0, ",
"      vm_ops = 0xc02392a0, ",
"      vm_offset = 0x0, ",
"      vm_file = 0xc1e23660, ",
"      vm_pte = 0x0",
"    }",
"    struct vm_area_struct {",
"      vm_mm = 0xc4b0d200, ",
"      vm_start = 0x804d000, ",
"      vm_end = 0x804e000, ",
"      vm_next = 0xc3e3a010, ",
"      vm_page_prot = {",
"        pgprot = 0x25",
"      }, ",
"      vm_flags = 0x1873, ",
"      vm_avl_height = 0x2, ",
"      vm_avl_left = 0xc3e3a810, ",
"      vm_avl_right = 0xc3e3a010, ",
"      vm_next_share = 0xc3e3a810, ",
"      vm_pprev_share = 0xc3699c14",
"      ...",
" ",
"  Translate a FLAGS value:\n",
"    %s> vm -f 3875",
"    3875: (READ|EXEC|MAYREAD|MAYWRITE|MAYEXEC|DENYWRITE|EXECUTABLE|LOCKED)",
" ",
"  Display the page translations of the VM area at address f5604f2c:\n",
"    %s> vm -P f5604f2c",
"    PID: 5508   TASK: f56a9570  CPU: 0   COMMAND: \"crond\"",
"      VMA       START      END    FLAGS  FILE",
"    f5604f2c    f5b000    f67000 8000075  /lib/libnss_files-2.12.so",
"    VIRTUAL   PHYSICAL",
"    f5b000    3fec1000",
"    f5c000    3d3a4000",
"    f5d000    FILE: /lib/libnss_files-2.12.so  OFFSET: 2000",
"    f5e000    FILE: /lib/libnss_files-2.12.so  OFFSET: 3000",
"    f5f000    FILE: /lib/libnss_files-2.12.so  OFFSET: 4000",
"    f60000    3fd31000",
"    f61000    3fd32000",
"    f62000    FILE: /lib/libnss_files-2.12.so  OFFSET: 7000",
"    f63000    FILE: /lib/libnss_files-2.12.so  OFFSET: 8000",
"    f64000    3ff35000",
"    f65000    FILE: /lib/libnss_files-2.12.so  OFFSET: a000",
"    f66000    FILE: /lib/libnss_files-2.12.so  OFFSET: b000",
NULL               
};

char *help_task[] = {
"task",
"task_struct and thread_info contents",
"[-R member[,member]] [-dx] [pid | taskp] ...",
"  This command dumps a formatted display of the contents of a task's",
"  task_struct and thread_info structures.  Multiple task or PID numbers",
"  may be entered; if no arguments are entered, the task_struct and",
"  thread_info structures of the current context are displayed.  The -R option,",
"  which may also be invoked indirectly via \"foreach task\", pares the output",
"  down to one or more structure members.",
" ",
"        pid  a process PID.",
"      taskp  a hexadecimal task_struct pointer.",
"  -R member  a comma-separated list of one or more task_struct and/or",
"             thread_info structure members.  If any member contains an embedded",
"             structure, or is an array, the output may be restricted to the ",
"             embedded structure or an array element by expressing the member",
"             argument as \"member.member\" or \"member[index]\"; embedded member",
"             specifications may extend beyond one level deep, by expressing the",
"             member argument as \"member.member.member...\".",
"         -x  override default output format with hexadecimal format.",
"         -d  override default output format with decimal format.",
"\nEXAMPLES",
"  Dump the task_struct and thread_info structures of the current context",
"  in hexadecimal format:\n",
"    %s> task -x",
"    PID: 3176   TASK: f2451550  CPU: 1   COMMAND: \"memtest\"",
"    struct task_struct {",
"      state = 0x0, ",
"      stack = 0xf05b6000, ",
"      usage = {",
"        counter = 0x2",
"      }, ",
"      flags = 0x402040, ",
"      ptrace = 0x0, ",
"      lock_depth = 0xffffffff, ",
"      prio = 0x78, ",
"      static_prio = 0x78, ",
"      normal_prio = 0x78, ",
"      rt_priority = 0x0, ",
"    ...",
"      perf_event_ctxp = {0x0, 0x0}, ",
"      memcg_batch = {",
"        do_batch = 0x0, ",
"        memcg = 0x0, ",
"        bytes = 0x0, ",
"        memsw_bytes = 0x0",
"      }",
"    }",
"    ",
"    struct thread_info {",
"      task = 0xf2451550, ",
"      exec_domain = 0xc0a60860, ",
"      flags = 0x88, ",
"      status = 0x0, ",
"      cpu = 0x1, ",
"      preempt_count = 0x4010000, ",
"      addr_limit = {",
"        seg = 0xc0000000",
"      }, ",
"      restart_block = {",
"    ...",
" ",
"  Display the ngroups and groups task_struct members for PID 2958:\n",
"    %s> task -R ngroups,groups 2958",
"    PID: 2958   TASK: c6718000  CPU: 0   COMMAND: \"bash\"",
"      ngroups = 6, ",
"      groups = {504, 8, 9, 1000, 1007, 1006, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,",
"        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},",
" ",
"  Display the embedded sched_entity structure's on_rq member:\n",
"    %s> task -R se.on_rq",
"    PID: 6529   TASK: ffff880116538790  CPU: 1   COMMAND: \"bash\"",
"      se.on_rq = 1,",
" ",
"  Display the 3rd pid_link structure in the embedded pids[] array:\n",
"  %s> task -R pids[2]",
"  PID: 6529   TASK: ffff880116538790  CPU: 0   COMMAND: \"bash\"",
"    pids[2] =   {",
"    node = {",
"      next = 0xffff8801165391b0,",
"      pprev = 0xffff880209d011b0",
"    },",
"    pid = 0xffff8801f0876e00",
"  }",
" ",
"  NOTE: When this command is invoked directly (i.e., not from \"foreach\"), it",
"  is not necessary to include the \"-R\" before the task_struct/thread_info",
"  member name(s).",
NULL               
};

char *help_sig[] = {
"sig",
"task signal handling",
"[[-l] | [-s sigset]] | [-g] [pid | taskp] ...",
"  This command displays signal-handling data of one or more tasks.  Multiple",
"  task or PID numbers may be entered; if no arguments are entered, the signal",
"  handling data of the current context will be displayed.  The default display",
"  shows:",
" ",
"    1.  A formatted dump of the \"sig\" signal_struct structure referenced by",
"        the task_struct.  For each defined signal, it shows the sigaction",
"        structure address, the signal handler, the signal sigset_t mask ",
"        (also expressed as a 64-bit hexadecimal value), and the flags.",
"    2.  Whether the task has an unblocked signal pending.",
"    3.  The contents of the \"blocked\" and \"signal\" sigset_t structures",
"        from the task_struct/signal_struct, both of which are represented ",
"        as a 64-bit hexadecimal value.", 
"    4.  For each queued signal, private and/or shared, if any, its signal",
"        number and associated siginfo structure address.",
" ",
"  The -l option lists the signal numbers and their name(s).  The -s option",
"  translates a 64-bit hexadecimal value representing the contents of a",
"  sigset_t structure into the signal names whose bits are set.",
" ",        
"        pid  a process PID.",
"      taskp  a hexadecimal task_struct pointer.",
"         -g  displays signal information for all threads in a task's ",
"             thread group.",
"         -l  displays the defined signal numbers and names.",
"  -s sigset  translates a 64-bit hexadecimal value representing a sigset_t",
"             into a list of signal names associated with the bits set.",
"\nEXAMPLES",
"  Dump the signal-handling data of PID 8970:\n",
"    %s> sig 8970",
"    PID: 8970   TASK: f67d8560  CPU: 1   COMMAND: \"procsig\"",
"    SIGNAL_STRUCT: f6018680  COUNT: 1",
"     SIG SIGACTION  HANDLER       MASK       FLAGS   ",
"     [1]  f7877684  SIG_DFL 0000000000000000 0 ",
"     [2]  f7877698  SIG_DFL 0000000000000000 0 ",
"    ...",
"     [8]  f7877710  SIG_DFL 0000000000000000 0 ",
"     [9]  f7877724  SIG_DFL 0000000000000000 0 ",
"    [10]  f7877738  804867a 0000000000000000 80000000 (SA_RESETHAND)",
"    [11]  f787774c  SIG_DFL 0000000000000000 0 ",
"    [12]  f7877760  804867f 0000000000000000 10000004 (SA_SIGINFO|SA_RESTART)",
"    [13]  f7877774  SIG_DFL 0000000000000000 0 ",
"    ...",
"    [31]  f78778dc  SIG_DFL 0000000000000000 0 ",
"    [32]  f78778f0  SIG_DFL 0000000000000000 0 ",
"    [33]  f7877904  SIG_DFL 0000000000000000 0 ",
"    [34]  f7877918  804867f 0000000000000000 10000004 (SA_SIGINFO|SA_RESTART)",
"    [35]  f787792c  SIG_DFL 0000000000000000 0 ",
"    [36]  f7877940  SIG_DFL 0000000000000000 0 ",
"    ...",
"    [58]  f7877af8  SIG_DFL 0000000000000000 0 ",
"    [59]  f7877b0c  SIG_DFL 0000000000000000 0 ",
"    [60]  f7877b20  SIG_DFL 0000000000000000 0 ",
"    [61]  f7877b34  SIG_DFL 0000000000000000 0 ",
"    [62]  f7877b48  SIG_DFL 0000000000000000 0 ",
"    [63]  f7877b5c  SIG_DFL 0000000000000000 0 ",
"    [64]  f7877b70  804867f 0000000000000000 10000004 (SA_SIGINFO|SA_RESTART)",
"   SIGPENDING: no",
"      BLOCKED: 8000000200000800",
"   PRIVATE_PENDING",
"       SIGNAL: 0000000200000800",
"     SIGQUEUE:  SIG  SIGINFO ",
"                 12  f51b9c84",
"                 34  f51b9594",
"   SHARED_PENDING",
"       SIGNAL: 8000000000000800",
"     SIGQUEUE:  SIG  SIGINFO ",
"                 12  f51b9188",
"                 64  f51b9d18",
"                 64  f51b9500",
"    ",
"  Dump the signal-handling data for all tasks in the thread group containing",
"  PID 2578:\n",
"    %s> sig -g 2578",
"    PID: 2387   TASK: f617d020  CPU: 0   COMMAND: \"slapd\"",
"    SIGNAL_STRUCT: f7dede00  COUNT: 6",
"    SIG SIGACTION  HANDLER       MASK       FLAGS",
"    [1]  c1f60c04   a258a7 0000000000000000 10000000 (SA_RESTART)",
"    [2]  c1f60c18   a258a7 0000000000000000 10000000 (SA_RESTART)",
"    [3]  c1f60c2c  SIG_DFL 0000000000000000 0",
"    [4]  c1f60c40  SIG_DFL 0000000000000000 0",
"    [5]  c1f60c54   a258a7 0000000000000000 10000000 (SA_RESTART)",
"    [6]  c1f60c68  SIG_DFL 0000000000000000 0",
"    [7]  c1f60c7c  SIG_DFL 0000000000000000 0",
"    [8]  c1f60c90  SIG_DFL 0000000000000000 0",
"    [9]  c1f60ca4  SIG_DFL 0000000000000000 0",
"   [10]  c1f60cb8   a25911 0000000000000000 10000000 (SA_RESTART)",
"   ...",
"   [64]  c1f610f0  SIG_DFL 0000000000000000 0",
"   SHARED_PENDING",
"       SIGNAL: 0000000000000000",
"     SIGQUEUE: (empty)",
"     ",
"     PID: 2387   TASK: f617d020  CPU: 0   COMMAND: \"slapd\"",
"     SIGPENDING: no",
"        BLOCKED: 0000000000000000",
"     PRIVATE_PENDING",
"         SIGNAL: 0000000000000000",
"       SIGQUEUE: (empty)",
"    ",
"     PID: 2392   TASK: f6175aa0  CPU: 0   COMMAND: \"slapd\"",
"     SIGPENDING: no",
"        BLOCKED: 0000000000000000",
"     PRIVATE_PENDING",
"         SIGNAL: 0000000000000000",
"       SIGQUEUE: (empty)",
"    ",
"     PID: 2523   TASK: f7cd4aa0  CPU: 1   COMMAND: \"slapd\"",
"     SIGPENDING: no",
"        BLOCKED: 0000000000000000",
"     PRIVATE_PENDING",
"         SIGNAL: 0000000000000000",
"       SIGQUEUE: (empty)",
"    ",
"     ...",
"    ",
"  Translate the sigset_t mask value, cut-and-pasted from the signal handling",
"  data from signals 1 and 10 above:",
" ",
"    %s> sig -s 800A000000000201",
"    SIGHUP SIGUSR1 SIGRTMAX-14 SIGRTMAX-12 SIGRTMAX",
" ",
"  List the signal numbers and their names:",
" ",
"    %s> sig -l",
"     [1] SIGHUP",
"     [2] SIGINT",
"     [3] SIGQUIT",
"     [4] SIGILL",
"     [5] SIGTRAP",
"     [6] SIGABRT/SIGIOT",
"     [7] SIGBUS",
"     [8] SIGFPE",
"     [9] SIGKILL",
"    [10] SIGUSR1",
"    [11] SIGSEGV",
"    [12] SIGUSR2",
"    [13] SIGPIPE",
"    [14] SIGALRM",
"    [15] SIGTERM",
"    [16] SIGSTKFLT",
"    [17] SIGCHLD/SIGCLD",
"    [18] SIGCONT",
"    [19] SIGSTOP",
"    [20] SIGTSTP",
"    [21] SIGTTIN",
"    [22] SIGTTOU",
"    [23] SIGURG",
"    [24] SIGXCPU",
"    [25] SIGXFSZ",
"    [26] SIGVTALRM",
"    [27] SIGPROF",
"    [28] SIGWINCH",
"    [29] SIGIO/SIGPOLL",
"    [30] SIGPWR",
"    [31] SIGSYS",
"    [32] SIGRTMIN",
"    [33] SIGRTMIN+1",
"    [34] SIGRTMIN+2",
"    [35] SIGRTMIN+3",
"    [36] SIGRTMIN+4",
"    [37] SIGRTMIN+5",
"    [38] SIGRTMIN+6",
"    [39] SIGRTMIN+7",
"    [40] SIGRTMIN+8",
"    [41] SIGRTMIN+9",
"    [42] SIGRTMIN+10",
"    [43] SIGRTMIN+11",
"    [44] SIGRTMIN+12",
"    [45] SIGRTMIN+13",
"    [46] SIGRTMIN+14",
"    [47] SIGRTMIN+15",
"    [48] SIGRTMIN+16",
"    [49] SIGRTMAX-15",
"    [50] SIGRTMAX-14",
"    [51] SIGRTMAX-13",
"    [52] SIGRTMAX-12",
"    [53] SIGRTMAX-11",
"    [54] SIGRTMAX-10",
"    [55] SIGRTMAX-9",
"    [56] SIGRTMAX-8",
"    [57] SIGRTMAX-7",
"    [58] SIGRTMAX-6",
"    [59] SIGRTMAX-5",
"    [60] SIGRTMAX-4",
"    [61] SIGRTMAX-3",
"    [62] SIGRTMAX-2",
"    [63] SIGRTMAX-1",
"    [64] SIGRTMAX",


NULL               
};

char *help_struct[] = {
"struct",
"structure contents",
"struct_name[.member[,member]][-o][-l offset][-rfuxdp]\n"
"         [address | symbol][:cpuspec] [count | -c count]",
"  This command displays either a structure definition, or a formatted display",
"  of the contents of a structure at a specified address.  When no address is",
"  specified, the structure definition is shown along with the structure size.",
"  A structure member may be appended to the structure name in order to limit",
"  the scope of the data displayed to that particular member; when no address",
"  is specified, the member's offset and definition are shown.\n",
"    struct_name  name of a C-code structure used by the kernel.",
"        .member  name of a structure member; to display multiple members of a",
"                 structure, use a comma-separated list of members.  If any",
"                 member contains an embedded structure, or the member is an ",
"                 array, the output may be restricted to just the embedded ",
"                 structure or an array element by expressing the member argument",
"                 as \"member.member\" or \"member[index]\"; embedded member",
"                 specifications may extend beyond one level deep, by expressing",
"                 the member argument as \"member.member.member...\".",
"             -o  show member offsets when displaying structure definitions; ",
"                 if used with an address or symbol argument, each member will",
"                 be preceded by its virtual address.",
"      -l offset  if the address argument is a pointer to a structure member that",
"                 is contained by the target data structure, typically a pointer",
"                 to an embedded list_head, the offset to the embedded member may", 
"                 be entered in either of the following manners:",
"                   1. in \"structure.member\" format.",
"                   2. a number of bytes. ",
"             -r  raw dump of structure data.",
"             -f  address argument is a dumpfile offset.",
"             -u  address argument is a user virtual address in the current",
"                 context.",
"             -x  override default output format with hexadecimal format.",
"             -d  override default output format with decimal format.",
"             -p  if a structure member is a pointer value, show the member's",
"                 data type on the output line; and on the subsequent line(s),", 
"                 dereference the pointer, display the pointer target's symbol",
"                 value in brackets if appropriate, and if possible, display the",
"                 target data; requires an address argument.",
"        address  hexadecimal address of a structure; if the address points",  
"                 to an embedded list_head structure contained within the",
"                 target data structure, then the \"-l\" option must be used.",
"         symbol  symbolic reference to the address of a structure.",
"       :cpuspec  CPU specification for a per-cpu address or symbol:",
"                   :             CPU of the currently selected task.",
"                   :a[ll]        all CPUs.",
"                   :#[-#][,...]  CPU list(s), e.g. \"1,3,5\", \"1-3\",",
"                                 or \"1,3,5-7,10\".",
"          count  count of structures to dump from an array of structures;",
"                 if used, this must be the last argument entered.",
"       -c count  \"-c\" is only required if \"count\" is not the last argument",
"                 entered or if a negative number is entered; if a negative",
"                 value is entered, the (positive) \"count\" structures that",
"                 lead up to and include the target structure will be displayed.\n",
"  Structure data, sizes, and member offsets are shown in the current output",
"  radix unless the -x or -d option is specified.",
" ",
"  Please note that in the vast majority of cases, the \"struct\" command",
"  name may be dropped; if the structure name does not conflict with any %s",
"  or gdb command name, then the \"struct_name[.member]\" argument will be",
"  recognized as a structure name, and this command automatically executed.",
"  See the NOTE below.",
"\nEXAMPLES",
"  Display the vm_area_struct at address c1e44f10:\n",
"    %s> struct vm_area_struct c1e44f10",
"    struct vm_area_struct {",
"      vm_mm = 0xc2857750,",
"      vm_start = 0x8048000, ",
"      vm_end = 0x80a5000, ",
"      vm_next = 0xc1e44a10,",
"      vm_page_prot = {",
"        pgprot = 0x25      ",
"      },",
"      vm_flags = 0x1875,",
"      vm_avl_height = 0x2,   ",
"      vm_avl_left = 0xc30fe200,",
"      vm_avl_right = 0xc30fed00,",
"      vm_next_share = 0x0,       ",
"      vm_pprev_share = 0xc1e44a30,",
"      vm_ops = 0xc0215ca0,",
"      vm_offset = 0x0,       ",
"      vm_file = 0xc0bfdc70,",
"      vm_pte = 0   ",
"    }\n",
"  Display the definition and size of a vm_area_struct structure.  This first",
"  example below displays just the structure and size.  The second example",
"  uses the -o option to also display member offsets.  Both examples were",
"  run with the output radix set to 10 (decimal):\n",
"    %s> struct vm_area_struct",
"    struct vm_area_struct {",
"        struct mm_struct *vm_mm;",
"        long unsigned int vm_start;",
"        long unsigned int vm_end;",
"        struct vm_area_struct *vm_next;",
"        pgprot_t vm_page_prot;",
"        short unsigned int vm_flags;",
"        short int vm_avl_height;",
"        struct vm_area_struct *vm_avl_left;",
"        struct vm_area_struct *vm_avl_right;",
"        struct vm_area_struct *vm_next_share;",
"        struct vm_area_struct **vm_pprev_share;",
"        struct vm_operations_struct *vm_ops;",
"        long unsigned int vm_offset;",
"        struct file *vm_file;",
"        long unsigned int vm_pte;",
"    }",
"    SIZE: 56\n",
"    %s> struct vm_area_struct -o",
"    struct vm_area_struct {",
"       [0] struct mm_struct *vm_mm;",
"       [4] long unsigned int vm_start;",
"       [8] long unsigned int vm_end;",
"      [12] struct vm_area_struct *vm_next;",
"      [16] pgprot_t vm_page_prot;",
"      [20] short unsigned int vm_flags;",
"      [22] short int vm_avl_height;",
"      [24] struct vm_area_struct *vm_avl_left;",
"      [28] struct vm_area_struct *vm_avl_right;",
"      [32] struct vm_area_struct *vm_next_share;",
"      [36] struct vm_area_struct **vm_pprev_share;",
"      [40] struct vm_operations_struct *vm_ops;",
"      [44] long unsigned int vm_offset;",
"      [48] struct file *vm_file;",
"      [52] long unsigned int vm_pte;",
"    }",
"    SIZE: 56\n",
"  Display the definition and offset of the pgd member of an mm_struct:\n",
"    %s> struct mm_struct.pgd",
"    struct mm_struct {",
"       [80] pgd_t *pgd;",
"    }\n",
"  Display the pgd member of the mm_struct at address ffff810022e7d080:\n",
"    %s> struct mm_struct.pgd ffff810022e7d080",
"      pgd = 0xffff81000e3ac000\n",
"  Display the pgd_t pointed to by the mm_struct.pgd pointer above, forcing",
"  the output to be expressed in hexadecimal:\n",
"    %s> mm_struct.pgd ffff810022e7d080 -px",
"      pgd_t *pgd = 0xffff81000e3ac000",
"      -> {",
"           pgd = 0x2c0a6067",
"         }\n",
"  Display the thread_info structure pointed to by the thread_info",
"  member of the task_struct at ffff8100181190c0:\n",
"    %s> task_struct.thread_info ffff8100181190c0 -p",
"      struct thread_info *thread_info = 0xffff810023c06000",
"      -> {",
"           task = 0xffff8100181190c0,",
"           exec_domain = 0xffffffff802f78e0,",
"           flags = 128,",
"           status = 1,",
"           cpu = 3,",
"           preempt_count = 0,",
"           addr_limit = {",
"             seg = 18446604435732824064",
"           },",
"           restart_block = {",
"             fn = 0xffffffff80095a52 <do_no_restart_syscall>,",
"             arg0 = 0,",
"             arg1 = 0,",
"             arg2 = 0,",
"             arg3 = 0",
"           }",
"         }\n",
"  Display the flags and virtual members of 4 contiguous page structures",
"  in the mem_map page structure array:\n",
"    %s> page.flags,virtual c101196c 4",
"      flags = 0x8000,",
"      virtual = 0xc04b0000",
"    ",
"      flags = 0x8000,",
"      virtual = 0xc04b1000",
"    ",
"      flags = 0x8000,",
"      virtual = 0xc04b2000",
"    ",
"      flags = 0x8000,",
"      virtual = 0xc04b3000",
" ",
"  Display the array of tcp_sl_timer structures declared by tcp_slt_array[]:\n",
"    %s> struct tcp_sl_timer tcp_slt_array 4",
"    struct tcp_sl_timer {",
"      count = {",
"        counter = 0x0       ",
"      },",
"      period = 0x32,      ",
"      last = 0x1419e4,  ",
"      handler = 0xc0164854  <tcp_syn_recv_timer>",
"    }",
"    struct tcp_sl_timer {",
"      count = {",
"        counter = 0x2       ",
"      },",
"      period = 0x753,     ",
"      last = 0x14a6df,  ",
"      handler = 0xc01645b0  <tcp_keepalive>",
"    }",
"    struct tcp_sl_timer {",
"      count = {",
"        counter = 0x0       ",
"      },",
"      period = 0x2ee,     ",
"      last = 0x143134,  ",
"      handler = 0xc016447c  <tcp_twkill>",
"    }",
"    struct tcp_sl_timer {",
"      count = {",
"        counter = 0x0       ",
"      },",
"      period = 0x64,      ",
"      last = 0x143198,  ",
"      handler = 0xc0164404  <tcp_bucketgc>",
"    }",
" ",
"  Without using the \"struct\" command name, display the the \"d_child\" ",
"  list_head member from a dentry structure:\n",
"    %s> dentry.d_child 0xe813cb4",
"      d_child = {",
"        next = 0x3661344,",
"        prev = 0xdea4bc4",
"      },",
" ",
"  Display the child dentry structure referenced by the \"next\" pointer above.",
"  Since the \"next\" address of 0x3661344 above is a pointer to an embedded",
"  list_head structure within the child dentry structure, the -l option",
"  is required:\n",
"    %s> dentry -l dentry.d_child 0x3661344",
"    struct dentry {",
"      d_count = {",
"        counter = 1",
"      }, ",
"      d_flags = 0, ",
"      d_inode = 0xf9aa604, ",
"      d_parent = 0x11152b1c, ",
"      d_hash = {",
"        next = 0x11fb3fc0, ",
"        prev = 0x11fb3fc0",
"      }, ",
"      d_lru = {",
"        next = 0x366133c, ",
"        prev = 0x366133c",
"      }, ",
"      d_child = {",
"        next = 0x36613cc, ",
"        prev = 0xe813cd4",
"      }, ",
"      d_subdirs = {",
"        next = 0x366134c, ",
"        prev = 0x366134c",
"      }, ",
"      d_alias = {",
"        next = 0xf9aa614, ",
"        prev = 0xf9aa614",
"      }, ",
"      d_mounted = 0, ",
"      d_name = {",
"        name = 0x3661384 \"boot.log\", ",
"        len = 8, ",
"        hash = 1935169207",
"      }, ",
"      d_time = 1515870810, ",
"      d_op = 0x0, ",
"      d_sb = 0x11fc9c00, ",
"      d_vfs_flags = 0, ",
"      d_fsdata = 0x0, ",
"      d_extra_attributes = 0x0, ",
"      d_iname = \"boot.log\\000\"",
"    }",
" ",
"  Display the virtual address of each member of the task_struct at",
"  ffff8100145d2080:\n",
"    %s> task_struct -o ffff8100145d2080",
"    struct task_struct {",
"      [ffff8100145d2080] volatile long int state;",
"      [ffff8100145d2088] struct thread_info *thread_info;",
"      [ffff8100145d2090] atomic_t usage;",
"      [ffff8100145d2098] long unsigned int flags;",
"      [ffff8100145d20a0] int lock_depth;",
"      [ffff8100145d20a4] int load_weight;",
"      [ffff8100145d20a8] int prio;",
"      [ffff8100145d20ac] int static_prio;",
"      [ffff8100145d20b0] int normal_prio;",
"      [ffff8100145d20b8] struct list_head run_list;",
"      [ffff8100145d20c8] struct prio_array *array;",
"    ...",
" ",
"  Display the embedded sched_entity structure's on_rq member and",
"  the third pid_link structure in the embedded pids[] array of the",
"  task_struct at ffff88011653e250:\n",
"    %s> task_struct.se.on_rq,pids[2] ffff88011653e250",
"      se.on_rq = 1,",
"      pids[2] =   {",
"        node = {",
"          next = 0xffff88011653aff0,",
"          pprev = 0xffff88011653a860",
"        },",
"        pid = 0xffff88010d07ed00",
"      }",
" ",
"  For an example of displaying per-cpu variables, consider the",
"  struct hd_struct.dkstats member, which is a percpu pointer to",
"  a disk_stats structure:",
"",
"    %s> struct hd_struct.dkstats ",
"    struct hd_struct {",
"      [1232] struct disk_stats *dkstats;",
"    }",
"",
" Taking an hd_struct at address ffff8802450e2848, display all",
" of the per-cpu disk_stats structures that it references:",
" ",
"    %s> struct hd_struct.dkstats ffff8802450e2848",
"      dkstats = 0x60fdb48026c8",
"    %s> struct disk_stats 0x60fdb48026c8:a",
"    [0]: ffffe8fefe6026c8",
"    struct disk_stats {",
"      sectors = {451376, 80468}, ",
"      ios = {6041, 971}, ",
"      merges = {386, 390}, ",
"      ticks = {194877, 56131}, ",
"      io_ticks = 12371, ",
"      time_in_queue = 309163",
"    }",
"    [1]: ffffe8fefe8026c8",
"    struct disk_stats {",
"      sectors = {0, 0}, ",
"      ios = {0, 0}, ",
"      merges = {7, 242}, ",
"      ticks = {0, 0}, ",
"      io_ticks = 23, ",
"      time_in_queue = 581",
"    }",
"    [2]: ffffe8fefea026c8",
"    struct disk_stats {",
"      sectors = {0, 0}, ",
"      ios = {0, 0}, ",
"      merges = {4, 112}, ",
"      ticks = {0, 0}, ",
"      io_ticks = 11, ",
"      time_in_queue = 305",
"    }",
"    [3]: ffffe8fefec026c8",
"    struct disk_stats {",
"      sectors = {0, 0}, ",
"      ios = {0, 0}, ",
"      merges = {5, 54}, ",
"      ticks = {0, 0}, ",
"      io_ticks = 17, ",
"      time_in_queue = 41",
"    }",
" ",
"\nNOTE",
"  If the structure name does not conflict with any %s command name, the",
"  \"struct\" command may be dropped.  Accordingly, the examples above could",
"  also have been accomplished like so:\n",
"    %s> vm_area_struct c1e44f10",
"    %s> vm_area_struct",
"    %s> vm_area_struct -o",
"    %s> mm_struct.pgd ffff810022e7d080",
"    %s> mm_struct.pgd",
"    %s> tcp_sl_timer tcp_slt_array 4\n",
"  Lastly, the short-cut \"*\" pointer-to command may also be used to negate",
"  the need to enter the \"struct\" command name (enter \"help *\" for details).",
NULL               
};


char *help_union[] = {
"union",
"union contents",
"union_name[.member[,member]] [-o][-l offset][-rfuxdp]\n"
"         [address | symbol][:cpuspec] [count | -c count]",
"  This command displays either a union definition, or a formatted display",
"  of the contents of a union at a specified address.  When no address is",
"  specified, the union definition is shown along with the union size.",
"  A union member may be appended to the structure name in order to limit",
"  the scope of the data displayed to that particular member; when no address",
"  is specified, the member's offset (always 0) and definition are shown.\n",
"     union_name  name of a C-code union used by the kernel.",
"        .member  name of a union member; to display multiple members of a",
"                 union, use a comma-separated list of members.  If any member",
"                 contains an embedded structure, or the member is an array, the",
"                 output may be restricted to just the embedded structure or an",
"                 array element by expressing the argument as \"member.member\"",
"                 or \"member[index]\"; embedded member specifications may extend",
"                 beyond one level deep, by expressing the member argument as",
"                 \"member.member.member...\".",
"             -o  show member offsets when displaying union definitions; the",
"                 offset is always 0 unless used with an address or symbol",
"                 argument, in which case each member will be preceded by its",
"                 virtual address.",
"      -l offset  if the address argument is a pointer to a list_head structure",
"                 that is embedded in the target union structure, the offset",
"                 to the list_head member may be entered in either of the",
"                 following manners:",
"                   1. in \"structure.member\" format.",
"                   2. a number of bytes. ",
"             -r  raw dump of union data.",
"             -f  address argument is a dumpfile offset.",
"             -x  override default output format with hexadecimal format.",
"             -d  override default output format with decimal format.",
"             -p  if a union member is a pointer value, show the member's",
"                 data type on the output line; and on the subsequent line(s),",
"                 dereference the pointer, display the pointer target's symbol",
"                 value in brackets if appropriate, and if possible, display the",
"                 target data; requires an address argument.",
"             -u  address argument is a user virtual address in the current",
"                 context.",
"        address  hexadecimal address of a union; if the address points",
"                 to an embedded list_head structure contained within the",
"                 target union structure, then the \"-l\" option must be used.",
"         symbol  symbolic reference to the address of a union.",
"       :cpuspec  CPU specification for a per-cpu address or symbol:",
"                   :             CPU of the currently selected task.",
"                   :a[ll]        all CPUs.",
"                   :#[-#][,...]  CPU list(s), e.g. \"1,3,5\", \"1-3\",",
"                                or \"1,3,5-7,10\".",
"          count  count of unions to dump from an array of unions; if used,",
"                 this must be the last argument entered.",
"       -c count  \"-c\" is only required if \"count\" is not the last argument",
"                 entered or if a negative number is entered; if a negative",
"                 value is entered, the (positive) \"count\" structures that",
"                 lead up to and include the target structure will be displayed.\n",
"  Union data, sizes, and member offsets are shown in the current output radix",
"  unless the -x or -d option is specified.",
" ",
"  Please note that in the vast majority of cases, the \"union\" command",
"  name may be dropped; if the union name does not conflict with any %s",
"  or gdb command name, then the \"union_name[.member]\" argument will be",
"  recognized as a union name, and this command automatically executed.",
"  See the NOTE below.",
"\nEXAMPLES",
"\n  Display the bdflush_param union definition, and then an instance of it:\n",
"    %s> union bdflush_param",
"    union bdflush_param {",
"        struct {",
"            int nfract;",
"            int ndirty;",
"            int nrefill;",
"            int nref_dirt;",
"            int dummy1;",
"            int age_buffer;",
"            int age_super;",
"            int dummy2;",
"            int dummy3;",
"        } b_un;",
"        unsigned int data[9];",
"    }",
"    ",
"    SIZE: 36  (0x24)",
" ",
"    %s> union bdflush_param bdf_prm",
"    union bdflush_param {",
"      b_un = {",
"        nfract = 40, ",
"        ndirty = 500, ",
"        nrefill = 64, ",
"        nref_dirt = 256, ",
"        dummy1 = 15, ",
"        age_buffer = 3000, ",
"        age_super = 500, ",
"        dummy2 = 1884, ",
"        dummy3 = 2",
"      }, ",
"      data = {40, 500, 64, 256, 15, 3000, 500, 1884, 2}",
"    }",
"\nNOTE",
"  If the union name does not conflict with any %s command name, the",
"  \"union\" command may be dropped.  Accordingly, the examples above could",
"  also have been accomplished like so:\n",
"    %s> bdflush_param",
"    %s> bdflush_param bdf_prm",
" ",
"  Lastly, the short-cut \"*\" (pointer-to) command may also be used to negate",
"  the need to enter the \"union\" command name (enter \"help *\" for details).",
NULL               
};

char *help_ptov[] = {
"ptov",
"physical to virtual\n         per-cpu to virtual",
"[address | offset:cpuspec]",
"  This command translates a hexadecimal physical address into a kernel",
"  virtual address.  Alternatively, a hexadecimal per-cpu offset and",
"  cpu specifier will be translated into kernel virtual addresses for",
"  each cpu specified.\n",
"         address  a physical address",
"  offset:cpuspec  a per-cpu offset with a CPU specifier:",
"                    :             CPU of the currently selected task.",
"                    :a[ll]        all CPUs.",
"                    :#[-#][,...]  CPU list(s), e.g. \"1,3,5\", \"1-3\",",
"                                or \"1,3,5-7,10\".",
"\nEXAMPLES",
"  Translate physical address 56e000 into a kernel virtual address:\n",
"    %s> ptov 56e000",
"    VIRTUAL           PHYSICAL",        
"    ffff88000056e000  56e000",         
"",
"  Translate per-cpu offset b0c0 into a kernel virtual address for",
"  all cpus:\n",
"    %s> ptov b0c0:a",
"    PER-CPU OFFSET: b0c0",
"      CPU    VIRTUAL",         
"      [0]  ffff88021e20b0c0",
"      [1]  ffff88021e24b0c0",
"      [2]  ffff88021e28b0c0",
"      [3]  ffff88021e2cb0c0",
NULL               
};

char *help_mod[] = {
"mod",
"module information and loading of symbols and debugging data",
"-s module [objfile] | -d module | -S [directory] [-D|-t|-r|-R|-o|-g]",
"  With no arguments, this command displays basic information of the currently",
"  installed modules, consisting of the module address, name, base address,",
"  size, the object file name (if known), and whether the module was compiled",
"  with CONFIG_KALLSYMS.",
" ",
"  The arguments are concerned with with the loading or deleting of symbolic",
"  and debugging data from a module's object file.  A modules's object file",
"  always contains symbolic data (symbol names and addresses), but contains",
"  debugging data only if the module was compiled with the -g CFLAG.  In",
"  addition, the module may have compiled with CONFIG_KALLSYMS, which means",
"  that the module's symbolic data will have been loaded into the kernel's",
"  address space when it was installed.  If the module was not compiled with",
"  CONFIG_KALLSYMS, then only the module's exported symbols will be loaded",
"  into the kernel's address space.  Therefore, for the purpose of this",
"  command, it should noted that a kernel module may have been compiled in",
"  one of following manners:\n",
"  1. If the module was built without CONFIG_KALLSYMS and without the -g CFLAG,",
"     then the loading of the module's additional non-exported symbols can",
"     be accomplished with this command.",
"  2. If the module was built with CONFIG_KALLSYMS, but without the -g CFLAG,",
"     then there is no benefit in loading the symbols from the module object",
"     file, because all of the module's symbols will have been loaded into the",
"     kernel's address space when it was installed.",
"  3. If the module was built with CONFIG_KALLSYMS and with the the -g CFLAG,",
"     then the loading of the module's debugging data can be accomplished",
"     with this command.",
"  4. If the module was built without CONFIG_KALLSYMS but with the -g CFLAG,",
"     then the loading of the both module's symbolic and debugging data can",
"     be accomplished with this command.",
" ",
"  -s module [objfile]  Loads symbolic and debugging data from the object file",
"                       for the module specified.  If no objfile argument is",
"                       appended, a search will be made for an object file",
"                       consisting of the module name with a .o or .ko suffix,",
"                       starting at the /lib/modules/<release> directory on",
"                       the host system, or if not found there, starting at the",
"                       directory containing the kernel namelist file.  If an",
"                       objfile argument is appended, then that file will be",
"                       used.",
"            -d module  Deletes the symbolic and debugging data of the module",
"                       specified.",
"       -S [directory]  Load symbolic and debugging data from the object file",
"                       for all loaded modules.  For each module, a search",
"                       will be made for an object file consisting of the",
"                       module name with a .o or .ko suffix, starting at the",
"                       /lib/modules/<release> directory of the host system,",
"                       or if not found there, starting at the directory",
"                       containing the kernel namelist file.  If a directory",
"                       argument is appended, then the search will be restricted",
"                       to that directory.",
"                   -D  Deletes the symbolic and debugging data of all modules.",
"                   -t  Display the contents of the module's \"taints\" bitmask",
"                       if it is non-zero.  When possible, the \"taints\" bits",
"                       are translated to symbolic letters of the taint type;",
"                       otherwise the hexadecimal value is shown.  In older",
"                       kernels, the contents of the \"license_gplok\" field is",
"                       displayed in hexadecimal; the field may be either a ",
"                       bitmask or a boolean, depending upon the kernel version.",
"                       The relevant kernel sources should be consulted for the",
"                       meaning of the letter(s) or hexadecimal bit value(s). ",
"                       For modules that have a \"gpgsig_ok\" field that is zero",
"                       (unsigned), the notation \"(U)\" is shown.",
"                   -r  Passes the -readnow flag to the embedded gdb module,",
"                       which will override the two-stage strategy that it uses",
"                       for reading symbol tables from module object files.",
"                   -R  Reinitialize module data. All currently-loaded symbolic",
"                       and debugging data will be deleted, and the installed",
"                       module list will be updated (live system only).",
"                   -g  When used with -s or -S, add a module object's section",
"                       start and end addresses to its symbol list.",
"                   -o  Load module symbols with old mechanism.",
" ",
"  If the %s session was invoked with the \"--mod <directory>\" option, or",
"  a CRASH_MODULE_PATH environment variable exists, then /lib/modules/<release>",
"  will be overridden as the default directory tree that is searched for module",
"  object files.",
" ",
"  After symbolic and debugging data have been loaded, backtraces and text",
"  disassembly will be displayed appropriately.  Depending upon the processor",
"  architecture, data may also printed symbolically with the \"p\" command;",
"  at a minimum, the \"rd\" command may be used with module data symbols.",
" ",
"  If %s can recognize that the set of modules has changed while running a",
"  session on a live kernel, the module data will be reinitialized the next",
"  time this command is run; the -r option forces the reinitialization.",
"\nEXAMPLES",
"  Display the currently-installed modules:\n",
"    %s> mod",
"     MODULE   NAME              BASE      SIZE  OBJECT FILE",
"    f7e44c20  dm_mod          f7e34000   88568  (not loaded)",
"    f7e5a8a0  dm_log          f7e59000    8354  (not loaded)",
"    f7e66420  dm_region_hash  f7e65000    9708  (not loaded)",
"    f7e76b60  dm_mirror       f7e74000   12609  (not loaded)",
"    f7e8b8e0  ata_piix        f7e87000   20637  (not loaded)",
"    ...",
" ",
"  Display the currently-installed modules on a system where all modules were",
"  compiled with CONFIG_KALLSYMS:",
" ",
"    %s> mod",
"     MODULE   NAME              BASE      SIZE  OBJECT FILE",
"    f7e44c20  dm_mod          f7e34000   88568  (not loaded)  [CONFIG_KALLSYMS]",
"    f7e5a8a0  dm_log          f7e59000    8354  (not loaded)  [CONFIG_KALLSYMS]",
"    f7e66420  dm_region_hash  f7e65000    9708  (not loaded)  [CONFIG_KALLSYMS]",
"    f7e76b60  dm_mirror       f7e74000   12609  (not loaded)  [CONFIG_KALLSYMS]",
"    f7e8b8e0  ata_piix        f7e87000   20637  (not loaded)  [CONFIG_KALLSYMS]",
"    ...",
" ",
"  Load the symbolic and debugging data of all modules:\n",
"    %s> mod -S",
"     MODULE   NAME              BASE      SIZE  OBJECT FILE",
"    f7e44c20  dm_mod          f7e34000   88568  /lib/modules/2.6.32/kernel/drivers/md/dm-mod.ko",
"    f7e5a8a0  dm_log          f7e59000    8354  /lib/modules/2.6.32/kernel/drivers/md/dm-log.ko",
"    f7e66420  dm_region_hash  f7e65000    9708  /lib/modules/2.6.32/kernel/drivers/md/dm-region-hash.ko",
"    f7e76b60  dm_mirror       f7e74000   12609  /lib/modules/2.6.32/kernel/drivers/md/dm-mirror.ko",
"    f7e8b8e0  ata_piix        f7e87000   20637  /lib/modules/2.6.32/kernel/drivers/ata/ata_piix.ko",
"    ...",
"    ",
"  Load the symbolic and debugging data of the dm_mod module from its",
"  known location:",
" ",
"    %s> mod -s dm_mod",
"     MODULE   NAME              BASE      SIZE  OBJECT FILE",
"    f7e44c20  dm_mod          f7e34000   88568  /lib/modules/2.6.32/kernel/drivers/md/dm-mod.ko",
"    ",
"  Delete the current symbolic and debugging data of the dm_mod module,",
"  and then re-load it from a specified object file:",
" ",
"    %s> mod -d dm_mod",
"    %s> mod -s dm_mod /tmp/dm_mod.ko",
"     MODULE   NAME              BASE      SIZE  OBJECT FILE",
"    f7e44c20  dm_mod          f7e34000   88568  /tmp/dm-mod.ko",
" ",
"  After installing a new kernel module on a live system, reinitialize the",
"  installed module list:\n",
"    %s> !modprobe soundcore",
"    %s> mod",
"    mod: NOTE: modules have changed on this system -- reinitializing",
"     MODULE   NAME              BASE      SIZE  OBJECT FILE",
"    f7e44c20  dm_mod          f7e34000   88568  (not loaded)",
"    f7e5a8a0  dm_log          f7e59000    8354  (not loaded)",
"    f7e62e40  soundcore       f7e62000    6390  (not loaded)",
"    f7e66420  dm_region_hash  f7e65000    9708  (not loaded)",
"    f7e76b60  dm_mirror       f7e74000   12609  (not loaded)",
"    f7e8b8e0  ata_piix        f7e87000   20637  (not loaded)",
"    ...",
" ",
"  Display modules that are \"tainted\", where in this case",
"  where they are proprietary and unsigned:",
" ",
"    %s> mod -t",
"    NAME      TAINT",
"    vxspec    P(U)",
"    vxportal  P(U)",
"    fdd       P(U)",
"    vxfs      P(U)",
"    vxdmp     P(U)",
"    vxio      P(U)",
"    vxglm     P(U)",
"    vxgms     P(U)",
"    vxodm     P(U)",
NULL               
};


char *help__list[] = {
"list",
"linked list",
"[[-o] offset][-e end][-[s|S] struct[.member[,member] [-l offset]] -[x|d]]"
"\n       [-r|-B] [-h [-O head_offset]|-H] start",
" ",
"  This command dumps the contents of a linked list.  The entries in a linked",
"  list are typically data structures that are tied together in one of two",
"  formats:",
" ",
"  1. A starting address points to a data structure; that structure contains",
"     a member that is a pointer to the next structure, and so on.  This type",
"     of a singly-linked list typically ends when a \"next\" pointer value ",
"     contains one of the following:",
"",
"       (a) a NULL pointer.",
"       (b) a pointer to the start address.",
"       (c) a pointer to the first item pointed to by the start address.",
"       (d) a pointer to its containing structure.",
"  ",
"  2. Most Linux lists of data structures are doubly-linked using \"list_head\"",
"     structures that are embedded members of the data structures in the list:",
" ",
"       struct list_head {",
"           struct list_head *next, *prev;",
"       };",
" ",
"     The linked list is typically headed by an external, standalone list_head,",
"     which is simply initialized to point to itself, signifying that the list",
"     is empty:",
" ",
"       #define LIST_HEAD_INIT(name) { &(name), &(name) } ",
"       #define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)",
" ",
"     In the case of list_head-linked lists, the \"list_head.next\" pointer is",
"     the address of a list_head structure that is embedded in the next data",
"     structure in the list, and not the address of the next data structure ",
"     itself.  The starting point of the list may be:",
"",
"       (a) an external, standalone, LIST_HEAD().",
"       (b) a list_head that is embedded within a data structure of the same",
"           type as the whole linked list.",
"       (c) a list_head that is embedded within a data structure that is",
"           different than the type of structures in the the linked list.",
" ",
"     The list typically ends when the embedded \"list_head.next\" pointer of",
"     a data structure in the linked list points back to the LIST_HEAD()",
"     address.  However, some list_head-linked lists have no defined starting",
"     point, but just link back onto themselves in a circular manner.",
"",
"  This command can handle both types of linked list; in both cases the list",
"  of addresses that are dumped are the addresses of the data structures",
"  themselves.",
" ",
"  Alternatively, the address of a list_head, or other similar list linkage ",
"  structure whose first member points to the next linkage structure, may be",
"  used as the starting address.  The caveat with this type of usage is that",
"  the list may pass through, and display the address of, an external standalone",
"  list head which is not an address of a list linkage structure that is embedded",
"  within the data structure of interest.",
"",
"  The arguments are as follows:",
"",
"  [-o] offset  The offset within the structure to the \"next\" pointer",
"               (default is 0).  If non-zero, the offset may be entered",
"               in either of two manners:",
"",
"               1. In \"structure.member\" format; the \"-o\" is not necessary.",
"               2. A number of bytes; the \"-o\" is only necessary on processors",
"                  where the offset value could be misconstrued as a kernel",
"                  virtual address.",
"",
"       -e end  If the list ends in a manner unlike the typical manners that",
"               are described above, an explicit ending address value may be",
"               entered.",
"    -s struct  For each address in list, format and print as this type of",
"               structure; use the \"struct.member\" format in order to display",
"               a particular member of the structure.  To display multiple",
"               members of a structure, use a comma-separated list of members.",
"               If any structure member contains an embedded structure or is an",
"               array, the output may be restricted to the embedded structure",
"               or an array element by expressing the struct argument as ",
"               \"struct.member.member\" or \"struct.member[index]\"; embedded",
"               member specifications may extend beyond one level deep by ",
"               expressing the argument as \"struct.member.member.member...\".",
"    -S struct  Similar to -s, but instead of parsing gdb output, member values",
"               are read directly from memory, so the command works much faster",
"               for 1-, 2-, 4-, and 8-byte members.",
"    -O offset  Only used in conjunction with -h; it specifies the offset of",
"               head node list_head embedded within a data structure which is",
"               different than the offset of list_head of other nodes embedded",
"               within a data structure.",
"               The offset may be entered in either of the following manners:",
"",
"                 1. in \"structure.member\" format.",
"                 2. a number of bytes.",
"",
"    -l offset  Only used in conjunction with -s, if the start address argument",
"               is a pointer to an embedded list head (or any other similar list",
"               linkage structure whose first member points to the next linkage",
"               structure), the offset to the embedded member may be entered",
"               in either of the following manners:",
" ",
"                 1. in \"structure.member\" format.",
"                 2. a number of bytes. ",
" ",
"           -x  Override the default output format with hexadecimal format.",
"           -d  Override the default output format with decimal format.",
"           -r  For a list linked with list_head structures, traverse the list",
"               in the reverse order by using the \"prev\" pointer instead",
"               of \"next\".",
"           -B  Use the algorithm from R. P. Brent to detect loops instead of",
"               using a hash table.  This algorithm uses a tiny fixed amount of",
"               memory and so is especially helpful for longer lists.  The output",
"               is slightly different than the normal list output as it will",
"               print the length of the loop, the start of the loop, and the",
"               first duplicate in the list.",
" ",
"  The meaning of the \"start\" argument, which can be expressed symbolically,",
"  in hexadecimal format, or an expression evaluating to an address, depends",
"  upon whether the -h or -H option is pre-pended:",
" ",
"      start  The address of the first data structure in the list.",
"      start  When both the -s and -l options are used, the address of an",
"             embedded list_head or similar linkage structure whose first",
"             member points to the next linkage structure.",
"   -H start  The address of a list_head structure, typically that of an",
"             external, standalone LIST_HEAD().  The list typically ends ",
"             when the embedded \"list_head.next\" of a data structure in ",
"             the linked list points back to this \"start\" address.",
"   -h start  The address of a data structure which contains an embedded",
"             list_head.  The list typically ends when the embedded",
"             \"list_head.next\" of a data structure in the linked list ",
"             points back to the embedded list_head contained in the data",
"             structure whose address is this \"start\" argument.",
"",
"WARNING ",
"  When the \"-h start\" option is used, it is possible that the list_head-linked",
"  list will:",
" ",
"    1. pass through an external standalone LIST_HEAD(), or",
"    2. pass through a list_head that is the actual starting list_head, but is",
"       contained within a data structure that is not the same type as all of",
"       the other data structures in the list.",
" ",
"  When that occurs, the data structure address displayed for that list_head",
"  will be incorrect, because the \"-h start\" option presumes that all",
"  list_head structures in the list are contained within the same type of",
"  data structure.  Furthermore, if the \"-s struct[.member[,member]\" option",
"  is used, it will display bogus data for that particular list_head.",
" ",
"  A similar issue may be encountered when the \"start\" address is an embedded",
"  list_head or similar linkage structure whose first member points to the next",
"  linkage structure.  When that occurs, the address of any external list head",
"  will not be distinguishable from the addresses that are embedded in the data",
"  structure of interest.  Furthermore, if the \"-s\" and \"-l\" options are used,",
"  it will display bogus structure data when passing through any external list",
"  head structure that is not embedded in the specified data structure type.",
"\nEXAMPLES",
"  Note that each task_struct is linked to its parent's task_struct via the",
"  p_pptr member:",
" ",
"    %s> struct task_struct.p_pptr",
"    struct task_struct {",
"       [136] struct task_struct *p_pptr;",
"    }",
" ",    
"  That being the case, given a task_struct pointer of c169a000, show its ",
"  parental hierarchy back to the \"init_task\" (the \"swapper\" task):\n",
"    %s> list task_struct.p_pptr c169a000",
"    c169a000",
"    c0440000",
"    c50d0000",
"    c0562000",
"    c0d28000",
"    c7894000",
"    c6a98000",
"    c009a000",
"    c0252000\n",
"  Given that the \"task_struct.p_pptr\" offset is 136 bytes, the same",
"  result could be accomplished like so:\n",
"    %s> list 136 c169a000",
"    c169a000",
"    c0440000",
"    c50d0000",
"    c0562000",
"    c0d28000",
"    c7894000",
"    c6a98000",
"    c009a000",
"    c0252000",
" ",
"  The list of currently-registered file system types are headed up by a",
"  struct file_system_type pointer named \"file_systems\", and linked by",
"  the \"next\" field in each file_system_type structure.  The following",
"  sequence displays the structure address followed by the name and ",
"  fs_flags members of each registered file system type:",
" ",
"    %s> p file_systems",
"    file_systems = $1 = (struct file_system_type *) 0xc03adc90",
"    %s> list file_system_type.next -s file_system_type.name,fs_flags c03adc90",
"    c03adc90",
"      name = 0xc02c05c8 \"rootfs\",",
"      fs_flags = 0x30,",
"    c03abf94",
"      name = 0xc02c0319 \"bdev\",",
"      fs_flags = 0x10,",
"    c03acb40",
"      name = 0xc02c07c4 \"proc\",",
"      fs_flags = 0x8,",
"    c03e9834",
"      name = 0xc02cfc83 \"sockfs\",",
"      fs_flags = 0x10,",
"    c03ab8e4",
"      name = 0xc02bf512 \"tmpfs\",",
"      fs_flags = 0x20,",
"    c03ab8c8",
"      name = 0xc02c3d6b \"shm\",",
"      fs_flags = 0x20,",
"    c03ac394",
"      name = 0xc02c03cf \"pipefs\",",
"      fs_flags = 0x10,",
"    c03ada74",
"      name = 0xc02c0e6b \"ext2\",",
"      fs_flags = 0x1,",
"    c03adc74",
"      name = 0xc02c0e70 \"ramfs\",",
"      fs_flags = 0x20,",
"    c03ade74",
"      name = 0xc02c0e76 \"hugetlbfs\",",
"      fs_flags = 0x20,",
"    c03adf8c",
"      name = 0xc02c0f84 \"iso9660\",",
"      fs_flags = 0x1,",
"    c03aec14",
"      name = 0xc02c0ffd \"devpts\",",
"      fs_flags = 0x8,",
"    c03e93f4",
"      name = 0xc02cf1b9 \"pcihpfs\",",
"      fs_flags = 0x28,",
"    e0831a14",
"      name = 0xe082f89f \"ext3\",",
"      fs_flags = 0x1,",
"    e0846af4",
"      name = 0xe0841ac6 \"usbdevfs\",",
"      fs_flags = 0x8,",
"    e0846b10",
"      name = 0xe0841acf \"usbfs\",",
"      fs_flags = 0x8,",
"    e0992370",
"      name = 0xe099176c \"autofs\",",
"      fs_flags = 0x0,",
"    e2dcc030",
"      name = 0xe2dc8849 \"nfs\",",
"      fs_flags = 0x48000,",
" ",
"  In some kernels, the system run queue is a linked list headed up by the",
"  \"runqueue_head\", which is defined like so:",
" ",
"    static LIST_HEAD(runqueue_head);",
" ",
"  The run queue linking is done with the \"run_list\" member of the task_struct:",
" ",
"    %s> struct task_struct.run_list",
"    struct task_struct {",
"        [60] struct list_head run_list;",
"    }",
" ",
"  Therefore, to view the list of task_struct addresses in the run queue,",
"  either of the following commands will work:\n",
"    %s> list task_struct.run_list -H runqueue_head",
"    f79ac000",
"    f7254000",
"    f7004000",
"    %s> list 60 -H runqueue_head",
"    f79ac000",
"    f7254000",
"    f7004000",
" ",
"  In some kernel versions, the vfsmount structures of the mounted",
"  filesystems are linked by the LIST_HEAD \"vfsmntlist\", which uses the",
"  mnt_list list_head of each vfsmount structure in the list.  To dump each",
"  vfsmount structure in the list, append the -s option:\n",
"    %s> list -H vfsmntlist vfsmount.mnt_list -s vfsmount",
"    c3fc9e60",
"    struct vfsmount {",
"      mnt_hash = {",
"        next = 0xc3fc9e60, ",
"        prev = 0xc3fc9e60",
"      }, ",
"      mnt_parent = 0xc3fc9e60, ",
"      mnt_mountpoint = 0xc3fc5dc0, ",
"      mnt_root = 0xc3fc5dc0, ",
"      mnt_instances = {",
"        next = 0xc3f60a74, ",
"        prev = 0xc3f60a74",
"      }, ",
"      mnt_sb = 0xc3f60a00, ",
"      mnt_mounts = {",
"        next = 0xf7445e08, ",
"        prev = 0xf7445f88",
"      }, ",
"      mnt_child = {",
"        next = 0xc3fc9e88, ",
"        prev = 0xc3fc9e88",
"      }, ",
"      mnt_count = {",
"        counter = 209",
"      }, ",
"      mnt_flags = 0, ",
"      mnt_devname = 0xc8465b20 \"/dev/root\", ",
"      mnt_list = {",
"        next = 0xf7445f9c, ",
"        prev = 0xc02eb828",
"      }, ",
"      mnt_owner = 0",
"    }",
"    f7445f60",
"    struct vfsmount {",
"    ...",
" ",
"  The task_struct of every task in the system is linked into a circular list",
"  by its embedded \"tasks\" list_head.  Show the task_struct addresses and the",
"  pids of all tasks in the system using \"-h\" option, starting with the ",
"  task_struct at ffff88012b98e040:\n",
"    %s> list task_struct.tasks -s task_struct.pid -h ffff88012b98e040",
"    ffff88012b98e040",
"      pid = 14187",
"    ffff8801277be0c0",
"      pid = 14248",
"    ffffffff81a2d020",
"      pid = 0",
"    ffff88012d7dd4c0",
"      pid = 1",
"    ffff88012d7dca80",
"      pid = 2",
"    ffff88012d7dc040",
"      pid = 3",
"    ffff88012d7e9500",
"      pid = 4",
"    ...",
"    ffff88012961a100",
"      pid = 14101",
"    ffff880129017580",
"      pid = 14134",
"    ffff8801269ed540",
"      pid = 14135",
"    ffff880128256080",
"      pid = 14138",
"    ffff88012b8f4100",
"      pid = 14183",
" ",
"  Similar to the above, display the embedded sched_entity structure's on_rq",
"  member from each task_struct in the system:\n",
"    %s> list task_struct.tasks -s task_struct.se.on_rq -h ffff8800b66a0000",
"    ffff8800b66a0000",
"      se.on_rq = 1,",
"    ffff8800b66a0ad0",
"      se.on_rq = 0,",
"    ffff8800b66a15a0",
"      se.on_rq = 0,",
"    ffff8800b66a2070",
"      se.on_rq = 0,",
"    ffff8800b66a2b40",
"      se.on_rq = 0,",
"    ffff8800b67315a0",
"      se.on_rq = 0,",
"    ffff8800b6732b40",
"      se.on_rq = 0,",
"    ...",
" ",
"  The task_struct.tasks example above requires that the -h option be given",
"  the address of a task_struct.  Alternatively, the -l option can be given",
"  the address of a list_head or similar linkage structure whose first member",
"  points to the next linkage structure.  Again using the task_struct.tasks",
"  embedded list_head, dump the \"comm\" member of all tasks by using -l in",
"  conjunction with -s option:",
"  ",
"    %s> task -R tasks.next",
"    PID: 7044   TASK: ffff88005ac10000  CPU: 2   COMMAND: \"crash\"",
"      tasks.next = 0xffff880109b8e3d0,",
"    %s> list 0xffff880109b8e3d0 -l task_struct.tasks -s task_struct.comm",
"    ffff880109b8e3d0",
"      comm = \"kworker/1:2\"",
"    ffff880109b8be00",
"      comm = \"bash\"",
"    ffff88019d26c590",
"      comm = \"cscope\"",
"    ffff880109b8b670",
"      comm = \"kworker/0:1\"",
"    ffff880109b8cd20",
"      comm = \"kworker/1:0\"",
"    ffff88005ac15c40",
"      comm = \"vi\"",
"    ffff88005ac11fc0",
"      comm = \"sleep\"",
"    ffffffff81c135c0",
"      comm = \"swapper/0\"",
"    ffff880212828180",
"      comm = \"systemd\"",
"    ... ",
"    ffff8801288d1830",
"      comm = \"chrome\"",
"    ffff8801534dd4b0",
"      comm = \"kworker/0:0\"",
"    ffff8801534d8180",
"      comm = \"kworker/1:1\"",
"    ffff88010902b670",
"      comm = \"kworker/2:2\"",
"    ffff880109b8a750",
"      comm = \"sudo\"",
"    ffff88005ac10180",
"      comm = \"crash\"",
"",
"  To display a linked list whose head node and other nodes are embedded within",
"  either same or different data structures resulting in different offsets for",
"  head node and other nodes, e.g. dentry.d_subdirs and dentry.d_child, the",
"  -O option can be used:",
"",
"    %s> list -o dentry.d_child -s dentry.d_name.name -O dentry.d_subdirs -h ffff9c585b81a180",
"    ffff9c585b9cb140",
"      d_name.name = 0xffff9c585b9cb178 ccc.txt",
"    ffff9c585b9cb980",
"      d_name.name = 0xffff9c585b9cb9b8 bbb.txt",
"    ffff9c585b9cb740",
"      d_name.name = 0xffff9c585b9cb778 aaa.txt",
"",
"  The dentry.d_subdirs example above is equal to the following sequence:",
"",
"    %s> struct -o dentry.d_subdirs ffff9c585b81a180",
"    struct dentry {",
"      [ffff9c585b81a220] struct list_head d_subdirs;",
"    }",
"    %s> list -o dentry.d_child -s dentry.d_name.name -H ffff9c585b81a220",
NULL               
};

char *help_tree[] = {
"tree",
"display radix tree, XArray, red-black tree or maple tree",
"[-t [radix|xarray|rbtree|maple]] [-r offset] [-[s|S] struct[.member[,member]]]\n"
"       -[x|d] [-o offset] [-l] [-p] [-v] [-N] start",
"  This command dumps the contents of a radix tree, an XAarray, a red-black",
"  tree, or a maple tree.  The arguments are as follows:\n",
"    -t type  The type of tree to dump; the type string can be one of ",
"             \"radix\", \"rbtree\", \"xarray\", or \"maple\", or alternatively,",
"             \"ra\", \"rb\", \"x\" or \"m\" are acceptable. If not specified,",
"             rbtree is the default type.",
"  -r offset  If the \"start\" argument is the address of a data structure that",
"             contains an radix_tree_root, maple_tree, xarray or rb_root",
"             structure, then this is the offset to that structure member. If",
"             the offset is non-zero, then this option is required.  The offset",
"             may be entered in either of two manners:",
"               1. In \"structure.member\" format.",
"               2. A number of bytes.",
"  -o offset  For red-black trees only, the offset of the rb_node within its ",
"             containing data structure; if the offset is non-zero, then this",
"             option is required.  The offset may be entered in either of two",
"             manners:",
"               1. In \"structure.member\" format.",
"               2. A number of bytes.",
"             This option is not applicable to radix trees.",
"  -s struct  For each entry in a tree, format and print it as this type of data",
"             structure; use the \"struct.member\" format in order to display a",
"             particular member of the structure.  To display multiple members",
"             of a structure, use a comma-separated list of members.  If any",
"             structure member contains an embedded structure or is an array, the",
"             the output may be restricted to the embedded structure or an array",
"             element by expressing the member argument as \"struct.member.member\"",
"             or \"struct.member[index]\"; embedded member specifications may",
"             extend beyond one level deep by expressing the struct argument as", 
"             \"struct.member.member.member...\".",
"  -S struct  Similar to -s, but instead of parsing gdb output, member values",
"             are read directly from memory, so the command works much faster", 
"             for 1-, 2-, 4-, and 8-byte members.",
"         -l  For red-black trees, dump the tree sorted in linear order starting",
"             with the leftmost node and progressing to the right.  This option",
"             does not apply to radix trees.",
"         -p  Display the node's position information, showing the relationship",
"             between it and the root.  For red-black trees, a position that",
"             indicates \"root/l/r\" means that the node is the right child",
"             of the left child of the root node.  For radix trees, xarrays and",
"             maple trees, the index, the height, and the slot index values are",
"             shown with respect to the root.",
"         -x  Override default output format with hexadecimal format.",
"         -d  Override default output format with decimal format.",
"         -v  For maple trees only, dump the contents of each maple tree node.",
" ",
"  The meaning of the \"start\" argument, which can be expressed either in",
"  hexadecimal format or symbolically, depends upon whether the -N option",
"  is prepended:",
" ",
"      start  The address of a radix_tree_root, maple_tree, xarray or rb_root",
"             structure, or the address of a structure containing the",
"             radix_tree_root, maple_tree, xarray or rb_root structure; if the",
"             latter, then the \"-r offset\" option must be used if the member",
"             offset of the root structure is non-zero.",
"               ",
"   -N start  The address of a radix_tree_node, maple_node, xa_node or rb_node",
"             structure, bypassing the radix_tree_root, maple_tree, xarray, or",
"             rb_root that points to it.",
"",
"\nEXAMPLES",
"  The vmap_area_root is a standalone rb_root structure.  Display the ",
"  virtual addresses of each vmap_area in its red-black tree:\n",
"    %s> whatis vmap_area_root",
"    struct rb_root vmap_area_root;",
"    %s> tree -t rbtree -o vmap_area.rb_node vmap_area_root",
"    ffff880128c508c0",
"    ffff88012cb68140",
"    ffff88012c9afec0",
"    ffff88012d65c440",
"    ...",
"",
"  Display the vmap_area's va_start and va_end members of each of",
"  the entries above expressing the vmap_area.rb_node offset as a",
"  number of bytes:\n",
"    %s> tree -t rbtree -o 24 vmap_area_root -s vmap_area.va_start,va_end",
"    ffff880128c508c0",
"      va_start = 0xffffc90014900000",
"      va_end = 0xffffc90014921000",
"    ffff88012cb68140",
"      va_start = 0xffffc900110c0000",
"      va_end = 0xffffc900110d1000",
"    ffff88012c9afec0",
"      va_start = 0xffffc90000640000",
"      va_end = 0xffffc90000642000",
"    ffff88012d65c440",
"      va_start = 0xffffc90000620000",
"      va_end = 0xffffc90000622000",
"    ...",
"",
"  Alternatively, use the -N option with the rb_node address contained",
"  in the vmap_area_root structure:\n",
"    %s> p vmap_area_root",
"    vmap_area_root = $8 = {",
"      rb_node = 0xffff880128c508d8",
"    }",
"    %s> tree -t rbtree -o vmap_area.rb_node -N 0xffff880128c508d8",
"    ffff880128c508c0",
"    ffff88012cb68140",
"    ffff88012c9afec0",
"    ffff88012d65c440",
" ",
"  Display the virtual address of each vm_area_struct in the red-black",
"  tree that has its root inside an mm_struct located at ffff880128b5a300.",
"  The vm_area_struct.vm_rb rb_node member has an offset of 0x38 bytes:\n",
"    %s> tree -t rbtree -r mm_struct.mm_rb ffff880128b5a300 -o 0x38",
"    ffff88012a0de080",
"    ffff880123e3ac78",
"    ffff880123e3a700",
"    ffff88012b2837c8",
"    ...",
"    ffff880128c02ed0",
"    ffff8801292e7958",
"    ffff880123e3a318",
"    ffff880123e3ad40",
" ",
"  Add the -p option to the command above to show position information:\n",
"    %s> tree -t rbtree -r mm_struct.mm_rb ffff880128b5a300 -o 0x38 -p",
"    ffff88012a0de080",
"      position: root",
"    ffff880123e3ac78",
"      position: root/l",
"    ffff880123e3a700",
"      position: root/l/l",
"    ffff88012b2837c8",
"      position: root/l/l/l",
"    ...",
"    ffff880128c02ed0",
"      position: root/r/r/l/r",
"    ffff8801292e7958",
"      position: root/r/r/l/r/r",
"    ffff880123e3a318",
"      position: root/r/r/r",
"    ffff880123e3ad40",
"      position: root/r/r/r/r",
"",
"  Given an mm_struct address of 0xffff880074b5be80, list the VMA tree in linear",
"  order from the leftmost node progressing to the right using the -l option:\n",
"    %s> tree -ls vm_area_struct.vm_start -o vm_area_struct.vm_rb \\",
"    -r mm_struct.mm_rb 0xffff880074b5be80 | paste - -",
"    ffff88001f2c50e0	  vm_start = 0x400000",
"    ffff88001f2c5290	  vm_start = 0xceb000",
"    ffff880074bfc6c0	  vm_start = 0xcec000",
"    ffff88001f2c4bd0	  vm_start = 0xd10000",
"    ffff880074bfc948	  vm_start = 0x1fe9000",
"    ffff880036e54510	  vm_start = 0x7ff6aa296000",
"    ffff88001f2c5bd8	  vm_start = 0x7ff6aa298000",
"    ffff880036e54af8	  vm_start = 0x7ff6aa497000",
"    ffff880036e54f30	  vm_start = 0x7ff6aa498000",
"    ffff88000e06aa20	  vm_start = 0x7ff6aa499000",
"    ffff88000e06b368	  vm_start = 0x7ff6ab95f000",
"    ...",
"    ffff88001f2c5e60	  vm_start = 0x7ff6bc1af000",
"    ffff88001f2c4ca8	  vm_start = 0x7ff6bc1b6000",
"    ffff88001f2c5008	  vm_start = 0x7ff6bc200000",
"    ffff88001f2c5d88	  vm_start = 0x7ff6bc205000",
"    ffff880074bfd6c8	  vm_start = 0x7ff6bc206000",
"    ffff88001f2c4288	  vm_start = 0x7ff6bc207000",
"    ffff88001f2c4510	  vm_start = 0x7ffc7a5fc000",
"    ffff88001f2c5b00	  vm_start = 0x7ffc7a6d1000",
"",
"  Compared to the top/down root/leaves order:\n",
"    %s> tree -s vm_area_struct.vm_start -o vm_area_struct.vm_rb \\",
"    -r mm_struct.mm_rb 0xffff880074b5be80 | paste - -",
"    ffff88001f2c5a28	  vm_start = 0x7ff6bbbb9000",
"    ffff88001f2c55f0	  vm_start = 0x7ff6bb252000",
"    ffff88000e06a360	  vm_start = 0x7ff6ac6c3000",
"    ffff88001f2c4bd0	  vm_start = 0xd10000",
"    ffff88001f2c5290	  vm_start = 0xceb000",
"    ffff88001f2c50e0	  vm_start = 0x400000",
"    ffff880074bfc6c0	  vm_start = 0xcec000",
"    ffff88000e06b368	  vm_start = 0x7ff6ab95f000",
"    ffff88001f2c5bd8	  vm_start = 0x7ff6aa298000",
"    ffff880074bfc948	  vm_start = 0x1fe9000",
"    ffff880036e54510	  vm_start = 0x7ff6aa296000",
"    ffff880036e54f30	  vm_start = 0x7ff6aa498000",
"    ffff880036e54af8	  vm_start = 0x7ff6aa497000",
"    ffff88000e06aa20	  vm_start = 0x7ff6aa499000",
"    ffff88000e06ae58	  vm_start = 0x7ff6ac1df000",
"    ffff88000e06ba28	  vm_start = 0x7ff6abefc000",
"    ffff88000e06a6c0	  vm_start = 0x7ff6ac41b000",
"    ffff88001f2c4000	  vm_start = 0x7ff6bac75000",
"    ffff88000e06bd88	  vm_start = 0x7ff6b2d00000",
"    ffff88000e06b440	  vm_start = 0x7ff6b28de000",
"    ...",
"    ffff880074bfd6c8	  vm_start = 0x7ff6bc206000",
"    ffff88001f2c4510	  vm_start = 0x7ffc7a5fc000",
"    ffff88001f2c5b00	  vm_start = 0x7ffc7a6d1000",
"",
"  Display a list of the page structs in the radix tree of an address_space",
"  structure located at ffff88012d364de0:\n",
"    %s> tree -t radix -r address_space.page_tree ffff88012d364de0",
"    ffffea00040d12c0",
"    ffffea00040d9a60",
"    ffffea00040d9b08",
"    ffffea000407eda8",
"    ffffea0004084288",
"    ...",
"    ffffea000407bc70",
"    ffffea00040baf48",
"    ffffea0004043f48",
"    ffffea000407de58",
" ",
"  Add the -p option to the command above to show position information:\n",
"    %s> tree -t radix -r address_space.page_tree ffff88012d364de0 -p",
"    ffffea00040d12c0",
"      index: 0  position: root/0/0",
"    ffffea00040d9a60",
"      index: 1  position: root/0/1",
"    ffffea00040d9b08",
"      index: 2  position: root/0/2",
"    ffffea000407eda8",
"      index: 3  position: root/0/3",
"    ffffea0004084288",
"      index: 4  position: root/0/4",
"    ...",
"    ffffea000407bc70",
"      index: 217  position: root/3/25",
"    ffffea00040baf48",
"      index: 218  position: root/3/26",
"    ffffea0004043f48",
"      index: 219  position: root/3/27",
"    ffffea000407de58",
"      index: 220  position: root/3/28",
"",
"  Alternatively, take the address of the radix_tree_node from the",
"  radix_tree_root structure in the address_space structure above,",
"  and display the tree with the -N option:\n",
"    %s> struct address_space.page_tree ffff88012d364de0",
"      page_tree = {",
"        height = 0x2, ",
"        gfp_mask = 0x20, ",
"        rnode = 0xffff8801238add71",
"      }",
"    %s> tree -t radix -N 0xffff8801238add71",
"    ffffea00040d12c0",
"    ffffea00040d9a60",
"    ffffea00040d9b08",
"    ffffea000407eda8",
"    ffffea0004084288",
"    ffffea00040843a0",
"    ...",
" ",
"  Using the same radix tree as above, display the flags and _count",
"  members of each page struct in the list, and force the output format",
"  to be hexadecimal:\n",
"    %s> tree -t radix -N 0xffff8801238add71 -s page.flags,_count -x",
"    ffffea00040d12c0",
"      flags = 0x4000000002006c",
"      _count = {",
"        counter = 0x7",
"      }",
"    ffffea00040d9a60",
"      flags = 0x4000000002006c",
"      _count = {",
"        counter = 0x7",
"      }",
"    ffffea00040d9b08",
"      flags = 0x4000000002006c",
"      _count = {",
"        counter = 0x7",
"      }",
"    ffffea000407eda8",
"      flags = 0x4000000002006c",
"      _count = {",
"        counter = 0x7",
"      }",
"    ...",
"",
"  In more recent kernels, the XArray facility has replaced radix trees.",
"  Display a list of the page structs in the XArray of an address_space",
"  structure located at 0xffff94c235e76828, where the i_pages field is",
"  an embedded xarray structure:",
"",
"    %s> tree -t xarray -r address_space.i_pages 0xffff94c235e76828",
"    fffffcc005aa8380",
"    fffffcc005cafa80",
"    fffffcc005a79c80",
"    fffffcc005ccad80",
"    fffffcc005a72ec0",
"    fffffcc005e27c00",
"    fffffcc005ce3100",
"    fffffcc005ff8dc0",
"    fffffcc005c9a100",
"    fffffcc005a49e40",
"    fffffcc005c95a80",
"    ",
"  Add the -p option to the command above to show position information:",
"",
"    %s> tree -t xarray -r address_space.i_pages 0xffff94c235e76828 -p",
"    fffffcc005aa8380",
"      index: 90  position: root/1/26",
"    fffffcc005cafa80",
"      index: 91  position: root/1/27",
"    fffffcc005a79c80",
"      index: 92  position: root/1/28",
"    fffffcc005ccad80",
"      index: 93  position: root/1/29",
"    fffffcc005a72ec0",
"      index: 94  position: root/1/30",
"    fffffcc005e27c00",
"      index: 95  position: root/1/31",
"    fffffcc005ce3100",
"      index: 96  position: root/1/32",
"    fffffcc005ff8dc0",
"      index: 97  position: root/1/33",
"    fffffcc005c9a100",
"      index: 98  position: root/1/34",
"    fffffcc005a49e40",
"      index: 99  position: root/1/35",
"    fffffcc005c95a80",
"      index: 100  position: root/1/36",
"    ",
"  Alternatively, take the value found in the xa_head field from",
"  the xarray structure, and display the tree with the -N option:",
"",
"    %s> address_space.i_pages 0xffff94c235e76828",
"      i_pages = {",
"        ... [ xa_lock field not shown ] ...",
"        xa_flags = 1, ",
"        xa_head = 0xffff94c23c1566ca",
"      }",
"    %s> tree -t x -N 0xffff94c23c1566ca",
"    fffffcc005aa8380",
"    fffffcc005cafa80",
"    fffffcc005a79c80",
"    fffffcc005ccad80",
"    fffffcc005a72ec0",
"    fffffcc005e27c00",
"    fffffcc005ce3100",
"    fffffcc005ff8dc0",
"    fffffcc005c9a100",
"    fffffcc005a49e40",
"    fffffcc005c95a80",
"     ",
"  Using the same xarray command as above, display the flags and _refcount",
"  members of each page struct in the list, and force the output format",
"  to be hexadecimal:",
"",
"    %s> tree -t x -N 0xffff94c23c1566ca -s page.flags,_refcount -x ",
"    fffffcc005aa8380",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005cafa80",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005a79c80",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005ccad80",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005a72ec0",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005e27c00",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005ce3100",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005ff8dc0",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005c9a100",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005a49e40",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"    fffffcc005c95a80",
"      flags = 0x57ffffc0000014",
"      _refcount = {",
"        counter = 0x1",
"      }",
"",
"  The -v option is introduced specifically for dumping the complete content of",
"  maple tree:",
"",
"    %s> tree -t maple 0xffff9034c006aec0 -v",
"",
"    maple_tree(ffff9034c006aec0) flags 309, height 2 root 0xffff9034de70041e",
"",
"    0-18446744073709551615: node 0xffff9034de700400 depth 0 type 3 parent ...",
"      0-140112331583487: node 0xffff9034c01e8800 depth 1 type 1 parent ...",
"        0-94643156942847: 0x0",
"        94643156942848-94643158024191: 0xffff9035131754c0",
"        94643158024192-94643160117247: 0x0",
"        ...",
"",
"  The existing options can work as well for maple tree:",
"",
"    %s> tree -t maple -r mm_struct.mm_mt 0xffff9034c006aec0 -p",
"    ffff9035131754c0",
"      index: 1  position: root/0/1",
"    ffff9035131751c8",
"      index: 2  position: root/0/3",
"    ffff9035131757b8",
"      index: 3  position: root/0/4",
"    ...",
"",
"    %s> tree -t maple 0xffff9034c006aec0 -p -x -s vm_area_struct.vm_start,vm_end",
"    ffff9035131754c0",
"      index: 1  position: root/0/1",
"      vm_start = 0x5613d3c00000,",
"      vm_end = 0x5613d3d08000,",
"    ffff9035131751c8",
"      index: 2  position: root/0/3",
"      vm_start = 0x5613d3f07000,",
"      vm_end = 0x5613d3f0b000,",
"    ffff9035131757b8",
"      index: 3  position: root/0/4",
"      vm_start = 0x5613d3f0b000,",
"      vm_end = 0x5613d3f14000,",
"    ....",
NULL
};

char *help_ptob[] = {
"ptob",
"page to bytes",
"page_number ...",
"  This command translates a page frame number to its byte value.",
"\nEXAMPLES",
"    %s> ptob 512a",
"    512a: 512a000",
NULL               
};

char *help_gdb[] = {
"gdb",
"gdb command",
"command ...",
"  This command passes its arguments directly to gdb for processing.",
"  This is typically not necessary, but where ambiguities between %s and",
"  gdb command names exist, this will force the command to be executed by gdb.",
"",
"  Alternatively, if \"set gdb on\" is entered, the session will be run in a",
"  mode where all commands are passed directly to gdb.  When running in that",
"  mode, native %s commands may be executed by preceding them with the", 
"  \"crash\" directive.  To restore native %s mode, enter \"set gdb off\".",
"\nEXAMPLES",
"    %s> gdb help",
"    List of classes of commands:",
"    ",
"    aliases -- Aliases of other commands",
"    breakpoints -- Making program stop at certain points",
"    data -- Examining data",
"    files -- Specifying and examining files",
"    internals -- Maintenance commands",
"    obscure -- Obscure features",
"    running -- Running the program",
"    stack -- Examining the stack",
"    status -- Status inquiries",
"    support -- Support facilities",
"    tracepoints -- Tracing of program execution without stopping the program",
"    user-defined -- User-defined commands",
"    ",
"    Type \"help\" followed by a class name for a list of commands in that class.",
"    Type \"help\" followed by command name for full documentation.",
"    Command name abbreviations are allowed if unambiguous.",
NULL               
};


char *help_kmem[] = {
"kmem",
"kernel memory",
"[-f|-F|-c|-C|-i[=shared]|-v|-V|-n|-z|-o|-h] [-p | -m member[,member]]\n"
"       [[-s|-S|-S=cpu[s]|-r] [slab] [-I slab[,slab]]] [-g [flags]] [[-P] address]]",
"  This command displays information about the use of kernel memory.\n",
"        -f  displays the contents of the system free memory headers.",
"            also verifies that the page count equals nr_free_pages.",
"        -F  same as -f, but also dumps all pages linked to that header.",
"        -c  walks through the page_hash_table and verifies page_cache_size.",
"        -C  same as -c, but also dumps all pages in the page_hash_table.",
"        -i  displays general memory usage information.",
"            Note: SHARED is no longer printed (too slow on large memory systems)",
"            unless specifying \"-i=shared\".",
"        -v  displays the mapped virtual memory regions allocated by vmalloc().",
"        -V  displays the kernel vm_stat table if it exists, or in more recent",
"            kernels, the vm_zone_stat, vm_node_stat and vm_numa_stat tables,",
"            the cumulative page_states counter values if they exist, and/or ",
"            the cumulative, vm_event_states counter values if they exist.",
"        -n  display memory node, memory section, memory block data and state;",
"            the state of each memory section is shown as the following flags:",
"              \"P\": SECTION_MARKED_PRESENT",
"              \"M\": SECTION_HAS_MEM_MAP",
"              \"O\": SECTION_IS_ONLINE",
"              \"E\": SECTION_IS_EARLY",
"              \"D\": SECTION_TAINT_ZONE_DEVICE",
"        -z  displays per-zone memory statistics.",
"        -o  displays each cpu's offset value that is added to per-cpu symbol",
"            values to translate them into kernel virtual addresses.",
"        -h  display the address of hugepage hstate array entries, along with",
"            their hugepage size, total and free counts, and name.",
"        -p  displays basic information about each page structure in the system",
"            mem_map[] array, made up of the page struct address, its associated",
"            physical address, the page.mapping, page.index, page._count and",
"            page.flags fields.",
" -m member  similar to -p, but displays page structure contents specified by",
"            a comma-separated list of one or more struct page members.  The",
"            \"flags\" member will always be expressed in hexadecimal format, and",
"            the \"_count\" and \"_mapcount\" members will always be expressed",
"            in decimal format.  Otherwise, all other members will be displayed",
"            in hexadecimal format unless the output radix is 10 and the member",
"            is a signed/unsigned integer.  Members that are data structures may",
"            be specified either by the data structure's member name, or expanded",
"            to specify a member of the data structure.  For example, \"-m lru\"",
"            refers to a list_head data structure, and both the list_head.next",
"            and list_head.prev pointer values will be displayed, whereas if", 
"            \"-m lru.next\" is specified, just the list_head.next value will",
"            be displayed.",
"        -s  displays basic kmalloc() slab data.",
"        -S  displays all kmalloc() slab data, including all slab objects,",
"            and whether each object is in use or is free.  If CONFIG_SLUB,",
"            slab data for each per-cpu slab is displayed, along with the",
"            address of each kmem_cache_node, its count of full and partial",
"            slabs, and a list of all tracked slabs.",
"            Note: one can specify the per-cpu slab data to be displayed;",
"            the cpu[s] can be given as \"1,3,5\", \"1-3\", \"1,3,5-7,10\",",
"            \"all\", or \"a\" (shortcut for \"all\").",
"        -r  displays the accumulated basic kmalloc() slab data of each",
"            root slab cache and its children.  The kernel must contain the",
"            \"slab_root_caches\" list_head. (currently only available if",
"            CONFIG_SLUB)",
"      slab  when used with -s, -S or -r, limits the command to only the slab",
"            cache of name \"slab\".  If the slab argument is \"list\", then",
"            all slab cache names and addresses are listed.",
"   -I slab  when used with -s, -S or -r, one or more slab cache names in a",
"            comma-separated list may be specified as slab caches to ignore.",
"        -g  displays the enumerator value of all bits in the page structure's",
"            \"flags\" field.",
"     flags  when used with -g, translates all bits in this hexadecimal page",
"            structure flags value into its enumerator values.",
"        -P  declares that the following address argument is a physical address.",
"   address  when used without any flag, the address can be a kernel virtual,",
"            or physical address; a search is made through the symbol table,",
"            the kmalloc() slab subsystem, the free list, the page_hash_table,",
"            the vmalloc() region subsystem, the current set of task_structs",
"            and kernel stacks, and the mem_map array.  If found in any of",
"            those areas, the information will be dumped in the same manner as",
"            if the location-specific flags were used; if contained within a",
"            current task_struct or kernel stack, that task's context will be",
"            displayed.",
"   address  when used with -s or -S, searches the kmalloc() slab subsystem",
"            for the slab containing of this virtual address, showing whether",
"            it is in use or free.",
"   address  when used with -f, the address can be either a page pointer,",
"            a physical address, or a kernel virtual address; the free_area",
"            header containing the page (if any) is displayed.",
"   address  when used with -p, the address can be either a page pointer, a",
"            physical address, or a kernel virtual address; its basic mem_map",
"            page information is displayed.",
"   address  when used with -m, the address can be either a page pointer, a",
"            physical address, or a kernel virtual address; the specified",
"            members of the associated page struct are displayed.",
"   address  when used with -c, the address must be a page pointer address;",
"            the page_hash_table entry containing the page is displayed.",
"   address  when used with -v, the address can be a mapped kernel virtual",
"            address or physical address; the mapped region containing the",
"            address is displayed.\n",
"  All address arguments above must be expressed in hexadecimal format.",
"\nEXAMPLES",
"  Display memory usage information:\n",
"    %s> kmem -i",
"                     PAGES        TOTAL      PERCENTAGE",
"        TOTAL MEM  1974231       7.5 GB         ----",
"             FREE   208962     816.3 MB   10% of TOTAL MEM",
"             USED  1765269       6.7 GB   89% of TOTAL MEM",
"           SHARED   365066       1.4 GB   18% of TOTAL MEM",
"          BUFFERS   111376     435.1 MB    5% of TOTAL MEM",
"           CACHED  1276196       4.9 GB   64% of TOTAL MEM",
"             SLAB   120410     470.4 MB    6% of TOTAL MEM",
"    ",
"       TOTAL HUGE   524288         2 GB         ----",
"        HUGE FREE   524288         2 GB  100% of TOTAL HUGE",
"    ",
"       TOTAL SWAP  2498559       9.5 GB         ----",
"        SWAP USED    81978     320.2 MB    3% of TOTAL SWAP",
"        SWAP FREE  2416581       9.2 GB   96% of TOTAL SWAP",
"    ",
"     COMMIT LIMIT  3485674      13.3 GB         ----",
"        COMMITTED   850651       3.2 GB   24% of TOTAL LIMIT",
"    ",
"  Display and verify free memory data:\n",
"    %s> kmem -f",
"    NODE",
"      0",
"    ZONE  NAME        SIZE    FREE  MEM_MAP   START_PADDR  START_MAPNR",
"      0   DMA         4096    3372  c4000040       0            0     ",
"    AREA  SIZE  FREE_AREA_STRUCT  BLOCKS  PAGES",
"      0     4k      c02eb004           2      2",
"      1     8k      c02eb010           3      6",
"      2    16k      c02eb01c           5     20",
"      3    32k      c02eb028           4     32",
"      4    64k      c02eb034           5     80",
"      5   128k      c02eb040           3     96",
"      6   256k      c02eb04c           3    192",
"      7   512k      c02eb058           1    128",
"      8  1024k      c02eb064           1    256",
"      9  2048k      c02eb070           5   2560",
" ",
"    ZONE  NAME        SIZE    FREE  MEM_MAP   START_PADDR  START_MAPNR",
"      1   Normal    225280  202269  c4044040    1000000        4096   ",
"    AREA  SIZE  FREE_AREA_STRUCT  BLOCKS  PAGES",
"      0     4k      c02eb0b8           1      1",
"      1     8k      c02eb0c4           2      4",
"      2    16k      c02eb0d0           0      0",
"      3    32k      c02eb0dc           1      8",
"      4    64k      c02eb0e8           1     16",
"      5   128k      c02eb0f4           0      0",
"      6   256k      c02eb100           0      0",
"      7   512k      c02eb10c           0      0",
"      8  1024k      c02eb118           0      0",
"      9  2048k      c02eb124         395 202240",
" ",
"    ZONE  NAME        SIZE    FREE  MEM_MAP   START_PADDR  START_MAPNR",
"      2   HighMem   819200  748686  c4ee0040    38000000      229376  ",
"    AREA  SIZE  FREE_AREA_STRUCT  BLOCKS  PAGES",
"      0     4k      c02eb16c          10     10",
"      1     8k      c02eb178           2      4",
"      2    16k      c02eb184           0      0",
"      3    32k      c02eb190           2     16",
"      4    64k      c02eb19c           1     16",
"      5   128k      c02eb1a8           1     32",
"      6   256k      c02eb1b4           1     64",
"      7   512k      c02eb1c0           0      0",
"      8  1024k      c02eb1cc           0      0",
"      9  2048k      c02eb1d8        1462 748544",
"    ",
"    nr_free_pages: 954327  (verified)",
" ",
"  Dump all the base addresses of each free memory area from above:\n",
"    %s> kmem -F",
"    NODE",
"      0",
"    ZONE  NAME        SIZE    FREE  MEM_MAP   START_PADDR  START_MAPNR",
"      0   DMA         4096    3372  c4000040       0            0     ",
"    AREA  SIZE  FREE_AREA_STRUCT",
"      0     4k      c02eb004      ",
"    c400ded8",
"    c4042528",
"    AREA  SIZE  FREE_AREA_STRUCT",
"      1     8k      c02eb010      ",
"    c400de50",
"    c400cee8",
"    c40424a0",
"    AREA  SIZE  FREE_AREA_STRUCT",
"      2    16k      c02eb01c      ",
"    c400dd40",
"    c400cf70",
"    c40425b0",
"    c400f7d0",
"    c40028a0",
"    AREA  SIZE  FREE_AREA_STRUCT",
"      3    32k      c02eb028      ",
"    c4042280",
"    c400f8e0",
"    c4002680",
"    c4000260",
"    AREA  SIZE  FREE_AREA_STRUCT",
"      4    64k      c02eb034      ",
"    c400d080",
"    c4041e40",
"    ...",
" ",
"  Dump the mem_map[] array:\n",
"    %s> kmem -p",
"      PAGE    PHYSICAL   MAPPING    INDEX CNT FLAGS",
"    f5c51200     10000         0         0  1 80 slab",
"    f5c51220     11000         0         0  1 80 slab",
"    f5c51240     12000         0         0  1 80 slab",
"    f5c51260     13000         0         0  1 80 slab",
"    f5c51280     14000         0         0  1 80 slab",
"    f5c512a0     15000         0         0  1 80 slab",
"    f5c512c0     16000         0         0  1 80 slab",
"    f5c512e0     17000         0         0  1 80 slab",
"    f5c51300     18000         0         0  1 80 slab",
"    f5c51320     19000         0         0  1 80 slab",
"    f5c51340     1a000         0         0  1 80 slab",
"    f5c51360     1b000         0         0  1 80 slab",
"    f5c51380     1c000  e6c6a754     13b67  2 868 uptodate,lru,active,private",
"    f5c513a0     1d000         0         0  1 80 slab",
"    f5c513c0     1e000         0         0  1 80 slab",
"    f5c513e0     1f000         0         0  1 80 slab",
"    f5c51400     20000  e6c6a754     13bbb  2 868 uptodate,lru,active,private",
"    f5c51420     21000         0         0  1 80 slab",
"    f5c51440     22000         0         0  1 80 slab",
"    ...",
"    ",
"  Display the \"page.lru\" list_head structure member in each page:\n",
"    %s> kmem -m lru",
"         PAGE         lru  ",
"    ffffea0000000000  0000000000000000,0000000000000000  ",
"    ffffea0000000040  ffffea0000000060,ffffea0000000060  ",
"    ffffea0000000080  ffffea00000000a0,ffffea00000000a0  ",
"    ffffea00000000c0  ffffea00000000e0,ffffea00000000e0  ",
"    ffffea0000000100  ffffea0000000120,ffffea0000000120  ",
"    ffffea0000000140  ffffea0000000160,ffffea0000000160  ",
"    ffffea0000000180  ffffea00000001a0,ffffea00000001a0  ",
"    ffffea00000001c0  ffffea00000001e0,ffffea00000001e0  ",
"    ffffea0000000200  ffffea0000000220,ffffea0000000220  ",
"    ffffea0000000240  ffffea0000000260,ffffea0000000260  ",
"    ffffea0000000280  ffffea00000002a0,ffffea00000002a0  ",
"    ffffea00000002c0  ffffea00000002e0,ffffea00000002e0  ",
"    ffffea0000000300  ffffea0000000320,ffffea0000000320  ",
"    ffffea0000000340  ffffea0000000360,ffffea0000000360  ",
"    ffffea0000000380  ffffea00000003a0,ffffea00000003a0  ",
"    ffffea00000003c0  ffffea00000003e0,ffffea00000003e0  ",
"    ffffea0000000400  ffff88021e5e41e8,ffffea0000002020  ",
"    ffffea0000000440  dead000000100100,dead000000200200  ",
"    ffffea0000000480  dead000000100100,dead000000200200  ",
"    ffffea00000004c0  dead000000100100,dead000000200200 ",
"    ...",
"    ",
"  Find the two pages that link to the page at ffffea0001dafb20 ",
"  via their page.lru list_head's next and prev pointers:\n",
"    %s> kmem -m lru | grep ffffea0001dafb20",
"    ffffea000006b500  ffffea0001dafb20,ffffea0001eb4520  ",
"    ffffea0000127d80  ffffea000152b620,ffffea0001dafb20  ",
"    ",
"  Find all of the combined slab/page structures that are used by",
"  the kmalloc-8192 slab cache:\n",
"    %s> kmem -s kmalloc-8192",
"    CACHE             OBJSIZE  ALLOCATED     TOTAL  SLABS  SSIZE  NAME",
"    ffff880215802e00     8192         65        80     20    32k  kmalloc-8192",
"    %s> kmem -m slab_cache | grep ffff880215802e00",
"    ffffea0004117800  ffff880215802e00  ",
"    ffffea00041ca600  ffff880215802e00  ",
"    ffffea00044ab200  ffff880215802e00  ",
"    ffffea0004524000  ffff880215802e00  ",
"    ffffea0004591600  ffff880215802e00  ",
"    ffffea00047eac00  ffff880215802e00  ",
"    ffffea0004875800  ffff880215802e00  ",
"    ffffea0008357a00  ffff880215802e00  ",
"    ffffea0008362a00  ffff880215802e00  ",
"    ffffea00083b9400  ffff880215802e00  ",
"    ffffea00083c1000  ffff880215802e00  ",
"    ffffea00083c1e00  ffff880215802e00  ",
"    ffffea00083c2000  ffff880215802e00  ",
"    ffffea00083c2a00  ffff880215802e00  ",
"    ffffea00083d2000  ffff880215802e00  ",
"    ffffea00083d3e00  ffff880215802e00  ",
"    ffffea0008407c00  ffff880215802e00  ",
"    ffffea000848ce00  ffff880215802e00  ",
"    ffffea0008491800  ffff880215802e00  ",
"    ffffea00084bf800  ffff880215802e00  ",
"    ",
"  Use the commands above with a page pointer or a physical address argument:\n",
"    %s> kmem -f c40425b0",
"    NODE ",
"      0 ",
"    ZONE  NAME        SIZE    FREE  MEM_MAP   START_PADDR  START_MAPNR",
"      0   DMA         4096    3372  c4000040       0            0     ",
"    AREA  SIZE  FREE_AREA_STRUCT ",
"      2    16k      c02eb01c      ",
"    c40425b0  (c40425b0 is 1st of 4 pages) ",
" ",
"    %s> kmem -p c25a9c00",
"      PAGE     PHYSICAL   MAPPING    INDEX CNT FLAGS",
"    c25a9c00    1fe0000  f429d2e4   21fe3eb  2 800828 uptodate,lru,private",
" ",
"    %s> kmem -p 1fe0000",
"      PAGE     PHYSICAL   MAPPING    INDEX CNT FLAGS",
"    c25a9c00    1fe0000  f429d2e4   21fe3eb  2 800828 uptodate,lru,private",
" ",
"  Display the mapped memory regions allocated by vmalloc():\n",
"    %s> kmem -v",
"    VMAP_AREA  VM_STRUCT     ADDRESS RANGE        SIZE",
"    f7048e00   f7048e40   f7dfe000 - f7e00000     8192",
"    f7048ec0   f7048f00   f7e00000 - f7e05000    20480",
"    f7151fc0   f7159540   f7e06000 - f7e08000     8192",
"    f704da80   f704dac0   f7e0a000 - f7e0c000     8192",
"    f704d980   f704d9c0   f7e0e000 - f7e10000     8192",
"    f724f1c0   f724f200   f7e12000 - f7e14000     8192",
"    f704d840   f704d880   f7e14000 - f7e17000    12288",
"    f704d400   f704d440   f7e18000 - f7e1d000    20480",
"    f73f5840   f73f5880   f7e1e000 - f7e2a000    49152",
"    f6334480   f63344c0   f7e2c000 - f7e2e000     8192",
"    f635d600   f635d640   f7e4a000 - f7e5b000    69632",
"    f41b4700   f5771a40   f7e6e000 - f7e70000     8192",
"    f622f6c0   f622f700   f7e71000 - f7e79000    32768",
"    f63a9f00   f63a9f40   f7e84000 - f7e87000    12288",
"    f63a9d00   f63a9d40   f7e8f000 - f7e91000     8192",
"    f5546480   f39db800   f7eb8000 - f7ec2000    40960",
"    f5ce9640   f5777e80   f7ec6000 - f7ed1000    45056",
"    f63a9b00   f63a9b40   f7ed1000 - f7efd000   180224",
"    f63a9800   f63a9840   f7f1d000 - f7f26000    36864",
"    f63a9640   f63a9880   f7f43000 - f7f52000    61440",
"    f5771f00   f4183840   f7f53000 - f7f64000    69632",
"    f5ce9a00   f30c4a00   f7fcf000 - f801e000   323584",
"    f63a93c0   f63a9400   f805d000 - f8132000   872448",
"    f63a91c0   f63a95c0   f814b000 - f8150000    20480",
"    f63a9140   f63a9180   f8151000 - f8352000  2101248",
"    f624eb00   f624eb40   f8353000 - f8355000     8192",
"    f563eb40   f563eb80   f8356000 - f835e000    32768",
"    f63d5ec0   f63d5f00   f8360000 - f8371000    69632",
"    f63d5cc0   f6287b80   f83c2000 - f84c3000  1052672",
"    ...",
" ",
"  Dump the virtual memory statistics:\n",
"    %s> kmem -V",
"      VM_ZONE_STAT:",
"             NR_FREE_PAGES: 30085",
"     NR_ZONE_INACTIVE_ANON: 1985",
"       NR_ZONE_ACTIVE_ANON: 338275",
"     NR_ZONE_INACTIVE_FILE: 19760",
"       NR_ZONE_ACTIVE_FILE: 12018",
"       NR_ZONE_UNEVICTABLE: 0",
"     NR_ZONE_WRITE_PENDING: 4",
"                  NR_MLOCK: 0",
"              NR_PAGETABLE: 1562",
"        NR_KERNEL_STACK_KB: 1728",
"                 NR_BOUNCE: 0",
"         NR_FREE_CMA_PAGES: 0",
"    ",
"      VM_NODE_STAT:",
"          NR_INACTIVE_ANON: 1985",
"            NR_ACTIVE_ANON: 338275",
"          NR_INACTIVE_FILE: 19760",
"            NR_ACTIVE_FILE: 12018",
"            NR_UNEVICTABLE: 0",
"       NR_SLAB_RECLAIMABLE: 3111",
"     NR_SLAB_UNRECLAIMABLE: 3039",
"          NR_ISOLATED_ANON: 0",
"          NR_ISOLATED_FILE: 0",
"        WORKINGSET_REFAULT: 0",
"       WORKINGSET_ACTIVATE: 0",
"    WORKINGSET_NODERECLAIM: 0",
"            NR_ANON_MAPPED: 338089",
"            NR_FILE_MAPPED: 8102",
"             NR_FILE_PAGES: 33949",
"             NR_FILE_DIRTY: 4",
"              NR_WRITEBACK: 0",
"         NR_WRITEBACK_TEMP: 0",
"                  NR_SHMEM: 2171",
"             NR_SHMEM_THPS: 0",
"        NR_SHMEM_PMDMAPPED: 0",
"              NR_ANON_THPS: 86",
"           NR_UNSTABLE_NFS: 0",
"           NR_VMSCAN_WRITE: 0",
"       NR_VMSCAN_IMMEDIATE: 0",
"                NR_DIRTIED: 155",
"                NR_WRITTEN: 75",
"    ",
"      VM_NUMA_STAT:",
"                  NUMA_HIT: 575409",
"                 NUMA_MISS: 0",
"              NUMA_FOREIGN: 0",
"       NUMA_INTERLEAVE_HIT: 12930",
"                NUMA_LOCAL: 575409",
"                NUMA_OTHER: 0",
"    ",
"      VM_EVENT_STATES:",
"                           PGPGIN: 282492",
"                          PGPGOUT: 6773",
"                           PSWPIN: 0",
"                          PSWPOUT: 0",
"                      PGALLOC_DMA: 0",
"                    PGALLOC_DMA32: 693092",
"                   PGALLOC_NORMAL: 0",
"    ...",
"    ",
"  Display hugepage hstate information: \n",
"    %s> kmem -h",
"         HSTATE        SIZE    FREE   TOTAL  NAME",
"    ffffffff81f7a800    2MB      10      64  hugepages-2048kB",
"",
"  Determine (and verify) the page cache size:\n",
"    %s> kmem -c",
"    page_cache_size: 18431 (verified)",
" ",
"  Dump all pages in the page_hash_table:\n",
"    %s> kmem -C",
"    page_hash_table[0]",
"    c0325b40",
"    c03a0598",
"    c03b4070",
"    c0364c28",
"    c0357690",
"    c02ef338",
"    c02d7c60",
"    c02c11e0",
"    c02a3d70",
"    page_hash_table[1]",
"    c0394ce8",
"    c03c4218",
"    c03b4048",
"    c0364c00",
"    c0357668",
"    c02d6e50",
"    c02d7dc8",
"    c02c0cb8",
"    c02db630",
"    c02ebad0",
"    page_hash_table[2]",
"    c037e808",
"    c034e248",
"    c03b4020",
"    c02ec868",
"    c03baa60",
"    ...",
"    page_hash_table[2047]",
"    c033a798",
"    c0390b48",
"    c03b4098",
"    c0364890",
"    c03576b8",
"    c02d2c38",
"    c02d7c88",
"    c02de5d8",
"    ",
"    page_cache_size: 18437 (verified)",
"    ",
"  Find the page_hash_table entry containing page c03576b8:\n",
"    %s> kmem -c c03576b8",
"    page_hash_table[2047]",
"    c03576b8",
" ",
"  Display kmalloc() slab data:\n",
"    %s> kmem -s",
"    CACHE     OBJSIZE  ALLOCATED     TOTAL  SLABS  SSIZE  NAME",
"    c02eadc0      232         58        68      4     4k  kmem_cache",
"    f79c2888      128          0         0      0     4k  ip_vs_conn",
"    f79c2970       96          0         0      0     4k  tcp_tw_bucket",
"    f79c2a58       32         12       565      5     4k  tcp_bind_bucket",
"    f79c2b40       64          0        59      1     4k  tcp_open_request",
"    f79c2c28       64          1        59      1     4k  inet_peer_cache",
"    f79c2d10       32         11       339      3     4k  ip_fib_hash",
"    f79c2df8      160          8       120      5     4k  ip_dst_cache",
"    f79c2ee0      128          1        30      1     4k  arp_cache",
"    c8402970       96      30208     37800    945     4k  blkdev_requests",
"    c8402a58      384          0         0      0     4k  nfs_read_data",
"    c8402b40      384          0         0      0     4k  nfs_write_data",
"    c8402c28       96          0         0      0     4k  nfs_page",
"    c8402d10       20          0         0      0     4k  dnotify cache",
"    c8402df8       92          3       336      8     4k  file lock cache",
"    c8402ee0       16          0         0      0     4k  fasync cache",
"    c84027a0       32          3       339      3     4k  uid_cache",
"    c84026b8      160        320       624     26     4k  skbuff_head_cache",
"    c84025d0      832         32       180     20     8k  sock",
"    c84024e8      132          0       203      7     4k  sigqueue",
"    c8402400       64         19       472      8     4k  cdev_cache",
"    c8402318       64          8       236      4     4k  bdev_cache",
"    c8402230       96         11       120      3     4k  mnt_cache",
"    c8402148      480        817       848    106     4k  inode_cache",
"    c8402060      128       1352      1470     49     4k  dentry_cache",
"    c8403ee0       96        244       440     11     4k  filp",
"    c8403df8     4096          0        12     12     4k  names_cache",
"    c8403d10       96      14936     16000    400     4k  buffer_head",
"    c8403c28      128         25       240      8     4k  mm_struct",
"    c8403b40       64        393      1298     22     4k  vm_area_struct",
"    c8403a58       64         30       472      8     4k  fs_cache",
"    c8403970      416         30       135     15     4k  files_cache",
"    c8403888     1312         32        99     33     4k  signal_act",
"    c84037a0   131072          0         0      0   128k  size-131072(DMA)",
"    c84036b8   131072          1         1      1   128k  size-131072",
"    c84035d0    65536          0         0      0    64k  size-65536(DMA)",
"    c84034e8    65536          0         0      0    64k  size-65536",
"    c8403400    32768          0         0      0    32k  size-32768(DMA)",
"    c8403318    32768          0         1      1    32k  size-32768",
"    c8403230    16384          0         0      0    16k  size-16384(DMA)",
"    c8403148    16384          0         0      0    16k  size-16384",
"    c8403060     8192          0         0      0     8k  size-8192(DMA)",
"    c8401ee0     8192          1         2      2     8k  size-8192",
"    c8401df8     4096          0         0      0     4k  size-4096(DMA)",
"    c8401d10     4096         30        30     30     4k  size-4096",
"    c8401c28     2048          0         0      0     4k  size-2048(DMA)",
"    c8401b40     2048         37       132     66     4k  size-2048",
"    c8401a58     1024          0         0      0     4k  size-1024(DMA)",
"    c8401970     1024        301       328     82     4k  size-1024",
"    c8401888      512          0         0      0     4k  size-512(DMA)",
"    c84017a0      512        141       168     21     4k  size-512",
"    c84016b8      256          0         0      0     4k  size-256(DMA)",
"    c84015d0      256         80       435     29     4k  size-256",
"    c84014e8      128          0         0      0     4k  size-128(DMA)",
"    c8401400      128        508       840     28     4k  size-128",
"    c8401318       64          0         0      0     4k  size-64(DMA)",
"    c8401230       64        978      1357     23     4k  size-64",
"    c8401148       32          0         0      0     4k  size-32(DMA)",
"    c8401060       32       1244      1808     16     4k  size-32",

" ",
"  Display all slab data in the \"arp_cache\" cache:\n",
"    %s> kmem -S arp_cache",
"    CACHE     OBJSIZE  ALLOCATED     TOTAL  SLABS  SSIZE  NAME",
"    f79c2ee0      128          1        30      1     4k  arp_cache",
"    SLAB      MEMORY    TOTAL  ALLOCATED  FREE",
"    f729d000  f729d0a0     30          1    29",
"    FREE / [ALLOCATED]",
"       f729d0a0  (cpu 7 cache)",
"       f729d120  (cpu 7 cache)",
"       f729d1a0  (cpu 7 cache)",
"       f729d220  (cpu 7 cache)",
"       f729d2a0  (cpu 7 cache)",
"       f729d320  (cpu 7 cache)",
"       f729d3a0  (cpu 7 cache)",
"       f729d420  (cpu 7 cache)",
"       f729d4a0  (cpu 7 cache)",
"       f729d520  (cpu 7 cache)",
"       f729d5a0  (cpu 7 cache)",
"       f729d620  (cpu 7 cache)",
"       f729d6a0  (cpu 7 cache)",
"       f729d720  (cpu 7 cache)",
"       f729d7a0  (cpu 7 cache)",
"       f729d820  (cpu 7 cache)",
"       f729d8a0  (cpu 7 cache)",
"       f729d920  (cpu 7 cache)",
"       f729d9a0  (cpu 7 cache)",
"       f729da20  (cpu 7 cache)",
"       f729daa0  (cpu 7 cache)",
"       f729db20  (cpu 7 cache)",
"       f729dba0  (cpu 7 cache)",
"       f729dc20  (cpu 7 cache)",
"       f729dca0  (cpu 7 cache)",
"       f729dd20  (cpu 7 cache)",
"       f729dda0  (cpu 7 cache)",
"       f729de20  (cpu 7 cache)",
"       f729dea0  (cpu 3 cache)",
"      [f729df20]",
" ",
"  Search the kmalloc() slab subsystem for address c3fbdb60:\n",
"    %s> kmem -s c3fbdb60",
"    CACHE     OBJSIZE  ALLOCATED     TOTAL  SLABS  SSIZE  NAME",
"    c8402970       96      30208     37800    945     4k  blkdev_requests",
"    SLAB      MEMORY    TOTAL  ALLOCATED  FREE",
"    c3fbd020  c3fbd0e0     40         40     0",
"    FREE / [ALLOCATED]",
"      [c3fbdb60]",
" ",
"  Make a generic search (no flags) for the same address c3fbdb60:\n",
"    %s> kmem c3fbdb60 ",
"    CACHE     OBJSIZE  ALLOCATED     TOTAL  SLABS  SSIZE  NAME",
"    c8402970       96      30208     37800    945     4k  blkdev_requests",
"    SLAB      MEMORY    TOTAL  ALLOCATED  FREE",
"    c3fbd020  c3fbd0e0     40         40     0 ",
"    FREE / [ALLOCATED]",
"      [c3fbdb60]",
" ",
"      PAGE     PHYSICAL   MAPPING    INDEX CNT FLAGS",
"    c410ee74    3fbd000         0         0  1 slab",
"\n  Display memory node data (if supported):\n",
"    %s> kmem -n",
"    NODE    SIZE      PGLIST_DATA       BOOTMEM_DATA       NODE_ZONES   ",
"      0    262095   ffff88003d52a000        ----        ffff88003d52a000",
"                                                        ffff88003d52a740",
"                                                        ffff88003d52ae80",
"                                                        ffff88003d52b5c0",
"        MEM_MAP          START_PADDR    START_MAPNR",
"    ffffea0000000040        1000             1     ",
"    ",
"    ZONE  NAME         SIZE       MEM_MAP      START_PADDR  START_MAPNR",
"      0   DMA          4095  ffffea0000000040         1000            1",
"      1   DMA32      258000  ffffea0000040000      1000000         4096",
"      2   Normal          0                 0            0            0",
"      3   Movable         0                 0            0            0",
"    ",
"    -------------------------------------------------------------------",
"    ",
"    NR      SECTION        CODED_MEM_MAP        MEM_MAP       STATE PFN",
"     0  ffff88003d4d9000  ffffea0000000000  ffffea0000000000   PM   0",
"     1  ffff88003d4d9020  ffffea0000000000  ffffea0000200000   PM   32768",
"     2  ffff88003d4d9040  ffffea0000000000  ffffea0000400000   PM   65536",
"     3  ffff88003d4d9060  ffffea0000000000  ffffea0000600000   PM   98304",
"     4  ffff88003d4d9080  ffffea0000000000  ffffea0000800000   PM   131072",
"     5  ffff88003d4d90a0  ffffea0000000000  ffffea0000a00000   PM   163840",
"     6  ffff88003d4d90c0  ffffea0000000000  ffffea0000c00000   PM   196608",
"     7  ffff88003d4d90e0  ffffea0000000000  ffffea0000e00000   PM   229376",
"    ",
"       MEM_BLOCK        NAME     PHYSICAL RANGE      STATE   START_SECTION_NO",
"     ffff88003a707c00  memory0          0 -  7ffffff ONLINE  0",
"     ffff88003a6e0000  memory1    8000000 -  fffffff ONLINE  1",
"     ffff88003a6e1000  memory2   10000000 - 17ffffff ONLINE  2",
"     ffff88003a6e1400  memory3   18000000 - 1fffffff ONLINE  3",
"     ffff88003a6e1800  memory4   20000000 - 27ffffff ONLINE  4",
"     ffff88003a6e0400  memory5   28000000 - 2fffffff ONLINE  5",
"     ffff88003a6e0800  memory6   30000000 - 37ffffff ONLINE  6",
"     ffff88003a6e0c00  memory7   38000000 - 3fffffff ONLINE  7",

"\n  Translate a page structure's flags field contents:\n",
"    %s> kmem -g 4080",
"    FLAGS: 4080",
"      PAGE-FLAG        BIT  VALUE",
"      PG_slab            7  0000080",
"      PG_head           14  0004000",
"    %s>",
NULL               
};

char *help_dis[] = {
"dis",
"disassemble",
"[-rfludxs][-b [num]] [address | symbol | (expression)] [count]",
"  This command disassembles source code instructions starting (or ending) at",
"  a text address that may be expressed by value, symbol or expression:\n",
"            -r  (reverse) displays all instructions from the start of the ",
"                routine up to and including the designated address.",
"            -f  (forward) displays all instructions from the given address ",
"                to the end of the routine.",
"            -l  displays source code line number data in addition to the ",
"                disassembly output.", 
"            -u  address is a user virtual address in the current context;",
"                otherwise the address is assumed to be a kernel virtual address.",
"                If this option is used, then -r and -l are ignored.",
"            -x  override default output format with hexadecimal format.",
"            -d  override default output format with decimal format.",
"            -s  displays the filename and line number of the source code that",
"                is associated with the specified text location, followed by a",
"                source code listing if it is available on the host machine.",
"                The line associated with the text location will be marked with",
"                an asterisk; depending upon gdb's internal \"listsize\" variable,",
"                several lines will precede the marked location. If a \"count\"",
"                argument is entered, it specifies the number of source code",
"                lines to be displayed after the marked location; otherwise",
"                the remaining source code of the containing function will be",
"                displayed.",
"      -b [num]  modify the pre-calculated number of encoded bytes to skip after",
"                a kernel BUG (\"ud2a\") instruction; with no argument, displays",  
"                the current number of bytes being skipped. (x86 and x86_64 only)",
"       address  starting hexadecimal text address.",
"        symbol  symbol of starting text address.  On ppc64, the symbol",
"                preceded by '.' is used.",
"  (expression)  expression evaluating to a starting text address.",
"         count  the number of instructions to be disassembled (default is 1).",
"                If no count argument is entered, and the starting address",
"                is entered as a text symbol, then the whole routine will be",
"                disassembled.  The count argument is supported when used with",
"                the -r and -f options.",
"\nEXAMPLES",
"  Disassemble the sys_signal() routine without, and then with, line numbers:\n",
"    %s> dis sys_signal",
"    0xc0112c88 <sys_signal>:        push   \%ebp",
"    0xc0112c89 <sys_signal+1>:      mov    \%esp,\%ebp",
"    0xc0112c8b <sys_signal+3>:      sub    $0x28,\%esp",
"    0xc0112c8e <sys_signal+6>:      mov    0xc(\%ebp),\%eax",
"    0xc0112c91 <sys_signal+9>:      mov    \%eax,0xffffffec(\%ebp)",
"    0xc0112c94 <sys_signal+12>:     movl   $0xc0000000,0xfffffff0(\%ebp)",
"    0xc0112c9b <sys_signal+19>:     lea    0xffffffd8(\%ebp),\%eax",
"    0xc0112c9e <sys_signal+22>:     push   \%eax",
"    0xc0112c9f <sys_signal+23>:     lea    0xffffffec(\%ebp),\%eax",
"    0xc0112ca2 <sys_signal+26>:     push   \%eax",
"    0xc0112ca3 <sys_signal+27>:     pushl  0x8(\%ebp)",
"    0xc0112ca6 <sys_signal+30>:     call   0xc01124b8 <do_sigaction>",
"    0xc0112cab <sys_signal+35>:     test   \%eax,\%eax",
"    0xc0112cad <sys_signal+37>:     jne    0xc0112cb2 <sys_signal+42>",
"    0xc0112caf <sys_signal+39>:     mov    0xffffffd8(\%ebp),\%eax",
"    0xc0112cb2 <sys_signal+42>:     leave",
"    0xc0112cb3 <sys_signal+43>:     ret",
" ",
"    %s> dis -l sys_signal",
"    /usr/src/linux-2.2.5/kernel/signal.c: 1074",
"    0xc0112c88 <sys_signal>:        push   \%ebp",
"    0xc0112c89 <sys_signal+1>:      mov    \%esp,\%ebp",
"    0xc0112c8b <sys_signal+3>:      sub    $0x28,\%esp",
"    0xc0112c8e <sys_signal+6>:      mov    0xc(\%ebp),\%eax",
"    /usr/src/linux-2.2.5/kernel/signal.c: 1078",
"    0xc0112c91 <sys_signal+9>:      mov    \%eax,0xffffffec(\%ebp)",
"    /usr/src/linux-2.2.5/kernel/signal.c: 1079",
"    0xc0112c94 <sys_signal+12>:     movl   $0xc0000000,0xfffffff0(\%ebp)",
"    /usr/src/linux-2.2.5/kernel/signal.c: 1081",
"    0xc0112c9b <sys_signal+19>:     lea    0xffffffd8(\%ebp),\%eax",
"    0xc0112c9e <sys_signal+22>:     push   \%eax",
"    0xc0112c9f <sys_signal+23>:     lea    0xffffffec(\%ebp),\%eax",
"    0xc0112ca2 <sys_signal+26>:     push   \%eax",
"    0xc0112ca3 <sys_signal+27>:     pushl  0x8(\%ebp)",
"    0xc0112ca6 <sys_signal+30>:     call   0xc01124b8 <do_sigaction>",
"    /usr/src/linux-2.2.5/kernel/signal.c: 1083",
"    0xc0112cab <sys_signal+35>:     test   \%eax,\%eax",
"    0xc0112cad <sys_signal+37>:     jne    0xc0112cb2 <sys_signal+42>",
"    0xc0112caf <sys_signal+39>:     mov    0xffffffd8(\%ebp),\%eax",
"    /usr/src/linux-2.2.5/kernel/signal.c: 1084",
"    0xc0112cb2 <sys_signal+42>:     leave",
"    0xc0112cb3 <sys_signal+43>:     ret",
" ",
"  Given a return address expression of \"do_no_page+65\", find out the ",
"  function that do_no_page() calls by using the reverse flag:\n",
"    %s> dis -r (do_no_page+65)",
"    0xc011ea68 <do_no_page>:        push   \%ebp",
"    0xc011ea69 <do_no_page+1>:      mov    \%esp,\%ebp",
"    0xc011ea6b <do_no_page+3>:      push   \%edi",
"    0xc011ea6c <do_no_page+4>:      push   \%esi",
"    0xc011ea6d <do_no_page+5>:      push   \%ebx",
"    0xc011ea6e <do_no_page+6>:      mov    0xc(\%ebp),\%ebx",
"    0xc011ea71 <do_no_page+9>:      mov    0x10(\%ebp),\%edx",
"    0xc011ea74 <do_no_page+12>:     mov    0x14(\%ebp),\%edi",
"    0xc011ea77 <do_no_page+15>:     mov    0x28(\%ebx),\%eax",
"    0xc011ea7a <do_no_page+18>:     test   \%eax,\%eax",
"    0xc011ea7c <do_no_page+20>:     je     0xc011ea85 <do_no_page+29>",
"    0xc011ea7e <do_no_page+22>:     mov    0x18(\%eax),\%ecx",
"    0xc011ea81 <do_no_page+25>:     test   \%ecx,\%ecx",
"    0xc011ea83 <do_no_page+27>:     jne    0xc011eab0 <do_no_page+72>",
"    0xc011ea85 <do_no_page+29>:     mov    $0xffffe000,\%eax",
"    0xc011ea8a <do_no_page+34>:     and    \%esp,\%eax",
"    0xc011ea8c <do_no_page+36>:     decl   0x30(\%eax)",
"    0xc011ea8f <do_no_page+39>:     jns    0xc011ea9a <do_no_page+50>",
"    0xc011ea91 <do_no_page+41>:     lock btrl $0x0,0xc022fb60",
"    0xc011ea9a <do_no_page+50>:     push   \%edi",
"    0xc011ea9b <do_no_page+51>:     mov    0x18(\%ebp),\%esi",
"    0xc011ea9e <do_no_page+54>:     push   \%esi",
"    0xc011ea9f <do_no_page+55>:     push   \%ebx",
"    0xc011eaa0 <do_no_page+56>:     mov    0x8(\%ebp),\%esi",
"    0xc011eaa3 <do_no_page+59>:     push   \%esi",
"    0xc011eaa4 <do_no_page+60>:     call   0xc011e9e4 <do_anonymous_page>",
"    0xc011eaa9 <do_no_page+65>:     jmp    0xc011eb47 <do_no_page+223>",
"    ",
"  Disassemble 10 instructions starting at user virtual address 0x81ec624:\n",
"    %s> dis -u 81ec624 10",
"    0x81ec624:      push   \%ebp",
"    0x81ec625:      mov    \%esp,\%ebp",
"    0x81ec627:      sub    $0x18,\%esp",
"    0x81ec62a:      movl   $0x1,0x8(\%ebp)",
"    0x81ec631:      mov    0x82f9040,\%eax",
"    0x81ec636:      mov    0x10(\%eax),\%edx",
"    0x81ec639:      and    $0x100,\%edx",
"    0x81ec63f:      mov    0x14(\%eax),\%ecx",
"    0x81ec642:      and    $0x0,\%ecx",
"    0x81ec645:      mov    \%ecx,\%eax",
" ",
"  Override the current decimal output radix format:\n",
"    %s> dis sys_read 10 -x",
"    0xffffffff8001178f <sys_read>:  push   %r13",
"    0xffffffff80011791 <sys_read+0x2>:    mov    %rsi,%r13",
"    0xffffffff80011794 <sys_read+0x5>:    push   %r12",
"    0xffffffff80011796 <sys_read+0x7>:    mov    $0xfffffffffffffff7,%r12",
"    0xffffffff8001179d <sys_read+0xe>:    push   %rbp",
"    0xffffffff8001179e <sys_read+0xf>:    mov    %rdx,%rbp",
"    0xffffffff800117a1 <sys_read+0x12>:   push   %rbx",
"    0xffffffff800117a2 <sys_read+0x13>:   sub    $0x18,%rsp",
"    0xffffffff800117a6 <sys_read+0x17>:   lea    0x14(%rsp),%rsi",
"    0xffffffff800117ab <sys_read+0x1c>:   callq  0xffffffff8000b5b4 <fget_light>",
" ",
"  Disassemble from vfs_read+320 until the end of the function:\n",
"    %s> dis -f vfs_read+320",
"    0xffffffff8119d4e0 <vfs_read+320>:  cmpq   $0x0,0x20(%rax)",
"    0xffffffff8119d4e5 <vfs_read+325>:  jne    0xffffffff8119d3e8 <vfs_read+72>",
"    0xffffffff8119d4eb <vfs_read+331>:  mov    $0xffffffffffffffea,%r12",
"    0xffffffff8119d4f2 <vfs_read+338>:  jmp    0xffffffff8119d4c3 <vfs_read+291>",
"    0xffffffff8119d4f4 <vfs_read+340>:  nopl   0x0(%rax)",
"    0xffffffff8119d4f8 <vfs_read+344>:  callq  0xffffffff8119cc40 <do_sync_read>",
"    0xffffffff8119d4fd <vfs_read+349>:  mov    %rax,%r12",
"    0xffffffff8119d500 <vfs_read+352>:  jmpq   0xffffffff8119d44c <vfs_read+172>",
"    0xffffffff8119d505 <vfs_read+357>:  nopl   (%rax)",
"    0xffffffff8119d508 <vfs_read+360>:  mov    $0xfffffffffffffff7,%r12",
"    0xffffffff8119d50f <vfs_read+367>:  jmp    0xffffffff8119d4c3 <vfs_read+291>",
"    0xffffffff8119d511 <vfs_read+369>:  mov    $0xfffffffffffffff2,%r12",
"    0xffffffff8119d518 <vfs_read+376>:  jmp    0xffffffff8119d4c3 <vfs_read+291>",
"    0xffffffff8119d51a <vfs_read+378>:  nopw   0x0(%rax,%rax,1)",
" ",
"  Display the source code listing of the mmput() function:\n",
"    %s> dis -s mmput",
"    FILE: kernel/fork.c",
"    LINE: 617",
"    ",
"      612   ",
"      613   /*",
"      614    * Decrement the use count and release all resources for an mm.",
"      615    */",
"      616   void mmput(struct mm_struct *mm)",
"    * 617   {",
"      618           might_sleep();",
"      619   ",
"      620           if (atomic_dec_and_test(&mm->mm_users)) {",
"      621                   uprobe_clear_state(mm);",
"      622                   exit_aio(mm);",
"      623                   ksm_exit(mm);",
"      624                   khugepaged_exit(mm); /* must run before exit_mmap */",
"      625                   exit_mmap(mm);",
"      626                   set_mm_exe_file(mm, NULL);",
"      627                   if (!list_empty(&mm->mmlist)) {",
"      628                           spin_lock(&mmlist_lock);",
"      629                           list_del(&mm->mmlist);",
"      630                           spin_unlock(&mmlist_lock);",
"      631                   }",
"      632                   if (mm->binfmt)",
"      633                           module_put(mm->binfmt->module);",
"      634                   mmdrop(mm);",
"      635           }",
"      636   }",
" ",
"  The disassembly of dentry_kill() shows an indirect call to a function",
"  whose address is contained within a register.  Display the source code",
"  associated with the indirect function call:\n",
"    %s> dis dentry_kill",
"    ...",
"    0xffffffff811dcfb4 <dentry_kill+324>:	callq  *%rax",
"    ...",
"    %s> dis -s 0xffffffff811dcfb4",
"    FILE: fs/dcache.c",
"    LINE: 276",
"    ",
"      271                   spin_unlock(&dentry->d_lock);",
"      272                   spin_unlock(&inode->i_lock);",
"      273                   if (!inode->i_nlink)",
"      274                           fsnotify_inoderemove(inode);",
"      275                   if (dentry->d_op && dentry->d_op->d_iput)",
"    * 276                           dentry->d_op->d_iput(dentry, inode);",
"      277                   else",
"      278                           iput(inode);",
"      279           } else {",
"      280                   spin_unlock(&dentry->d_lock);",
"      281           }",
"      282   }",
"    ",
NULL               
};


char *help_eval[] = {
"eval",
"evaluate",
"[-b][-l] (expression) | value",
"  This command evaluates an expression or numeric value, and displays its",
"  result in hexadecimal, decimal, octal and binary. If the resultant value",
"  is an integral number of gigabytes, megabytes, or kilobytes, a short-hand",
"  translation of the number will also be shown next to the hexadecimal",
"  value.  If the most significant bit is set, the decimal display will show",
"  both unsigned and signed (negative) values.  Expressions must of the format", 
"  (x operator y), where \"x\" and \"y\" may be either numeric values or",
"  symbols.  The list of operators are:\n",
"                     +  -  &  |  ^  *  \%  /  <<  >>\n",
"  Enclosing the expression within parentheses is optional except when the",
"  \"|\", \"<<\" or \">>\" operators are used.  The single \"value\" argument may",
"  be a number or symbol.  Number arguments must be hexadecimal or decimal.",
"  A leading \"0x\" identifies a number as hexadecimal, but is not required",
"  when obvious.  Numbers may be followed by the letters \"k\" or \"K\", \"m\"",
"  or \"M\", and \"g\" or \"G\", which multiplies the value by a factor of 1024,",
"  1 megabyte or 1 gigabyte, respectively.  Numeric arguments may be preceded",
"  by the one's complement operator ~.",
" ",
"    -b  Indicate which bit positions in the resultant value are set.",
"    -l  Numeric arguments are presumed to be 64-bit values, and the result",
"        will be expressed as a 64-bit value. (ignored on 64-bit processors)",
"        However, if either operand or the resultant value are 64-bit values,",
"        then the result will be also be expressed as a 64-bit value.",
" ",
" The -b and -l options must precede the expression or value arguments.",
"\nEXAMPLES",
"   %s> eval 128m",
"   hexadecimal: 8000000  (128MB)",
"       decimal: 134217728  ",
"         octal: 1000000000",
"        binary: 00001000000000000000000000000000",
"    ",
"   %s> eval 128 * 1m",
"   hexadecimal: 8000000  (128MB)",
"       decimal: 134217728  ",
"         octal: 1000000000",
"        binary: 00001000000000000000000000000000",
"    ",
"   %s> eval (1 << 27)",
"   hexadecimal: 8000000  (128MB)",
"       decimal: 134217728  ",
"         octal: 1000000000",
"        binary: 00001000000000000000000000000000",
"   ",
"   %s> eval (1 << 32)",
"   hexadecimal: 100000000  (4GB)",
"       decimal: 4294967296",
"         octal: 40000000000",
"        binary: 0000000000000000000000000000000100000000000000000000000000000000",
" ",
"   %s> eval -b 41dc065",
"   hexadecimal: 41dc065",
"       decimal: 69058661  ",
"         octal: 407340145",
"        binary: 00000100000111011100000001100101",
"      bits set: 26 20 19 18 16 15 14 6 5 2 0 ",
" ",
"   %s> eval -lb 64g",
"   hexadecimal: 1000000000  (64GB)",
"       decimal: 68719476736",
"         octal: 1000000000000",
"        binary: 0000000000000000000000000001000000000000000000000000000000000000",
"      bits set: 36",
NULL               
};


char *help_sym[] = {
"sym",
"translate a symbol to its virtual address, or vice-versa ",
"[-l] | [-M] | [-m module] | [-p|-n] | [-q string] | [symbol | vaddr]",
"  This command translates a symbol to its virtual address, or a static ",
"  kernel virtual address to its symbol -- or to a symbol-plus-offset value,",
"  if appropriate.  Additionally, the symbol type is shown in parentheses, ",
"  and if the symbol is a known text value, the file and line number are shown.\n",
"              -l  dumps all symbols and their values.",
"              -M  dumps the current set of module symbols.",
"       -m module  dumps the current set of symbols for a specified module.",
"              -p  display the target symbol and the previous symbol.",
"              -n  display the target symbol and the next symbol.",
"       -q string  searches for all symbols containing \"string\".",
"          symbol  a kernel text or data symbol.",
"           vaddr  a kernel virtual address.",
" ",
"  If the \"symbol\", \"vaddr\" or \"string\" argument resolves to a module",
"  symbol, then the module name will be displayed in brackets following the",
"  symbol value.",
"\nEXAMPLES",
"  Translate data symbol jiffies to its value, and vice-versa:\n",
"    %s> sym jiffies",
"    c0213ae0 (D) jiffies\n", 
"    %s> sym c0213ae0",
"    c0213ae0 (D) jiffies\n", 
"  Translate a text address to its symbolic value and source file:\n",
"    %s> sym c0109944",
"    c0109944 (T) system_call+0x34  ../linux-2.2.5/arch/i386/kernel/signal.c: 723\n",
"  Dump the whole symbol table:\n",
"    %s> sym -l",
"    c0100000 (T) _stext",
"    c0100000 (A) _text",
"    c0100000 (t) startup_32",
"    c0100000 (T) stext",
"    c01000a4 (t) checkCPUtype",
"    c0100139 (t) is486",
"    c0100148 (t) is386",
"    c01001b1 (t) L6",
"    c01001b3 (t) ready",
"    c01001b4 (t) check_x87",
"    c01001da (t) setup_idt",
"    c01001f7 (t) rp_sidt",
"    c0100204 (T) stack_start",
"    c010020c (t) int_msg",
"    c0100220 (t) ignore_int",
"    c0100242 (t) idt_descr",
"    c0100244 (T) idt",
"    c010024a (t) gdt_descr",
"    c010024c (T) gdt",
"    c0101000 (T) swapper_pg_dir",
"    c0102000 (T) pg0",
"    c0103000 (T) empty_bad_page",
"    c0104000 (T) empty_bad_page_table",
"    c0105000 (T) empty_zero_page",
"    ...\n",
"  Find all symbols containing the string \"pipe\":\n",
"    %s> sym -q pipe",
"    c010ec60 (T) sys_pipe  ",
"    c012f660 (t) pipe_read  ",
"    c012f7b8 (t) pipe_write  ",
"    c012f9c0 (t) pipe_lseek  ",
"    c012f9d0 (t) bad_pipe_r  ",
"    c012f9dc (t) bad_pipe_w  ",
"    c012f9e8 (t) pipe_ioctl  ",
"    c012fa18 (t) pipe_poll  ",
"    c012fb00 (t) pipe_release  ",
"    c012fb48 (t) pipe_read_release  ",
"    c012fb5c (t) pipe_write_release  ",
"    c012fb70 (t) pipe_rdwr_release  ",
"    c012fba0 (t) pipe_read_open  ",
"    c012fbb0 (t) pipe_write_open  ",
"    c012fbc0 (t) pipe_rdwr_open  ",
"    c012fbec (t) get_pipe_inode  ",
"    c012fcc4 (T) do_pipe  ",
"    c023a920 (D) read_pipe_fops  ",
"    c023a960 (D) write_pipe_fops  ",
"    c023a9a0 (D) rdwr_pipe_fops  ",
"    c023a9e0 (D) pipe_inode_operations  ",

"\n  Dump the symbols of the uart401 module, both before, and then after,",
"  the complete set of symbols are loaded with the \"mod -s\" command:\n",
"    %s> sym -m uart401",
"    c8032000 MODULE START: uart401",
"    c8032138 (?) uart401intr  ",
"    c803235c (?) attach_uart401  ",
"    c8032638 (?) probe_uart401  ",
"    c80326d4 (?) unload_uart401  ",
"    c8033770 MODULE END: uart401",
"    %s> mod -s uart401",
"     MODULE   NAME         SIZE  OBJECT FILE",
"    c8032000  uart401      6000  /lib/modules/2.2.14/misc/uart401.o",
"    %s> sym -m uart401",
"    c8032000 MODULE START: uart401",
"    c8032050 (t) my_notifier_call  ",
"    c8032084 (t) uart401_status  ",
"    c8032098 (t) uart401_cmd  ",
"    c80320a8 (t) uart401_read  ",
"    c80320bc (t) uart401_write  ",
"    c80320cc (t) uart401_input_loop  ",
"    c8032138 (T) uart401intr  ",
"    c8032168 (t) uart401_open  ",
"    c80321c8 (t) uart401_close  ",
"    c80321f4 (t) uart401_out  ",
"    c80322ac (t) uart401_start_read  ",
"    c80322b4 (t) uart401_end_read  ",
"    c80322bc (t) uart401_kick  ",
"    c80322c4 (t) uart401_buffer_status  ",
"    c80322cc (t) enter_uart_mode  ",
"    c803235c (T) attach_uart401  ",
"    c803259c (t) reset_uart401  ",
"    c8032638 (T) probe_uart401  ",
"    c80326d4 (T) unload_uart401  ",
"    c8032760 (T) init_module",
"    c80327cc (T) cleanup_module  ",
"    c8032b00 (d) sound_notifier  ",
"    c8032b0c (d) detected_devc  ",
"    c8032b20 (d) std_synth_info  ",
"    c8032bc0 (d) std_midi_synth  ",
"    c8033600 (d) uart401_operations  ",
"    c80336c4 (D) io  ",
"    c80336c8 (D) irq  ",
"    c80336e0 (b) hw_info.508  ",
"    c8033770 MODULE END: uart401",

"\n  Display the value of jiffies, along with the next and previous symbols:\n",
"    %s> sym -np jiffies",
"    c023027c (D) prof_shift",  
"    c0230280 (D) jiffies ", 
"    c02302a0 (D) task",
"\n  Translate a symbol value to its name and module:\n",
"    crash> sym f88878d1",
"    f88878d1 (t) ext3_readdir [ext3]",  
"    crash>",
NULL               
};

char *help_files[] = {
"files",
"open files",
"[-d dentry] | [-p inode] | [-c] [-R reference] [pid | taskp] ... ",
"  This command displays information about open files of a context.",
"  It prints the context's current root directory and current working", 
"  directory, and then for each open file descriptor it prints a pointer",
"  to its file struct, a pointer to its dentry struct, a pointer to the",
"  inode, the file type, and the pathname.  If no arguments are entered,",
"  the current context is used.  The -R option, typically invoked from",
"  \"foreach files\", searches for references to a supplied number, address,",
"  or filename argument, and prints only the essential information leading",
"  up to and including the reference.  The -d option is not context",
"  specific, and only shows the data requested.\n",
"     -d dentry  given a hexadecimal dentry address, display its inode,",
"                super block, file type, and full pathname.",
"     -p inode   given a hexadecimal inode address, dump all of its pages",
"                that are in the page cache.",
"     -c         for each open file descriptor, prints a pointer to its",
"                inode, a pointer to the inode's i_mapping address_space",
"                structure, the number of pages of the inode that are in",
"                the page cache, the file type, and the pathname.",
"  -R reference  search for references to this file descriptor number,",
"                filename, dentry, inode, address_space, or file structure",
"                address.",
"           pid  a process PID.",
"         taskp  a hexadecimal task_struct pointer.",
"\nEXAMPLES",
"  Display the open files of the current context:\n",
"    %s> files",
"    PID: 720    TASK: c67f2000  CPU: 1   COMMAND: \"innd\"",
"    ROOT: /    CWD: /var/spool/news/articles",
"     FD    FILE     DENTRY    INODE    TYPE  PATH",
"      0  c6b9c740  c7cc45a0  c7c939e0  CHR   /dev/null",
"      1  c6b9c800  c537bb20  c54d0000  REG   /var/log/news/news",
"      2  c6df9600  c537b420  c5c36360  REG   /var/log/news/errlog",
"      3  c74182c0  c6ede260  c6da3d40  PIPE",
"      4  c6df9720  c696c620  c69398c0  SOCK",
"      5  c6b9cc20  c68e7000  c6938d80  SOCK",
"      6  c6b9c920  c7cc45a0  c7c939e0  CHR   /dev/null",
"      7  c6b9c680  c58fa5c0  c58a1200  REG   /var/lib/news/history",
"      8  c6df9f00  c6ede760  c6da3200  PIPE",
"      9  c6b9c6e0  c58fa140  c5929560  REG   /var/lib/news/history.dir",
"     10  c7fa9320  c7fab160  c7fafd40  CHR   /dev/console",
"     11  c6b9c7a0  c58fa5c0  c58a1200  REG   /var/lib/news/history",
"     12  c377ec60  c58fa5c0  c58a1200  REG   /var/lib/news/history",
"     13  c4528aa0  c58fa6c0  c52fbb00  REG   /var/lib/news/history.pag",
"     14  c6df9420  c68e7700  c6938360  SOCK",
"     15  c6df9360  c68e7780  c6938120  SOCK",
"     16  c6b9c0e0  c68e7800  c6772000  SOCK",
"     17  c6b9c200  c6b5f9c0  c6b5cea0  REG   /var/lib/news/active",
"     21  c6b9c080  c6ede760  c6da3200  PIPE", 
" ",
"  Display the files opened by the \"crond\" daemon, which is PID 462:\n",
"  %s> files 462",
"    PID: 462    TASK: f7220000  CPU: 2   COMMAND: \"crond\"",
"    ROOT: /    CWD: /var/spool",
"     FD    FILE     DENTRY    INODE    TYPE  PATH",
"      0  f7534ae0  f7538de0  f7518dc0  CHR   /dev/console",
"      1  f7368f80  f72c7a40  f72f27e0  FIFO  pipe:/[1456]",
"      2  f74f3c80  f72c79c0  f72f2600  FIFO  pipe:/[1457]",
"      3  f7368b60  f72a5be0  f74300c0  REG   /var/run/crond.pid",
"      4  f7534360  f73408c0  f72c2840  REG   /var/log/cron",
"      7  f7368ce0  f72c7940  f72f2420  FIFO  pipe:/[1458]",
"      8  f7295de0  f72c7940  f72f2420  FIFO  pipe:/[1458]",
"     21  f74f36e0  f747cdc0  f747e840  CHR   /dev/null",
" ",
"  The -R option is typically invoked from \"foreach files\".  This example",
"  shows all tasks that have \"/dev/pts/4\" open:\n",
"    %s> foreach files -R pts/4",
"    PID: 18633  TASK: c310a000  CPU: 0   COMMAND: \"crash\"",
"    ROOT: /    CWD: /home/CVS_pool/crash ",
"     FD    FILE     DENTRY    INODE    TYPE  PATH",
"      0  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"      1  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"      2  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"    ",
"    PID: 18664  TASK: c2392000  CPU: 1   COMMAND: \"less\"",
"    ROOT: /    CWD: /home/CVS_pool/crash ",
"     FD    FILE     DENTRY    INODE    TYPE  PATH",
"      1  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"      2  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"    ",
"    PID: 23162  TASK: c5088000  CPU: 1   COMMAND: \"bash\"",
"    ROOT: /    CWD: /home/CVS_pool/crash ",
"     FD    FILE     DENTRY    INODE    TYPE  PATH",
"      0  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"      1  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"      2  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"    255  c1412850  c2cb96d0  c2cad430  CHR   /dev/pts/4",
"    ",
"    PID: 23159  TASK: c10fc000  CPU: 1   COMMAND: \"xterm\"",
"    ROOT: /    CWD: /homes/anderson/ ",
"     FD    FILE     DENTRY    INODE    TYPE  PATH",
"      5  c1560da0  c2cb96d0  c2cad430  CHR   /dev/pts/4",
" ",
"  Display information about the dentry at address f745fd60:\n",
"    %s> files -d f745fd60",
"     DENTRY    INODE    SUPERBLK  TYPE  PATH",
"     f745fd60  f7284640  f73a3e00  REG   /var/spool/lpd/lpd.lock",
" ",
"  For each open file, display the number of pages that are in the page cache:\n",
"    %s> files -c 1954",
"    PID: 1954   TASK: f7a28000  CPU: 1   COMMAND: \"syslogd\"",
"    ROOT: /    CWD: /",
"     FD   INODE    I_MAPPING  NRPAGES  TYPE  PATH",
"      0  cb3ae868   cb3ae910        0  SOCK  socket:/[4690]",
"      2  f2721c5c   f2721d04      461  REG   /var/log/messages",
"      3  cbda4884   cbda492c       47  REG   /var/log/secure",
"      4  e48092c0   e4809368       58  REG   /var/log/maillog",
"      5  f65192c0   f6519368       48  REG   /var/log/cron",
"      6  e4809e48   e4809ef0        0  REG   /var/log/spooler",
"      7  d9c43884   d9c4392c        0  REG   /var/log/boot.log",
" ",
"  For the inode at address f59b90fc, display all of its pages that are in",
"  the page cache:\n",
"    %s> files -p f59b90fc",
"     INODE    NRPAGES",
"    f59b90fc        6",
"    ",
"      PAGE    PHYSICAL   MAPPING   INDEX CNT FLAGS",
"    ca3353e0  39a9f000  f59b91ac        0  2 82c referenced,uptodate,lru,private",
"    ca22cb20  31659000  f59b91ac        1  2 82c referenced,uptodate,lru,private",
"    ca220160  3100b000  f59b91ac        2  2 82c referenced,uptodate,lru,private",
"    ca1ddde0  2eeef000  f59b91ac        3  2 82c referenced,uptodate,lru,private",
"    ca36b300  3b598000  f59b91ac        4  2 82c referenced,uptodate,lru,private",
"    ca202680  30134000  f59b91ac        5  2 82c referenced,uptodate,lru,private",
" ",
NULL               
};

char *help_fuser[] = {
"fuser",
"file users",
"[pathname | inode]",
"  This command displays the tasks using specified files or sockets.",
"  Tasks will be listed that reference the file as the current working", 
"  directory, root directory, an open file descriptor, or that mmap the",
"  file.  If the file is held open in the kernel by the lockd server on",
"  behalf of a client discretionary file lock, the client hostname is",
"  listed.\n",
"    pathname  the full pathname of the file.",
"    inode     the hexadecimal inode address for the file.",
"",
"  NOTE: This commmand does not expect arguments other than inode address",
"  or full pathname.  If others are specified, the command may accept them,",
"  but an unexpected output can be displayed.",
"\nEXAMPLES",
"  Display the tasks using file /usr/lib/libkfm.so.2.0.0\n",
"    %s> fuser /usr/lib/libkfm.so.2.0.0",
"     PID    TASK    COMM            USAGE",
"     779  c5e82000  \"kwm\"           mmap",
"     808  c5a8e000  \"krootwm\"       mmap",
"     806  c5b42000  \"kfm\"           mmap",
"     809  c5dde000  \"kpanel\"        mmap",     
NULL               
};

char *help_net[] = {
"net",
"network command",
"[[-s | -S] [-xd] [-R ref] [pid | task]] [-a] [ -n [pid | task]] [-N addr]",
"  Displays various network related data.\n",
"  If no arguments are entered, the list of network devices, names and IP",
"  addresses are displayed.  For kernels supporting namespaces, the -n option",
"  may be used to display the list of network devices with respect to the",
"  network namespace of a current context or a task specified by pid or task:\n",
"        -n  the namespace of the current context.",
"    -n pid  a process PID.",
"   -n task  a hexadecimal task_struct pointer.\n",

"  The -s and -S options display data with respect to the current context, but",
"  may be appended with an argument to show the socket data with respect",
"  to a specified task:",
" ",
"        -s  display open network socket/sock addresses, their family and type,",
"            and for INET and INET6 families, their source and destination",
"            addresses and ports.",
"    -s pid  same as above, for task with process PID pid.",
"   -s task  same as above, for task with hexadecimal task_struct pointer task.\n",
"        -S  displays open network socket/sock addresses followed by a dump",
"            of both data structures.",
"    -S pid  same as above, with respect to process PID.",
"   -S task  same as above, with respect to hexadecimal task_struct pointer.",
" ",
"  The -R option, typically invoked from \"foreach net\", and in conjunction",
"  with the -s or -S options, searches for references to a socket address,",
"  sock address, or a file descriptor; if found, only the referenced fd, socket",
"  or sock data will be displayed:\n",
"    -R ref  socket or sock address, or file descriptor.",
" ",
"  Other options:\n",
"        -a  display the ARP cache.",
"   -N addr  translates an IPv4 address expressed as a decimal or hexadecimal",
"            value into a standard numbers-and-dots notation.",
"        -x  override default output format with hexadecimal format.",
"        -d  override default output format with decimal format.",
"\nEXAMPLES",
"  Display the system's network device list:",
"\n    %s> net", 
"       NET_DEVICE     NAME   IP ADDRESS(ES)",
"    ffff8803741c0000  lo     127.0.0.1",
"    fff88037059c0000  eth0   10.226.229.141",
"    ffff8803705c0000  eth1   10.226.228.250",
"    ffff880374ad6000  usb0   169.254.95.120",
" ",
"  Display the network device list with respect to the network namespace",
"  of PID 2618:",
"\n    %s> net -n 2618",
"       NET_DEVICE     NAME   IP ADDRESS(ES)",
"    ffff880456ee7020  lo     127.0.0.1",
"    ffff8804516a1020  eth0   10.1.9.223",
" ",
"  Dump the ARP cache:\n",
"    %s> net -a",
"    NEIGHBOUR      IP ADDRESS     HW TYPE   HW ADDRESS         DEVICE  STATE",
"    f38d1b00       10.16.64.14    ETHER     00:16:3e:4b:a5:4a  eth1    STALE",
"    f38d1080       0.0.0.0        UNKNOWN   00 00 00 00 00 00  lo      NOARP",
"    f38d1bc0       10.16.71.254   ETHER     00:00:0c:07:ac:00  eth1    REACHABLE",
"    f38d1200       10.16.64.21    ETHER     00:16:3e:51:d8:09  eth1    REACHABLE",
"   ",
"  Display the sockets for PID 2517, using both -s and -S output formats:\n",
"    %s> net -s 2517",
"    PID: 2517   TASK: c1598000  CPU: 1   COMMAND: \"rlogin\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     3  c57375dc  c1ff1850  INET:STREAM      10.1.8.20-1023      10.1.16.62-513",
"    ",
"    %s> net -S 2517",
"    PID: 2517   TASK: c1598000  CPU: 1   COMMAND: \"rlogin\"",
"    FD   SOCKET     SOCK",
"     3  c57375dc  c1ff1850",
"    ",
"    struct socket {",
"      state = SS_CONNECTED,",
"      flags = 131072,",
"      ops = 0xc023f820,",
"      inode = 0xc5737540,",
"      fasync_list = 0x0,",
"      file = 0xc58892b0,",
"      sk = 0xc1ff1850,",
"      wait = 0xc14d9ed4,",
"      type = 1,",
"      passcred = 0 '\\000',",
"      tli = 0 '\\000'",
"    }",
"    struct sock {",
"      sklist_next = 0xc1ff12f0,",
"      sklist_prev = 0xc216bc00,",
"      bind_next = 0x0,",
"      bind_pprev = 0xc0918448,",
"      daddr = 1041236234,",
"      rcv_saddr = 336068874,",
"      dport = 258,",
"      num = 1023,",
"      bound_dev_if = 0,",
"      next = 0x0,",
"      pprev = 0xc0286dd4,",
"      state = 1 '\\001',",
"      zapped = 0 '\\000',",
"      sport = 65283,",
"      family = 2,",
"      reuse = 0 '\\000',",
"      ...",
" "
"  Translate the rcv_saddr from above into dotted-decimal notation:\n",
"    %s> net -N 1041236234",
"    10.1.16.62",
" ",
"  From \"foreach\", find all tasks with references to socket c08ea3cc:\n",
"    %s> foreach net -s -R c08ea3cc",
"    PID: 2184   TASK: c7026000  CPU: 1   COMMAND: \"klines.kss\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2200   TASK: c670a000  CPU: 1   COMMAND: \"kpanel\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2201   TASK: c648a000  CPU: 1   COMMAND: \"kbgndwm\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 19294  TASK: c250a000  CPU: 0   COMMAND: \"prefdm\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2194   TASK: c62dc000  CPU: 1   COMMAND: \"kaudioserver\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2195   TASK: c6684000  CPU: 1   COMMAND: \"maudio\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2196   TASK: c6b58000  CPU: 1   COMMAND: \"kwmsound\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2197   TASK: c6696000  CPU: 0   COMMAND: \"kfm\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2199   TASK: c65ec000  CPU: 0   COMMAND: \"krootwm\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 694    TASK: c1942000  CPU: 0   COMMAND: \"prefdm\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 698    TASK: c6a2c000  CPU: 1   COMMAND: \"X\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
"    PID: 2159   TASK: c4a5a000  CPU: 1   COMMAND: \"kwm\"",
"    FD   SOCKET     SOCK    FAMILY:TYPE         SOURCE-PORT     DESTINATION-PORT",
"     5  c08ea3cc  c50d3c80  INET:STREAM        0.0.0.0-1026         0.0.0.0-0",
"    ",
NULL               
};

char *help_rustfilt[] = {
"rustfilt",
"demangle a mangled Rust symbol to human readable symbol",
"<symbol>",
"  This command converts a mangled Rust symbol to human readable symbol.",
"\nEXAMPLES",
"  crash> rustfilt _RNvNtCshc5sK6KjdJJ_6kernel5print11call_printk",
"  kernel::print::call_printk",
NULL
};

char *help_waitq[] = {
"waitq",
"list tasks queued on a wait queue",
" [ symbol ] | [ struct.member struct_addr ] | [ address ]",
"  This command walks the wait queue list displaying the tasks which ",
"  are blocked on the specified wait queue.  The command differentiates",
"  between the old- and new-style wait queue structures used by the kernel.",
"  It can be invoked with the following argument types:",
" ",
"                     symbol  a global symbol of a wait queue.",
"  struct.member struct_addr  a structure name and wait queue member combination",
"                             followed by the structure's hexadecimal address.",
"                    address  a hexadecimal wait queue pointer.",
"\nEXAMPLES\n",
"  Find out if any tasks are blocked on the \"buffer_wait\" wait queue:\n",
"    %s> waitq buffer_wait",
"    wait queue \"buffer_wait\" (c02927f0) is empty",
" ",
"  See who is blocked on the \"wait_chldexit\" queue of task c5496000:\n",
"    %s> waitq task_struct.wait_chldexit c5496000",
"    PID: 30879  TASK: c5496000  CPU: 0   COMMAND: \"bash\"",
" ",
"  Display the task list waiting on a known task queue:\n",
"    %s> waitq c3534098",
"    PID: 13691  TASK: c3534000  CPU: 1   COMMAND: \"bash\"",
NULL
};


/*
 *  Find out what the help request is looking for, accepting aliases as well,
 *  and print the relevant strings from the appropriate help table.
 */
void
cmd_usage(char *cmd, int helpflag)
{
	char **p, *scroll_command;
	struct command_table_entry *cp;
	char buf[BUFSIZE];
	FILE *scroll;
	int i;

	if (helpflag & PIPE_TO_SCROLL) {
		if ((scroll_command = setup_scroll_command()) &&
                    (scroll = popen(scroll_command, "w")))
			fp = scroll;
                else
                        scroll = NULL;
	} else {
		scroll_command = NULL;
		scroll = NULL;
	}

	if (STREQ(cmd, "copying")) {
		display_copying_info();
		goto done_usage;
	}

	if (STREQ(cmd, "warranty")) {
		display_warranty_info();
		goto done_usage;
	}

	if (STREQ(cmd, "input")) {
		display_input_info();
		goto done_usage;
	}

        if (STREQ(cmd, "output")) {
                display_output_info();
                goto done_usage;
        }

	if (STREQ(cmd, "all")) {
		display_input_info();
                display_output_info();
		help_init();
		for (i = 0; i < pc->ncmds; i++)
			cmd_usage(pc->cmdlist[i], COMPLETE_HELP);
		display_warranty_info();
		display_copying_info();
		goto done_usage;
	}

	if (STREQ(cmd, "commands")) {
		display_commands();
		goto done_usage;
	}

	if (STREQ(cmd, "README")) {
		display_README();
		goto done_usage;
	}

	/* look up command, possibly through an alias */
	for (;;) {
		struct alias_data *ad;

		cp = get_command_table_entry(cmd);
		if (cp != NULL)
			break;	/* found command */

		/* try for an alias */
		ad = is_alias(cmd);
		if (ad == NULL)
			break;	/* neither command nor alias */

		cmd = ad->args[0];
		cp = get_command_table_entry(cmd);
	}

	if (cp == NULL || (p = cp->help_data) == NULL) {
		if (helpflag & SYNOPSIS) { 
			fprintf(fp,
				"No usage data for the \"%s\" command"
				" is available.\n",
				cmd);
			RESTART();
		}

		if (helpflag & MUST_HELP) {
			if (cp || !(pc->flags & GDB_INIT))
				fprintf(fp,
				    "No help data for the \"%s\" command"
				    " is available.\n",
					cmd);
			else if (!gdb_pass_through(concat_args(buf, 0, FALSE), 
				NULL, GNU_RETURN_ON_ERROR))
				fprintf(fp, 
					"No help data for \"%s\" is available.\n",
					cmd);
		}
		goto done_usage;
        }

	p++;

        if (helpflag & SYNOPSIS) {
                p++;
                fprintf(fp, "Usage:\n  %s ", cmd);
		fprintf(fp, *p, pc->program_name, pc->program_name);
		fprintf(fp, "\nEnter \"help %s\" for details.\n", cmd);
                RESTART();
        }

        fprintf(fp, "\nNAME\n  %s - ", cmd);
        fprintf(fp, *p, pc->program_name);

        fprintf(fp, "\n\nSYNOPSIS\n");
        p++;
        fprintf(fp, "  %s ", cmd);
        fprintf(fp, *p, pc->program_name);

        fprintf(fp,"\n\nDESCRIPTION\n");
        p++;
        do {
		if (strstr(*p, "%") && !strstr(*p, "%s")) 
			print_verbatim(fp, *p);
		else
                	fprintf(fp, *p, pc->program_name, pc->program_name);
		fprintf(fp, "\n");
                p++;
        } while (*p);

        fprintf(fp, "\n");

done_usage:

	if (scroll) {
		fflush(scroll);
		pclose(scroll);
	}
	if (scroll_command)
		FREEBUF(scroll_command);
}


static
char *input_info[] = {

"Interactive %s commands are gathered using the GNU readline library,",
"which implements a command line history mechanism, and a command line editing",
"mode.\n", 

"The command line history consists of a numbered list of previously run ",
"commands, which can be viewed by entering \"h\" at any time.  A previously", 
"run command can be re-executed in a number of manners:",
" ",       
"  1. To re-execute the last command, enter \"r\" alone, or \"!!\".",
"  2. Enter \"r\" followed by the number identifying the desired command.",
"  3. Enter \"r\" followed by a uniquely-identifying set of characters from",
"     the beginning of the desired command string.",
"  4. Enter \"!\" followed by the number identifying the desired command,", 
"     providing that the number is not a command name in the user's PATH.",
"  5. Recycle back through the command history list by hitting the up-arrow",
"     key until the desired command is re-displayed, and then hit <ENTER>.",
"     If you go too far back, hit the down-arrow key.",
" ",
"The command line editing mode can be set to emulate either vi or emacs.",
"The mode can be set in the following manners, listed in increasing order of",
"precedence:",
" ",
"  1. The setting of the EDITOR environment variable.",
"  2. An entry in either in a .%src file, which can be located either",
"     in the current directory or in your home directory.  The entry must",
"     be of the form \"set vi\" or \"set emacs\".",
"  3. By use of the %s \"-e\" command line option, as in \"-e vi\" or \"-e emacs\".",
" ",
"To edit a previously entered command:",
" ",
"  1. Recycle back through the command history list until the desired command",
"     is re-displayed.",
"  2. Edit the line using vi or emacs editing commands, as appropriate. ",
"  3. Hit <ENTER>.",
" ",
"It should be noted that command line re-cycling may be accomplished by using",
"the CTRL-p and CTRL-n keys instead of the up- and down-arrow keys; in vi mode",
"you can enter <ESC>, then \"k\" to cycle back, or \"j\" to cycle forward.",
" ",
"A set of %s commands may be entered into a regular file that can be used as",
"input, using standard command line syntax:\n",
"  %s> < inputfile\n",
"An input file may be also be run from the %s command line using the -i ",
"option:\n",
"  $ %s -i inputfile",
"",
"Alternatively, an input file containing command arguments may be created.",
"The arguments in the input file will be passed to the command specified,",
"which will be executed repetitively for each line of arguments in the file:",
"",
"  %s> ps -p < inputfile",
"",
"Lastly, if a command is entered that is not recognized, it is checked against",
"the kernel's list of variables, structure, union or typedef names, and if ",
"found, the command is passed to p, struct, union or whatis.  That being the ",
"case, as long as a kernel variable/structure/union name is different than any",
"of the current commands, the appropriate command above will be executed.  If",
"not, the command will be passed on to the built-in gdb command for execution.",
"If an input line starts with \"#\" or \"//\", then the line will be saved",
"as a comment that is visible when re-cycling through the history list.",
"",
"To execute an external shell command, precede the command with an \"!\".",
"To escape to a shell, enter \"!\" alone.",
NULL
};


/*
 *  Display information concerning command input options: history,
 *  command recall, command-line editing, and input files.
 */
static void
display_input_info(void)
{
	int i;

        for (i = 0; input_info[i]; i++) {
                fprintf(fp, input_info[i],  
                        pc->program_name, pc->program_name);
                fprintf(fp, "\n");
	}
}

static
char *output_info[] = {

"\nBy default, %s command output is piped to \"/usr/bin/less -E -X\" along",
"with a prompt line.  This behavior can be turned off in two ways:\n",
"  1. During runtime, enter \"set scroll off\" or the alias \"sf\".",
"  2. Enter \"set scroll off\" in a .%src file, which can be located either",
"     in the current directory or in your home directory.\n",
"To restore the scrolling behavior during runtime, enter \"set scroll on\"",
"or the alias: \"sn\"\n",
"Command output may be piped to an external command using standard command",
"line pipe syntax.  For example:\n", 
"  %s> log | grep eth0\n",
"Command output may be redirected to a file using standard command line syntax.",
"For example:\n",
"  %s> foreach bt > bt.all\n",
"Use double brackets to append the output to a pre-existing file:\n",
"  %s> ps >> crash.data\n",
"The default output radix for gdb output and certain %s commands is",
"hexadecimal.  This can be changed to decimal by entering \"set radix 10\"",
"or the alias \"dec\".  It can be reverted back to hexadecimal by entering",
"\"set radix 16\" or the alias \"hex\".\n",
"To execute an external shell command, precede the command with an \"!\".",
"To escape to a shell, enter \"!\" alone.",
" ",
NULL
};

/*
 *  Display information concerning command output options.
 */
static void
display_output_info(void)
{
        int i;

        for (i = 0; output_info[i]; i++) {
                fprintf(fp, output_info[i], 
			pc->program_name, pc->program_name);
                fprintf(fp, "\n");
	}
}


/*
 *  Display the program name, version, and the GPL-required stuff for
 *  interactive programs.
 */
void
display_version(void)
{
	int i;

	if (pc->flags & SILENT)
		return;

        fprintf(fp, "\n%s %s\n", pc->program_name, pc->program_version);

        for (i = 0; version_info[i]; i++) 
                fprintf(fp, "%s\n", version_info[i]);
}

static 
char *version_info[] = {

"Copyright (C) 2002-2025  Red Hat, Inc.",
"Copyright (C) 2004, 2005, 2006, 2010  IBM Corporation", 
"Copyright (C) 1999-2006  Hewlett-Packard Co",
"Copyright (C) 2005, 2006, 2011, 2012  Fujitsu Limited",
"Copyright (C) 2006, 2007  VA Linux Systems Japan K.K.",
"Copyright (C) 2005, 2011, 2020-2024  NEC Corporation",
"Copyright (C) 1999, 2002, 2007  Silicon Graphics, Inc.",
"Copyright (C) 1999, 2000, 2001, 2002  Mission Critical Linux, Inc.",
"Copyright (C) 2015, 2021  VMware, Inc.",
"This program is free software, covered by the GNU General Public License,",
"and you are welcome to change it and/or distribute copies of it under",
"certain conditions.  Enter \"help copying\" to see the conditions.",
"This program has absolutely no warranty.  Enter \"help warranty\" for details.",
" ",
NULL
};

/*
 *  "help copying" output
 */
static void
display_copying_info(void)
{
	int i;

	switch (GPL_version)
	{
	case GPLv2:
		for (i = 0; !strstr(gnu_public_license[i], "NO WARRANTY"); i++)
			fprintf(fp, "%s\n", gnu_public_license[i]);
		break;

	case GPLv3:
		for (i = 0; !strstr(gnu_public_license_v3[i], 
		    "15. Disclaimer of Warranty."); i++)
			fprintf(fp, "%s\n", gnu_public_license_v3[i]);
		break;
	}
}

/*
 *  "help warranty" output
 */
static void
display_warranty_info(void)
{
	int i;

	switch (GPL_version)
	{
	case GPLv2:
		for (i = 0; !strstr(gnu_public_license[i], "NO WARRANTY"); i++)
			;

		do {
			fprintf(fp, "%s\n", gnu_public_license[i]);
		} while (!strstr(gnu_public_license[i++], "END OF TERMS"));
		break;

	case GPLv3:
		for (i = 0; !strstr(gnu_public_license_v3[i], 
		    "15. Disclaimer of Warranty."); i++)
			;

		while (!strstr(gnu_public_license_v3[i], "END OF TERMS"))
			fprintf(fp, "%s\n", gnu_public_license_v3[i++]);
		break;
	}
}

static
char *gnu_public_license[] = {
"",
"		    GNU GENERAL PUBLIC LICENSE",
"		       Version 2, June 1991",
"",
" Copyright (C) 1989, 1991 Free Software Foundation, Inc.",
"                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA",
" Everyone is permitted to copy and distribute verbatim copies",
" of this license document, but changing it is not allowed.",
"",
"			    Preamble",
"",
"  The licenses for most software are designed to take away your",
"freedom to share and change it.  By contrast, the GNU General Public",
"License is intended to guarantee your freedom to share and change free",
"software--to make sure the software is free for all its users.  This",
"General Public License applies to most of the Free Software",
"Foundation's software and to any other program whose authors commit to",
"using it.  (Some other Free Software Foundation software is covered by",
"the GNU Library General Public License instead.)  You can apply it to",
"your programs, too.",
"",
"  When we speak of free software, we are referring to freedom, not",
"price.  Our General Public Licenses are designed to make sure that you",
"have the freedom to distribute copies of free software (and charge for",
"this service if you wish), that you receive source code or can get it",
"if you want it, that you can change the software or use pieces of it",
"in new free programs; and that you know you can do these things.",
"",
"  To protect your rights, we need to make restrictions that forbid",
"anyone to deny you these rights or to ask you to surrender the rights.",
"These restrictions translate to certain responsibilities for you if you",
"distribute copies of the software, or if you modify it.",
"",
"  For example, if you distribute copies of such a program, whether",
"gratis or for a fee, you must give the recipients all the rights that",
"you have.  You must make sure that they, too, receive or can get the",
"source code.  And you must show them these terms so they know their",
"rights.",
"",
"  We protect your rights with two steps: (1) copyright the software, and",
"(2) offer you this license which gives you legal permission to copy,",
"distribute and/or modify the software.",
"",
"  Also, for each author's protection and ours, we want to make certain",
"that everyone understands that there is no warranty for this free",
"software.  If the software is modified by someone else and passed on, we",
"want its recipients to know that what they have is not the original, so",
"that any problems introduced by others will not reflect on the original",
"authors' reputations.",
"",
"  Finally, any free program is threatened constantly by software",
"patents.  We wish to avoid the danger that redistributors of a free",
"program will individually obtain patent licenses, in effect making the",
"program proprietary.  To prevent this, we have made it clear that any",
"patent must be licensed for everyone's free use or not licensed at all.",
"",
"  The precise terms and conditions for copying, distribution and",
"modification follow.",
"",
"		    GNU GENERAL PUBLIC LICENSE",
"   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION",
"",
"  0. This License applies to any program or other work which contains",
"a notice placed by the copyright holder saying it may be distributed",
"under the terms of this General Public License.  The \"Program\", below,",
"refers to any such program or work, and a \"work based on the Program\"",
"means either the Program or any derivative work under copyright law:",
"that is to say, a work containing the Program or a portion of it,",
"either verbatim or with modifications and/or translated into another",
"language.  (Hereinafter, translation is included without limitation in",
"the term \"modification\".)  Each licensee is addressed as \"you\".",
"",
"Activities other than copying, distribution and modification are not",
"covered by this License; they are outside its scope.  The act of",
"running the Program is not restricted, and the output from the Program",
"is covered only if its contents constitute a work based on the",
"Program (independent of having been made by running the Program).",
"Whether that is true depends on what the Program does.",
"",
"  1. You may copy and distribute verbatim copies of the Program's",
"source code as you receive it, in any medium, provided that you",
"conspicuously and appropriately publish on each copy an appropriate",
"copyright notice and disclaimer of warranty; keep intact all the",
"notices that refer to this License and to the absence of any warranty;",
"and give any other recipients of the Program a copy of this License",
"along with the Program.",
"",
"You may charge a fee for the physical act of transferring a copy, and",
"you may at your option offer warranty protection in exchange for a fee.",
"",
"  2. You may modify your copy or copies of the Program or any portion",
"of it, thus forming a work based on the Program, and copy and",
"distribute such modifications or work under the terms of Section 1",
"above, provided that you also meet all of these conditions:",
"",
"    a) You must cause the modified files to carry prominent notices",
"    stating that you changed the files and the date of any change.",
"",
"    b) You must cause any work that you distribute or publish, that in",
"    whole or in part contains or is derived from the Program or any",
"    part thereof, to be licensed as a whole at no charge to all third",
"    parties under the terms of this License.",
"",
"    c) If the modified program normally reads commands interactively",
"    when run, you must cause it, when started running for such",
"    interactive use in the most ordinary way, to print or display an",
"    announcement including an appropriate copyright notice and a",
"    notice that there is no warranty (or else, saying that you provide",
"    a warranty) and that users may redistribute the program under",
"    these conditions, and telling the user how to view a copy of this",
"    License.  (Exception: if the Program itself is interactive but",
"    does not normally print such an announcement, your work based on",
"    the Program is not required to print an announcement.)",
"",
"These requirements apply to the modified work as a whole.  If",
"identifiable sections of that work are not derived from the Program,",
"and can be reasonably considered independent and separate works in",
"themselves, then this License, and its terms, do not apply to those",
"sections when you distribute them as separate works.  But when you",
"distribute the same sections as part of a whole which is a work based",
"on the Program, the distribution of the whole must be on the terms of",
"this License, whose permissions for other licensees extend to the",
"entire whole, and thus to each and every part regardless of who wrote it.",
"",
"Thus, it is not the intent of this section to claim rights or contest",
"your rights to work written entirely by you; rather, the intent is to",
"exercise the right to control the distribution of derivative or",
"collective works based on the Program.",
"",
"In addition, mere aggregation of another work not based on the Program",
"with the Program (or with a work based on the Program) on a volume of",
"a storage or distribution medium does not bring the other work under",
"the scope of this License.",
"",
"  3. You may copy and distribute the Program (or a work based on it,",
"under Section 2) in object code or executable form under the terms of",
"Sections 1 and 2 above provided that you also do one of the following:",
"",
"    a) Accompany it with the complete corresponding machine-readable",
"    source code, which must be distributed under the terms of Sections",
"    1 and 2 above on a medium customarily used for software interchange; or,",
"",
"    b) Accompany it with a written offer, valid for at least three",
"    years, to give any third party, for a charge no more than your",
"    cost of physically performing source distribution, a complete",
"    machine-readable copy of the corresponding source code, to be",
"    distributed under the terms of Sections 1 and 2 above on a medium",
"    customarily used for software interchange; or,",
"",
"    c) Accompany it with the information you received as to the offer",
"    to distribute corresponding source code.  (This alternative is",
"    allowed only for noncommercial distribution and only if you",
"    received the program in object code or executable form with such",
"    an offer, in accord with Subsection b above.)",
"",
"The source code for a work means the preferred form of the work for",
"making modifications to it.  For an executable work, complete source",
"code means all the source code for all modules it contains, plus any",
"associated interface definition files, plus the scripts used to",
"control compilation and installation of the executable.  However, as a",
"special exception, the source code distributed need not include",
"anything that is normally distributed (in either source or binary",
"form) with the major components (compiler, kernel, and so on) of the",
"operating system on which the executable runs, unless that component",
"itself accompanies the executable.",
"",
"If distribution of executable or object code is made by offering",
"access to copy from a designated place, then offering equivalent",
"access to copy the source code from the same place counts as",
"distribution of the source code, even though third parties are not",
"compelled to copy the source along with the object code.",
"",
"  4. You may not copy, modify, sublicense, or distribute the Program",
"except as expressly provided under this License.  Any attempt",
"otherwise to copy, modify, sublicense or distribute the Program is",
"void, and will automatically terminate your rights under this License.",
"However, parties who have received copies, or rights, from you under",
"this License will not have their licenses terminated so long as such",
"parties remain in full compliance.",
"",
"  5. You are not required to accept this License, since you have not",
"signed it.  However, nothing else grants you permission to modify or",
"distribute the Program or its derivative works.  These actions are",
"prohibited by law if you do not accept this License.  Therefore, by",
"modifying or distributing the Program (or any work based on the",
"Program), you indicate your acceptance of this License to do so, and",
"all its terms and conditions for copying, distributing or modifying",
"the Program or works based on it.",
"",
"  6. Each time you redistribute the Program (or any work based on the",
"Program), the recipient automatically receives a license from the",
"original licensor to copy, distribute or modify the Program subject to",
"these terms and conditions.  You may not impose any further",
"restrictions on the recipients' exercise of the rights granted herein.",
"You are not responsible for enforcing compliance by third parties to",
"this License.",
"",
"  7. If, as a consequence of a court judgment or allegation of patent",
"infringement or for any other reason (not limited to patent issues),",
"conditions are imposed on you (whether by court order, agreement or",
"otherwise) that contradict the conditions of this License, they do not",
"excuse you from the conditions of this License.  If you cannot",
"distribute so as to satisfy simultaneously your obligations under this",
"License and any other pertinent obligations, then as a consequence you",
"may not distribute the Program at all.  For example, if a patent",
"license would not permit royalty-free redistribution of the Program by",
"all those who receive copies directly or indirectly through you, then",
"the only way you could satisfy both it and this License would be to",
"refrain entirely from distribution of the Program.",
"",
"If any portion of this section is held invalid or unenforceable under",
"any particular circumstance, the balance of the section is intended to",
"apply and the section as a whole is intended to apply in other",
"circumstances.",
"",
"It is not the purpose of this section to induce you to infringe any",
"patents or other property right claims or to contest validity of any",
"such claims; this section has the sole purpose of protecting the",
"integrity of the free software distribution system, which is",
"implemented by public license practices.  Many people have made",
"generous contributions to the wide range of software distributed",
"through that system in reliance on consistent application of that",
"system; it is up to the author/donor to decide if he or she is willing",
"to distribute software through any other system and a licensee cannot",
"impose that choice.",
"",
"This section is intended to make thoroughly clear what is believed to",
"be a consequence of the rest of this License.",
"",
"  8. If the distribution and/or use of the Program is restricted in",
"certain countries either by patents or by copyrighted interfaces, the",
"original copyright holder who places the Program under this License",
"may add an explicit geographical distribution limitation excluding",
"those countries, so that distribution is permitted only in or among",
"countries not thus excluded.  In such case, this License incorporates",
"the limitation as if written in the body of this License.",
"",
"  9. The Free Software Foundation may publish revised and/or new versions",
"of the General Public License from time to time.  Such new versions will",
"be similar in spirit to the present version, but may differ in detail to",
"address new problems or concerns.",
"",
"Each version is given a distinguishing version number.  If the Program",
"specifies a version number of this License which applies to it and \"any",
"later version\", you have the option of following the terms and conditions",
"either of that version or of any later version published by the Free",
"Software Foundation.  If the Program does not specify a version number of",
"this License, you may choose any version ever published by the Free Software",
"Foundation.",
"",
"  10. If you wish to incorporate parts of the Program into other free",
"programs whose distribution conditions are different, write to the author",
"to ask for permission.  For software which is copyrighted by the Free",
"Software Foundation, write to the Free Software Foundation; we sometimes",
"make exceptions for this.  Our decision will be guided by the two goals",
"of preserving the free status of all derivatives of our free software and",
"of promoting the sharing and reuse of software generally.",
"",
"\n			    NO WARRANTY",
"",
"  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY",
"FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN",
"OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES",
"PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED",
"OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF",
"MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS",
"TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE",
"PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,",
"REPAIR OR CORRECTION.",
"",
"  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING",
"WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR",
"REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,",
"INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING",
"OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED",
"TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY",
"YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER",
"PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE",
"POSSIBILITY OF SUCH DAMAGES.",
"",
"		     END OF TERMS AND CONDITIONS\n",
};

static
char *gnu_public_license_v3[] = {
"                    GNU GENERAL PUBLIC LICENSE",
"                       Version 3, 29 June 2007",
"",
" Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>",
" Everyone is permitted to copy and distribute verbatim copies",
" of this license document, but changing it is not allowed.",
"",
"                            Preamble",
"",
"  The GNU General Public License is a free, copyleft license for",
"software and other kinds of works.",
"",
"  The licenses for most software and other practical works are designed",
"to take away your freedom to share and change the works.  By contrast,",
"the GNU General Public License is intended to guarantee your freedom to",
"share and change all versions of a program--to make sure it remains free",
"software for all its users.  We, the Free Software Foundation, use the",
"GNU General Public License for most of our software; it applies also to",
"any other work released this way by its authors.  You can apply it to",
"your programs, too.",
"",
"  When we speak of free software, we are referring to freedom, not",
"price.  Our General Public Licenses are designed to make sure that you",
"have the freedom to distribute copies of free software (and charge for",
"them if you wish), that you receive source code or can get it if you",
"want it, that you can change the software or use pieces of it in new",
"free programs, and that you know you can do these things.",
"",
"  To protect your rights, we need to prevent others from denying you",
"these rights or asking you to surrender the rights.  Therefore, you have",
"certain responsibilities if you distribute copies of the software, or if",
"you modify it: responsibilities to respect the freedom of others.",
"",
"  For example, if you distribute copies of such a program, whether",
"gratis or for a fee, you must pass on to the recipients the same",
"freedoms that you received.  You must make sure that they, too, receive",
"or can get the source code.  And you must show them these terms so they",
"know their rights.",
"",
"  Developers that use the GNU GPL protect your rights with two steps:",
"(1) assert copyright on the software, and (2) offer you this License",
"giving you legal permission to copy, distribute and/or modify it.",
"",
"  For the developers' and authors' protection, the GPL clearly explains",
"that there is no warranty for this free software.  For both users' and",
"authors' sake, the GPL requires that modified versions be marked as",
"changed, so that their problems will not be attributed erroneously to",
"authors of previous versions.",
"",
"  Some devices are designed to deny users access to install or run",
"modified versions of the software inside them, although the manufacturer",
"can do so.  This is fundamentally incompatible with the aim of",
"protecting users' freedom to change the software.  The systematic",
"pattern of such abuse occurs in the area of products for individuals to",
"use, which is precisely where it is most unacceptable.  Therefore, we",
"have designed this version of the GPL to prohibit the practice for those",
"products.  If such problems arise substantially in other domains, we",
"stand ready to extend this provision to those domains in future versions",
"of the GPL, as needed to protect the freedom of users.",
"",
"  Finally, every program is threatened constantly by software patents.",
"States should not allow patents to restrict development and use of",
"software on general-purpose computers, but in those that do, we wish to",
"avoid the special danger that patents applied to a free program could",
"make it effectively proprietary.  To prevent this, the GPL assures that",
"patents cannot be used to render the program non-free.",
"",
"  The precise terms and conditions for copying, distribution and",
"modification follow.",
"",
"                       TERMS AND CONDITIONS",
"",
"  0. Definitions.",
"",
"  \"This License\" refers to version 3 of the GNU General Public License.",
"",
"  \"Copyright\" also means copyright-like laws that apply to other kinds of",
"works, such as semiconductor masks.",
"",
"  \"The Program\" refers to any copyrightable work licensed under this",
"License.  Each licensee is addressed as \"you\".  \"Licensees\" and",
"\"recipients\" may be individuals or organizations.",
"",
"  To \"modify\" a work means to copy from or adapt all or part of the work",
"in a fashion requiring copyright permission, other than the making of an",
"exact copy.  The resulting work is called a \"modified version\" of the",
"earlier work or a work \"based on\" the earlier work.",
"",
"  A \"covered work\" means either the unmodified Program or a work based",
"on the Program.",
"",
"  To \"propagate\" a work means to do anything with it that, without",
"permission, would make you directly or secondarily liable for",
"infringement under applicable copyright law, except executing it on a",
"computer or modifying a private copy.  Propagation includes copying,",
"distribution (with or without modification), making available to the",
"public, and in some countries other activities as well.",
"",
"  To \"convey\" a work means any kind of propagation that enables other",
"parties to make or receive copies.  Mere interaction with a user through",
"a computer network, with no transfer of a copy, is not conveying.",
"",
"  An interactive user interface displays \"Appropriate Legal Notices\"",
"to the extent that it includes a convenient and prominently visible",
"feature that (1) displays an appropriate copyright notice, and (2)",
"tells the user that there is no warranty for the work (except to the",
"extent that warranties are provided), that licensees may convey the",
"work under this License, and how to view a copy of this License.  If",
"the interface presents a list of user commands or options, such as a",
"menu, a prominent item in the list meets this criterion.",
"",
"  1. Source Code.",
"",
"  The \"source code\" for a work means the preferred form of the work",
"for making modifications to it.  \"Object code\" means any non-source",
"form of a work.",
"",
"  A \"Standard Interface\" means an interface that either is an official",
"standard defined by a recognized standards body, or, in the case of",
"interfaces specified for a particular programming language, one that",
"is widely used among developers working in that language.",
"",
"  The \"System Libraries\" of an executable work include anything, other",
"than the work as a whole, that (a) is included in the normal form of",
"packaging a Major Component, but which is not part of that Major",
"Component, and (b) serves only to enable use of the work with that",
"Major Component, or to implement a Standard Interface for which an",
"implementation is available to the public in source code form.  A",
"\"Major Component\", in this context, means a major essential component",
"(kernel, window system, and so on) of the specific operating system",
"(if any) on which the executable work runs, or a compiler used to",
"produce the work, or an object code interpreter used to run it.",
"",
"  The \"Corresponding Source\" for a work in object code form means all",
"the source code needed to generate, install, and (for an executable",
"work) run the object code and to modify the work, including scripts to",
"control those activities.  However, it does not include the work's",
"System Libraries, or general-purpose tools or generally available free",
"programs which are used unmodified in performing those activities but",
"which are not part of the work.  For example, Corresponding Source",
"includes interface definition files associated with source files for",
"the work, and the source code for shared libraries and dynamically",
"linked subprograms that the work is specifically designed to require,",
"such as by intimate data communication or control flow between those",
"subprograms and other parts of the work.",
"",
"  The Corresponding Source need not include anything that users",
"can regenerate automatically from other parts of the Corresponding",
"Source.",
"",
"  The Corresponding Source for a work in source code form is that",
"same work.",
"",
"  2. Basic Permissions.",
"",
"  All rights granted under this License are granted for the term of",
"copyright on the Program, and are irrevocable provided the stated",
"conditions are met.  This License explicitly affirms your unlimited",
"permission to run the unmodified Program.  The output from running a",
"covered work is covered by this License only if the output, given its",
"content, constitutes a covered work.  This License acknowledges your",
"rights of fair use or other equivalent, as provided by copyright law.",
"",
"  You may make, run and propagate covered works that you do not",
"convey, without conditions so long as your license otherwise remains",
"in force.  You may convey covered works to others for the sole purpose",
"of having them make modifications exclusively for you, or provide you",
"with facilities for running those works, provided that you comply with",
"the terms of this License in conveying all material for which you do",
"not control copyright.  Those thus making or running the covered works",
"for you must do so exclusively on your behalf, under your direction",
"and control, on terms that prohibit them from making any copies of",
"your copyrighted material outside their relationship with you.",
"",
"  Conveying under any other circumstances is permitted solely under",
"the conditions stated below.  Sublicensing is not allowed; section 10",
"makes it unnecessary.",
"",
"  3. Protecting Users' Legal Rights From Anti-Circumvention Law.",
"",
"  No covered work shall be deemed part of an effective technological",
"measure under any applicable law fulfilling obligations under article",
"11 of the WIPO copyright treaty adopted on 20 December 1996, or",
"similar laws prohibiting or restricting circumvention of such",
"measures.",
"",
"  When you convey a covered work, you waive any legal power to forbid",
"circumvention of technological measures to the extent such circumvention",
"is effected by exercising rights under this License with respect to",
"the covered work, and you disclaim any intention to limit operation or",
"modification of the work as a means of enforcing, against the work's",
"users, your or third parties' legal rights to forbid circumvention of",
"technological measures.",
"",
"  4. Conveying Verbatim Copies.",
"",
"  You may convey verbatim copies of the Program's source code as you",
"receive it, in any medium, provided that you conspicuously and",
"appropriately publish on each copy an appropriate copyright notice;",
"keep intact all notices stating that this License and any",
"non-permissive terms added in accord with section 7 apply to the code;",
"keep intact all notices of the absence of any warranty; and give all",
"recipients a copy of this License along with the Program.",
"",
"  You may charge any price or no price for each copy that you convey,",
"and you may offer support or warranty protection for a fee.",
"",
"  5. Conveying Modified Source Versions.",
"",
"  You may convey a work based on the Program, or the modifications to",
"produce it from the Program, in the form of source code under the",
"terms of section 4, provided that you also meet all of these conditions:",
"",
"    a) The work must carry prominent notices stating that you modified",
"    it, and giving a relevant date.",
"",
"    b) The work must carry prominent notices stating that it is",
"    released under this License and any conditions added under section",
"    7.  This requirement modifies the requirement in section 4 to",
"    \"keep intact all notices\".",
"",
"    c) You must license the entire work, as a whole, under this",
"    License to anyone who comes into possession of a copy.  This",
"    License will therefore apply, along with any applicable section 7",
"    additional terms, to the whole of the work, and all its parts,",
"    regardless of how they are packaged.  This License gives no",
"    permission to license the work in any other way, but it does not",
"    invalidate such permission if you have separately received it.",
"",
"    d) If the work has interactive user interfaces, each must display",
"    Appropriate Legal Notices; however, if the Program has interactive",
"    interfaces that do not display Appropriate Legal Notices, your",
"    work need not make them do so.",
"",
"  A compilation of a covered work with other separate and independent",
"works, which are not by their nature extensions of the covered work,",
"and which are not combined with it such as to form a larger program,",
"in or on a volume of a storage or distribution medium, is called an",
"\"aggregate\" if the compilation and its resulting copyright are not",
"used to limit the access or legal rights of the compilation's users",
"beyond what the individual works permit.  Inclusion of a covered work",
"in an aggregate does not cause this License to apply to the other",
"parts of the aggregate.",
"",
"  6. Conveying Non-Source Forms.",
"",
"  You may convey a covered work in object code form under the terms",
"of sections 4 and 5, provided that you also convey the",
"machine-readable Corresponding Source under the terms of this License,",
"in one of these ways:",
"",
"    a) Convey the object code in, or embodied in, a physical product",
"    (including a physical distribution medium), accompanied by the",
"    Corresponding Source fixed on a durable physical medium",
"    customarily used for software interchange.",
"",
"    b) Convey the object code in, or embodied in, a physical product",
"    (including a physical distribution medium), accompanied by a",
"    written offer, valid for at least three years and valid for as",
"    long as you offer spare parts or customer support for that product",
"    model, to give anyone who possesses the object code either (1) a",
"    copy of the Corresponding Source for all the software in the",
"    product that is covered by this License, on a durable physical",
"    medium customarily used for software interchange, for a price no",
"    more than your reasonable cost of physically performing this",
"    conveying of source, or (2) access to copy the",
"    Corresponding Source from a network server at no charge.",
"",
"    c) Convey individual copies of the object code with a copy of the",
"    written offer to provide the Corresponding Source.  This",
"    alternative is allowed only occasionally and noncommercially, and",
"    only if you received the object code with such an offer, in accord",
"    with subsection 6b.",
"",
"    d) Convey the object code by offering access from a designated",
"    place (gratis or for a charge), and offer equivalent access to the",
"    Corresponding Source in the same way through the same place at no",
"    further charge.  You need not require recipients to copy the",
"    Corresponding Source along with the object code.  If the place to",
"    copy the object code is a network server, the Corresponding Source",
"    may be on a different server (operated by you or a third party)",
"    that supports equivalent copying facilities, provided you maintain",
"    clear directions next to the object code saying where to find the",
"    Corresponding Source.  Regardless of what server hosts the",
"    Corresponding Source, you remain obligated to ensure that it is",
"    available for as long as needed to satisfy these requirements.",
"",
"    e) Convey the object code using peer-to-peer transmission, provided",
"    you inform other peers where the object code and Corresponding",
"    Source of the work are being offered to the general public at no",
"    charge under subsection 6d.",
"",
"  A separable portion of the object code, whose source code is excluded",
"from the Corresponding Source as a System Library, need not be",
"included in conveying the object code work.",
"",
"  A \"User Product\" is either (1) a \"consumer product\", which means any",
"tangible personal property which is normally used for personal, family,",
"or household purposes, or (2) anything designed or sold for incorporation",
"into a dwelling.  In determining whether a product is a consumer product,",
"doubtful cases shall be resolved in favor of coverage.  For a particular",
"product received by a particular user, \"normally used\" refers to a",
"typical or common use of that class of product, regardless of the status",
"of the particular user or of the way in which the particular user",
"actually uses, or expects or is expected to use, the product.  A product",
"is a consumer product regardless of whether the product has substantial",
"commercial, industrial or non-consumer uses, unless such uses represent",
"the only significant mode of use of the product.",
"",
"  \"Installation Information\" for a User Product means any methods,",
"procedures, authorization keys, or other information required to install",
"and execute modified versions of a covered work in that User Product from",
"a modified version of its Corresponding Source.  The information must",
"suffice to ensure that the continued functioning of the modified object",
"code is in no case prevented or interfered with solely because",
"modification has been made.",
"",
"  If you convey an object code work under this section in, or with, or",
"specifically for use in, a User Product, and the conveying occurs as",
"part of a transaction in which the right of possession and use of the",
"User Product is transferred to the recipient in perpetuity or for a",
"fixed term (regardless of how the transaction is characterized), the",
"Corresponding Source conveyed under this section must be accompanied",
"by the Installation Information.  But this requirement does not apply",
"if neither you nor any third party retains the ability to install",
"modified object code on the User Product (for example, the work has",
"been installed in ROM).",
"",
"  The requirement to provide Installation Information does not include a",
"requirement to continue to provide support service, warranty, or updates",
"for a work that has been modified or installed by the recipient, or for",
"the User Product in which it has been modified or installed.  Access to a",
"network may be denied when the modification itself materially and",
"adversely affects the operation of the network or violates the rules and",
"protocols for communication across the network.",
"",
"  Corresponding Source conveyed, and Installation Information provided,",
"in accord with this section must be in a format that is publicly",
"documented (and with an implementation available to the public in",
"source code form), and must require no special password or key for",
"unpacking, reading or copying.",
"",
"  7. Additional Terms.",
"",
"  \"Additional permissions\" are terms that supplement the terms of this",
"License by making exceptions from one or more of its conditions.",
"Additional permissions that are applicable to the entire Program shall",
"be treated as though they were included in this License, to the extent",
"that they are valid under applicable law.  If additional permissions",
"apply only to part of the Program, that part may be used separately",
"under those permissions, but the entire Program remains governed by",
"this License without regard to the additional permissions.",
"",
"  When you convey a copy of a covered work, you may at your option",
"remove any additional permissions from that copy, or from any part of",
"it.  (Additional permissions may be written to require their own",
"removal in certain cases when you modify the work.)  You may place",
"additional permissions on material, added by you to a covered work,",
"for which you have or can give appropriate copyright permission.",
"",
"  Notwithstanding any other provision of this License, for material you",
"add to a covered work, you may (if authorized by the copyright holders of",
"that material) supplement the terms of this License with terms:",
"",
"    a) Disclaiming warranty or limiting liability differently from the",
"    terms of sections 15 and 16 of this License; or",
"",
"    b) Requiring preservation of specified reasonable legal notices or",
"    author attributions in that material or in the Appropriate Legal",
"    Notices displayed by works containing it; or",
"",
"    c) Prohibiting misrepresentation of the origin of that material, or",
"    requiring that modified versions of such material be marked in",
"    reasonable ways as different from the original version; or",
"",
"    d) Limiting the use for publicity purposes of names of licensors or",
"    authors of the material; or",
"",
"    e) Declining to grant rights under trademark law for use of some",
"    trade names, trademarks, or service marks; or",
"",
"    f) Requiring indemnification of licensors and authors of that",
"    material by anyone who conveys the material (or modified versions of",
"    it) with contractual assumptions of liability to the recipient, for",
"    any liability that these contractual assumptions directly impose on",
"    those licensors and authors.",
"",
"  All other non-permissive additional terms are considered \"further",
"restrictions\" within the meaning of section 10.  If the Program as you",
"received it, or any part of it, contains a notice stating that it is",
"governed by this License along with a term that is a further",
"restriction, you may remove that term.  If a license document contains",
"a further restriction but permits relicensing or conveying under this",
"License, you may add to a covered work material governed by the terms",
"of that license document, provided that the further restriction does",
"not survive such relicensing or conveying.",
"",
"  If you add terms to a covered work in accord with this section, you",
"must place, in the relevant source files, a statement of the",
"additional terms that apply to those files, or a notice indicating",
"where to find the applicable terms.",
"",
"  Additional terms, permissive or non-permissive, may be stated in the",
"form of a separately written license, or stated as exceptions;",
"the above requirements apply either way.",
"",
"  8. Termination.",
"",
"  You may not propagate or modify a covered work except as expressly",
"provided under this License.  Any attempt otherwise to propagate or",
"modify it is void, and will automatically terminate your rights under",
"this License (including any patent licenses granted under the third",
"paragraph of section 11).",
"",
"  However, if you cease all violation of this License, then your",
"license from a particular copyright holder is reinstated (a)",
"provisionally, unless and until the copyright holder explicitly and",
"finally terminates your license, and (b) permanently, if the copyright",
"holder fails to notify you of the violation by some reasonable means",
"prior to 60 days after the cessation.",
"",
"  Moreover, your license from a particular copyright holder is",
"reinstated permanently if the copyright holder notifies you of the",
"violation by some reasonable means, this is the first time you have",
"received notice of violation of this License (for any work) from that",
"copyright holder, and you cure the violation prior to 30 days after",
"your receipt of the notice.",
"",
"  Termination of your rights under this section does not terminate the",
"licenses of parties who have received copies or rights from you under",
"this License.  If your rights have been terminated and not permanently",
"reinstated, you do not qualify to receive new licenses for the same",
"material under section 10.",
"",
"  9. Acceptance Not Required for Having Copies.",
"",
"  You are not required to accept this License in order to receive or",
"run a copy of the Program.  Ancillary propagation of a covered work",
"occurring solely as a consequence of using peer-to-peer transmission",
"to receive a copy likewise does not require acceptance.  However,",
"nothing other than this License grants you permission to propagate or",
"modify any covered work.  These actions infringe copyright if you do",
"not accept this License.  Therefore, by modifying or propagating a",
"covered work, you indicate your acceptance of this License to do so.",
"",
"  10. Automatic Licensing of Downstream Recipients.",
"",
"  Each time you convey a covered work, the recipient automatically",
"receives a license from the original licensors, to run, modify and",
"propagate that work, subject to this License.  You are not responsible",
"for enforcing compliance by third parties with this License.",
"",
"  An \"entity transaction\" is a transaction transferring control of an",
"organization, or substantially all assets of one, or subdividing an",
"organization, or merging organizations.  If propagation of a covered",
"work results from an entity transaction, each party to that",
"transaction who receives a copy of the work also receives whatever",
"licenses to the work the party's predecessor in interest had or could",
"give under the previous paragraph, plus a right to possession of the",
"Corresponding Source of the work from the predecessor in interest, if",
"the predecessor has it or can get it with reasonable efforts.",
"",
"  You may not impose any further restrictions on the exercise of the",
"rights granted or affirmed under this License.  For example, you may",
"not impose a license fee, royalty, or other charge for exercise of",
"rights granted under this License, and you may not initiate litigation",
"(including a cross-claim or counterclaim in a lawsuit) alleging that",
"any patent claim is infringed by making, using, selling, offering for",
"sale, or importing the Program or any portion of it.",
"",
"  11. Patents.",
"",
"  A \"contributor\" is a copyright holder who authorizes use under this",
"License of the Program or a work on which the Program is based.  The",
"work thus licensed is called the contributor's \"contributor version\".",
"",
"  A contributor's \"essential patent claims\" are all patent claims",
"owned or controlled by the contributor, whether already acquired or",
"hereafter acquired, that would be infringed by some manner, permitted",
"by this License, of making, using, or selling its contributor version,",
"but do not include claims that would be infringed only as a",
"consequence of further modification of the contributor version.  For",
"purposes of this definition, \"control\" includes the right to grant",
"patent sublicenses in a manner consistent with the requirements of",
"this License.",
"",
"  Each contributor grants you a non-exclusive, worldwide, royalty-free",
"patent license under the contributor's essential patent claims, to",
"make, use, sell, offer for sale, import and otherwise run, modify and",
"propagate the contents of its contributor version.",
"",
"  In the following three paragraphs, a \"patent license\" is any express",
"agreement or commitment, however denominated, not to enforce a patent",
"(such as an express permission to practice a patent or covenant not to",
"sue for patent infringement).  To \"grant\" such a patent license to a",
"party means to make such an agreement or commitment not to enforce a",
"patent against the party.",
"",
"  If you convey a covered work, knowingly relying on a patent license,",
"and the Corresponding Source of the work is not available for anyone",
"to copy, free of charge and under the terms of this License, through a",
"publicly available network server or other readily accessible means,",
"then you must either (1) cause the Corresponding Source to be so",
"available, or (2) arrange to deprive yourself of the benefit of the",
"patent license for this particular work, or (3) arrange, in a manner",
"consistent with the requirements of this License, to extend the patent",
"license to downstream recipients.  \"Knowingly relying\" means you have",
"actual knowledge that, but for the patent license, your conveying the",
"covered work in a country, or your recipient's use of the covered work",
"in a country, would infringe one or more identifiable patents in that",
"country that you have reason to believe are valid.",
"",
"  If, pursuant to or in connection with a single transaction or",
"arrangement, you convey, or propagate by procuring conveyance of, a",
"covered work, and grant a patent license to some of the parties",
"receiving the covered work authorizing them to use, propagate, modify",
"or convey a specific copy of the covered work, then the patent license",
"you grant is automatically extended to all recipients of the covered",
"work and works based on it.",
"",
"  A patent license is \"discriminatory\" if it does not include within",
"the scope of its coverage, prohibits the exercise of, or is",
"conditioned on the non-exercise of one or more of the rights that are",
"specifically granted under this License.  You may not convey a covered",
"work if you are a party to an arrangement with a third party that is",
"in the business of distributing software, under which you make payment",
"to the third party based on the extent of your activity of conveying",
"the work, and under which the third party grants, to any of the",
"parties who would receive the covered work from you, a discriminatory",
"patent license (a) in connection with copies of the covered work",
"conveyed by you (or copies made from those copies), or (b) primarily",
"for and in connection with specific products or compilations that",
"contain the covered work, unless you entered into that arrangement,",
"or that patent license was granted, prior to 28 March 2007.",
"",
"  Nothing in this License shall be construed as excluding or limiting",
"any implied license or other defenses to infringement that may",
"otherwise be available to you under applicable patent law.",
"",
"  12. No Surrender of Others' Freedom.",
"",
"  If conditions are imposed on you (whether by court order, agreement or",
"otherwise) that contradict the conditions of this License, they do not",
"excuse you from the conditions of this License.  If you cannot convey a",
"covered work so as to satisfy simultaneously your obligations under this",
"License and any other pertinent obligations, then as a consequence you may",
"not convey it at all.  For example, if you agree to terms that obligate you",
"to collect a royalty for further conveying from those to whom you convey",
"the Program, the only way you could satisfy both those terms and this",
"License would be to refrain entirely from conveying the Program.",
"",
"  13. Use with the GNU Affero General Public License.",
"",
"  Notwithstanding any other provision of this License, you have",
"permission to link or combine any covered work with a work licensed",
"under version 3 of the GNU Affero General Public License into a single",
"combined work, and to convey the resulting work.  The terms of this",
"License will continue to apply to the part which is the covered work,",
"but the special requirements of the GNU Affero General Public License,",
"section 13, concerning interaction through a network will apply to the",
"combination as such.",
"",
"  14. Revised Versions of this License.",
"",
"  The Free Software Foundation may publish revised and/or new versions of",
"the GNU General Public License from time to time.  Such new versions will",
"be similar in spirit to the present version, but may differ in detail to",
"address new problems or concerns.",
"",
"  Each version is given a distinguishing version number.  If the",
"Program specifies that a certain numbered version of the GNU General",
"Public License \"or any later version\" applies to it, you have the",
"option of following the terms and conditions either of that numbered",
"version or of any later version published by the Free Software",
"Foundation.  If the Program does not specify a version number of the",
"GNU General Public License, you may choose any version ever published",
"by the Free Software Foundation.",
"",
"  If the Program specifies that a proxy can decide which future",
"versions of the GNU General Public License can be used, that proxy's",
"public statement of acceptance of a version permanently authorizes you",
"to choose that version for the Program.",
"",
"  Later license versions may give you additional or different",
"permissions.  However, no additional obligations are imposed on any",
"author or copyright holder as a result of your choosing to follow a",
"later version.",
"",
"  15. Disclaimer of Warranty.",
"",
"  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY",
"APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT",
"HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY",
"OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,",
"THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR",
"PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM",
"IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF",
"ALL NECESSARY SERVICING, REPAIR OR CORRECTION.",
"",
"  16. Limitation of Liability.",
"",
"  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING",
"WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS",
"THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY",
"GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE",
"USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF",
"DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD",
"PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),",
"EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF",
"SUCH DAMAGES.",
"",
"  17. Interpretation of Sections 15 and 16.",
"",
"  If the disclaimer of warranty and limitation of liability provided",
"above cannot be given local legal effect according to their terms,",
"reviewing courts shall apply local law that most closely approximates",
"an absolute waiver of all civil liability in connection with the",
"Program, unless a warranty or assumption of liability accompanies a",
"copy of the Program in return for a fee.",
"",
"                     END OF TERMS AND CONDITIONS",
};

#define README_CRASH_VERSION      "README_CRASH_VERSION"
#define README_GNU_GDB_VERSION    "README_GNU_GDB_VERSION"
#define README_DATE               "README_DATE"
#define README_GPL_INFO           "README_GPL_INFO"
#define README_HELP_MENU          "README_HELP_MENU"
#define README_ENTER_DIRECTORY    "README_ENTER_DIRECTORY"
#define README_MEMORY_DRIVER      "README_MEMORY_DRIVER"

static void
display_README(void)
{
        int i, j;
    	time_t time_now;           

        for (i = 0; README[i]; i++) {
		if (STREQ(README[i], README_CRASH_VERSION)) {
			fprintf(fp, "    crash %s\n", pc->program_version);
		} else if (STREQ(README[i], README_GNU_GDB_VERSION)) {
			fprintf(fp, "    GNU gdb %s\n", pc->gdb_version);
		} else if (STREQ(README[i], README_DATE)) {
    			time(&time_now);               
			fprintf(fp, "            DATE: %s\n", ctime_tz(&time_now));
		} else if (STREQ(README[i], README_HELP_MENU)) {
			display_help_screen("    ");
		} else if (STREQ(README[i], README_GPL_INFO)) {
        		for (j = 0; version_info[j]; j++)
                		fprintf(fp, "    %s\n", version_info[j]);
		} else if (STREQ(README[i], README_ENTER_DIRECTORY)) {
			fprintf(fp, 
			    "    $ tar -xf crash-%s.tar.gz\n", 
					pc->program_version);
			fprintf(fp,
			    "    $ cd crash-%s\n", pc->program_version);
		} else if (STREQ(README[i], README_MEMORY_DRIVER)) {
			fprintf(fp, 
			    "  is included in the crash-%s/memory_driver subdirectory.\n",
				pc->program_version);
		} else 
			fprintf(fp, "%s\n", README[i]);
        }
}

static 
char *README[] = {
"",
"",
"                         CORE ANALYSIS SUITE",
"",
"  The core analysis suite is a self-contained tool that can be used to",
"  investigate either live systems, kernel core dumps created from dump",
"  creation facilities such as kdump, kvmdump, xendump, the netdump and",
"  diskdump packages offered by Red Hat, the LKCD kernel patch, the mcore",
"  kernel patch created by Mission Critical Linux, as well as other formats",
"  created by manufacturer-specific firmware.",
"",
"  o  The tool is loosely based on the SVR4 crash command, but has been",
"     completely integrated with gdb in order to be able to display ",
"     formatted kernel data structures, disassemble source code, etc.",
"     ",
"  o  The current set of available commands consist of common kernel core",
"     analysis tools such as a context-specific stack traces, source code",
"     disassembly, kernel variable displays, memory display, dumps of ",
"     linked-lists, etc.  In addition, any gdb command may be entered,",
"     which in turn will be passed onto the gdb module for execution.  ",
"",
"  o  There are several commands that delve deeper into specific kernel",
"     subsystems, which also serve as templates for kernel developers",
"     to create new commands for analysis of a specific area of interest.",
"     Adding a new command is a simple affair, and a quick recompile",
"     adds it to the command menu.",
"",
"  o  The intent is to make the tool independent of Linux version dependencies,",
"     building in recognition of major kernel code changes so as to adapt to ",
"     new kernel versions, while maintaining backwards compatibility.",
"",
"  A whitepaper with complete documentation concerning the use of this utility",
"  can be found here:",
" ",
"         https://crash-utility.github.io/crash_whitepaper.html",
" ",
"  These are the current prerequisites: ",
"",
"  o  At this point, x86, ia64, x86_64, ppc64, ppc, arm, arm64, alpha, mips,",
"     mips64, loongarch64, riscv64, s390 and s390x-based kernels are supported.",
"     Other architectures may be addressed in the future.",
"",
"  o  One size fits all -- the utility can be run on any Linux kernel version",
"     version dating back to 2.2.5-15.  A primary design goal is to always",
"     maintain backwards-compatibility.",
"",
"  o  In order to contain debugging data, the top-level kernel Makefile's CFLAGS",
"     definition must contain the -g flag.  Typically distributions will contain",
"     a package containing a vmlinux file with full debuginfo data.  If not, the",
"     kernel must be rebuilt:", 
"",
"     For 2.2 kernels that are not built with -g, change the following line:",
"",
"        CFLAGS = -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer",
"",
"     to:",
"",
"        CFLAGS = -g -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer",
"",
"     For 2.4 kernels that are not built with -g, change the following line:",
"",
"        CFLAGS := $(CPPFLAGS) -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strict-aliasing",
"",
"     to:",
"",
"        CFLAGS := -g $(CPPFLAGS) -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strict-aliasing",
"",
"     For 2.6 and later kernels that are not built with -g, the kernel should",
"     be configured with CONFIG_DEBUG_INFO enabled, which in turn will add",
"     the -g flag to the CFLAGS setting in the kernel Makefile.",
" ",
"     After the kernel is re-compiled, the uncompressed \"vmlinux\" kernel",
"     that is created in the top-level kernel build directory must be saved.",
"",
"  To build the crash utility: ",
"",
README_ENTER_DIRECTORY,
"    $ make",
"",
"  To cross compile the crash utility for aarch64 on x86_64: ",
"    $ make CROSS_COMPILE=aarch64-linux-gnu- -j`nproc`",
"",
"  Supported arches for cross compilation: x86_64, x86, aarch64, s390x, powerpc64, alpha, sparc64, mips, riscv64",
"",
"  The initial build will take several minutes  because the embedded gdb module",
"  must be configured and built.  Alternatively, the crash source RPM file",
"  may be installed and built, and the resultant crash binary RPM file installed.",
"",
"  The crash binary can only be used on systems of the same architecture as",
"  the host build system.  There are a few optional manners of building the",
"  crash binary:",
"",
"  o  On an x86_64 host, a 32-bit x86 binary that can be used to analyze",
"     32-bit x86 dumpfiles may be built by typing \"make target=X86\".",
"  o  On an x86 or x86_64 host, a 32-bit x86 binary that can be used to analyze",
"     32-bit arm dumpfiles may be built by typing \"make target=ARM\".",
"  o  On an x86 or x86_64 host, a 32-bit x86 binary that can be used to analyze",
"     32-bit mips dumpfiles may be built by typing \"make target=MIPS\".",
"  o  On an ppc64 host, a 32-bit ppc binary that can be used to analyze",
"     32-bit ppc dumpfiles may be built by typing \"make target=PPC\".",
"  o  On an x86_64 host, an x86_64 binary that can be used to analyze",
"     arm64 dumpfiles may be built by typing \"make target=ARM64\".",
"  o  On an x86_64 host, an x86_64 binary that can be used to analyze",
"     ppc64le dumpfiles may be built by typing \"make target=PPC64\".",
"  o  On an x86_64 host, an x86_64 binary that can be used to analyze",
"     riscv64 dumpfiles may be built by typing \"make target=RISCV64\".",
"  o  On an x86_64 host, an x86_64 binary that can be used to analyze",
"     loongarch64 dumpfiles may be built by typing \"make target=LOONGARCH64\".",
"",
"  Traditionally when vmcores are compressed via the makedumpfile(8) facility",
"  the libz compression library is used, and by default the crash utility",
"  only supports libz.  Recently makedumpfile has been enhanced to optionally",
"  use the LZO, snappy or zstd compression libraries.  To build crash with any",
"  or all of those libraries, type \"make lzo\", \"make snappy\" or \"make zstd\".",
"",
"  crash supports valgrind Memcheck tool on the crash's custom memory allocator.",
"  To build crash with this feature enabled, type \"make valgrind\" and then run",
"  crash with valgrind as \"valgrind crash vmlinux vmcore\".",
"",
"  All of the alternate build commands above are \"sticky\" in that the",
"  special \"make\" targets only have to be entered one time; all subsequent",
"  builds will follow suit.",
"",
"  If the tool is run against a kernel dumpfile, two arguments are required, the",
"  uncompressed kernel name and the kernel dumpfile name.  ",
"",
"  If run on a live system, only the kernel name is required, because /dev/mem ",
"  will be used as the \"dumpfile\".  On Red Hat or Fedora kernels where the",
"  /dev/mem device is restricted, the /dev/crash memory driver will be used.",
"  If neither /dev/mem or /dev/crash are available, then /proc/kcore will be",
"  be used as the live memory source.  If /proc/kcore is also restricted, then",
"  the Red Hat /dev/crash driver may be compiled and installed; its source",
README_MEMORY_DRIVER,
"",
"  If the kernel file is stored in /boot, /, /boot/efi, or in any /usr/src",
"  or /usr/lib/debug/lib/modules subdirectory, then no command line arguments",
"  are required -- the first kernel found that matches /proc/version will be",
"  used as the namelist.",
"  ",
"  For example, invoking crash on a live system would look like this:",
"",
"    $ crash",
"    ",
README_CRASH_VERSION,
README_GPL_INFO,
README_GNU_GDB_VERSION,
"    Copyright 2013 Free Software Foundation, Inc.",
"    License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>",
"    This is free software: you are free to change and redistribute it.",
"    There is NO WARRANTY, to the extent permitted by law.  Type \"show copying\"",
"    and \"show warranty\" for details.",
"    This GDB was configured as \"i686-pc-linux-gnu\"...",
"     ",
"          KERNEL: /boot/vmlinux",
"        DUMPFILE: /dev/mem",
"            CPUS: 1",
README_DATE,
"          UPTIME: 10 days, 22:55:18",
"    LOAD AVERAGE: 0.08, 0.03, 0.01",
"           TASKS: 42",
"        NODENAME: ha2.mclinux.com",
"         RELEASE: 2.4.0-test10",
"         VERSION: #11 SMP Thu Nov 4 15:09:25 EST 2000",
"         MACHINE: i686  (447 MHz)",
"	  MEMORY: 128 MB",
"             PID: 3621                                  ",
"         COMMAND: \"crash\"",
"            TASK: c463c000  ",
"             CPU: 0",
"           STATE: TASK_RUNNING (ACTIVE)",
"",
"    crash> help",
README_HELP_MENU,
"    crash> ",
" ",
"  When run on a dumpfile, both the kernel namelist and dumpfile must be ",
"  entered on the command line.  For example, when run on a core dump created",
"  by the Red Hat netdump or diskdump facilities:",
"",
"    $ crash vmlinux vmcore",
" ",   
README_CRASH_VERSION,
README_GPL_INFO,
README_GNU_GDB_VERSION,
"    Copyright 2013 Free Software Foundation, Inc.",
"    License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>",
"    This is free software: you are free to change and redistribute it.",
"    There is NO WARRANTY, to the extent permitted by law.  Type \"show copying\"",
"    and \"show warranty\" for details.",
"    This GDB was configured as \"i686-pc-linux-gnu\"...",
"    ",
"          KERNEL: vmlinux",
"        DUMPFILE: vmcore",
"            CPUS: 4",
"            DATE: Tue Mar  2 13:57:09 2004",
"          UPTIME: 00:02:40",
"    LOAD AVERAGE: 2.24, 0.96, 0.37",
"           TASKS: 70",
"        NODENAME: pro1.lab.boston.redhat.com",
"         RELEASE: 2.6.3-2.1.214.11smp",
"         VERSION: #1 SMP Tue Mar 2 10:58:27 EST 2004",
"         MACHINE: i686  (2785 Mhz)",
"          MEMORY: 512 MB",
"           PANIC: \"Oops: 0002 [#1]\" (check log for details)",
"             PID: 0",
"         COMMAND: \"swapper\"",
"            TASK: 22fa200  (1 of 4)  [THREAD_INFO: 2356000]",
"             CPU: 0",
"           STATE: TASK_RUNNING (PANIC)",
"    ",
"    crash> ",
"",
"  The tool's environment is context-specific.  On a live system, the default",
"  context is the command itself; on a dump the default context will be the",
"  task that panicked.  The most commonly-used commands are:",
"",
"    set     - set a new task context by pid, task address, or cpu.",
"    bt      - backtrace of the current context, or as specified with arguments.",
"    p       - print the contents of a kernel variable.",
"    rd      - read memory, which may be either kernel virtual, user virtual, or",
"              physical.",
"    ps      - simple process listing.",
"    log     - dump the kernel log_buf.",
"    struct  - print the contents of a structure at a specified address.",
"    foreach - execute a command on all tasks, or those specified, in the system.",
" ",
"  Detailed help concerning the use of each of the commands in the menu above ",
"  may be displayed by entering \"help command\", where \"command\" is one of those ",
"  listed above.  Rather than getting bogged down in details here, simply",
"  run the help command on each of the commands above.  Note that many commands",
"  have multiple options so as to avoid the proliferation of command names.",
"",
"  Command output may be piped to external commands or redirected to files.",
"  Enter \"help output\" for details.",
"",
"  The command line history mechanism allows for command-line recall and ",
"  command-line editing.  Input files containing a set of crash commands may ",
"  be substituted for command-line input.  Enter \"help input\" for details.",
"",
"  Note that a .crashrc file (or .<your-command-name>rc if the name has been ",
"  changed), may contain any number of \"set\" or \"alias\" commands -- see the",
"  help pages on those two commands for details.",
" ",
"  Lastly, if a command is entered that is not recognized, it is checked",
"  against the kernel's list of variables, structure, union or typedef names, ",
"  and if found, the command is passed to \"p\", \"struct\", \"union\" or \"whatis\".",
"  That being the case, as long as a kernel variable/structure/union name is ",
"  different than any of the current commands.",
"",
"  (1) A kernel variable can be dumped by simply entering its name:",
" ",
"      crash> init_mm",
"      init_mm = $2 = {",
"        mmap = 0xc022d540, ",
"        mmap_avl = 0x0, ",
"        mmap_cache = 0x0, ",
"        pgd = 0xc0101000, ",
"        count = {",
"          counter = 0x6",
"        }, ",
"        map_count = 0x1, ",
"        mmap_sem = {",
"          count = {",
"            counter = 0x1",
"          }, ",
"          waking = 0x0, ",
"          wait = 0x0",
"        }, ",
"        context = 0x0, ",
"        start_code = 0xc0000000, ",
"        end_code = 0xc022b4c8,",
"        end_data = c0250388,",
"        ...",
"      ",
"  (2) A structure or can be dumped simply by entering its name and address:  ",
"",
"      crash> vm_area_struct c5ba3910",
"      struct vm_area_struct {",
"        vm_mm = 0xc3ae3210, ",
"        vm_start = 0x821b000, ",
"        vm_end = 0x8692000, ",
"        vm_next = 0xc5ba3890, ",
"        vm_page_prot = {",
"          pgprot = 0x25",
"        }, ",
"        vm_flags = 0x77, ",
"        vm_avl_height = 0x4, ",
"        vm_avl_left = 0xc0499540, ",
"        vm_avl_right = 0xc0499f40, ",
"        vm_next_share = 0xc04993c0, ",
"        vm_pprev_share = 0xc0499060, ",
"        vm_ops = 0x0, ",
"        vm_offset = 0x0, ",
"        vm_file = 0x0, ",
"        vm_pte = 0x0",
"      }",
"",
"",
"  The crash utility has been designed to facilitate the task of adding new ",
"  commands.  New commands may be permanently compiled into the crash executable,",
"  or dynamically added during runtime using shared object files.",
" ",
"  To permanently add a new command to the crash executable's menu:",
"",
"    1. For a command named \"xxx\", put a reference to cmd_xxx() in defs.h.",
"   ",
"    2. Add cmd_xxx into the base_command_table[] array in global_data.c. ",
"",
"    3. Write cmd_xxx(), putting it in one of the appropriate files.  Look at ",
"       the other commands for guidance on getting symbolic data, reading",
"       memory, displaying data, etc...",
"",
"    4. Recompile and run.",
"",
"  Note that while the initial compile of crash, which configures and compiles",
"  the gdb module, takes several minutes, subsequent re-compiles to do such",
"  things as add new commands or fix bugs just takes a few seconds.",
"",
"  Alternatively, you can create shared object library files consisting of",
"  crash command extensions, that can be dynamically linked into the crash",
"  executable during runtime or during initialization.  This will allow",
"  the same shared object to be used with subsequent crash releases without",
"  having to re-merge the command's code into each new set of crash sources.",
"  The dynamically linked-in commands will automatically show up in the crash",
"  help menu.  For details, enter \"help extend\" during runtime, or enter",
"  \"crash -h extend\" from the shell command line.",
" ",
"",
"",
"",
"",
	0
};
