NAME¶

 make help

 SKIP_TEST_<CMD>_<NUM>=1

 SKIP_TEST_<CMD>=1

 TEST_ONLY="vfs_type zerofree"

 - 000+ basic tests:

   010  load the library
   020  create
   030  create-flags
   040  create multiple handles
   050  test setting and getting config properties
   060  explicit close
   065  implicit close (in GC'd languages)
   070  optargs
   080  version
   090  retvalues

 - 100  launch, create partitions and LVs and filesystems

 - 400+ events:

   410  close event
   420  log messages
   430  progress messages

 - 800+ regression tests (specific to the language)

 - 900+ any other custom tests for the language

 ;;; In libguestfs, indent with spaces everywhere (not TABs).
 ;;; Exceptions: Makefile and ChangeLog modes.
 (add-hook 'find-file-hook
     '(lambda () (if (and buffer-file-name
                          (string-match "/libguestfs\\>"
                              (buffer-file-name))
                          (not (string-equal mode-name "Change Log"))
                          (not (string-equal mode-name "Makefile")))
                     (setq indent-tabs-mode nil))))

 ;;; When editing C sources in libguestfs, use this style.
 (defun libguestfs-c-mode ()
   "C mode with adjusted defaults for use with libguestfs."
   (interactive)
   (c-set-style "K&R")
   (setq c-indent-level 2)
   (setq c-basic-offset 2))
 (add-hook 'c-mode-hook
           '(lambda () (if (string-match "/libguestfs\\>"
                               (buffer-file-name))
                           (libguestfs-c-mode))))

 ./configure --enable-werror

 make check-uml LIBGUESTFS_HV=~/d/linux-um/vmlinux

 make check-with-upstream-qemu QEMUDIR=/usr/src/qemu

 make check-with-upstream-libvirt LIBVIRTDIR=/usr/src/libvirt

 check-slow:
   $(MAKE) check TESTS="$(SLOW_TESTS)" SLOW=1

 check-root:
   $(MAKE) check TESTS="$(ROOT_TESTS)"

 ./autogen.sh
 make clean ||:
 make
 make installcheck

 $VG virt-foo

 check-valgrind:
     make VG="@VG@" check

 LOG_COMPILER = $(VG)

 check-valgrind:
     make VG="@VG@" check

 asprintf (&cmd, "cat %R", path);

 virt_customize_SOURCES = ... crypt-c.c perl_edit-c.c

 virt_resize_SOURCES = dummy.c

 virt_customize_DEPENDENCIES = ... customize_main.cmx

 virt_customize_LINK = \
     $(top_builddir)/ocaml-link.sh -cclib '-lutils -lgnu' -- ...

 Version $(VERSION) stable
 Version $(VERSION) development

 ./localconfigure
 make distclean -k
 ./localconfigure
 make && make dist
 make maintainer-commit
 make maintainer-tag

 git branch stable-1.XX
 git push origin stable-1.XX

 const char *
 guestfs_int_get_cpu_model (int kvm)

 #define VALID_TERM

 static char *
 get_root_uuid_with_file (guestfs_h *g, const char *appliance)

 static int
 run_qemu_img_dd (guestfs_h *g, const char *in_file, char *out_file)

 static char *
 get_root_uuid (guestfs_h *g, const char *appliance)

 char *
 guestfs_int_appliance_command_line (guestfs_h *g,
                                     const char *appliance,
                                    int flags)

 int
 guestfs_int_get_uefi (guestfs_h *g, char *const *firmwares,
                       const char **firmware, char **code, char **vars,
                       int *flags)

 int
 guestfs_int_build_appliance (guestfs_h *g,
                             char **kernel_rtn,
                             char **initrd_rtn,
                             char **appliance_rtn)

  $TMPDIR/.guestfs-$UID/lock            - the supermin lock file
  $TMPDIR/.guestfs-$UID/appliance.d/kernel - the kernel
  $TMPDIR/.guestfs-$UID/appliance.d/initrd - the supermin initrd
  $TMPDIR/.guestfs-$UID/appliance.d/root   - the appliance

 static int
 locate_or_build_appliance (guestfs_h *g,
                            struct appliance_files *appliance,
                            const char *path)

  1 = appliance is found, returns C<appliance>,
  0 = appliance not found,
 -1 = error which aborts the launch process.

 static int
 search_appliance (guestfs_h *g, struct appliance_files *appliance)

  1 = a path element matched, returns C<appliance>,
  0 = no path element matched,
 -1 = error which aborts the launch process.

 static int
 build_supermin_appliance (guestfs_h *g,
                           const char *supermin_path,
                           struct appliance_files *appliance)

 static int
 run_supermin_build (guestfs_h *g,
                     const char *lockfile,
                     const char *appliancedir,
                     const char *supermin_path)

 static int
 dir_contains_file (guestfs_h *g, const char *dir, const char *file)

 static int
 dir_contains_files (guestfs_h *g, const char *dir, ...)

 struct command *cmd;
 cmd = guestfs_int_new_command (g);

 guestfs_int_cmd_add_arg (cmd, "qemu-img");
 guestfs_int_cmd_add_arg (cmd, "info");
 guestfs_int_cmd_add_arg (cmd, filename);

 guestfs_int_cmd_add_string_unquoted (cmd, "qemu-img info ");
 guestfs_int_cmd_add_string_quoted (cmd, filename);

 r = guestfs_int_cmd_run (cmd);
 if (r == -1)
   // error
 // else test r using the WIF* functions

 guestfs_int_cmd_close (cmd);

 struct command *
 guestfs_int_new_command (guestfs_h *g)

 void
 guestfs_int_cmd_add_arg (struct command *cmd, const char *arg)

 void
 guestfs_int_cmd_add_arg_format (struct command *cmd, const char *fs, ...)

 void
 guestfs_int_cmd_add_string_unquoted (struct command *cmd, const char *str)

 void
 guestfs_int_cmd_add_string_quoted (struct command *cmd, const char *str)

 void
 guestfs_int_cmd_set_stdout_callback (struct command *cmd,
                                      cmd_stdout_callback stdout_callback,
                                      void *stdout_data, unsigned flags)

 void
 guestfs_int_cmd_set_stderr_to_stdout (struct command *cmd)

 void
 guestfs_int_cmd_clear_capture_errors (struct command *cmd)

 void
 guestfs_int_cmd_clear_close_files (struct command *cmd)

 void
 guestfs_int_cmd_set_child_callback (struct command *cmd,
                                     cmd_child_callback child_callback,
                                     void *data)

 void
 guestfs_int_cmd_set_child_rlimit (struct command *cmd, int resource, long limit)

 static void
 finish_command (struct command *cmd)

 static int
 loop (struct command *cmd)

 int
 guestfs_int_cmd_run (struct command *cmd)

 int
 guestfs_int_cmd_pipe_run (struct command *cmd, const char *mode)

 int
 guestfs_int_cmd_pipe_wait (struct command *cmd)

 char *
 guestfs_int_cmd_get_pipe_errors (struct command *cmd)

 void
 guestfs_int_cmd_close (struct command *cmd)

 static void
 process_line_buffer (struct command *cmd, int closed)

 static int
 handle_log_message (guestfs_h *g,
                     struct connection_socket *conn)

 struct connection *
 guestfs_int_new_conn_socket_listening (guestfs_h *g,
                                       int daemon_accept_sock,
                                       int console_sock)

 struct connection *
 guestfs_int_new_conn_socket_connected (guestfs_h *g,
                                       int daemon_sock,
                                       int console_sock)

 #define VALID_FORMAT

 static int
 create_overlay (guestfs_h *g, struct drive *drv)

 static struct drive *
 create_drive_file (guestfs_h *g,
                    const struct drive_create_data *data)

 static struct drive *
 create_drive_dev_null (guestfs_h *g,
                        struct drive_create_data *data)

 static char *
 drive_to_string (guestfs_h *g, const struct drive *drv)

 static void
 add_drive_to_handle_at (guestfs_h *g, struct drive *d, size_t drv_index)

 static void
 add_drive_to_handle (guestfs_h *g, struct drive *d)

 void
 guestfs_int_add_dummy_appliance_drive (guestfs_h *g)

 void
 guestfs_int_free_drives (guestfs_h *g)

 #define VALID_FORMAT_IFACE

 #define VALID_DISK_LABEL

 #define VALID_HOSTNAME

 static int
 valid_port (int port)

 static int
 valid_blocksize (int blocksize)

 int
 guestfs_impl_remove_drive (guestfs_h *g, const char *label)

 size_t
 guestfs_int_checkpoint_drives (guestfs_h *g)

 char **
 guestfs_impl_debug_drives (guestfs_h *g)

 if (something_bad) {
   error (g, "something bad happened");
   return -1;
 }

 void
 guestfs_int_warning (guestfs_h *g, const char *fs, ...)

 void
 guestfs_int_debug (guestfs_h *g, const char *fs, ...)

 void
 guestfs_int_trace (guestfs_h *g, const char *fs, ...)

 void
 guestfs_int_error_errno (guestfs_h *g, int errnum, const char *fs, ...)

 void
 guestfs_int_perrorf (guestfs_h *g, const char *fs, ...)

 void
 guestfs_int_launch_failed_error (guestfs_h *g)

 void
 guestfs_int_unexpected_close_error (guestfs_h *g)

 void
 guestfs_int_launch_timeout (guestfs_h *g)

 void
 guestfs_int_external_command_failed (guestfs_h *g, int status,
                                     const char *cmd_name, const char *extra)

 static void
 replace_old_style_event_callback (guestfs_h *g,
                                   guestfs_event_callback cb,
                                   uint64_t event_bitmask,
                                   void *opaque,
                                   void *opaque2)

 struct event {
   uint64_t event_bitmask;
   guestfs_event_callback cb;
   void *opaque;

   /* opaque2 is not exposed through the API, but is used internally to
    * emulate the old-style callback API.
    */
   void *opaque2;
 };

 struct drive {
   /* Original source of the drive, eg. file:..., http:... */
   struct drive_source src;

   /* If the drive is readonly, then an overlay [a local file] is
    * created before launch to protect the original drive content, and
    * the filename is stored here.  Backends should open this file if
    * it is non-NULL, else consult the original source above.
    *
    * Note that the overlay is in a backend-specific format, probably
    * different from the source format.  eg. qcow2, UML COW.
    */
   char *overlay;

   /* Various per-drive flags. */
   bool readonly;
   char *iface;
   char *name;
   char *disk_label;
   char *cachemode;
   enum discard discard;
   bool copyonread;
   int blocksize;
 };

 struct backend_ops {
   /* Size (in bytes) of the per-handle data structure needed by this
    * backend.  The data pointer is allocated and freed by libguestfs
    * and passed to the functions in the 'void *data' parameter.
    * Inside the data structure is opaque to libguestfs.  Any strings
    * etc pointed to by it must be freed by the backend during
    * shutdown.
    */
   size_t data_size;

   /* Create a COW overlay on top of a drive.  This must be a local
    * file, created in the temporary directory.  This is called when
    * the drive is added to the handle.
    */
   char *(*create_cow_overlay) (guestfs_h *g, void *data, struct drive *drv);

   /* Launch and shut down. */
   int (*launch) (guestfs_h *g, void *data, const char *arg);
   int (*shutdown) (guestfs_h *g, void *data, int check_for_errors);

   /* Miscellaneous. */
   int (*get_pid) (guestfs_h *g, void *data);
   int (*max_disks) (guestfs_h *g, void *data);

   /* Hotplugging drives. */
   int (*hot_add_drive) (guestfs_h *g, void *data, struct drive *drv, size_t drv_index);
   int (*hot_remove_drive) (guestfs_h *g, void *data, struct drive *drv, size_t drv_index);
 };

 struct connection {
   const struct connection_ops *ops;

   /* In the real struct, private data used by each connection module
    * follows here.
    */
 };

 struct cached_feature {
   char *group;
   int result;
 };

 struct guestfs_h {
   struct guestfs_h *next;      /* Linked list of open handles. */
   enum state state;             /* See the state machine diagram in guestfs(3)*/

   /* Lock acquired when entering any public guestfs_* function to
    * protect the handle.
    */
   gl_recursive_lock_define (, lock);

   /**** Configuration of the handle. ****/
   bool verbose;                 /* Debugging. */
   bool trace;                   /* Trace calls. */
   bool autosync;                /* Autosync. */
   bool direct_mode;             /* Direct mode. */
   bool recovery_proc;           /* Create a recovery process. */
   bool enable_network;          /* Enable the network. */
   bool selinux;                 /* selinux enabled? */
   bool pgroup;                  /* Create process group for children? */
   bool close_on_exit;           /* Is this handle on the atexit list? */

   int smp;                      /* If > 1, -smp flag passed to hv. */
   int memsize;                 /* Size of RAM (megabytes). */

   char *path;                  /* Path to the appliance. */
   char *hv;                    /* Hypervisor (HV) binary. */
   char *append;                        /* Append to kernel command line. */

   struct hv_param *hv_params;   /* Extra hv parameters. */

   char *program;                /* Program name. */
   char *identifier;             /* Handle identifier. */

   /* Array of drives added by add-drive* APIs.
    *
    * Before launch this list can be empty or contain some drives.
    *
    * During launch, a dummy slot may be added which represents the
    * slot taken up by the appliance drive.
    *
    * When hotplugging is supported by the backend, drives can be
    * added to the end of this list after launch.  Also hot-removing a
    * drive causes a NULL slot to appear in the list.
    *
    * During shutdown, this list is deleted, so that each launch gets a
    * fresh set of drives (however callers: don't do this, create a new
    * handle each time).
    *
    * Always use ITER_DRIVES macro to iterate over this list!
    */
   struct drive **drives;
   size_t nr_drives;

 #define ITER_DRIVES(g,i,drv)              \
   for (i = 0; i < (g)->nr_drives; ++i)    \
     if (((drv) = (g)->drives[i]) != NULL)

   /* Backend.  NB: Use guestfs_int_set_backend to change the backend. */
   char *backend;                /* The full string, always non-NULL. */
   char *backend_arg;            /* Pointer to the argument part. */
   const struct backend_ops *backend_ops;
   void *backend_data;           /* Per-handle data. */
   char **backend_settings;      /* Backend settings (can be NULL). */

   /**** Runtime information. ****/
   /* Temporary and cache directories. */
   /* The actual temporary directory - this is not created with the
    * handle, you have to call guestfs_int_lazy_make_tmpdir.
    */
   char *tmpdir;
   char *sockdir;
   /* Environment variables that affect tmpdir/cachedir/sockdir locations. */
   char *env_tmpdir;             /* $TMPDIR (NULL if not set) */
   char *env_runtimedir;         /* $XDG_RUNTIME_DIR (NULL if not set)*/
   char *int_tmpdir;   /* $LIBGUESTFS_TMPDIR or guestfs_set_tmpdir or NULL */
   char *int_cachedir; /* $LIBGUESTFS_CACHEDIR or guestfs_set_cachedir or NULL */

   /* Error handler, plus stack of old error handlers. */
   gl_tls_key_t error_data;

   /* Linked list of error_data structures allocated for this handle,
    * plus a mutex to protect the linked list.
    */
   gl_lock_define (, error_data_list_lock);
   struct error_data *error_data_list;

   /* Out of memory error handler. */
   guestfs_abort_cb           abort_cb;

   /* Events. */
   struct event *events;
   size_t nr_events;

   /* Private data area. */
   struct hash_table *pda;
   struct pda_entry *pda_next;

   /* User cancelled transfer.  Not signal-atomic, but it doesn't
    * matter for this case because we only care if it is != 0.
    */
   int user_cancel;

   struct timeval launch_t;      /* The time that we called guestfs_launch. */

   /* Used by bindtests. */
   FILE *test_fp;

   /* Used to generate unique numbers, eg for temp files.  To use this,
    * '++g->unique'.  Note these are only unique per-handle, not
    * globally unique.
    */
   int unique;

   /*** Protocol. ***/
   struct connection *conn;              /* Connection to appliance. */
   int msg_next_serial;

 #if HAVE_FUSE
   /**** Used by the mount-local APIs. ****/
   char *localmountpoint;
   struct fuse *fuse;                    /* FUSE handle. */
   int ml_dir_cache_timeout;             /* Directory cache timeout. */
   Hash_table *lsc_ht, *xac_ht, *rlc_ht; /* Directory cache. */
   int ml_read_only;                     /* If mounted read-only. */
   int ml_debug_calls;        /* Extra debug info on each FUSE call. */
 #endif

 #ifdef HAVE_LIBVIRT_BACKEND
   /* Used by lib/libvirt-auth.c. */
 #define NR_CREDENTIAL_TYPES 9
   unsigned int nr_supported_credentials;
   int supported_credentials[NR_CREDENTIAL_TYPES];
   const char *saved_libvirt_uri; /* Doesn't need to be freed. */
   bool wrapper_warning_done;
   unsigned int nr_requested_credentials;
   virConnectCredentialPtr requested_credentials;
 #endif

   /* Cached features. */
   struct cached_feature *features;
   size_t nr_features;

   /* Used by lib/info.c.  -1 = not tested or error; else 0 or 1. */
   int qemu_img_supports_U_option;
 };

 struct version {
   int v_major;
   int v_minor;
   int v_micro;
 };

 int
 guestfs_int_validate_guid (const char *str)

 static void
 init_libguestfs (void)

 static int
 shutdown_backend (guestfs_h *g, int check_for_errors)

 static void
 close_handles (void)

 int
 guestfs_int_get_backend_setting_bool (guestfs_h *g, const char *name)

 static int
 qemu_img_supports_U_option (guestfs_h *g)

 char *
 guestfs_int_download_to_tmp (guestfs_h *g, const char *filename,
                              const char *extension,
                              uint64_t max_size)

 static int
 add_drive_standard_params (guestfs_h *g, struct backend_direct_data *data,
                            struct qemuopts *qopts,
                            size_t i, struct drive *drv)

 static int
 add_device_blocksize_params (guestfs_h *g, struct qemuopts *qopts,
                            struct drive *drv)

 static char *
 get_source_format_or_autodetect (guestfs_h *g, struct drive *drv)

 static char *
 make_qcow2_overlay (guestfs_h *g, const char *backing_drive,
                     const char *format)

 void
 guestfs_int_launch_send_progress (guestfs_h *g, int perdozen)

   0 / 12: launch clock starts
   3 / 12: appliance created
   6 / 12: detected that guest kernel started
   9 / 12: detected that /init script is running
  12 / 12: launch completed successfully

 int64_t
 guestfs_int_timeval_diff (const struct timeval *x, const struct timeval *y)

 void
 guestfs_int_unblock_sigterm (void)

 int
 guestfs_impl_max_disks (guestfs_h *g)

 int
 guestfs_impl_wait_ready (guestfs_h *g)

 int
 guestfs_int_create_socketname (guestfs_h *g, const char *filename,
                                char (*sockpath)[UNIX_PATH_MAX])

 void
 guestfs_int_register_backend (const char *name, const struct backend_ops *ops)

 int
 guestfs_int_set_backend (guestfs_h *g, const char *method)

 struct pda_entry {
   char *key;                    /* key */
   void *data;                   /* opaque user data pointer */
 };

  guestfs_int_send
  guestfs_int_recv

  guestfs_int_send
  guestfs_int_send_file  (possibly multiple times)
  guestfs_int_recv

  guestfs_int_send
  guestfs_int_recv
  guestfs_int_recv_file  (possibly multiple times)

 static void
 child_cleanup (guestfs_h *g)

 void
 guestfs_int_progress_message_callback (guestfs_h *g,
                                       const guestfs_progress *message)

 void
 guestfs_int_log_message_callback (guestfs_h *g, const char *buf, size_t len)

 static ssize_t
 check_daemon_socket (guestfs_h *g)

 int
 guestfs_int_send_file (guestfs_h *g, const char *filename)

 static int
 send_file_data (guestfs_h *g, const char *buf, size_t len)

 static int
 send_file_cancellation (guestfs_h *g)

 static int
 send_file_complete (guestfs_h *g)

 static int
 recv_from_daemon (guestfs_h *g, uint32_t *size_rtn, void **buf_rtn)

 int
 guestfs_int_recv (guestfs_h *g, const char *fn,
                  guestfs_message_header *hdr,
                  guestfs_message_error *err,
                  xdrproc_t xdrp, char *ret)

 int
 guestfs_int_recv_discard (guestfs_h *g, const char *fn)

 int
 guestfs_int_recv_file (guestfs_h *g, const char *filename)

 static ssize_t
 receive_file_data (guestfs_h *g, void **buf_r)

 struct qemu_data *
 guestfs_int_test_qemu (guestfs_h *g)

 static char *
 cache_filename (guestfs_h *g, const char *cachedir,
                 const struct stat *statbuf, const char *suffix)

 static void
 parse_qemu_version (guestfs_h *g, const char *qemu_help,
                     struct version *qemu_version)

 static void
 parse_json (guestfs_h *g, const char *json, json_t **treep)

 static void
 parse_has_kvm (guestfs_h *g, const char *json, bool *ret)

 static int
 generic_read_cache (guestfs_h *g, const char *filename, char **strp)

 static int
 generic_qmp_test (guestfs_h *g, struct qemu_data *data,
                   const char *qmp_command,
                   char **outp)

 struct version
 guestfs_int_qemu_version (guestfs_h *g, struct qemu_data *data)

 int
 guestfs_int_qemu_supports (guestfs_h *g, const struct qemu_data *data,
                            const char *option)

 int
 guestfs_int_qemu_supports_device (guestfs_h *g,
                                   const struct qemu_data *data,
                                   const char *device_name)

 int
 guestfs_int_qemu_mandatory_locking (guestfs_h *g,
                                     const struct qemu_data *data)

 char *
 guestfs_int_qemu_escape_param (guestfs_h *g, const char *param)

 char *
 guestfs_int_drive_source_qemu_param (guestfs_h *g,
                                      const struct drive_source *src)

 bool
 guestfs_int_discard_possible (guestfs_h *g, struct drive *drv,
                              const struct version *qemu_version)

 void
 guestfs_int_free_qemu_data (struct qemu_data *data)

 void
 guestfs_int_add_string_nodup (guestfs_h *g, struct stringsbuf *sb, char *str)

 void
 guestfs_int_add_string (guestfs_h *g, struct stringsbuf *sb, const char *str)

 void
 guestfs_int_add_sprintf (guestfs_h *g, struct stringsbuf *sb,
                         const char *fs, ...)

 void
 guestfs_int_end_stringsbuf (guestfs_h *g, struct stringsbuf *sb)

 void
 guestfs_int_free_stringsbuf (struct stringsbuf *sb)

 static int
 set_abs_path (guestfs_h *g, const char *ctxstr,
               const char *tmpdir, char **tmpdir_ret)

 char *
 guestfs_impl_get_tmpdir (guestfs_h *g)

 char *
 guestfs_impl_get_cachedir (guestfs_h *g)

 char *
 guestfs_impl_get_sockdir (guestfs_h *g)

 int
 guestfs_int_lazy_make_tmpdir (guestfs_h *g)

 char *
 guestfs_int_make_temp_path (guestfs_h *g,
                             const char *name, const char *extension)

 char *
 guestfs_int_lazy_make_supermin_appliance_dir (guestfs_h *g)

 void
 guestfs_int_recursive_remove_dir (guestfs_h *g, const char *dir)

 int
 guestfs_int_getumask (guestfs_h *g)

 static int
 get_umask_from_proc (guestfs_h *g)

 static int
 get_umask_from_fork (guestfs_h *g)

 static void
 test_split (void)

 static void
 test_concat (void)

 static void
 test_join (void)

 static void
 test_validate_guid (void)

 static void
 test_drive_name (void)

 static void
 test_drive_index (void)

 static void
 test_getumask (void)

 static void
 test_command (void)

 static void
 test_qemu_escape_param (void)

 static void
 test_timeval_diff (void)

 int
 guestfs_int_version_from_x_y (guestfs_h *g, struct version *v, const char *str)

 int
 guestfs_int_version_from_x_y_re (guestfs_h *g, struct version *v,
                                  const char *str, const pcre *re)

 int
 guestfs_int_version_from_x_y_or_x (guestfs_h *g, struct version *v,
                                    const char *str)

 int
 guestfs_int_parse_unsigned_int (guestfs_h *g, const char *str)

 int
 guestfs_int_waitpid (guestfs_h *g, pid_t pid, int *status, const char *errmsg)

 void
 guestfs_int_waitpid_noerror (pid_t pid)

 int
 guestfs_int_wait4 (guestfs_h *g, pid_t pid, int *status,
                    struct rusage *rusage, const char *errmsg)

 int
 guestfs_int_read_whole_file (guestfs_h *g, const char *filename,
                              char **data_r, size_t *size_r)

 int
 edit_file_editor (guestfs_h *g, const char *filename, const char *editor,
                   const char *backup_extension, int verbose)

 int
 edit_file_perl (guestfs_h *g, const char *filename, const char *perl_expr,
                 const char *backup_extension, int verbose)

 static void
 make_mapname (const char *device, char *mapname, size_t len)

 void
 inspect_do_decrypt (guestfs_h *g, struct key_store *ks)

 void
 display_short_options (const char *format)

 void
 display_long_options (const struct option *long_options)

 int
 add_libvirt_drives (guestfs_h *g, const char *guest)

 void
 inspect_mount_handle (guestfs_h *g, struct key_store *ks)

 void
 print_inspect_prompt (void)

 char *
 read_key (const char *param)

 void
 option_a (const char *arg, const char *format, int blocksize,
           struct drv **drvsp)

 void
 option_d (const char *arg, struct drv **drvsp)

 static void
 display_mountpoints_on_failure (const char *mp_device,
                                 const char *user_supplied_options)

 void
 free_domains (void)

 void
 get_all_libvirt_domains (const char *libvirt_uri)

 size_t
 estimate_max_threads (void)

 static char *
 read_line_from (const char *cmd)

 int
 start_threads (size_t option_P, guestfs_h *options_handle, work_fn work)

 struct progress_bar *
 progress_bar_init (unsigned flags)

 void
 progress_bar_free (struct progress_bar *bar)

 void
 progress_bar_reset (struct progress_bar *bar)

 static double
 estimate_remaining_time (struct progress_bar *bar, double ratio)

 void
 progress_bar_set (struct progress_bar *bar,
                   uint64_t position, uint64_t total)

 [smp-opts]
   cpus = "4"

 struct qemuopts *
 qemuopts_create (void)

 void
 qemuopts_free (struct qemuopts *qopts)

 int
 qemuopts_add_flag (struct qemuopts *qopts, const char *flag)

 qemuopts_add_flag (qopts, "-no-user-config");

 int
 qemuopts_add_arg (struct qemuopts *qopts, const char *flag, const char *value)

 qemuopts_add_arg (qopts, "-m", "1024");

 int
 qemuopts_add_arg_format (struct qemuopts *qopts, const char *flag,
                          const char *fs, ...)

 qemuopts_add_arg_format (qopts, "-m", "%d", 1024);

 int
 qemuopts_add_arg_noquote (struct qemuopts *qopts, const char *flag,
                           const char *value)

 int
 qemuopts_start_arg_list (struct qemuopts *qopts, const char *flag)

 qemuopts_start_arg_list (qopts, "-drive");
 qemuopts_append_arg_list (qopts, "file=foo");
 qemuopts_append_arg_list_format (qopts, "if=%s", "ide");
 qemuopts_end_arg_list (qopts);

 int
 qemuopts_add_arg_list (struct qemuopts *qopts, const char *flag,
                        const char *elem0, ...)

 qemuopts_add_arg_list (qopts, "-drive", "file=foo", "if=ide", NULL);

 int
 qemuopts_set_binary (struct qemuopts *qopts, const char *binary)

 int
 qemuopts_set_binary_by_arch (struct qemuopts *qopts, const char *arch)

 qemuopts_set_binary_by_arch (qopts, NULL);

 int
 qemuopts_to_script (struct qemuopts *qopts, const char *filename)

 static void
 shell_quote (const char *str, FILE *fp)

 static void
 shell_and_comma_quote (const char *str, FILE *fp)

 int
 qemuopts_to_channel (struct qemuopts *qopts, FILE *fp)

 char **
 qemuopts_to_argv (struct qemuopts *qopts)

 int
 qemuopts_to_config_file (struct qemuopts *qopts, const char *filename)

 [memory]
   size = "1024"

 int
 qemuopts_to_config_channel (struct qemuopts *qopts, FILE *fp)

 fn ()
 {
   CLEANUP_FREE char *str = NULL;
   str = safe_asprintf (g, "foo");
   // str is freed automatically when the function returns
 }

 fn ()
 {
   CLEANUP_FREE char *str = NULL;
   str = safe_asprintf (g, "foo");
   // str is freed automatically when the function returns
 }

 #define start_element

 start_element ("name") {
   ...
 } end_element ();

 #define empty_element

 empty_element ("name");

 #define single_element

 single_element ("name", text);

 #define single_element_format

 single_element_format ("cores", "%d", nr_cores);

 #define attribute

 start_element ("name") {
   attribute ("foo", "bar");
   attribute_format ("count", "%d", count);
   ...
 } end_element ();

 #define attribute_ns

 #define string

 string ("hello");

 #define string_format

 string ("%s, world", greeting);

 #define base64

 base64 (data, size);

 #define comment

  comment ("number of items = %d", nr_items);

 char **
 guestfs_int_split_string (char sep, const char *str)

 char *
 guestfs_int_replace_string (const char *str, const char *s1, const char *s2)

 replace_string ("abcabb", "ab", "a");

 char *
 guestfs_int_exit_status_to_string (int status, const char *cmd_name,
                                   char *buffer, size_t buflen)

 int
 guestfs_int_random_string (char *ret, size_t len)

 char *
 guestfs_int_drive_name (size_t index, char *ret)

 ssize_t
 guestfs_int_drive_index (const char *name)

 int
 guestfs_int_is_true (const char *str)

 bool
 guestfs_int_string_is_valid (const char *str,
                              size_t min_length, size_t max_length,
                              int flags, const char *extra)

 void
 guestfs_int_fadvise_normal (int fd)

 void
 guestfs_int_fadvise_sequential (int fd)

 void
 guestfs_int_fadvise_random (int fd)

 void
 guestfs_int_fadvise_noreuse (int fd)

 void
 guestfs_int_fadvise_dontneed (int fd)

 void
 guestfs_int_fadvise_willneed (int fd)

 char *
 guestfs_int_shell_unquote (const char *str)

 int
 guestfs_int_is_reg (int64_t mode)

 int
 guestfs_int_is_dir (int64_t mode)

 int
 guestfs_int_is_chr (int64_t mode)

 int
 guestfs_int_is_blk (int64_t mode)

 int
 guestfs_int_is_fifo (int64_t mode)

 int
 guestfs_int_is_lnk (int64_t mode)

 int
 guestfs_int_is_sock (int64_t mode)

 char *
 guestfs_int_full_path (const char *dir, const char *name)

 void
 guestfs_int_hexdump (const void *data, size_t len, FILE *fp)

 int
 visit (guestfs_h *g, const char *dir, visitor_function f, void *opaque)

 int
 is_windows (guestfs_h *g, const char *root)

 char *
 windows_path (guestfs_h *g, const char *root, const char *path, int readonly)

 int
 commandf (char **stdoutput, char **stderror, unsigned flags,
           const char *name, ...)

 int
 commandrf (char **stdoutput, char **stderror, unsigned flags,
            const char *name, ...)

 int
 commandvf (char **stdoutput, char **stderror, unsigned flags,
            char const *const *argv)

 int
 commandrvf (char **stdoutput, char **stderror, unsigned flags,
             char const* const *argv)

 void
 device_name_translation_init (void)

 char *
 device_name_translation (const char *device)

 static int
 print_shell_quote (FILE *stream,
                    const struct printf_info *info ATTRIBUTE_UNUSED,
                    const void *const *args)

 static int
 is_root_device_stat (struct stat *statbuf)

 int
 is_device_parameter (const char *device)

 char *
 sysroot_path (const char *path)

 char *
 sysroot_realpath (const char *path)

 int
 is_power_of_2 (unsigned long v)

 struct stringsbuf
 split_lines_sb (char *str)

 char **
 filter_list (bool (*p) (const char *str), char **strs)

 void
 trim (char *str)

 int
 parse_btrfsvol (const char *desc_orig, mountable_t *mountable)

 btrfsvol:/dev/sda3/root

 char *
 mountable_to_string (const mountable_t *mountable)

 int
 prog_exists (const char *prog)

 int
 random_name (char *template)

 void
 udev_settle_file (const char *file)

 char *
 make_exclude_from_file (const char *function, char *const *excludes)

 char *
 read_whole_file (const char *filename, size_t *size_r)

 static char **
 split_attr_names (char *buf, size_t len)

 int
 alloc_disk (const char *filename, const char *size_str, int add, int sparse)

 static struct parsed_command
 parse_command_line (char *buf, int *exit_on_error_rtn)

 static ssize_t
 parse_quoted_string (char *p)

 static int
 execute_and_inline (const char *cmd, int global_exit_on_error)

 int
 issue_command (const char *cmd, char *argv[], const char *pipecmd,
                int rc_exit_on_error_flag)

 void
 extended_help_message (void)

  guestfish disk.img

 static void
 error_cb (guestfs_h *g, void *data, const char *msg)

 static void
 free_n_strings (char **str, size_t len)

 static char *
 decode_ps1 (const char *str)

 char *
 win_prefix (const char *path)

 char *
 file_in (const char *arg)

 char *
 file_out (const char *arg)

 void
 progress_callback (guestfs_h *g, void *data,
                    uint64_t event, int event_handle, int flags,
                    const char *buf, size_t buf_len,
                    const uint64_t *array, size_t array_len)

 static char **
 expand_devicename (guestfs_h *g, const char *device)

 static int
 add_strings_matching (char **pp, const char *glob,
                       char ***ret, size_t *size_r)

 static char **
 single_element_list (const char *element)

 int
 display_help (const char *cmd, size_t argc, char *argv[])

 int
 run_lcd (const char *cmd, size_t argc, char *argv[])

 int
 run_man (const char *cmd, size_t argc, char *argv[])

 void
 rc_listen (void)

 int
 rc_remote (int pid, const char *cmd, size_t argc, char *argv[],
            int exit_on_error)

 char *
 try_tilde_expansion (char *str)

 static char *
 expand_home (char *orig, const char *append)

 static const char *
 find_home_for_username (const char *username, size_t ulen)

NAME¶

DESCRIPTION¶

THE SOURCE CODE¶

SOURCE CODE SUBDIRECTORIES¶

THE BUILD SYSTEM¶

EXTENDING LIBGUESTFS¶

ADDING A NEW API¶

ADDING A NEW LANGUAGE BINDING¶

FORMATTING CODE¶

TESTING YOUR CHANGES¶

VALGRIND¶

SUBMITTING PATCHES¶

DAEMON CUSTOM PRINTF FORMATTERS¶

INTERNATIONALIZATION (I18N) SUPPORT¶

MISCELLANEOUS TOPICS¶

HOW OCAML PROGRAMS ARE COMPILED AND LINKED¶

MAINTAINER TASKS¶

MAINTAINER MAKEFILE TARGETS¶

MAKING A STABLE RELEASE¶

INTERNAL DOCUMENTATION¶

Subdirectory lib¶

Subdirectory builder¶

Subdirectory common/edit¶

Subdirectory common/mlxml¶

Subdirectory common/options¶

Subdirectory common/parallel¶

Subdirectory common/progress¶

Subdirectory common/qemuopts¶

Subdirectory common/utils¶

Subdirectory common/visit¶

Subdirectory common/windows¶

Subdirectory daemon¶

Subdirectory fish¶

Subdirectory python¶

SEE ALSO¶

AUTHORS¶

COPYRIGHT¶

LICENSE¶

BUGS¶

Source file:	guestfs-hacking.1.en.gz (from libguestfs-devel 1.44.0-9.module+el8.9.0+18724+20190c23)
Source last updated:	2023-10-02 02:49:46
Converted to HTML:	2024-06-22 22:07:23