/* main.c - core analysis suite

 *

 * Copyright (C) 1999, 2000, 2001, 2002 Mission Critical Linux, Inc.

 * Copyright (C) 2002-2019 David Anderson

 * Copyright (C) 2002-2019 Red Hat, Inc. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */

#include "defs.h"

#include "xen_hyper_defs.h"

#include <curses.h>

#include <getopt.h>

#include <sys/prctl.h>

static void setup_environment(int, char **);

static int is_external_command(void);

static int is_builtin_command(void);

static int is_input_file(void);

static void check_xen_hyper(void);

static void show_untrusted_files(void);

static void get_osrelease(char *);

static void get_log(char *);

static struct option long_options[] = {

        {"memory_module", required_argument, 0, 0},

        {"memory_device", required_argument, 0, 0},

        {"no_kallsyms", 0, 0, 0},

        {"no_modules", 0, 0, 0},

        {"help", optional_argument, 0, 'h'},

	{"no_data_debug", 0, 0, 0},

	{"no_crashrc", 0, 0, 0},

	{"no_kmem_cache", 0, 0, 0},

	{"kmem_cache_delay", 0, 0, 0},

	{"readnow", 0, 0, 0},

	{"smp", 0, 0, 0},

	{"machdep", required_argument, 0, 0},

	{"version", 0, 0, 0},

	{"buildinfo", 0, 0, 0},

        {"cpus", required_argument, 0, 0},

        {"no_ikconfig", 0, 0, 0},

        {"hyper", 0, 0, 0},

	{"p2m_mfn", required_argument, 0, 0},

	{"xen_phys_start", required_argument, 0, 0},

	{"zero_excluded", 0, 0, 0},

	{"no_panic", 0, 0, 0},

        {"more", 0, 0, 0},

        {"less", 0, 0, 0},

        {"CRASHPAGER", 0, 0, 0},

        {"no_scroll", 0, 0, 0},

        {"reloc", required_argument, 0, 0},

	{"kaslr", required_argument, 0, 0},

	{"active", 0, 0, 0},

	{"minimal", 0, 0, 0},

	{"mod", required_argument, 0, 0},

	{"kvmhost", required_argument, 0, 0},

	{"kvmio", required_argument, 0, 0},

	{"no_elf_notes", 0, 0, 0},

	{"osrelease", required_argument, 0, 0},

	{"log", required_argument, 0, 0},

	{"hex", 0, 0, 0},

	{"dec", 0, 0, 0},

	{"no_strip", 0, 0, 0},

	{"hash", required_argument, 0, 0},

	{"offline", required_argument, 0, 0},

	{"src", required_argument, 0, 0},

        {0, 0, 0, 0}

};

int

main(int argc, char **argv)

{

	int i, c, option_index;

	char *tmpname;

	setup_environment(argc, argv);

	/* 

	 *  Get and verify command line options.

	 */

	opterr = 0;

	optind = 0;

	while((c = getopt_long(argc, argv, "Lkgh::e:i:sSvc:d:tfp:m:xo:",

       		long_options, &option_index)) != -1) {

		switch (c)

		{

		case 0:

		        if (STREQ(long_options[option_index].name, 

			    "memory_module")) 

				pc->memory_module = optarg;

		        else if (STREQ(long_options[option_index].name, 

			    "memory_device")) 

				pc->memory_device = optarg;

		        else if (STREQ(long_options[option_index].name, 

			    "no_kallsyms")) 

				kt->flags |= NO_KALLSYMS;

		        else if (STREQ(long_options[option_index].name, 

			    "no_modules")) 

				kt->flags |= NO_MODULE_ACCESS;

		        else if (STREQ(long_options[option_index].name, 

			    "no_ikconfig")) 

				kt->flags |= NO_IKCONFIG;

		        else if (STREQ(long_options[option_index].name, 

			    "no_data_debug")) 

				pc->flags &= ~DATADEBUG;

		        else if (STREQ(long_options[option_index].name, 

			    "no_kmem_cache")) 

				vt->flags |= KMEM_CACHE_UNAVAIL;

		        else if (STREQ(long_options[option_index].name, 

			    "kmem_cache_delay")) 

				vt->flags |= KMEM_CACHE_DELAY;

		        else if (STREQ(long_options[option_index].name, 

			    "readnow")) 

				pc->flags |= READNOW;

		        else if (STREQ(long_options[option_index].name, 

			    "smp")) 

				kt->flags |= SMP;

		        else if (STREQ(long_options[option_index].name, 

			    "machdep")) {

				for (i = 0; i < MAX_MACHDEP_ARGS; i++) {

					if (machdep->cmdline_args[i])

						continue;

					machdep->cmdline_args[i] = optarg;

					break;

				}

				if (i == MAX_MACHDEP_ARGS)

					error(INFO, "option ignored: %s\n",

						optarg);

			}

		        else if (STREQ(long_options[option_index].name, 

			    "version")) { 

				pc->flags |= VERSION_QUERY;

                        	display_version();

                        	display_gdb_banner();

                        	clean_exit(0);

			}

		        else if (STREQ(long_options[option_index].name, 

			    "buildinfo")) {

				dump_build_data();

				clean_exit(0);

			}

		        else if (STREQ(long_options[option_index].name, "cpus")) 

				kt->cpus_override = optarg;

			else if (STREQ(long_options[option_index].name, "hyper"))

				pc->flags |= XEN_HYPER;

		        else if (STREQ(long_options[option_index].name, "p2m_mfn")) 

				xen_kdump_p2m_mfn(optarg);

		        else if (STREQ(long_options[option_index].name, "xen_phys_start")) 

				set_xen_phys_start(optarg);

		        else if (STREQ(long_options[option_index].name, "zero_excluded")) 

				*diskdump_flags |= ZERO_EXCLUDED;

			else if (STREQ(long_options[option_index].name, "no_elf_notes")) {

				if (machine_type("X86") || machine_type("X86_64"))

					*diskdump_flags |= NO_ELF_NOTES;

				else

					error(INFO,

					      "--no_elf_notes is only applicable to "

					      "the X86 and X86_64 architectures.\n");

			}

		        else if (STREQ(long_options[option_index].name, "no_panic")) 

				tt->flags |= PANIC_TASK_NOT_FOUND;

		        else if (STREQ(long_options[option_index].name, "no_strip")) 

				st->flags |= NO_STRIP;

		        else if (STREQ(long_options[option_index].name, "more")) {

				if ((pc->scroll_command != SCROLL_NONE) &&

				    file_exists("/bin/more", NULL))

					pc->scroll_command = SCROLL_MORE;

			}

		        else if (STREQ(long_options[option_index].name, "less")) {

				if ((pc->scroll_command != SCROLL_NONE) &&

				    file_exists("/usr/bin/less", NULL))

					pc->scroll_command = SCROLL_LESS;

			}

		        else if (STREQ(long_options[option_index].name, "CRASHPAGER")) {

				if ((pc->scroll_command != SCROLL_NONE) && 

				    CRASHPAGER_valid())

					pc->scroll_command = SCROLL_CRASHPAGER;

			}

		        else if (STREQ(long_options[option_index].name, "no_scroll"))

				 pc->flags &= ~SCROLL;

		        else if (STREQ(long_options[option_index].name, "no_crashrc"))

				pc->flags |= NOCRASHRC;

		        else if (STREQ(long_options[option_index].name, "active"))

				tt->flags |= ACTIVE_ONLY;

		        else if (STREQ(long_options[option_index].name, "mod"))

				kt->module_tree = optarg;

		        else if (STREQ(long_options[option_index].name, "hash")) {

				if (!calculate(optarg, &pc->nr_hash_queues, NULL, 0)) {

					error(INFO, "invalid --hash argument: %s\n",

						optarg);

				}

			} else if (STREQ(long_options[option_index].name, "kaslr")) {

				if (!machine_type("X86_64") &&

				    !machine_type("ARM64") && !machine_type("X86") &&

				    !machine_type("S390X"))

					error(INFO, "--kaslr not valid "

						"with this machine type.\n");

				else if (STREQ(optarg, "auto"))

					kt->flags2 |= (RELOC_AUTO|KASLR);

				else {

					if (!calculate(optarg, &kt->relocate,

							NULL, 0)) {

						error(INFO,

						    "invalid --kaslr argument: %s\n",

						    optarg);

						program_usage(SHORT_FORM);

					}

					kt->relocate *= -1;

					kt->flags |= RELOC_SET;

					kt->flags2 |= KASLR;

				}

			} else if (STREQ(long_options[option_index].name, "reloc")) {

				if (!calculate(optarg, &kt->relocate, NULL, 0)) {

					error(INFO, "invalid --reloc argument: %s\n",

						optarg);

					program_usage(SHORT_FORM);

				}

				kt->flags |= RELOC_SET;

			}

			else if (STREQ(long_options[option_index].name, "minimal")) 

				pc->flags |= MINIMAL_MODE;

		        else if (STREQ(long_options[option_index].name, "kvmhost"))

				set_kvmhost_type(optarg);

		        else if (STREQ(long_options[option_index].name, "kvmio"))

				set_kvm_iohole(optarg);

		        else if (STREQ(long_options[option_index].name, "osrelease")) {

				pc->flags2 |= GET_OSRELEASE;

				get_osrelease(optarg);

			}

		        else if (STREQ(long_options[option_index].name, "log")) {

				pc->flags2 |= GET_LOG;

				get_log(optarg);

			}

			else if (STREQ(long_options[option_index].name, "hex")) {

				pc->flags2 |= RADIX_OVERRIDE;

				pc->output_radix = 16;

			}

			else if (STREQ(long_options[option_index].name, "dec")) {

				pc->flags2 |= RADIX_OVERRIDE;

				pc->output_radix = 10;

			}

			else if (STREQ(long_options[option_index].name, "offline")) {

				if (STREQ(optarg, "show"))

					pc->flags2 &= ~OFFLINE_HIDE;

				else if (STREQ(optarg, "hide"))

					pc->flags2 |= OFFLINE_HIDE;

				else {

					error(INFO, "invalid --offline argument: %s\n", optarg);

					program_usage(SHORT_FORM);

				}

			}

			else if (STREQ(long_options[option_index].name, "src"))

				kt->source_tree = optarg;

			else {

				error(INFO, "internal error: option %s unhandled\n",

					long_options[option_index].name);

				program_usage(SHORT_FORM);

			}

			break;

		case 'f':

			st->flags |= FORCE_DEBUGINFO;

			break;

		case 'g':

			pc->flags |= KERNEL_DEBUG_QUERY;

			break;

		case 'h':

			/* note: long_getopt's handling of optional arguments is weak.

			 * To it, an optional argument must be part of the same argument

			 * as the flag itself (eg. --help=commands or -hcommands).

			 * We want to accept "--help commands" or "-h commands".

			 * So we must do that part ourselves.

			 */

			if (optarg != NULL)

				cmd_usage(optarg, COMPLETE_HELP|PIPE_TO_SCROLL|MUST_HELP);

			else if (argv[optind] != NULL && argv[optind][0] != '-')

				cmd_usage(argv[optind++], COMPLETE_HELP|PIPE_TO_SCROLL|MUST_HELP);

			else

				program_usage(LONG_FORM);

			clean_exit(0);

		case 'k':

			pc->flags |= KERNTYPES;

			break;

		case 'e':

			if (STREQ(optarg, "vi"))

				pc->editing_mode = "vi";

			else if (STREQ(optarg, "emacs"))

				pc->editing_mode = "emacs";

			else

				fprintf(fp, "invalid edit mode: %s\n", optarg);	

			break;

		case 't':

			kt->flags2 |= GET_TIMESTAMP;

			break;

		case 'i':

			pc->input_file = optarg;

			pc->flags |= CMDLINE_IFILE;

			break;

		case 'v':

			pc->flags |= VERSION_QUERY;

			display_version();

			display_gdb_banner();

			clean_exit(0);

		case 's':

			pc->flags |= SILENT;

			pc->flags &= ~SCROLL;

//   			pc->scroll_command = SCROLL_NONE;   (why?)

			break;

		case 'L':

			if (mlockall(MCL_CURRENT|MCL_FUTURE) == -1)

				perror("mlockall");

			break;

		case 'S':

			if (is_system_map("/boot/System.map")) {

                                pc->system_map = "/boot/System.map";

                                pc->flags |= (SYSMAP|SYSMAP_ARG);

			}

			break;	

		case 'c':

			create_console_device(optarg);

			break;

		case 'd': 

			pc->debug = atol(optarg);

			set_lkcd_debug(pc->debug);

			set_vas_debug(pc->debug);

			break;

		case 'p':

			force_page_size(optarg);

			break;

		case 'm':

			for (i = 0; i < MAX_MACHDEP_ARGS; i++) {

				if (machdep->cmdline_args[i])

					continue;

				machdep->cmdline_args[i] = optarg;

				break;

			}

			if (i == MAX_MACHDEP_ARGS)

				error(INFO, "option ignored: %s\n",

					optarg);

			break;

		case 'x':

			pc->flags |= PRELOAD_EXTENSIONS;

			break;

		case 'o':

			ramdump_elf_output_file(optarg);

			break;

		default:

			error(INFO, "invalid option: %s\n",

				argv[optind-1]);

			program_usage(SHORT_FORM);

		}

	}

	opterr = 1;

	display_version();

	/*

	 *  Take the kernel and dumpfile arguments in either order.

	 */

	while (argv[optind]) {

		if (is_ramdump(argv[optind])) {

			if (pc->flags & MEMORY_SOURCES) {

				error(INFO,

					"too many dumpfile arguments\n");

					program_usage(SHORT_FORM);

			}

			if (ACTIVE()) {

				pc->flags |= LIVE_RAMDUMP;

				pc->readmem = read_ramdump;

				pc->writemem = NULL;

				optind++;

				continue;

			}

			pc->dumpfile = ramdump_to_elf();

			if (is_kdump(pc->dumpfile, KDUMP_LOCAL)) {

				pc->flags |= KDUMP;

				if (is_ramdump_image())

					pc->readmem = read_ramdump;

				else

					pc->readmem = read_kdump;

				pc->writemem = NULL;

			} else {

				error(INFO, "malformed ELF file: %s\n",

					pc->dumpfile);

				program_usage(SHORT_FORM);

			}

			optind++;

			continue;

		}

		if (is_remote_daemon(argv[optind])) {

                	if (pc->flags & DUMPFILE_TYPES) {

				error(INFO, 

				      "too many dumpfile/memory arguments\n");

				program_usage(SHORT_FORM);

			}

			pc->flags2 |= REMOTE_DAEMON;

			optind++;

			continue;

		}

		if (STREQ(argv[optind], "/dev/crash")) {

			pc->memory_device = argv[optind];

			optind++;

			continue;

		}

		if (!file_exists(argv[optind], NULL)) {

			error(INFO, "%s: %s\n", argv[optind], strerror(ENOENT));

			program_usage(SHORT_FORM);

		} else if (is_directory(argv[optind])) {

			error(INFO, "%s: not a supported file format\n", 

				argv[optind]);

			program_usage(SHORT_FORM);

		} else if (!is_readable(argv[optind])) 

			program_usage(SHORT_FORM);

		if (is_kernel(argv[optind])) {

			if (pc->namelist || pc->server_namelist) {

				if (!select_namelist(argv[optind])) {

                               		error(INFO, 

					    "too many namelist arguments\n");

                               		program_usage(SHORT_FORM);

				}

			} else

				pc->namelist = argv[optind];

		} else if (is_compressed_kernel(argv[optind], &tmpname)) {

			if (pc->namelist) {

				if (!select_namelist(tmpname)) {

					error(INFO, 

					    "too many namelist arguments\n");

					program_usage(SHORT_FORM);

				}

				if (pc->namelist_debug == tmpname) {

					pc->namelist_debug_orig = argv[optind];

				} else {

					pc->namelist_debug_orig = pc->namelist_orig;

					pc->namelist_orig = argv[optind];

				}

			} else {

				pc->namelist = tmpname;

				pc->namelist_orig = argv[optind];

			}

			pc->cleanup = NULL;

		} else if (!(pc->flags & KERNEL_DEBUG_QUERY)) {

			if (is_flattened_format(argv[optind]))

				pc->flags2 |= FLAT;

			if (STREQ(argv[optind], "/dev/mem")) {

                        	if (pc->flags & MEMORY_SOURCES) {

                                	error(INFO, 

                                            "too many dumpfile arguments\n");

                                	program_usage(SHORT_FORM);

                        	}

				pc->flags |= DEVMEM;

				pc->dumpfile = NULL;

				pc->readmem = read_dev_mem;

				pc->writemem = write_dev_mem;

				pc->live_memsrc = argv[optind];

			} else if (is_proc_kcore(argv[optind], KCORE_LOCAL)) {

				if (pc->flags & MEMORY_SOURCES) {

					error(INFO, 

					    "too many dumpfile arguments\n");

					program_usage(SHORT_FORM);

				}

				pc->flags |= PROC_KCORE;

				pc->dumpfile = NULL;

				pc->readmem = read_proc_kcore;

				pc->writemem = write_proc_kcore;

				pc->live_memsrc = argv[optind];

			} else if (is_netdump(argv[optind], NETDUMP_LOCAL)) {

                                if (pc->flags & MEMORY_SOURCES) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

                                pc->flags |= NETDUMP;

                                pc->dumpfile = argv[optind];

				if (is_sadump_xen()) {

					pc->readmem = read_kdump;

					pc->writemem = write_kdump;

				} else {

					pc->readmem = read_netdump;

					pc->writemem = write_netdump;

				}

                        } else if (is_kdump(argv[optind], KDUMP_LOCAL)) {

                                if (pc->flags & MEMORY_SOURCES) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

                                pc->flags |= KDUMP;

                                pc->dumpfile = argv[optind];

                                pc->readmem = read_kdump;

                                pc->writemem = write_kdump;

                        } else if (is_kvmdump(argv[optind])) {

                                if (pc->flags & MEMORY_SOURCES) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

                                pc->flags |= KVMDUMP;

                                pc->dumpfile = argv[optind];

                                pc->readmem = read_kvmdump;

                                pc->writemem = write_kvmdump;

			} else if (is_kvmdump_mapfile(argv[optind])) {

				if (pc->kvmdump_mapfile) {

                                        error(INFO,

                                            "too many KVM map file arguments\n");

                                        program_usage(SHORT_FORM);

				}

				pc->kvmdump_mapfile = argv[optind];

                        } else if (is_xendump(argv[optind])) {

                                if (pc->flags & MEMORY_SOURCES) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

                                pc->flags |= XENDUMP;

                                pc->dumpfile = argv[optind];

                                pc->readmem = read_xendump;

                                pc->writemem = write_xendump;

                        } else if (is_system_map(argv[optind])) {

                                pc->system_map = argv[optind];

                                pc->flags |= (SYSMAP|SYSMAP_ARG);

			} else if (is_diskdump(argv[optind])) {

                                if ((pc->flags & MEMORY_SOURCES) &&

                                    (!dumpfile_is_split())) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

                                pc->flags |= DISKDUMP;

                                pc->dumpfile = argv[optind];

                                pc->readmem = read_diskdump;

                                pc->writemem = write_diskdump;

			} else if (is_lkcd_compressed_dump(argv[optind])) {

				if (pc->flags & MEMORY_SOURCES) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

                                pc->flags |= LKCD;

                                pc->dumpfile = argv[optind];

				pc->readmem = read_lkcd_dumpfile;

				pc->writemem = write_lkcd_dumpfile;

			} else if (is_mclx_compressed_dump(argv[optind])) {

				if (pc->flags & MEMORY_SOURCES) {

					error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

				pc->flags |= MCLXCD;

				pc->dumpfile = argv[optind];

				pc->readmem = read_mclx_dumpfile;

				pc->writemem = write_mclx_dumpfile;

                        } else if (is_s390_dump(argv[optind])) {

                                if (pc->flags & MEMORY_SOURCES) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

                                pc->flags |= S390D;

                                pc->dumpfile = argv[optind];

                                pc->readmem = read_s390_dumpfile;

                                pc->writemem = write_s390_dumpfile;

			} else if (is_sadump(argv[optind])) {

				if ((pc->flags & MEMORY_SOURCES) &&

				    !sadump_is_diskset()) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

				}

				pc->flags |= SADUMP;

				pc->dumpfile = argv[optind];

				pc->readmem = read_sadump;

				pc->writemem = write_sadump;

			} else if (is_vmware_vmss(argv[optind])) {

                                if (pc->flags & MEMORY_SOURCES) {

                                        error(INFO,

                                            "too many dumpfile arguments\n");

                                        program_usage(SHORT_FORM);

                                }

				pc->flags |= VMWARE_VMSS;

				pc->dumpfile = argv[optind];

				pc->readmem = read_vmware_vmss;

				pc->writemem = write_vmware_vmss;

			} else { 

				error(INFO, 

				    "%s: not a supported file format\n",

					argv[optind]);

				program_usage(SHORT_FORM);

			}

		}

		optind++;

	}

	check_xen_hyper();

        if (setjmp(pc->main_loop_env))

                clean_exit(1);

	/*

	 *  Initialize various subsystems.

	 */

	fd_init();

	buf_init();

        cmdline_init();

        mem_init();

       	hq_init();

	machdep_init(PRE_SYMTAB);

        symtab_init();

	paravirt_init();

	machdep_init(PRE_GDB);

        datatype_init();

	/*

	 *  gdb_main_loop() modifies "command_loop_hook" to point to the 

         *  main_loop() function below, and then calls gdb's main() function.

         *  After gdb initializes itself, it calls back to main_loop().

	 */

	gdb_main_loop(argc, argv);   

	clean_exit(0);

	exit(0); 

}

/*

 *  This routine is called from above, but also will be re-entered

 *  as part of gdb's SIGINT handling.  Since GDB_INIT and RUNTIME 

 *  will be set on re-entrancy, the initialization routines won't 

 *  be called.  This can be avoided by always making gdb ignore SIGINT.

 */

void

main_loop(void)

{

	if (pc->flags2 & ERASEINFO_DATA)

		error(WARNING, "\n%s:\n         "

		    "Kernel data has been erased from this dumpfile.  This may "

		    "cause\n         the crash session to fail entirely, may "

                    "cause commands to fail,\n         or may result in "

		    "unpredictable\n         runtime behavior.\n",

			pc->dumpfile);

	if (pc->flags2 & INCOMPLETE_DUMP) {

		error(WARNING, "\n%s:\n         "

		    "This dumpfile is incomplete.  This may cause the crash session"

		    "\n         to fail entirely, may cause commands to fail, or may"

		    " result in\n         unpredictable runtime behavior.\n",

			pc->dumpfile);

		if (!(*diskdump_flags & ZERO_EXCLUDED))

			fprintf(fp,

			    "   NOTE: This dumpfile may be analyzed with the --zero_excluded command\n"

			    "         line option, in which case any read requests from missing pages\n"

			    "         will return zero-filled memory.\n");

	}

	if (pc->flags2 & EXCLUDED_VMEMMAP) {

		error(WARNING, "\n%s:\n         "

		    "This dumpfile is incomplete because the page structures associated\n"

                    "         with excluded pages may also be excluded.  This may cause the crash\n"

		    "         session to fail entirely, may cause commands to fail (most notably\n"

		    "         the \"kmem\" command), or may result in unpredictable runtime behavior.\n",

			pc->dumpfile);

	}

        if (!(pc->flags & GDB_INIT)) {

		gdb_session_init();

		machdep_init(POST_RELOC);

		show_untrusted_files();

		kdump_backup_region_init();

		if (XEN_HYPER_MODE()) {

#ifdef XEN_HYPERVISOR_ARCH

			machdep_init(POST_GDB);

			xen_hyper_init();

			machdep_init(POST_INIT);

#else

        		error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);

#endif

		} else if (!(pc->flags & MINIMAL_MODE)) {

			read_in_kernel_config(IKCFG_INIT);

			kernel_init();

			machdep_init(POST_GDB);

        		vm_init();

			machdep_init(POST_VM);

        		module_init();

        		help_init();

        		task_init();

        		vfs_init();

			net_init();

			dev_init();

			machdep_init(POST_INIT);

		}

	} else

		SIGACTION(SIGINT, restart, &pc->sigaction, NULL);

        /*

         *  Display system statistics and current context.

         */

        if (!(pc->flags & SILENT) && !(pc->flags & RUNTIME)) {

		if (XEN_HYPER_MODE()) {

#ifdef XEN_HYPERVISOR_ARCH

			xen_hyper_display_sys_stats();

			xen_hyper_show_vcpu_context(XEN_HYPER_VCPU_LAST_CONTEXT());

                	fprintf(fp, "\n");

#else

        		error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);

#endif

		} else if (!(pc->flags & MINIMAL_MODE)) {

			display_sys_stats();

			show_context(CURRENT_CONTEXT());

                	fprintf(fp, "\n");

		}

        }

	if (pc->flags & MINIMAL_MODE)

            error(NOTE, 

		"minimal mode commands: log, dis, rd, sym, eval, set, extend and exit\n\n");

        pc->flags |= RUNTIME;

	if (pc->flags & PRELOAD_EXTENSIONS)

		preload_extensions();

	/*

	 *  Return here if a non-recoverable error occurs

	 *  during command execution.

	 */

	if (setjmp(pc->main_loop_env)) {

		;

	}

	/*

	 *  process_command_line() reads, parses and stores input command lines

	 *  in the global args[] array.  exec_command() figures out what to 

         *  do with the parsed line.

	 */

	while (TRUE) {

		process_command_line();

		exec_command();

	}

}

/*

 *  Most of the time args[0] simply contains the name string of a command

 *  found in the global command_table[].  Special consideration is done for 

 *  dealing with input files, "known" external commands, and built-in commands.

 *  If none of the above apply, the args[0] string is checked against the

 *  known list of structure, union and typedef names, and if found, passed

 *  on to cmd_struct(), cmd_union() or cmd_whatis().

 */

void

exec_command(void)

{

	struct command_table_entry *ct;

	struct args_input_file args_ifile;

        if (args[0] && (args[0][0] == '\\') && args[0][1]) {

		shift_string_left(args[0], 1);

                shift_string_left(pc->orig_line, 1);

		pc->curcmd_flags |= NO_MODIFY;

	}

reattempt:

	if (!args[0])

		return;

	optind = argerrs = 0;

	if ((ct = get_command_table_entry(args[0]))) {

                if (ct->flags & REFRESH_TASK_TABLE) {

			if (XEN_HYPER_MODE()) {

#ifdef XEN_HYPERVISOR_ARCH

				xen_hyper_refresh_domain_context_space();

				xen_hyper_refresh_vcpu_context_space();

#else

        			error(FATAL, XEN_HYPERVISOR_NOT_SUPPORTED);

#endif

			} else if (!(pc->flags & MINIMAL_MODE)) {

				tt->refresh_task_table();

				sort_context_array();

				sort_tgid_array();	

			}

		}

                if (!STREQ(pc->curcmd, pc->program_name))

                        pc->lastcmd = pc->curcmd;

                pc->curcmd = ct->name;

		pc->cmdgencur++;

		if (is_args_input_file(ct, &args_ifile))

			exec_args_input_file(ct, &args_ifile);

		else

			(*ct->func)();