int main (int argc, char *argv[]) { guestfs_h *g = guestfs_create (); /* Call some non-daemon functions that have a String parameter, but * setting that parameter to NULL. Previously this would cause a * segfault inside libguestfs. After this bug was fixed, this * turned into an error message. */ assert (guestfs_add_drive (g, NULL) == -1); assert (guestfs_config (g, NULL, NULL) == -1); /* This optional argument must not be NULL. */ assert (guestfs_add_drive_opts (g, "/dev/null", GUESTFS_ADD_DRIVE_OPTS_FORMAT, NULL, -1) == -1); /* These can be safely set to NULL, should be no error. */ assert (guestfs_set_path (g, NULL) == 0); assert (guestfs_set_append (g, NULL) == 0); assert (guestfs_set_qemu (g, NULL) == 0); guestfs_close (g); exit (EXIT_SUCCESS); }
int main (int argc, char *argv[]) { guestfs_h *g; size_t i; int lengths[] = { 0, 1, 1024, GUESTFS_ERROR_LEN-2, GUESTFS_ERROR_LEN-1, GUESTFS_ERROR_LEN, GUESTFS_ERROR_LEN+1, GUESTFS_ERROR_LEN+2, GUESTFS_ERROR_LEN*2, -1 }; char len_s[64]; char *args[2]; g = guestfs_create (); if (g == NULL) { perror ("guestfs_create"); exit (EXIT_FAILURE); } if (guestfs_add_drive (g, "/dev/null") == -1) exit (EXIT_FAILURE); if (guestfs_launch (g) == -1) exit (EXIT_FAILURE); guestfs_push_error_handler (g, NULL, NULL); for (i = 0; lengths[i] != -1; ++i) { snprintf (len_s, sizeof len_s, "%d", lengths[i]); args[0] = len_s; args[1] = NULL; if (guestfs_debug (g, "error", args) != NULL) { fprintf (stderr, "%s: unexpected return value from 'debug error'\n", argv[0]); exit (EXIT_FAILURE); } /* EROFS is a magic value returned by debug_error in the daemon. */ if (guestfs_last_errno (g) != EROFS) { fprintf (stderr, "%s: unexpected error from 'debug error': %s\n", argv[0], guestfs_last_error (g)); exit (EXIT_FAILURE); } /* else OK */ } guestfs_pop_error_handler (g); guestfs_close (g); exit (EXIT_SUCCESS); }
static void test_block_device (void) { int fd; char tmpfile[] = "/tmp/speedtestXXXXXX"; CLEANUP_FREE char **devices = NULL; char *r; const char *argv[4]; int t = max_time_override > 0 ? max_time_override : TEST_BLOCK_DEVICE_TIME; char tbuf[64]; int64_t bytes_written, bytes_read; if (!block_device_write && !block_device_read) return; snprintf (tbuf, sizeof tbuf, "%d", t); g = guestfs_create (); if (!g) error (EXIT_FAILURE, errno, "guestfs_create"); /* Create a fully allocated backing file. Note we are not testing * the speed of allocation on the host. */ fd = mkstemp (tmpfile); if (fd == -1) error (EXIT_FAILURE, errno, "mkstemp: %s", tmpfile); close (fd); if (guestfs_disk_create (g, tmpfile, "raw", INT64_C (1024*1024*1024), GUESTFS_DISK_CREATE_PREALLOCATION, "full", -1) == -1) exit (EXIT_FAILURE); if (guestfs_add_drive (g, tmpfile) == -1) exit (EXIT_FAILURE); if (guestfs_launch (g) == -1) exit (EXIT_FAILURE); devices = guestfs_list_devices (g); if (devices == NULL) exit (EXIT_FAILURE); if (devices[0] == NULL) { fprintf (stderr, "%s: expected guestfs_list_devices to return at least 1 device\n", guestfs_int_program_name); exit (EXIT_FAILURE); } if (block_device_write) { /* Test write speed. */ argv[0] = devices[0]; argv[1] = "w"; argv[2] = tbuf; argv[3] = NULL; r = guestfs_debug (g, "device_speed", (char **) argv); if (r == NULL) exit (EXIT_FAILURE); if (sscanf (r, "%" SCNi64, &bytes_written) != 1) { fprintf (stderr, "%s: could not parse device_speed output\n", guestfs_int_program_name); exit (EXIT_FAILURE); } print_rate ("block device writes:", bytes_written / t); } if (block_device_read) { /* Test read speed. */ argv[0] = devices[0]; argv[1] = "r"; argv[2] = tbuf; argv[3] = NULL; r = guestfs_debug (g, "device_speed", (char **) argv); if (r == NULL) exit (EXIT_FAILURE); if (sscanf (r, "%" SCNi64, &bytes_read) != 1) { fprintf (stderr, "%s: could not parse device_speed output\n", guestfs_int_program_name); exit (EXIT_FAILURE); } print_rate ("block device reads:", bytes_read / t); } if (guestfs_shutdown (g) == -1) exit (EXIT_FAILURE); guestfs_close (g); /* Remove temporary file. */ unlink (tmpfile); }
char add_drives (struct drv *drv, char next_drive) { int r; struct guestfs_add_drive_opts_argv ad_optargs; if (next_drive > 'z') { fprintf (stderr, _("%s: too many drives added on the command line\n"), program_name); exit (EXIT_FAILURE); } if (drv) { next_drive = add_drives (drv->next, next_drive); free (drv->device); drv->device = NULL; if (asprintf (&drv->device, "/dev/sd%c", next_drive) == -1) { perror ("asprintf"); exit (EXIT_FAILURE); } switch (drv->type) { case drv_a: ad_optargs.bitmask = 0; if (read_only) { ad_optargs.bitmask |= GUESTFS_ADD_DRIVE_OPTS_READONLY_BITMASK; ad_optargs.readonly = 1; } if (drv->a.format) { ad_optargs.bitmask |= GUESTFS_ADD_DRIVE_OPTS_FORMAT_BITMASK; ad_optargs.format = drv->a.format; } r = guestfs_add_drive_opts_argv (g, drv->a.filename, &ad_optargs); if (r == -1) exit (EXIT_FAILURE); drv->nr_drives = 1; next_drive++; break; case drv_d: r = add_libvirt_drives (drv->d.guest); if (r == -1) exit (EXIT_FAILURE); drv->nr_drives = r; next_drive += r; break; #if COMPILING_GUESTFISH case drv_N: /* guestfs_add_drive (ie. autodetecting) should be safe here * since we have just created the prepared disk. At the moment * it will always be "raw" but in a theoretical future we might * create other formats. */ /* -N option is not affected by --ro */ r = guestfs_add_drive (g, drv->N.filename); if (r == -1) exit (EXIT_FAILURE); drv->nr_drives = 1; next_drive++; break; #endif default: /* keep GCC happy */ abort (); } } return next_drive; }