toaruos/modules/debug_shell.c

/*
 * Kernel Debug Shell
 */
#include <system.h>
#include <fs.h>
#include <printf.h>
#include <logging.h>
#include <process.h>
#include <version.h>
#include <termios.h>
#include <tokenize.h>
#include <hashmap.h>
#include <pci.h>
#include <pipe.h>
#include <elf.h>
#include <module.h>

#include <mod/shell.h>

/*
 * This is basically the same as a userspace buffered/unbuffered
 * termio call. These are the same sorts of things I would use in
 * a text editor in userspace, but with the internal kernel calls
 * rather than system calls.
 */
static struct termios old;

static void set_unbuffered(fs_node_t * dev) {
	ioctl_fs(dev, TCGETS, &old);
	struct termios new = old;
	new.c_lflag &= (~ICANON & ~ECHO);
	ioctl_fs(dev, TCSETSF, &new);
}

static void set_buffered(fs_node_t * dev) {
	ioctl_fs(dev, TCSETSF, &old);
}

/*
 * Quick readline implementation.
 *
 * Most of these TODOs are things I've done already in older code:
 * TODO tabcompletion would be nice
 * TODO history is also nice
 */
int debug_shell_readline(fs_node_t * dev, char * linebuf, int max) {
	int read = 0;
	set_unbuffered(dev);
	while (read < max) {
		uint8_t buf[1];
		int r = read_fs(dev, 0, 1, (unsigned char *)buf);
		if (!r) {
			debug_print(WARNING, "Read nothing?");
			continue;
		}
		linebuf[read] = buf[0];
		if (buf[0] == '\n') {
			fprintf(dev, "\n");
			linebuf[read] = 0;
			break;
		} else if (buf[0] == 0x08) {
			if (read > 0) {
				fprintf(dev, "\010 \010");
				read--;
				linebuf[read] = 0;
			}
		} else if (buf[0] < ' ') {
			switch (buf[0]) {
				case 0x0C: /* ^L */
					/* Should reset display here */
					break;
				default:
					/* do nothing */
					break;
			}
		} else {
			fprintf(dev, "%c", buf[0]);
			read += r;
		}
	}
	set_buffered(dev);
	return read;
}

/*
 * Tasklet for running a userspace application.
 */
static void debug_shell_run_sh(void * data, char * name) {

	char * argv[] = {
		"/bin/sh",
		NULL
	};
	int argc = 0;
	while (argv[argc]) {
		argc++;
	}
	system(argv[0], argc, argv); /* Run shell */

	task_exit(42);
}

static hashmap_t * shell_commands_map = NULL;

/*
 * Shell commands
 */
static int shell_create_userspace_shell(fs_node_t * tty, int argc, char * argv[]) {
	int pid = create_kernel_tasklet(debug_shell_run_sh, "[[k-sh]]", NULL);
	fprintf(tty, "Shell started with pid = %d\n", pid);
	int status;
	waitpid(pid,&status,0);
	return status;
}

static int shell_echo(fs_node_t * tty, int argc, char * argv[]) {
	for (int i = 1; i < argc; ++i) {
		fprintf(tty, "%s ", argv[i]);
	}
	fprintf(tty, "\n");
	return 0;
}

static int dumb_strcmp(void * a, void *b) {
	return strcmp(a, b);
}

static void dumb_sort(void ** list, size_t length, int (*compare)(void*,void*)) {
	for (unsigned int i = 0; i < length-1; ++i) {
		for (unsigned int j = 0; j < length-1; ++j) {
			if (compare(list[j], list[j+1]) > 0) {
				void * t = list[j+1];
				list[j+1] = list[j];
				list[j] = t;
			}
		}
	}
}

static void print_spaces(fs_node_t * tty, int num_spaces) {
	for (int i = 0; i < num_spaces; ++i) {
		fprintf(tty, " ");
	}
}

static int shell_help(fs_node_t * tty, int argc, char * argv[]) {
	list_t * hash_keys = hashmap_keys(shell_commands_map);

	char ** keys = malloc(sizeof(char *) * hash_keys->length);

	unsigned int i = 0;
	unsigned int max_width = 0;

	foreach(_key, hash_keys) {
		char * key = (char *)_key->value;
		keys[i] = key;
		i++;
		if (strlen(key) > max_width) {
			max_width = strlen(key);
		}
	}

	dumb_sort((void **)keys, hash_keys->length, &dumb_strcmp);

	for (i = 0; i < hash_keys->length; ++i) {
		struct shell_command * c = hashmap_get(shell_commands_map, keys[i]);
		fprintf(tty, "\033[1;32m%s\033[0m ", c->name);
		print_spaces(tty, max_width- strlen(c->name));
		fprintf(tty, "- %s\n", c->description);
	}

	free(keys);
	list_free(hash_keys);
	free(hash_keys);

	return 0;
}

static int shell_cd(fs_node_t * tty, int argc, char * argv[]) {
	if (argc < 2) {
		return -1;
	}
	char * newdir = argv[1];
	char * path = canonicalize_path(current_process->wd_name, newdir);
	fs_node_t * chd = kopen(path, 0);
	if (chd) {
		if ((chd->flags & FS_DIRECTORY) == 0) {
			return -1;
		}
		free(current_process->wd_name);
		current_process->wd_name = malloc(strlen(path) + 1);
		memcpy(current_process->wd_name, path, strlen(path) + 1);
		return 0;
	} else {
		return -1;
	}
}

static int shell_ls(fs_node_t * tty, int argc, char * argv[]) {
	/* Okay, we're going to take the working directory... */
	fs_node_t * wd = kopen(current_process->wd_name, 0);
	uint32_t index = 0;
	struct dirent * kentry = readdir_fs(wd, index);
	while (kentry) {
		fprintf(tty, "%s\n", kentry->name);
		free(kentry);

		index++;
		kentry = readdir_fs(wd, index);
	}
	close_fs(wd);
	free(wd);
	return 0;
}

static int shell_log(fs_node_t * tty, int argc, char * argv[]) {
	if (argc < 2) {
		fprintf(tty, "Log level is currently %d.\n", debug_level);
		fprintf(tty, "Serial logging is %s.\n", !!debug_file ? "enabled" : "disabled");
		fprintf(tty, "Usage: log [on|off] [<level>]\n");
	} else {
		if (!strcmp(argv[1], "on")) {
			debug_file = tty;
			if (argc > 2) {
				debug_level = atoi(argv[2]);
			}
		} else if (!strcmp(argv[1], "off")) {
			debug_file = NULL;
		}
	}
	return 0;
}

static void scan_hit_list(uint32_t device, uint16_t vendorid, uint16_t deviceid, void * extra) {

	fs_node_t * tty = extra;

	fprintf(tty, "%2x:%2x.%d (%4x, %4x:%4x) %s %s\n",
			(int)pci_extract_bus(device),
			(int)pci_extract_slot(device),
			(int)pci_extract_func(device),
			(int)pci_find_type(device),
			vendorid,
			deviceid,
			pci_vendor_lookup(vendorid),
			pci_device_lookup(vendorid,deviceid));

	fprintf(tty, " BAR0: 0x%8x\n", pci_read_field(device, PCI_BAR0, 4));
	fprintf(tty, " BAR1: 0x%8x\n", pci_read_field(device, PCI_BAR1, 4));
	fprintf(tty, " BAR2: 0x%8x\n", pci_read_field(device, PCI_BAR2, 4));
	fprintf(tty, " BAR3: 0x%8x\n", pci_read_field(device, PCI_BAR3, 4));
	fprintf(tty, " BAR4: 0x%8x\n", pci_read_field(device, PCI_BAR4, 4));
	fprintf(tty, " BAR6: 0x%8x\n", pci_read_field(device, PCI_BAR5, 4));

}

static int shell_pci(fs_node_t * tty, int argc, char * argv[]) {
	pci_scan(&scan_hit_list, -1, tty);
	return 0;
}

static int shell_uid(fs_node_t * tty, int argc, char * argv[]) {
	if (argc < 2) {
		fprintf(tty, "uid=%d\n", current_process->user);
	} else {
		current_process->user = atoi(argv[1]);
	}
	return 0;
}

char * special_thing = "I am a string from the kernel.\n";

static int shell_mod(fs_node_t * tty, int argc, char * argv[]) {
	if (argc < 2) {
		fprintf(tty, "expected argument\n");
		return 1;
	}
	fs_node_t * file = kopen(argv[1], 0);
	if (!file) {
		fprintf(tty, "Failed to load module: %s\n", argv[1]);
		return 1;
	}

	fprintf(tty, "Okay, going to load a module!\n");
	module_data_t * mod_info = module_load(argv[1]);
	if (!mod_info) {
		fprintf(tty, "Something went wrong, failed to load module: %s\n", argv[1]);
		return 1;
	}

	fprintf(tty, "Loaded %s at 0x%x\n", mod_info->mod_info->name, mod_info->bin_data);

	return 0;
}

static int shell_symbols(fs_node_t * tty, int argc, char * argv[]) {
	extern char kernel_symbols_start[];
	extern char kernel_symbols_end[];

	struct ksym {
		uintptr_t addr;
		char name[];
	} * k = (void*)&kernel_symbols_start;

	while ((uintptr_t)k < (uintptr_t)&kernel_symbols_end) {
		fprintf(tty, "0x%x - %s\n", k->addr, k->name);
		k = (void *)((uintptr_t)k + sizeof(uintptr_t) + strlen(k->name) + 1);
	}

	return 0;
}

static int shell_print(fs_node_t * tty, int argc, char * argv[]) {

	if (argc < 3) {
		fprintf(tty, "print format_string symbol_name\n");
		return 1;
	}

	char * format = argv[1];
	char * symbol = argv[2];
	int deref = 0;

	if (symbol[0] == '*') {
		symbol = &symbol[1];
		deref = 1;
	}

	extern char kernel_symbols_start[];
	extern char kernel_symbols_end[];

	struct ksym {
		uintptr_t addr;
		char name[];
	} * k = (void*)&kernel_symbols_start;

	while ((uintptr_t)k < (uintptr_t)&kernel_symbols_end) {
		if (!strcmp(symbol, k->name)) {
			if (deref) {
				fprintf(tty, format, k->addr);
			} else {
				fprintf(tty, format, *((uintptr_t *)k->addr));
			}
			fprintf(tty, "\n");
			break;
		}
		k = (void *)((uintptr_t)k + sizeof(uintptr_t) + strlen(k->name) + 1);
	}

	return 0;
}

static int shell_modules(fs_node_t * tty, int argc, char * argv[]) {
	list_t * hash_keys = hashmap_keys(modules_get_list());
	foreach(_key, hash_keys) {
		char * key = (char *)_key->value;
		module_data_t * mod_info = hashmap_get(modules_get_list(), key);

		fprintf(tty, "0x%x {.init=0x%x, .fini=0x%x} %s",
				mod_info->bin_data,
				mod_info->mod_info->initialize,
				mod_info->mod_info->finalize,
				mod_info->mod_info->name);

		if (mod_info->deps) {
			unsigned int i = 0;
			fprintf(tty, " Deps: ");
			while (i < mod_info->deps_length) {
				fprintf(tty, "%s ", &mod_info->deps[i]);
				i += strlen(&mod_info->deps[i]) + 1;
			}
		}

		fprintf(tty, "\n");
	}

	return 0;
}

/*
 * Determine the size of a smart terminal that we don't have direct
 * termios access to. This is done by sending a cursor-move command
 * that will put the cursor into the lower right corner and then
 * requesting the cursor position report. We then read and parse
 * the position report. In the case where the terminal on the other
 * end is actually dumb, we end up waiting for some input and
 * then timing out.
 * TODO with asyncio support, the timeout should actually work.
 *      consider also using an alarm (which I also don't have)
 */
static void divine_size(fs_node_t * dev, int * width, int * height) {
	char tmp[100];
	int read = 0;
	unsigned long start_tick = timer_ticks;
	memset(tmp, 0, sizeof(tmp));
	/* Move cursor, Request position, Reset cursor */
	set_unbuffered(dev);
	fprintf(dev, "\033[1000;1000H\033[6n\033[H");
	while (1) {
		char buf[1];
		int r = read_fs(dev, 0, 1, (unsigned char *)buf);
		if (r > 0) {
			if (buf[0] != 'R') {
				if (read > 1) {
					tmp[read-2] = buf[0];
				}
				read++;
			} else {
				break;
			}
		}
		if (timer_ticks - start_tick >= 2) {
			/*
			 * We've timed out. This will only be triggered
			 * when we eventually receive something, though
			 */
			*width  = 80;
			*height = 23;
			/* Clear and return */
			fprintf(dev, "\033[J");
			return;
		}
	}
	/* Clear */
	fprintf(dev, "\033[J");
	/* Break up the result into two strings */

	for (unsigned int i = 0; i < strlen(tmp); i++) {
		if (tmp[i] == ';') {
			tmp[i] = '\0';
			break;
		}
	}
	char * h = (char *)((uintptr_t)tmp + strlen(tmp)+1);
	/* And then parse it into numbers */
	*height = atoi(tmp);
	*width  = atoi(h);
}

static int shell_divinesize(fs_node_t * tty, int argc, char * argv[]) {
	struct winsize size = {0,0,0,0};

	/* Attempt to divine the terminal size. Changing the window size after this will do bad things */
	int width, height;
	divine_size(tty, &width, &height);

	fprintf(tty, "Identified size: %d x %d\n", width, height);

	size.ws_row = height;
	size.ws_col = width;

	ioctl_fs(tty, TIOCSWINSZ, &size);

	return 0;
}

static int shell_exit(fs_node_t * tty, int argc, char * argv[]) {
	kexit(0);
	return 0;
}

static struct shell_command shell_commands[] = {
	{"shell", &shell_create_userspace_shell,
		"Runs a userspace shell on this tty."},
	{"echo",  &shell_echo,
		"Prints arguments."},
	{"help",  &shell_help,
		"Prints a list of possible shell commands and their descriptions."},
	{"cd",    &shell_cd,
		"Change current directory."},
	{"ls",    &shell_ls,
		"List files in current or other directory."},
	{"log", &shell_log,
		"Configure serial debug logging."},
	{"pci", &shell_pci,
		"Print PCI devices, as well as their names and BARs."},
	{"uid", &shell_uid,
		"Change the effective user id of the shell."},
	{"mod", &shell_mod,
		"[testing] Module loading."},
	{"symbols", &shell_symbols,
		"Dump symbol table."},
	{"print", &shell_print,
		"[dangerous] Print the value of a symbol using a format string."},
	{"modules", &shell_modules,
		"Print names and addresses of all loaded modules."},
	{"divine-size", &shell_divinesize,
		"Attempt to discover TTY size of serial."},
	{"exit", &shell_exit,
		"Quit the shell."},
	{NULL, NULL, NULL}
};

void debug_shell_install(struct shell_command * sh) {
	hashmap_set(shell_commands_map, sh->name, sh);
}

/*
 * A TTY object to pass to the tasklets for handling
 * serial-tty interaction. This probably shouldn't
 * be done as tasklets - TTYs should just be able
 * to wrap existing fs_nodes themselves, but that's
 * a problem for another day.
 */
struct tty_o {
	fs_node_t * node;
	fs_node_t * tty;
};

/*
 * These tasklets handle tty-serial interaction.
 */
static void debug_shell_handle_in(void * data, char * name) {
	struct tty_o * tty = (struct tty_o *)data;
	while (1) {
		uint8_t buf[1];
		int r = read_fs(tty->tty, 0, 1, (unsigned char *)buf);
		write_fs(tty->node, 0, r, buf);
	}
}

static void debug_shell_handle_out(void * data, char * name) {
	struct tty_o * tty = (struct tty_o *)data;
	while (1) {
		uint8_t buf[1];
		int r = read_fs(tty->node, 0, 1, (unsigned char *)buf);
		write_fs(tty->tty, 0, r, buf);
	}
}

static void debug_shell_actual(void * data, char * name) {

	fs_node_t * tty = (fs_node_t *)data;

	/* Our prompt will include the version number of the current kernel */
	char version_number[1024];
	sprintf(version_number, __kernel_version_format,
			__kernel_version_major,
			__kernel_version_minor,
			__kernel_version_lower,
			__kernel_version_suffix);

	/* Initialize the shell commands map */
	int retval = 0;

	while (1) {
		char command[512];

		/* Print out the prompt */
		if (retval) {
			fprintf(tty, "\033[1;34m%s-%s \033[1;31m%d\033[1;34m %s#\033[0m ", __kernel_name, version_number, retval, current_process->wd_name);
		} else {
			fprintf(tty, "\033[1;34m%s-%s %s#\033[0m ", __kernel_name, version_number, current_process->wd_name);
		}

		/* Read a line */
		debug_shell_readline(tty, command, 511);

		char * arg = strdup(command);
		char * argv[1024];  /* Command tokens (space-separated elements) */
		int argc = tokenize(arg, " ", argv);

		if (!argc) continue;

		/* Parse the command string */
		struct shell_command * sh = hashmap_get(shell_commands_map, argv[0]);
		if (sh) {
			retval = sh->function(tty, argc, argv);
		} else {
			fprintf(tty, "Unrecognized command: %s\n", argv[0]);
		}

		free(arg);
	}

}

/*
 * Tasklet for managing the kernel serial console.
 * This is basically a very simple shell, with access
 * to some internal kernel commands, and (eventually)
 * debugging routines.
 */
static void debug_shell_run(void * data, char * name) {
	/*
	 * We will run on the first serial port.
	 * TODO detect that this failed
	 */
	fs_node_t * tty = kopen("/dev/ttyS0", 0);

	fs_node_t * fs_master;
	fs_node_t * fs_slave;

	pty_create(NULL, &fs_master, &fs_slave);

	/* Attach the serial to the TTY interface */
	struct tty_o _tty = {.node = fs_master, .tty = tty};

	create_kernel_tasklet(debug_shell_handle_in,  "[kttydebug-in]",  (void *)&_tty);
	create_kernel_tasklet(debug_shell_handle_out, "[kttydebug-out]", (void *)&_tty);

	/* Set the device to be the actual TTY slave */
	tty = fs_slave;

	current_process->fds->entries[0] = tty;
	current_process->fds->entries[1] = tty;
	current_process->fds->entries[2] = tty;
	current_process->fds->length = 3;

	debug_shell_actual(tty, name);
}

int debug_shell_start(void) {
	/* Setup shell commands */
	shell_commands_map = hashmap_create(10);
	struct shell_command * sh = &shell_commands[0];
	while (sh->name) {
		hashmap_set(shell_commands_map, sh->name, sh);
		sh++;
	}

	debug_hook = debug_shell_actual;

	int i = create_kernel_tasklet(debug_shell_run, "[kttydebug]", NULL);
	debug_print(NOTICE, "Started tasklet with pid=%d", i);

	return 0;
}

int debug_shell_stop(void) {
	debug_print(NOTICE, "Tried to unload debug shell, but debug shell has no real shutdown routine. Don't do that!");
	return 0;
}

MODULE_DEF(debugshell, debug_shell_start, debug_shell_stop);
MODULE_DEPENDS(serial);