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;
}
