X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=daemon%2Fdebug.c;h=bca6b9f6abcd7994a1505a97143537c8e1869c60;hp=25fe64f129e5d7cd821271b4972a9af19439e5b2;hb=aa96881a512a144f4611a8e7c9801be9bb7ff9cf;hpb=21dbad6b95d5355f622e74c9c9d8a547c04e6e00 diff --git a/daemon/debug.c b/daemon/debug.c index 25fe64f..bca6b9f 100644 --- a/daemon/debug.c +++ b/daemon/debug.c @@ -1,5 +1,5 @@ /* libguestfs - the guestfsd daemon - * Copyright (C) 2009 Red Hat Inc. + * Copyright (C) 2009 Red Hat Inc. * * 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 @@ -24,7 +24,9 @@ #include #include #include +#include #include +#include #include "../src/guestfs_protocol.h" #include "daemon.h" @@ -36,51 +38,58 @@ * to find out what you can do. * * Commands always output a freeform string. + * + * Since libguestfs 1.5.7, the debug command has been enabled + * by default for all builds (previously you had to enable it + * in configure). This command is not part of the stable ABI + * and may change at any time. */ -#if ENABLE_DEBUG_COMMAND struct cmd { const char *cmd; char * (*f) (const char *subcmd, int argc, char *const *const argv); }; static char *debug_help (const char *subcmd, int argc, char *const *const argv); +static char *debug_core_pattern (const char *subcmd, int argc, char *const *const argv); +static char *debug_env (const char *subcmd, int argc, char *const *const argv); static char *debug_fds (const char *subcmd, int argc, char *const *const argv); -static char *debug_mem (const char *subcmd, int argc, char *const *const argv); +static char *debug_ls (const char *subcmd, int argc, char *const *const argv); +static char *debug_ll (const char *subcmd, int argc, char *const *const argv); +static char *debug_progress (const char *subcmd, int argc, char *const *const argv); +static char *debug_segv (const char *subcmd, int argc, char *const *const argv); static char *debug_sh (const char *subcmd, int argc, char *const *const argv); static struct cmd cmds[] = { { "help", debug_help }, + { "core_pattern", debug_core_pattern }, + { "env", debug_env }, { "fds", debug_fds }, - { "mem", debug_mem }, + { "ls", debug_ls }, + { "ll", debug_ll }, + { "progress", debug_progress }, + { "segv", debug_segv }, { "sh", debug_sh }, { NULL, NULL } }; -#endif char * -do_debug (const char *subcmd, char *const *const argv) +do_debug (const char *subcmd, char *const *argv) { -#if ENABLE_DEBUG_COMMAND int argc, i; for (i = argc = 0; argv[i] != NULL; ++i) argc++; for (i = 0; cmds[i].cmd != NULL; ++i) { - if (strcasecmp (subcmd, cmds[i].cmd) == 0) + if (STRCASEEQ (subcmd, cmds[i].cmd)) return cmds[i].f (subcmd, argc, argv); } reply_with_error ("use 'debug help' to list the supported commands"); return NULL; -#else - reply_with_error ("guestfsd was not configured with --enable-debug-command"); - return NULL; -#endif } -#if ENABLE_DEBUG_COMMAND static char * debug_help (const char *subcmd, int argc, char *const *const argv) { @@ -116,20 +125,29 @@ static char * debug_fds (const char *subcmd, int argc, char *const *const argv) { int r; - char *out = NULL; + char *out; + size_t size; + FILE *fp; DIR *dir; struct dirent *d; char fname[256], link[256]; struct stat statbuf; + fp = open_memstream (&out, &size); + if (!fp) { + reply_with_perror ("open_memstream"); + return NULL; + } + dir = opendir ("/proc/self/fd"); if (!dir) { reply_with_perror ("opendir: /proc/self/fd"); + fclose (fp); return NULL; } while ((d = readdir (dir)) != NULL) { - if (strcmp (d->d_name, ".") == 0 || strcmp (d->d_name, "..") == 0) + if (STREQ (d->d_name, ".") || STREQ (d->d_name, "..")) continue; snprintf (fname, sizeof fname, "/proc/self/fd/%s", d->d_name); @@ -137,6 +155,7 @@ debug_fds (const char *subcmd, int argc, char *const *const argv) r = lstat (fname, &statbuf); if (r == -1) { reply_with_perror ("stat: %s", fname); + fclose (fp); free (out); closedir (dir); return NULL; @@ -145,25 +164,21 @@ debug_fds (const char *subcmd, int argc, char *const *const argv) if (S_ISLNK (statbuf.st_mode)) { r = readlink (fname, link, sizeof link - 1); if (r == -1) { - reply_with_perror ("readline: %s", fname); - free (out); - closedir (dir); - return NULL; + reply_with_perror ("readline: %s", fname); + fclose (fp); + free (out); + closedir (dir); + return NULL; } link[r] = '\0'; - r = catprintf (&out, "%2s %s\n", d->d_name, link); + fprintf (fp, "%2s %s\n", d->d_name, link); } else - r = catprintf (&out, "%2s 0%o\n", d->d_name, statbuf.st_mode); - - if (r == -1) { - reply_with_perror ("catprintf"); - free (out); - closedir (dir); - return NULL; - } + fprintf (fp, "%2s 0%o\n", d->d_name, statbuf.st_mode); } + fclose (fp); + if (closedir (dir) == -1) { reply_with_perror ("closedir"); free (out); @@ -173,44 +188,82 @@ debug_fds (const char *subcmd, int argc, char *const *const argv) return out; } -/* Report how much memory we can blindly allocate before - * we get an error. +/* Force a segfault in the daemon. */ +static char * +debug_segv (const char *subcmd, int argc, char *const *const argv) +{ + *(int*)0 = 0; + return NULL; +} + +/* Run an arbitrary shell command using /bin/sh from the appliance. + * + * Note this is somewhat different from the ordinary guestfs_sh command + * because it's not using the guest shell, and is not chrooted. */ static char * -debug_mem (const char *subcmd, int argc, char *const *const argv) +debug_sh (const char *subcmd, int argc, char *const *const argv) { - char *mem = NULL, *p; - int size = 0; - char *buf; + if (argc < 1) { + reply_with_error ("sh: expecting a command to run"); + return NULL; + } - for (;;) { - size += 128 * 1024; - p = realloc (mem, size); - if (p == NULL) { - free (mem); - break; - } - mem = p; + char *cmd; + int len, i, j; + + /* guestfish splits the parameter(s) into a list of strings, + * and we have to reassemble them here. Not ideal. XXX + */ + for (i = len = 0; i < argc; ++i) + len += strlen (argv[i]) + 1; + cmd = malloc (len); + if (!cmd) { + reply_with_perror ("malloc"); + return NULL; } + for (i = j = 0; i < argc; ++i) { + len = strlen (argv[i]); + memcpy (&cmd[j], argv[i], len); + j += len; + cmd[j] = ' '; + j++; + } + cmd[j-1] = '\0'; + + /* Set up some environment variables. */ + setenv ("root", sysroot, 1); + if (access ("/sys/block/sda", F_OK) == 0) + setenv ("sd", "sd", 1); + else if (access ("/sys/block/hda", F_OK) == 0) + setenv ("sd", "hd", 1); + else if (access ("/sys/block/vda", F_OK) == 0) + setenv ("sd", "vd", 1); + + char *err; + int r = commandf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR, + "/bin/sh", "-c", cmd, NULL); + free (cmd); - if (asprintf (&buf, "%.1f MBytes", size / 1024.0 / 1024.0) == -1) { - reply_with_perror ("asprintf"); + if (r == -1) { + reply_with_error ("%s", err); + free (err); return NULL; } - return buf; /* caller frees */ + return err; } -/* Run an arbitrary shell command. */ +/* Print the environment that commands get (by running external printenv). */ static char * -debug_sh (const char *subcmd, int argc, char *const *const argv) +debug_env (const char *subcmd, int argc, char *const *const argv) { int r; char *out, *err; - r = commandv (&out, &err, argv); + r = command (&out, &err, "printenv", NULL); if (r == -1) { - reply_with_error ("ps: %s", err); + reply_with_error ("printenv: %s", err); free (out); free (err); return NULL; @@ -221,4 +274,194 @@ debug_sh (const char *subcmd, int argc, char *const *const argv) return out; } -#endif /* ENABLE_DEBUG_COMMAND */ +/* List files in the appliance. */ +static char * +debug_ls (const char *subcmd, int argc, char *const *const argv) +{ + int len = count_strings (argv); + const char *cargv[len+3]; + int i; + + cargv[0] = "ls"; + cargv[1] = "-a"; + for (i = 0; i < len; ++i) + cargv[2+i] = argv[i]; + cargv[2+len] = NULL; + + int r; + char *out, *err; + + r = commandv (&out, &err, (void *) cargv); + if (r == -1) { + reply_with_error ("ls: %s", err); + free (out); + free (err); + return NULL; + } + + free (err); + + return out; +} + +/* List files in the appliance. */ +static char * +debug_ll (const char *subcmd, int argc, char *const *const argv) +{ + int len = count_strings (argv); + const char *cargv[len+3]; + int i; + + cargv[0] = "ls"; + cargv[1] = "-la"; + for (i = 0; i < len; ++i) + cargv[2+i] = argv[i]; + cargv[2+len] = NULL; + + int r; + char *out, *err; + + r = commandv (&out, &err, (void *) cargv); + if (r == -1) { + reply_with_error ("ll: %s", err); + free (out); + free (err); + return NULL; + } + + free (err); + + return out; +} + +/* Generate progress notification messages in order to test progress bars. */ +static char * +debug_progress (const char *subcmd, int argc, char *const *const argv) +{ + if (argc < 1) { + error: + reply_with_error ("progress: expecting arg (time in seconds as string)"); + return NULL; + } + + char *secs_str = argv[0]; + unsigned secs; + if (sscanf (secs_str, "%u", &secs) != 1 || secs == 0) + goto error; + + unsigned i; + unsigned tsecs = secs * 10; /* 1/10ths of seconds */ + for (i = 1; i <= tsecs; ++i) { + usleep (100000); + notify_progress ((uint64_t) i, (uint64_t) tsecs); + } + + char *ret = strdup ("ok"); + if (ret == NULL) { + reply_with_perror ("strdup"); + return NULL; + } + + return ret; +} + +/* Enable core dumping to the given core pattern. + * Note that this pattern is relative to any chroot of the process which + * crashes. This means that if you want to write the core file to the guest's + * storage the pattern must start with /sysroot only if the command which + * crashes doesn't chroot. + */ +static char * +debug_core_pattern (const char *subcmd, int argc, char *const *const argv) +{ + if (argc < 1) { + reply_with_error ("core_pattern: expecting a core pattern"); + return NULL; + } + + const char *pattern = argv[0]; + const size_t pattern_len = strlen(pattern); + +#define CORE_PATTERN "/proc/sys/kernel/core_pattern" + int fd = open (CORE_PATTERN, O_WRONLY); + if (fd == -1) { + reply_with_perror ("open: " CORE_PATTERN); + return NULL; + } + if (write (fd, pattern, pattern_len) < (ssize_t) pattern_len) { + reply_with_perror ("write: " CORE_PATTERN); + return NULL; + } + if (close (fd) == -1) { + reply_with_perror ("close: " CORE_PATTERN); + return NULL; + } + + struct rlimit limit = { + .rlim_cur = RLIM_INFINITY, + .rlim_max = RLIM_INFINITY + }; + if (setrlimit (RLIMIT_CORE, &limit) == -1) { + reply_with_perror ("setrlimit (RLIMIT_CORE)"); + return NULL; + } + + char *ret = strdup ("ok"); + if (NULL == ret) { + reply_with_perror ("strdup"); + return NULL; + } + + return ret; +} + +static int +write_cb (void *fd_ptr, const void *buf, size_t len) +{ + int fd = *(int *)fd_ptr; + return xwrite (fd, buf, len); +} + +/* Has one FileIn parameter. */ +int +do_debug_upload (const char *filename, int mode) +{ + /* Not chrooted - this command lets you upload a file to anywhere + * in the appliance. + */ + int fd = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_NOCTTY, mode); + + if (fd == -1) { + int err = errno; + cancel_receive (); + errno = err; + reply_with_perror ("%s", filename); + return -1; + } + + int r = receive_file (write_cb, &fd); + if (r == -1) { /* write error */ + int err = errno; + cancel_receive (); + errno = err; + reply_with_error ("write error: %s", filename); + close (fd); + return -1; + } + if (r == -2) { /* cancellation from library */ + close (fd); + /* Do NOT send any error. */ + return -1; + } + + if (close (fd) == -1) { + int err = errno; + if (r == -1) /* if r == 0, file transfer ended already */ + cancel_receive (); + errno = err; + reply_with_perror ("close: %s", filename); + return -1; + } + + return 0; +}