mirror of
https://github.com/libguestfs/libguestfs.git
synced 2026-03-22 07:03:38 +00:00
a659f2c316
The new API splits orderly close into a two-step process:
if (guestfs_shutdown (g) == -1) {
/* handle the error, eg. qemu error */
}
guestfs_close (g);
Note that the explicit shutdown step is only necessary in the case
where you have made changes to the disk image and want to handle write
errors. Read the documentation for further information.
This change also:
- deprecates guestfs_kill_subprocess
- turns guestfs_kill_subprocess into the same as guestfs_shutdown
- changes guestfish and other tools to call shutdown + close
where necessary (not for read-only tools)
- updates documentation
- updates examples
(cherry picked from commit ffbf1475f7)
121 lines
3.3 KiB
C
121 lines
3.3 KiB
C
/* Example showing how to create a disk image. */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <guestfs.h>
|
|
|
|
int
|
|
main (int argc, char *argv[])
|
|
{
|
|
guestfs_h *g;
|
|
size_t i;
|
|
|
|
g = guestfs_create ();
|
|
if (g == NULL) {
|
|
perror ("failed to create libguestfs handle");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
|
|
/* Create a raw-format sparse disk image, 512 MB in size. */
|
|
int fd = open ("disk.img", O_CREAT|O_WRONLY|O_TRUNC|O_NOCTTY, 0666);
|
|
if (fd == -1) {
|
|
perror ("disk.img");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
if (ftruncate (fd, 512 * 1024 * 1024) == -1) {
|
|
perror ("disk.img: truncate");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
if (close (fd) == -1) {
|
|
perror ("disk.img: close");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
|
|
/* Set the trace flag so that we can see each libguestfs call. */
|
|
guestfs_set_trace (g, 1);
|
|
|
|
/* Add the disk image to libguestfs. */
|
|
if (guestfs_add_drive_opts (g, "disk.img",
|
|
GUESTFS_ADD_DRIVE_OPTS_FORMAT, "raw", /* raw format */
|
|
GUESTFS_ADD_DRIVE_OPTS_READONLY, 0, /* for write */
|
|
-1) /* this marks end of optional arguments */
|
|
== -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
/* Run the libguestfs back-end. */
|
|
if (guestfs_launch (g) == -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
/* Get the list of devices. Because we only added one drive
|
|
* above, we expect that this list should contain a single
|
|
* element.
|
|
*/
|
|
char **devices = guestfs_list_devices (g);
|
|
if (devices == NULL)
|
|
exit (EXIT_FAILURE);
|
|
if (devices[0] == NULL || devices[1] != NULL) {
|
|
fprintf (stderr, "error: expected a single device from list-devices\n");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
|
|
/* Partition the disk as one single MBR partition. */
|
|
if (guestfs_part_disk (g, devices[0], "mbr") == -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
/* Get the list of partitions. We expect a single element, which
|
|
* is the partition we have just created.
|
|
*/
|
|
char **partitions = guestfs_list_partitions (g);
|
|
if (partitions == NULL)
|
|
exit (EXIT_FAILURE);
|
|
if (partitions[0] == NULL || partitions[1] != NULL) {
|
|
fprintf (stderr, "error: expected a single partition from list-partitions\n");
|
|
exit (EXIT_FAILURE);
|
|
}
|
|
|
|
/* Create a filesystem on the partition. */
|
|
if (guestfs_mkfs (g, "ext4", partitions[0]) == -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
/* Now mount the filesystem so that we can add files. */
|
|
if (guestfs_mount_options (g, "", partitions[0], "/") == -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
/* Create some files and directories. */
|
|
if (guestfs_touch (g, "/empty") == -1)
|
|
exit (EXIT_FAILURE);
|
|
const char *message = "Hello, world\n";
|
|
if (guestfs_write (g, "/hello", message, strlen (message)) == -1)
|
|
exit (EXIT_FAILURE);
|
|
if (guestfs_mkdir (g, "/foo") == -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
/* This one uploads the local file /etc/resolv.conf into
|
|
* the disk image.
|
|
*/
|
|
if (guestfs_upload (g, "/etc/resolv.conf", "/foo/resolv.conf") == -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
/* Because we wrote to the disk and we want to detect write
|
|
* errors, call guestfs_shutdown. You don't need to do this:
|
|
* guestfs_close will do it implicitly.
|
|
*/
|
|
if (guestfs_shutdown (g) == -1)
|
|
exit (EXIT_FAILURE);
|
|
|
|
guestfs_close (g);
|
|
|
|
/* Free up the lists. */
|
|
for (i = 0; devices[i] != NULL; ++i)
|
|
free (devices[i]);
|
|
free (devices);
|
|
for (i = 0; partitions[i] != NULL; ++i)
|
|
free (partitions[i]);
|
|
free (partitions);
|
|
|
|
exit (EXIT_SUCCESS);
|
|
}
|