X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=daemon%2Fdebug.c;h=522012f20ac8840c934d7433c974c783174f9857;hp=9df4dc21ff6a2b6f2fe66e8c4bee8f2e74609cdd;hb=01e717b3c141c509a7200b0a6c560f75815c08f2;hpb=99679fe5a28efcee3be2406aeaf446b4e1a976df diff --git a/daemon/debug.c b/daemon/debug.c index 9df4dc2..522012f 100644 --- a/daemon/debug.c +++ b/daemon/debug.c @@ -13,7 +13,7 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include @@ -28,7 +28,7 @@ #include #include -#include "../src/guestfs_protocol.h" +#include "guestfs_protocol.h" #include "daemon.h" #include "actions.h" @@ -51,21 +51,29 @@ struct cmd { }; static char *debug_help (const char *subcmd, int argc, char *const *const argv); +static char *debug_binaries (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_ldd (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_qtrace (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 }, + { "binaries", debug_binaries }, { "core_pattern", debug_core_pattern }, { "env", debug_env }, { "fds", debug_fds }, + { "ldd", debug_ldd }, { "ls", debug_ls }, { "ll", debug_ll }, + { "progress", debug_progress }, + { "qtrace", debug_qtrace }, { "segv", debug_segv }, { "sh", debug_sh }, { NULL, NULL } @@ -84,7 +92,7 @@ do_debug (const char *subcmd, char *const *argv) return cmds[i].f (subcmd, argc, argv); } - reply_with_error ("use 'debug help' to list the supported commands"); + reply_with_error ("use 'debug help 0' to list the supported commands"); return NULL; } @@ -190,7 +198,13 @@ debug_fds (const char *subcmd, int argc, char *const *const argv) static char * debug_segv (const char *subcmd, int argc, char *const *const argv) { - *(int*)0 = 0; + /* http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html + * "Dereferencing a NULL Pointer: contrary to popular belief, + * dereferencing a null pointer in C is undefined. It is not defined + * to trap [...]" + */ + volatile int *ptr = NULL; + *ptr = 1; return NULL; } @@ -272,6 +286,77 @@ debug_env (const char *subcmd, int argc, char *const *const argv) return out; } +/* Return binaries in the appliance. + * See tests/regressions/rhbz727178.sh + */ +static char * +debug_binaries (const char *subcmd, int argc, char *const *const argv) +{ + int r; + char *out, *err; + + const char cmd[] = + "find / -xdev -type f -executable " + "| xargs file -i " + "| grep application/x-executable " + "| gawk -F: '{print $1}'"; + + r = command (&out, &err, "sh", "-c", cmd, NULL); + if (r == -1) { + reply_with_error ("find: %s", err); + free (out); + free (err); + return NULL; + } + + free (err); + + return out; +} + +/* Run 'ldd' on a file from the appliance. + * See tests/regressions/rhbz727178.sh + */ +static char * +debug_ldd (const char *subcmd, int argc, char *const *const argv) +{ + int r; + char *out, *err, *ret; + + if (argc != 1) { + reply_with_error ("ldd: no file argument"); + return NULL; + } + + /* Note that 'ldd' doesn't fail if it finds errors. We have to grep + * for errors in the regression test instead. 'ldd' only fails here + * if the binary is not a binary at all (eg. for shell scripts). + * Also 'ldd' randomly sends messages to stderr and errors to stdout + * depending on the phase of the moon. + */ + r = command (&out, &err, "ldd", "-r", argv[0], NULL); + if (r == -1) { + reply_with_error ("ldd: %s: %s", argv[0], err); + free (out); + free (err); + return NULL; + } + + /* Concatenate stdout and stderr in the result. */ + ret = realloc (out, strlen (out) + strlen (err) + 1); + if (ret == NULL) { + reply_with_perror ("realloc"); + free (out); + free (err); + return NULL; + } + + strcat (ret, err); + free (err); + + return ret; +} + /* List files in the appliance. */ static char * debug_ls (const char *subcmd, int argc, char *const *const argv) @@ -332,6 +417,37 @@ debug_ll (const char *subcmd, int argc, char *const *const argv) 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 @@ -389,6 +505,95 @@ write_cb (void *fd_ptr, const void *buf, size_t len) return xwrite (fd, buf, len); } +/* This requires a non-upstream qemu patch. See contrib/visualize-alignment/ + * directory in the libguestfs source tree. + */ +static char * +debug_qtrace (const char *subcmd, int argc, char *const *const argv) +{ + int enable; + + if (argc != 2) { + bad_args: + reply_with_error ("qtrace "); + return NULL; + } + + if (STREQ (argv[1], "on")) + enable = 1; + else if (STREQ (argv[1], "off")) + enable = 0; + else + goto bad_args; + + /* This does a sync and flushes all caches. */ + if (do_drop_caches (3) == -1) + return NULL; + + /* Note this doesn't do device name translation or check this is a device. */ + int fd = open (argv[0], O_RDONLY | O_DIRECT); + if (fd == -1) { + reply_with_perror ("qtrace: %s: open", argv[0]); + return NULL; + } + + /* The pattern of reads is what signals to the analysis program that + * tracing should be started or stopped. Note this assumes both 512 + * byte sectors, and that O_DIRECT will let us do 512 byte aligned + * reads. We ought to read the sector size of the device and use + * that instead (XXX). The analysis program currently assumes 512 + * byte sectors anyway. + */ +#define QTRACE_SIZE 512 + const int patterns[2][5] = { + { 2, 15, 21, 2, -1 }, /* disable trace */ + { 2, 21, 15, 2, -1 } /* enable trace */ + }; + void *buf; + size_t i; + + /* For O_DIRECT, buffer must be aligned too (thanks Matt). + * Note posix_memalign has this strange errno behaviour. + */ + errno = posix_memalign (&buf, QTRACE_SIZE, QTRACE_SIZE); + if (errno != 0) { + reply_with_perror ("posix_memalign"); + close (fd); + return NULL; + } + + for (i = 0; patterns[enable][i] >= 0; ++i) { + if (lseek (fd, patterns[enable][i]*QTRACE_SIZE, SEEK_SET) == -1) { + reply_with_perror ("qtrace: %s: lseek", argv[0]); + close (fd); + free (buf); + return NULL; + } + + if (read (fd, buf, QTRACE_SIZE) == -1) { + reply_with_perror ("qtrace: %s: read", argv[0]); + close (fd); + free (buf); + return NULL; + } + } + + close (fd); + free (buf); + + /* This does a sync and flushes all caches. */ + if (do_drop_caches (3) == -1) + return NULL; + + char *ret = strdup ("ok"); + if (NULL == ret) { + reply_with_perror ("strdup"); + return NULL; + } + + return ret; +} + /* Has one FileIn parameter. */ int do_debug_upload (const char *filename, int mode) @@ -416,16 +621,15 @@ do_debug_upload (const char *filename, int mode) return -1; } if (r == -2) { /* cancellation from library */ + /* This error is ignored by the library since it initiated the + * cancel. Nevertheless we must send an error reply here. + */ + reply_with_error ("file upload cancelled"); 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; }