int
init_basic_fs_on_lvm (guestfs_h *g)
{
const char *pvs[] = { "/dev/sda1", NULL };
if (init_partition (g) == -1)
return -1;
if (guestfs_pvcreate (g, "/dev/sda1") == -1)
return -1;
if (guestfs_vgcreate (g, "VG", (char **) pvs) == -1)
return -1;
if (guestfs_lvcreate (g, "LV", "VG", 8) == -1)
return -1;
if (guestfs_mkfs (g, "ext2", "/dev/VG/LV") == -1)
return -1;
if (guestfs_mount (g, "/dev/VG/LV", "/") == -1)
return -1;
return 0;
}
int
init_scratch_fs (guestfs_h *g)
{
if (init_empty (g) == -1)
return -1;
if (guestfs_mount (g, "/dev/sdb1", "/") == -1)
return -1;
return 0;
}
int
init_basic_fs (guestfs_h *g)
{
if (init_partition (g) == -1)
return -1;
if (guestfs_mkfs (g, "ext2", "/dev/sda1") == -1)
return -1;
if (guestfs_mount (g, "/dev/sda1", "/") == -1)
return -1;
return 0;
}
static void
mount_drive_letter (char drive_letter, const char *root)
{
char *device;
size_t i;
/* Resolve the drive letter using the drive mappings table. */
CLEANUP_FREE_STRING_LIST char **drives =
guestfs_inspect_get_drive_mappings (g, root);
if (drives == NULL || drives[0] == NULL) {
fprintf (stderr, _("%s: to use Windows drive letters, this must be a Windows guest\n"),
program_name);
exit (EXIT_FAILURE);
}
device = NULL;
for (i = 0; drives[i] != NULL; i += 2) {
if (c_tolower (drives[i][0]) == drive_letter && drives[i][1] == '\0') {
device = drives[i+1];
break;
}
}
if (device == NULL) {
fprintf (stderr, _("%s: drive '%c:' not found.\n"),
program_name, drive_letter);
exit (EXIT_FAILURE);
}
/* Unmount current disk and remount device. */
if (guestfs_umount_all (g) == -1)
exit (EXIT_FAILURE);
if (guestfs_mount (g, device, "/") == -1)
exit (EXIT_FAILURE);
/* Don't need to free (device) because that string was in the
* drives array.
*/
}
void
inspect_mount_root (const char *root)
{
CLEANUP_FREE_STRING_LIST char **mountpoints =
guestfs_inspect_get_mountpoints (g, root);
if (mountpoints == NULL)
exit (EXIT_FAILURE);
/* Sort by key length, shortest key first, so that we end up
* mounting the filesystems in the correct order.
*/
qsort (mountpoints, guestfs___count_strings (mountpoints) / 2,
2 * sizeof (char *),
compare_keys_len);
size_t i;
size_t mount_errors = 0;
for (i = 0; mountpoints[i] != NULL; i += 2) {
int r;
if (!read_only)
r = guestfs_mount (g, mountpoints[i+1], mountpoints[i]);
else
r = guestfs_mount_ro (g, mountpoints[i+1], mountpoints[i]);
if (r == -1) {
/* If the "/" filesystem could not be mounted, give up, else
* just count the errors and print a warning.
*/
if (STREQ (mountpoints[i], "/"))
exit (EXIT_FAILURE);
mount_errors++;
}
}
if (mount_errors)
fprintf (stderr, _("%s: some filesystems could not be mounted (ignored)\n"),
program_name);
}
int
main (int argc, char *argv[])
{
guestfs_h *g;
struct guestfs_internal_mountable *mountable;
const char *devices[] = { "/dev/VG/LV", NULL };
const char *feature[] = { "btrfs", NULL };
g = guestfs_create ();
if (g == NULL) {
perror ("could not create handle");
exit (EXIT_FAILURE);
}
if (guestfs_add_drive_scratch (g, 1024*1024*1024, -1) == -1) {
error:
guestfs_close (g);
exit (EXIT_FAILURE);
}
if (guestfs_launch (g) == -1) goto error;
if (!guestfs_feature_available (g, (char **) feature)) {
printf ("skipping test because btrfs is not available\n");
guestfs_close (g);
exit (77);
}
if (!guestfs_filesystem_available (g, "btrfs")) {
printf ("skipping test because btrfs filesystem is not available\n");
guestfs_close (g);
exit (77);
}
if (guestfs_part_disk (g, "/dev/sda", "mbr") == -1) goto error;
if (guestfs_pvcreate (g, "/dev/sda1") == -1) goto error;
const char *pvs[] = { "/dev/sda1", NULL };
if (guestfs_vgcreate (g, "VG", (char **) pvs) == -1) goto error;
if (guestfs_lvcreate (g, "LV", "VG", 900) == -1) goto error;
if (guestfs_mkfs_btrfs (g, (char * const *)devices, -1) == -1) goto error;
if (guestfs_mount (g, "/dev/VG/LV", "/") == -1) goto error;
if (guestfs_btrfs_subvolume_create (g, "/sv") == -1) goto error;
mountable = guestfs_internal_parse_mountable (g, "/dev/VG/LV");
if (mountable == NULL) goto error;
if (mountable->im_type != MOUNTABLE_DEVICE ||
STRNEQ ("/dev/VG/LV", mountable->im_device)) {
fprintf (stderr, "incorrectly parsed /dev/VG/LV: im_device=%s\n",
mountable->im_device);
goto error;
}
guestfs_free_internal_mountable (mountable);
mountable = guestfs_internal_parse_mountable (g, "btrfsvol:/dev/VG/LV/sv");
if (mountable == NULL) goto error;
if (mountable->im_type != MOUNTABLE_BTRFSVOL ||
STRNEQ ("/dev/VG/LV", mountable->im_device) ||
STRNEQ ("sv", mountable->im_volume)) {
fprintf (stderr, "incorrectly parsed /dev/VG/LV/sv: im_device=%s, im_volume=%s\n",
mountable->im_device, mountable->im_volume);
goto error;
}
guestfs_free_internal_mountable (mountable);
guestfs_close (g);
exit (EXIT_SUCCESS);
}
static void
test_virtio_serial (void)
{
int fd, r, eh;
char tmpfile[] = "/tmp/speedtestXXXXXX";
struct sigaction sa, old_sa;
if (!virtio_serial_upload && !virtio_serial_download)
return;
/* Create a sparse file. We could upload from /dev/zero, but we
* won't get progress messages because libguestfs tests if the
* source file is a regular file.
*/
fd = mkstemp (tmpfile);
if (fd == -1)
error (EXIT_FAILURE, errno, "mkstemp: %s", tmpfile);
if (ftruncate (fd, TEST_SERIAL_MAX_SIZE) == -1)
error (EXIT_FAILURE, errno, "ftruncate");
if (close (fd) == -1)
error (EXIT_FAILURE, errno, "close");
g = guestfs_create ();
if (!g)
error (EXIT_FAILURE, errno, "guestfs_create");
if (guestfs_add_drive_scratch (g, INT64_C (100*1024*1024), -1) == -1)
exit (EXIT_FAILURE);
if (guestfs_launch (g) == -1)
exit (EXIT_FAILURE);
/* Make and mount a filesystem which will be used by the download test. */
if (guestfs_mkfs (g, "ext4", "/dev/sda") == -1)
exit (EXIT_FAILURE);
if (guestfs_mount (g, "/dev/sda", "/") == -1)
exit (EXIT_FAILURE);
/* Time out the upload after TEST_SERIAL_MAX_TIME seconds have passed. */
memset (&sa, 0, sizeof sa);
sa.sa_handler = stop_transfer;
sa.sa_flags = SA_RESTART;
sigaction (SIGALRM, &sa, &old_sa);
/* Get progress messages, which will tell us how much data has been
* transferred.
*/
eh = guestfs_set_event_callback (g, progress_cb, GUESTFS_EVENT_PROGRESS,
0, NULL);
if (eh == -1)
exit (EXIT_FAILURE);
if (virtio_serial_upload) {
gettimeofday (&start, NULL);
rate = -1;
operation = "upload";
alarm (max_time_override > 0 ? max_time_override : TEST_SERIAL_MAX_TIME);
/* For the upload test, upload the sparse file to /dev/null in the
* appliance. Hopefully this is mostly testing just virtio-serial.
*/
guestfs_push_error_handler (g, NULL, NULL);
r = guestfs_upload (g, tmpfile, "/dev/null");
alarm (0);
unlink (tmpfile);
guestfs_pop_error_handler (g);
/* It's possible that the upload will finish before the alarm fires,
* or that the upload will be stopped by the alarm.
*/
if (r == -1 && guestfs_last_errno (g) != EINTR) {
fprintf (stderr,
"%s: expecting upload command to return EINTR\n%s\n",
guestfs_int_program_name, guestfs_last_error (g));
exit (EXIT_FAILURE);
}
if (rate == -1) {
rate_error:
fprintf (stderr, "%s: internal error: progress callback was not called! (r=%d, errno=%d)\n",
guestfs_int_program_name,
r, guestfs_last_errno (g));
exit (EXIT_FAILURE);
}
print_rate ("virtio-serial upload rate:", rate);
}
if (virtio_serial_download) {
/* For the download test, download a sparse file within the
* appliance to /dev/null on the host.
*/
if (guestfs_touch (g, "/sparse") == -1)
exit (EXIT_FAILURE);
if (guestfs_truncate_size (g, "/sparse", TEST_SERIAL_MAX_SIZE) == -1)
exit (EXIT_FAILURE);
gettimeofday (&start, NULL);
rate = -1;
operation = "download";
alarm (max_time_override > 0 ? max_time_override : TEST_SERIAL_MAX_TIME);
guestfs_push_error_handler (g, NULL, NULL);
r = guestfs_download (g, "/sparse", "/dev/null");
alarm (0);
guestfs_pop_error_handler (g);
if (r == -1 && guestfs_last_errno (g) != EINTR) {
fprintf (stderr,
"%s: expecting download command to return EINTR\n%s\n",
guestfs_int_program_name, guestfs_last_error (g));
exit (EXIT_FAILURE);
}
if (rate == -1)
goto rate_error;
print_rate ("virtio-serial download rate:", rate);
}
if (guestfs_shutdown (g) == -1)
exit (EXIT_FAILURE);
guestfs_close (g);
/* Restore SIGALRM signal handler. */
sigaction (SIGALRM, &old_sa, NULL);
}
int
main (int argc, char *argv[])
{
guestfs_h *g;
int r, err;
struct guestfs_stat *stat;
g = guestfs_create ();
if (g == NULL) {
fprintf (stderr, "failed to create handle\n");
exit (EXIT_FAILURE);
}
if (guestfs_add_drive_scratch (g, 524288000, -1) == -1)
exit (EXIT_FAILURE);
if (guestfs_launch (g) == -1)
exit (EXIT_FAILURE);
if (guestfs_part_disk (g, "/dev/sda", "mbr") == -1)
exit (EXIT_FAILURE);
if (guestfs_mkfs (g, "ext2", "/dev/sda1") == -1)
exit (EXIT_FAILURE);
/* Mount read-only, and check that errno == EROFS is passed back when
* we create a file.
*/
if (guestfs_mount_ro (g, "/dev/sda1", "/") == -1)
exit (EXIT_FAILURE);
r = guestfs_touch (g, "/test");
if (r != -1) {
fprintf (stderr,
"guestfs_touch: expected error for read-only filesystem\n");
exit (EXIT_FAILURE);
}
err = guestfs_last_errno (g);
if (err != EROFS) {
fprintf (stderr,
"guestfs_touch: expected errno == EROFS, but got %d\n", err);
exit (EXIT_FAILURE);
}
if (guestfs_umount (g, "/") == -1)
exit (EXIT_FAILURE);
/* Mount it writable and test some other errors. */
if (guestfs_mount (g, "/dev/sda1", "/") == -1)
exit (EXIT_FAILURE);
stat = guestfs_lstat (g, "/nosuchfile");
if (stat != NULL) {
fprintf (stderr,
"guestfs_lstat: expected error for missing file\n");
exit (EXIT_FAILURE);
}
err = guestfs_last_errno (g);
if (err != ENOENT) {
fprintf (stderr,
"guestfs_lstat: expected errno == ENOENT, but got %d\n", err);
exit (EXIT_FAILURE);
}
if (guestfs_touch (g, "/test") == -1)
exit (EXIT_FAILURE);
r = guestfs_mkdir (g, "/test");
if (r != -1) {
fprintf (stderr,
"guestfs_mkdir: expected error for file which exists\n");
exit (EXIT_FAILURE);
}
err = guestfs_last_errno (g);
if (err != EEXIST) {
fprintf (stderr,
"guestfs_mkdir: expected errno == EEXIST, but got %d\n", err);
exit (EXIT_FAILURE);
}
guestfs_close (g);
exit (EXIT_SUCCESS);
}
