perl/Guestfs.xs

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "EXTERN.h"
  23 #include "perl.h"
  24 #include "XSUB.h"
  25
  26 #include <guestfs.h>
  27
  28 #ifndef PRId64
  29 #define PRId64 "lld"
  30 #endif
  31
  32 static SV *
  33 my_newSVll(long long val) {
  34 #ifdef USE_64_BIT_ALL
  35   return newSViv(val);
  36 #else
  37   char buf[100];
  38   int len;
  39   len = snprintf(buf, 100, "%" PRId64, val);
  40   return newSVpv(buf, len);
  41 #endif
  42 }
  43
  44 #ifndef PRIu64
  45 #define PRIu64 "llu"
  46 #endif
  47
  48 static SV *
  49 my_newSVull(unsigned long long val) {
  50 #ifdef USE_64_BIT_ALL
  51   return newSVuv(val);
  52 #else
  53   char buf[100];
  54   int len;
  55   len = snprintf(buf, 100, "%" PRIu64, val);
  56   return newSVpv(buf, len);
  57 #endif
  58 }
  59
  60 /* http://www.perlmonks.org/?node_id=680842 */
  61 static char **
  62 XS_unpack_charPtrPtr (SV *arg) {
  63   char **ret;
  64   AV *av;
  65   I32 i;
  66
  67   if (!arg || !SvOK (arg) || !SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV) {
  68     croak ("array reference expected");
  69   }
  70
  71   av = (AV *)SvRV (arg);
  72   ret = (char **)malloc (av_len (av) + 1 + 1);
  73
  74   for (i = 0; i <= av_len (av); i++) {
  75     SV **elem = av_fetch (av, i, 0);
  76
  77     if (!elem || !*elem)
  78       croak ("missing element in list");
  79
  80     ret[i] = SvPV_nolen (*elem);
  81   }
  82
  83   ret[i] = NULL;
  84
  85   return ret;
  86 }
  87
  88 MODULE = Sys::Guestfs  PACKAGE = Sys::Guestfs
  89
  90 guestfs_h *
  91 _create ()
  92    CODE:
  93       RETVAL = guestfs_create ();
  94       if (!RETVAL)
  95         croak ("could not create guestfs handle");
  96       guestfs_set_error_handler (RETVAL, NULL, NULL);
  97  OUTPUT:
  98       RETVAL
  99
 100 void
 101 DESTROY (g)
 102       guestfs_h *g;
 103  PPCODE:
 104       guestfs_close (g);
 105
 106 void
 107 launch (g)
 108       guestfs_h *g;
 109 PREINIT:
 110       int r;
 111  PPCODE:
 112       r = guestfs_launch (g);
 113       if (r == -1)
 114         croak ("launch: %s", guestfs_last_error (g));
 115
 116 void
 117 wait_ready (g)
 118       guestfs_h *g;
 119 PREINIT:
 120       int r;
 121  PPCODE:
 122       r = guestfs_wait_ready (g);
 123       if (r == -1)
 124         croak ("wait_ready: %s", guestfs_last_error (g));
 125
 126 void
 127 kill_subprocess (g)
 128       guestfs_h *g;
 129 PREINIT:
 130       int r;
 131  PPCODE:
 132       r = guestfs_kill_subprocess (g);
 133       if (r == -1)
 134         croak ("kill_subprocess: %s", guestfs_last_error (g));
 135
 136 void
 137 add_drive (g, filename)
 138       guestfs_h *g;
 139       char *filename;
 140 PREINIT:
 141       int r;
 142  PPCODE:
 143       r = guestfs_add_drive (g, filename);
 144       if (r == -1)
 145         croak ("add_drive: %s", guestfs_last_error (g));
 146
 147 void
 148 add_cdrom (g, filename)
 149       guestfs_h *g;
 150       char *filename;
 151 PREINIT:
 152       int r;
 153  PPCODE:
 154       r = guestfs_add_cdrom (g, filename);
 155       if (r == -1)
 156         croak ("add_cdrom: %s", guestfs_last_error (g));
 157
 158 void
 159 config (g, qemuparam, qemuvalue)
 160       guestfs_h *g;
 161       char *qemuparam;
 162       char *qemuvalue;
 163 PREINIT:
 164       int r;
 165  PPCODE:
 166       r = guestfs_config (g, qemuparam, qemuvalue);
 167       if (r == -1)
 168         croak ("config: %s", guestfs_last_error (g));
 169
 170 void
 171 set_qemu (g, qemu)
 172       guestfs_h *g;
 173       char *qemu;
 174 PREINIT:
 175       int r;
 176  PPCODE:
 177       r = guestfs_set_qemu (g, qemu);
 178       if (r == -1)
 179         croak ("set_qemu: %s", guestfs_last_error (g));
 180
 181 SV *
 182 get_qemu (g)
 183       guestfs_h *g;
 184 PREINIT:
 185       const char *qemu;
 186    CODE:
 187       qemu = guestfs_get_qemu (g);
 188       if (qemu == NULL)
 189         croak ("get_qemu: %s", guestfs_last_error (g));
 190       RETVAL = newSVpv (qemu, 0);
 191  OUTPUT:
 192       RETVAL
 193
 194 void
 195 set_path (g, path)
 196       guestfs_h *g;
 197       char *path;
 198 PREINIT:
 199       int r;
 200  PPCODE:
 201       r = guestfs_set_path (g, path);
 202       if (r == -1)
 203         croak ("set_path: %s", guestfs_last_error (g));
 204
 205 SV *
 206 get_path (g)
 207       guestfs_h *g;
 208 PREINIT:
 209       const char *path;
 210    CODE:
 211       path = guestfs_get_path (g);
 212       if (path == NULL)
 213         croak ("get_path: %s", guestfs_last_error (g));
 214       RETVAL = newSVpv (path, 0);
 215  OUTPUT:
 216       RETVAL
 217
 218 void
 219 set_autosync (g, autosync)
 220       guestfs_h *g;
 221       int autosync;
 222 PREINIT:
 223       int r;
 224  PPCODE:
 225       r = guestfs_set_autosync (g, autosync);
 226       if (r == -1)
 227         croak ("set_autosync: %s", guestfs_last_error (g));
 228
 229 SV *
 230 get_autosync (g)
 231       guestfs_h *g;
 232 PREINIT:
 233       int autosync;
 234    CODE:
 235       autosync = guestfs_get_autosync (g);
 236       if (autosync == -1)
 237         croak ("get_autosync: %s", guestfs_last_error (g));
 238       RETVAL = newSViv (autosync);
 239  OUTPUT:
 240       RETVAL
 241
 242 void
 243 set_verbose (g, verbose)
 244       guestfs_h *g;
 245       int verbose;
 246 PREINIT:
 247       int r;
 248  PPCODE:
 249       r = guestfs_set_verbose (g, verbose);
 250       if (r == -1)
 251         croak ("set_verbose: %s", guestfs_last_error (g));
 252
 253 SV *
 254 get_verbose (g)
 255       guestfs_h *g;
 256 PREINIT:
 257       int verbose;
 258    CODE:
 259       verbose = guestfs_get_verbose (g);
 260       if (verbose == -1)
 261         croak ("get_verbose: %s", guestfs_last_error (g));
 262       RETVAL = newSViv (verbose);
 263  OUTPUT:
 264       RETVAL
 265
 266 SV *
 267 is_ready (g)
 268       guestfs_h *g;
 269 PREINIT:
 270       int ready;
 271    CODE:
 272       ready = guestfs_is_ready (g);
 273       if (ready == -1)
 274         croak ("is_ready: %s", guestfs_last_error (g));
 275       RETVAL = newSViv (ready);
 276  OUTPUT:
 277       RETVAL
 278
 279 SV *
 280 is_config (g)
 281       guestfs_h *g;
 282 PREINIT:
 283       int config;
 284    CODE:
 285       config = guestfs_is_config (g);
 286       if (config == -1)
 287         croak ("is_config: %s", guestfs_last_error (g));
 288       RETVAL = newSViv (config);
 289  OUTPUT:
 290       RETVAL
 291
 292 SV *
 293 is_launching (g)
 294       guestfs_h *g;
 295 PREINIT:
 296       int launching;
 297    CODE:
 298       launching = guestfs_is_launching (g);
 299       if (launching == -1)
 300         croak ("is_launching: %s", guestfs_last_error (g));
 301       RETVAL = newSViv (launching);
 302  OUTPUT:
 303       RETVAL
 304
 305 SV *
 306 is_busy (g)
 307       guestfs_h *g;
 308 PREINIT:
 309       int busy;
 310    CODE:
 311       busy = guestfs_is_busy (g);
 312       if (busy == -1)
 313         croak ("is_busy: %s", guestfs_last_error (g));
 314       RETVAL = newSViv (busy);
 315  OUTPUT:
 316       RETVAL
 317
 318 SV *
 319 get_state (g)
 320       guestfs_h *g;
 321 PREINIT:
 322       int state;
 323    CODE:
 324       state = guestfs_get_state (g);
 325       if (state == -1)
 326         croak ("get_state: %s", guestfs_last_error (g));
 327       RETVAL = newSViv (state);
 328  OUTPUT:
 329       RETVAL
 330
 331 void
 332 set_busy (g)
 333       guestfs_h *g;
 334 PREINIT:
 335       int r;
 336  PPCODE:
 337       r = guestfs_set_busy (g);
 338       if (r == -1)
 339         croak ("set_busy: %s", guestfs_last_error (g));
 340
 341 void
 342 set_ready (g)
 343       guestfs_h *g;
 344 PREINIT:
 345       int r;
 346  PPCODE:
 347       r = guestfs_set_ready (g);
 348       if (r == -1)
 349         croak ("set_ready: %s", guestfs_last_error (g));
 350
 351 void
 352 mount (g, device, mountpoint)
 353       guestfs_h *g;
 354       char *device;
 355       char *mountpoint;
 356 PREINIT:
 357       int r;
 358  PPCODE:
 359       r = guestfs_mount (g, device, mountpoint);
 360       if (r == -1)
 361         croak ("mount: %s", guestfs_last_error (g));
 362
 363 void
 364 sync (g)
 365       guestfs_h *g;
 366 PREINIT:
 367       int r;
 368  PPCODE:
 369       r = guestfs_sync (g);
 370       if (r == -1)
 371         croak ("sync: %s", guestfs_last_error (g));
 372
 373 void
 374 touch (g, path)
 375       guestfs_h *g;
 376       char *path;
 377 PREINIT:
 378       int r;
 379  PPCODE:
 380       r = guestfs_touch (g, path);
 381       if (r == -1)
 382         croak ("touch: %s", guestfs_last_error (g));
 383
 384 SV *
 385 cat (g, path)
 386       guestfs_h *g;
 387       char *path;
 388 PREINIT:
 389       char *content;
 390    CODE:
 391       content = guestfs_cat (g, path);
 392       if (content == NULL)
 393         croak ("cat: %s", guestfs_last_error (g));
 394       RETVAL = newSVpv (content, 0);
 395       free (content);
 396  OUTPUT:
 397       RETVAL
 398
 399 SV *
 400 ll (g, directory)
 401       guestfs_h *g;
 402       char *directory;
 403 PREINIT:
 404       char *listing;
 405    CODE:
 406       listing = guestfs_ll (g, directory);
 407       if (listing == NULL)
 408         croak ("ll: %s", guestfs_last_error (g));
 409       RETVAL = newSVpv (listing, 0);
 410       free (listing);
 411  OUTPUT:
 412       RETVAL
 413
 414 void
 415 ls (g, directory)
 416       guestfs_h *g;
 417       char *directory;
 418 PREINIT:
 419       char **listing;
 420       int i, n;
 421  PPCODE:
 422       listing = guestfs_ls (g, directory);
 423       if (listing == NULL)
 424         croak ("ls: %s", guestfs_last_error (g));
 425       for (n = 0; listing[n] != NULL; ++n) /**/;
 426       EXTEND (SP, n);
 427       for (i = 0; i < n; ++i) {
 428         PUSHs (sv_2mortal (newSVpv (listing[i], 0)));
 429         free (listing[i]);
 430       }
 431       free (listing);
 432
 433 void
 434 list_devices (g)
 435       guestfs_h *g;
 436 PREINIT:
 437       char **devices;
 438       int i, n;
 439  PPCODE:
 440       devices = guestfs_list_devices (g);
 441       if (devices == NULL)
 442         croak ("list_devices: %s", guestfs_last_error (g));
 443       for (n = 0; devices[n] != NULL; ++n) /**/;
 444       EXTEND (SP, n);
 445       for (i = 0; i < n; ++i) {
 446         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
 447         free (devices[i]);
 448       }
 449       free (devices);
 450
 451 void
 452 list_partitions (g)
 453       guestfs_h *g;
 454 PREINIT:
 455       char **partitions;
 456       int i, n;
 457  PPCODE:
 458       partitions = guestfs_list_partitions (g);
 459       if (partitions == NULL)
 460         croak ("list_partitions: %s", guestfs_last_error (g));
 461       for (n = 0; partitions[n] != NULL; ++n) /**/;
 462       EXTEND (SP, n);
 463       for (i = 0; i < n; ++i) {
 464         PUSHs (sv_2mortal (newSVpv (partitions[i], 0)));
 465         free (partitions[i]);
 466       }
 467       free (partitions);
 468
 469 void
 470 pvs (g)
 471       guestfs_h *g;
 472 PREINIT:
 473       char **physvols;
 474       int i, n;
 475  PPCODE:
 476       physvols = guestfs_pvs (g);
 477       if (physvols == NULL)
 478         croak ("pvs: %s", guestfs_last_error (g));
 479       for (n = 0; physvols[n] != NULL; ++n) /**/;
 480       EXTEND (SP, n);
 481       for (i = 0; i < n; ++i) {
 482         PUSHs (sv_2mortal (newSVpv (physvols[i], 0)));
 483         free (physvols[i]);
 484       }
 485       free (physvols);
 486
 487 void
 488 vgs (g)
 489       guestfs_h *g;
 490 PREINIT:
 491       char **volgroups;
 492       int i, n;
 493  PPCODE:
 494       volgroups = guestfs_vgs (g);
 495       if (volgroups == NULL)
 496         croak ("vgs: %s", guestfs_last_error (g));
 497       for (n = 0; volgroups[n] != NULL; ++n) /**/;
 498       EXTEND (SP, n);
 499       for (i = 0; i < n; ++i) {
 500         PUSHs (sv_2mortal (newSVpv (volgroups[i], 0)));
 501         free (volgroups[i]);
 502       }
 503       free (volgroups);
 504
 505 void
 506 lvs (g)
 507       guestfs_h *g;
 508 PREINIT:
 509       char **logvols;
 510       int i, n;
 511  PPCODE:
 512       logvols = guestfs_lvs (g);
 513       if (logvols == NULL)
 514         croak ("lvs: %s", guestfs_last_error (g));
 515       for (n = 0; logvols[n] != NULL; ++n) /**/;
 516       EXTEND (SP, n);
 517       for (i = 0; i < n; ++i) {
 518         PUSHs (sv_2mortal (newSVpv (logvols[i], 0)));
 519         free (logvols[i]);
 520       }
 521       free (logvols);
 522
 523 void
 524 pvs_full (g)
 525       guestfs_h *g;
 526 PREINIT:
 527       struct guestfs_lvm_pv_list *physvols;
 528       int i;
 529       HV *hv;
 530  PPCODE:
 531       physvols = guestfs_pvs_full (g);
 532       if (physvols == NULL)
 533         croak ("pvs_full: %s", guestfs_last_error (g));
 534       EXTEND (SP, physvols->len);
 535       for (i = 0; i < physvols->len; ++i) {
 536         hv = newHV ();
 537         (void) hv_store (hv, "pv_name", 7, newSVpv (physvols->val[i].pv_name, 0), 0);
 538         (void) hv_store (hv, "pv_uuid", 7, newSVpv (physvols->val[i].pv_uuid, 32), 0);
 539         (void) hv_store (hv, "pv_fmt", 6, newSVpv (physvols->val[i].pv_fmt, 0), 0);
 540         (void) hv_store (hv, "pv_size", 7, my_newSVull (physvols->val[i].pv_size), 0);
 541         (void) hv_store (hv, "dev_size", 8, my_newSVull (physvols->val[i].dev_size), 0);
 542         (void) hv_store (hv, "pv_free", 7, my_newSVull (physvols->val[i].pv_free), 0);
 543         (void) hv_store (hv, "pv_used", 7, my_newSVull (physvols->val[i].pv_used), 0);
 544         (void) hv_store (hv, "pv_attr", 7, newSVpv (physvols->val[i].pv_attr, 0), 0);
 545         (void) hv_store (hv, "pv_pe_count", 11, my_newSVll (physvols->val[i].pv_pe_count), 0);
 546         (void) hv_store (hv, "pv_pe_alloc_count", 17, my_newSVll (physvols->val[i].pv_pe_alloc_count), 0);
 547         (void) hv_store (hv, "pv_tags", 7, newSVpv (physvols->val[i].pv_tags, 0), 0);
 548         (void) hv_store (hv, "pe_start", 8, my_newSVull (physvols->val[i].pe_start), 0);
 549         (void) hv_store (hv, "pv_mda_count", 12, my_newSVll (physvols->val[i].pv_mda_count), 0);
 550         (void) hv_store (hv, "pv_mda_free", 11, my_newSVull (physvols->val[i].pv_mda_free), 0);
 551         PUSHs (sv_2mortal ((SV *) hv));
 552       }
 553       guestfs_free_lvm_pv_list (physvols);
 554
 555 void
 556 vgs_full (g)
 557       guestfs_h *g;
 558 PREINIT:
 559       struct guestfs_lvm_vg_list *volgroups;
 560       int i;
 561       HV *hv;
 562  PPCODE:
 563       volgroups = guestfs_vgs_full (g);
 564       if (volgroups == NULL)
 565         croak ("vgs_full: %s", guestfs_last_error (g));
 566       EXTEND (SP, volgroups->len);
 567       for (i = 0; i < volgroups->len; ++i) {
 568         hv = newHV ();
 569         (void) hv_store (hv, "vg_name", 7, newSVpv (volgroups->val[i].vg_name, 0), 0);
 570         (void) hv_store (hv, "vg_uuid", 7, newSVpv (volgroups->val[i].vg_uuid, 32), 0);
 571         (void) hv_store (hv, "vg_fmt", 6, newSVpv (volgroups->val[i].vg_fmt, 0), 0);
 572         (void) hv_store (hv, "vg_attr", 7, newSVpv (volgroups->val[i].vg_attr, 0), 0);
 573         (void) hv_store (hv, "vg_size", 7, my_newSVull (volgroups->val[i].vg_size), 0);
 574         (void) hv_store (hv, "vg_free", 7, my_newSVull (volgroups->val[i].vg_free), 0);
 575         (void) hv_store (hv, "vg_sysid", 8, newSVpv (volgroups->val[i].vg_sysid, 0), 0);
 576         (void) hv_store (hv, "vg_extent_size", 14, my_newSVull (volgroups->val[i].vg_extent_size), 0);
 577         (void) hv_store (hv, "vg_extent_count", 15, my_newSVll (volgroups->val[i].vg_extent_count), 0);
 578         (void) hv_store (hv, "vg_free_count", 13, my_newSVll (volgroups->val[i].vg_free_count), 0);
 579         (void) hv_store (hv, "max_lv", 6, my_newSVll (volgroups->val[i].max_lv), 0);
 580         (void) hv_store (hv, "max_pv", 6, my_newSVll (volgroups->val[i].max_pv), 0);
 581         (void) hv_store (hv, "pv_count", 8, my_newSVll (volgroups->val[i].pv_count), 0);
 582         (void) hv_store (hv, "lv_count", 8, my_newSVll (volgroups->val[i].lv_count), 0);
 583         (void) hv_store (hv, "snap_count", 10, my_newSVll (volgroups->val[i].snap_count), 0);
 584         (void) hv_store (hv, "vg_seqno", 8, my_newSVll (volgroups->val[i].vg_seqno), 0);
 585         (void) hv_store (hv, "vg_tags", 7, newSVpv (volgroups->val[i].vg_tags, 0), 0);
 586         (void) hv_store (hv, "vg_mda_count", 12, my_newSVll (volgroups->val[i].vg_mda_count), 0);
 587         (void) hv_store (hv, "vg_mda_free", 11, my_newSVull (volgroups->val[i].vg_mda_free), 0);
 588         PUSHs (sv_2mortal ((SV *) hv));
 589       }
 590       guestfs_free_lvm_vg_list (volgroups);
 591
 592 void
 593 lvs_full (g)
 594       guestfs_h *g;
 595 PREINIT:
 596       struct guestfs_lvm_lv_list *logvols;
 597       int i;
 598       HV *hv;
 599  PPCODE:
 600       logvols = guestfs_lvs_full (g);
 601       if (logvols == NULL)
 602         croak ("lvs_full: %s", guestfs_last_error (g));
 603       EXTEND (SP, logvols->len);
 604       for (i = 0; i < logvols->len; ++i) {
 605         hv = newHV ();
 606         (void) hv_store (hv, "lv_name", 7, newSVpv (logvols->val[i].lv_name, 0), 0);
 607         (void) hv_store (hv, "lv_uuid", 7, newSVpv (logvols->val[i].lv_uuid, 32), 0);
 608         (void) hv_store (hv, "lv_attr", 7, newSVpv (logvols->val[i].lv_attr, 0), 0);
 609         (void) hv_store (hv, "lv_major", 8, my_newSVll (logvols->val[i].lv_major), 0);
 610         (void) hv_store (hv, "lv_minor", 8, my_newSVll (logvols->val[i].lv_minor), 0);
 611         (void) hv_store (hv, "lv_kernel_major", 15, my_newSVll (logvols->val[i].lv_kernel_major), 0);
 612         (void) hv_store (hv, "lv_kernel_minor", 15, my_newSVll (logvols->val[i].lv_kernel_minor), 0);
 613         (void) hv_store (hv, "lv_size", 7, my_newSVull (logvols->val[i].lv_size), 0);
 614         (void) hv_store (hv, "seg_count", 9, my_newSVll (logvols->val[i].seg_count), 0);
 615         (void) hv_store (hv, "origin", 6, newSVpv (logvols->val[i].origin, 0), 0);
 616         (void) hv_store (hv, "snap_percent", 12, newSVnv (logvols->val[i].snap_percent), 0);
 617         (void) hv_store (hv, "copy_percent", 12, newSVnv (logvols->val[i].copy_percent), 0);
 618         (void) hv_store (hv, "move_pv", 7, newSVpv (logvols->val[i].move_pv, 0), 0);
 619         (void) hv_store (hv, "lv_tags", 7, newSVpv (logvols->val[i].lv_tags, 0), 0);
 620         (void) hv_store (hv, "mirror_log", 10, newSVpv (logvols->val[i].mirror_log, 0), 0);
 621         (void) hv_store (hv, "modules", 7, newSVpv (logvols->val[i].modules, 0), 0);
 622         PUSHs (sv_2mortal ((SV *) hv));
 623       }
 624       guestfs_free_lvm_lv_list (logvols);
 625
 626 void
 627 read_lines (g, path)
 628       guestfs_h *g;
 629       char *path;
 630 PREINIT:
 631       char **lines;
 632       int i, n;
 633  PPCODE:
 634       lines = guestfs_read_lines (g, path);
 635       if (lines == NULL)
 636         croak ("read_lines: %s", guestfs_last_error (g));
 637       for (n = 0; lines[n] != NULL; ++n) /**/;
 638       EXTEND (SP, n);
 639       for (i = 0; i < n; ++i) {
 640         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
 641         free (lines[i]);
 642       }
 643       free (lines);
 644
 645 void
 646 aug_init (g, root, flags)
 647       guestfs_h *g;
 648       char *root;
 649       int flags;
 650 PREINIT:
 651       int r;
 652  PPCODE:
 653       r = guestfs_aug_init (g, root, flags);
 654       if (r == -1)
 655         croak ("aug_init: %s", guestfs_last_error (g));
 656
 657 void
 658 aug_close (g)
 659       guestfs_h *g;
 660 PREINIT:
 661       int r;
 662  PPCODE:
 663       r = guestfs_aug_close (g);
 664       if (r == -1)
 665         croak ("aug_close: %s", guestfs_last_error (g));
 666
 667 SV *
 668 aug_defvar (g, name, expr)
 669       guestfs_h *g;
 670       char *name;
 671       char *expr;
 672 PREINIT:
 673       int nrnodes;
 674    CODE:
 675       nrnodes = guestfs_aug_defvar (g, name, expr);
 676       if (nrnodes == -1)
 677         croak ("aug_defvar: %s", guestfs_last_error (g));
 678       RETVAL = newSViv (nrnodes);
 679  OUTPUT:
 680       RETVAL
 681
 682 void
 683 aug_defnode (g, name, expr, val)
 684       guestfs_h *g;
 685       char *name;
 686       char *expr;
 687       char *val;
 688 PREINIT:
 689       struct guestfs_int_bool *r;
 690  PPCODE:
 691       r = guestfs_aug_defnode (g, name, expr, val);
 692       if (r == NULL)
 693         croak ("aug_defnode: %s", guestfs_last_error (g));
 694       EXTEND (SP, 2);
 695       PUSHs (sv_2mortal (newSViv (r->i)));
 696       PUSHs (sv_2mortal (newSViv (r->b)));
 697       guestfs_free_int_bool (r);
 698
 699 SV *
 700 aug_get (g, path)
 701       guestfs_h *g;
 702       char *path;
 703 PREINIT:
 704       char *val;
 705    CODE:
 706       val = guestfs_aug_get (g, path);
 707       if (val == NULL)
 708         croak ("aug_get: %s", guestfs_last_error (g));
 709       RETVAL = newSVpv (val, 0);
 710       free (val);
 711  OUTPUT:
 712       RETVAL
 713
 714 void
 715 aug_set (g, path, val)
 716       guestfs_h *g;
 717       char *path;
 718       char *val;
 719 PREINIT:
 720       int r;
 721  PPCODE:
 722       r = guestfs_aug_set (g, path, val);
 723       if (r == -1)
 724         croak ("aug_set: %s", guestfs_last_error (g));
 725
 726 void
 727 aug_insert (g, path, label, before)
 728       guestfs_h *g;
 729       char *path;
 730       char *label;
 731       int before;
 732 PREINIT:
 733       int r;
 734  PPCODE:
 735       r = guestfs_aug_insert (g, path, label, before);
 736       if (r == -1)
 737         croak ("aug_insert: %s", guestfs_last_error (g));
 738
 739 SV *
 740 aug_rm (g, path)
 741       guestfs_h *g;
 742       char *path;
 743 PREINIT:
 744       int nrnodes;
 745    CODE:
 746       nrnodes = guestfs_aug_rm (g, path);
 747       if (nrnodes == -1)
 748         croak ("aug_rm: %s", guestfs_last_error (g));
 749       RETVAL = newSViv (nrnodes);
 750  OUTPUT:
 751       RETVAL
 752
 753 void
 754 aug_mv (g, src, dest)
 755       guestfs_h *g;
 756       char *src;
 757       char *dest;
 758 PREINIT:
 759       int r;
 760  PPCODE:
 761       r = guestfs_aug_mv (g, src, dest);
 762       if (r == -1)
 763         croak ("aug_mv: %s", guestfs_last_error (g));
 764
 765 void
 766 aug_match (g, path)
 767       guestfs_h *g;
 768       char *path;
 769 PREINIT:
 770       char **matches;
 771       int i, n;
 772  PPCODE:
 773       matches = guestfs_aug_match (g, path);
 774       if (matches == NULL)
 775         croak ("aug_match: %s", guestfs_last_error (g));
 776       for (n = 0; matches[n] != NULL; ++n) /**/;
 777       EXTEND (SP, n);
 778       for (i = 0; i < n; ++i) {
 779         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 780         free (matches[i]);
 781       }
 782       free (matches);
 783
 784 void
 785 aug_save (g)
 786       guestfs_h *g;
 787 PREINIT:
 788       int r;
 789  PPCODE:
 790       r = guestfs_aug_save (g);
 791       if (r == -1)
 792         croak ("aug_save: %s", guestfs_last_error (g));
 793
 794 void
 795 aug_load (g)
 796       guestfs_h *g;
 797 PREINIT:
 798       int r;
 799  PPCODE:
 800       r = guestfs_aug_load (g);
 801       if (r == -1)
 802         croak ("aug_load: %s", guestfs_last_error (g));
 803
 804 void
 805 aug_ls (g, path)
 806       guestfs_h *g;
 807       char *path;
 808 PREINIT:
 809       char **matches;
 810       int i, n;
 811  PPCODE:
 812       matches = guestfs_aug_ls (g, path);
 813       if (matches == NULL)
 814         croak ("aug_ls: %s", guestfs_last_error (g));
 815       for (n = 0; matches[n] != NULL; ++n) /**/;
 816       EXTEND (SP, n);
 817       for (i = 0; i < n; ++i) {
 818         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 819         free (matches[i]);
 820       }
 821       free (matches);
 822
 823 void
 824 rm (g, path)
 825       guestfs_h *g;
 826       char *path;
 827 PREINIT:
 828       int r;
 829  PPCODE:
 830       r = guestfs_rm (g, path);
 831       if (r == -1)
 832         croak ("rm: %s", guestfs_last_error (g));
 833
 834 void
 835 rmdir (g, path)
 836       guestfs_h *g;
 837       char *path;
 838 PREINIT:
 839       int r;
 840  PPCODE:
 841       r = guestfs_rmdir (g, path);
 842       if (r == -1)
 843         croak ("rmdir: %s", guestfs_last_error (g));
 844
 845 void
 846 rm_rf (g, path)
 847       guestfs_h *g;
 848       char *path;
 849 PREINIT:
 850       int r;
 851  PPCODE:
 852       r = guestfs_rm_rf (g, path);
 853       if (r == -1)
 854         croak ("rm_rf: %s", guestfs_last_error (g));
 855
 856 void
 857 mkdir (g, path)
 858       guestfs_h *g;
 859       char *path;
 860 PREINIT:
 861       int r;
 862  PPCODE:
 863       r = guestfs_mkdir (g, path);
 864       if (r == -1)
 865         croak ("mkdir: %s", guestfs_last_error (g));
 866
 867 void
 868 mkdir_p (g, path)
 869       guestfs_h *g;
 870       char *path;
 871 PREINIT:
 872       int r;
 873  PPCODE:
 874       r = guestfs_mkdir_p (g, path);
 875       if (r == -1)
 876         croak ("mkdir_p: %s", guestfs_last_error (g));
 877
 878 void
 879 chmod (g, mode, path)
 880       guestfs_h *g;
 881       int mode;
 882       char *path;
 883 PREINIT:
 884       int r;
 885  PPCODE:
 886       r = guestfs_chmod (g, mode, path);
 887       if (r == -1)
 888         croak ("chmod: %s", guestfs_last_error (g));
 889
 890 void
 891 chown (g, owner, group, path)
 892       guestfs_h *g;
 893       int owner;
 894       int group;
 895       char *path;
 896 PREINIT:
 897       int r;
 898  PPCODE:
 899       r = guestfs_chown (g, owner, group, path);
 900       if (r == -1)
 901         croak ("chown: %s", guestfs_last_error (g));
 902
 903 SV *
 904 exists (g, path)
 905       guestfs_h *g;
 906       char *path;
 907 PREINIT:
 908       int existsflag;
 909    CODE:
 910       existsflag = guestfs_exists (g, path);
 911       if (existsflag == -1)
 912         croak ("exists: %s", guestfs_last_error (g));
 913       RETVAL = newSViv (existsflag);
 914  OUTPUT:
 915       RETVAL
 916
 917 SV *
 918 is_file (g, path)
 919       guestfs_h *g;
 920       char *path;
 921 PREINIT:
 922       int fileflag;
 923    CODE:
 924       fileflag = guestfs_is_file (g, path);
 925       if (fileflag == -1)
 926         croak ("is_file: %s", guestfs_last_error (g));
 927       RETVAL = newSViv (fileflag);
 928  OUTPUT:
 929       RETVAL
 930
 931 SV *
 932 is_dir (g, path)
 933       guestfs_h *g;
 934       char *path;
 935 PREINIT:
 936       int dirflag;
 937    CODE:
 938       dirflag = guestfs_is_dir (g, path);
 939       if (dirflag == -1)
 940         croak ("is_dir: %s", guestfs_last_error (g));
 941       RETVAL = newSViv (dirflag);
 942  OUTPUT:
 943       RETVAL
 944
 945 void
 946 pvcreate (g, device)
 947       guestfs_h *g;
 948       char *device;
 949 PREINIT:
 950       int r;
 951  PPCODE:
 952       r = guestfs_pvcreate (g, device);
 953       if (r == -1)
 954         croak ("pvcreate: %s", guestfs_last_error (g));
 955
 956 void
 957 vgcreate (g, volgroup, physvols)
 958       guestfs_h *g;
 959       char *volgroup;
 960       char **physvols;
 961 PREINIT:
 962       int r;
 963  PPCODE:
 964       r = guestfs_vgcreate (g, volgroup, physvols);
 965       free (physvols);
 966       if (r == -1)
 967         croak ("vgcreate: %s", guestfs_last_error (g));
 968
 969 void
 970 lvcreate (g, logvol, volgroup, mbytes)
 971       guestfs_h *g;
 972       char *logvol;
 973       char *volgroup;
 974       int mbytes;
 975 PREINIT:
 976       int r;
 977  PPCODE:
 978       r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
 979       if (r == -1)
 980         croak ("lvcreate: %s", guestfs_last_error (g));
 981
 982 void
 983 mkfs (g, fstype, device)
 984       guestfs_h *g;
 985       char *fstype;
 986       char *device;
 987 PREINIT:
 988       int r;
 989  PPCODE:
 990       r = guestfs_mkfs (g, fstype, device);
 991       if (r == -1)
 992         croak ("mkfs: %s", guestfs_last_error (g));
 993
 994 void
 995 sfdisk (g, device, cyls, heads, sectors, lines)
 996       guestfs_h *g;
 997       char *device;
 998       int cyls;
 999       int heads;
1000       int sectors;
1001       char **lines;
1002 PREINIT:
1003       int r;
1004  PPCODE:
1005       r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1006       free (lines);
1007       if (r == -1)
1008         croak ("sfdisk: %s", guestfs_last_error (g));
1009
1010 void
1011 write_file (g, path, content, size)
1012       guestfs_h *g;
1013       char *path;
1014       char *content;
1015       int size;
1016 PREINIT:
1017       int r;
1018  PPCODE:
1019       r = guestfs_write_file (g, path, content, size);
1020       if (r == -1)
1021         croak ("write_file: %s", guestfs_last_error (g));
1022
1023 void
1024 umount (g, pathordevice)
1025       guestfs_h *g;
1026       char *pathordevice;
1027 PREINIT:
1028       int r;
1029  PPCODE:
1030       r = guestfs_umount (g, pathordevice);
1031       if (r == -1)
1032         croak ("umount: %s", guestfs_last_error (g));
1033
1034 void
1035 mounts (g)
1036       guestfs_h *g;
1037 PREINIT:
1038       char **devices;
1039       int i, n;
1040  PPCODE:
1041       devices = guestfs_mounts (g);
1042       if (devices == NULL)
1043         croak ("mounts: %s", guestfs_last_error (g));
1044       for (n = 0; devices[n] != NULL; ++n) /**/;
1045       EXTEND (SP, n);
1046       for (i = 0; i < n; ++i) {
1047         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
1048         free (devices[i]);
1049       }
1050       free (devices);
1051
1052 void
1053 umount_all (g)
1054       guestfs_h *g;
1055 PREINIT:
1056       int r;
1057  PPCODE:
1058       r = guestfs_umount_all (g);
1059       if (r == -1)
1060         croak ("umount_all: %s", guestfs_last_error (g));
1061
1062 void
1063 lvm_remove_all (g)
1064       guestfs_h *g;
1065 PREINIT:
1066       int r;
1067  PPCODE:
1068       r = guestfs_lvm_remove_all (g);
1069       if (r == -1)
1070         croak ("lvm_remove_all: %s", guestfs_last_error (g));
1071
1072 SV *
1073 file (g, path)
1074       guestfs_h *g;
1075       char *path;
1076 PREINIT:
1077       char *description;
1078    CODE:
1079       description = guestfs_file (g, path);
1080       if (description == NULL)
1081         croak ("file: %s", guestfs_last_error (g));
1082       RETVAL = newSVpv (description, 0);
1083       free (description);
1084  OUTPUT:
1085       RETVAL
1086
1087 SV *
1088 command (g, arguments)
1089       guestfs_h *g;
1090       char **arguments;
1091 PREINIT:
1092       char *output;
1093    CODE:
1094       output = guestfs_command (g, arguments);
1095       free (arguments);
1096       if (output == NULL)
1097         croak ("command: %s", guestfs_last_error (g));
1098       RETVAL = newSVpv (output, 0);
1099       free (output);
1100  OUTPUT:
1101       RETVAL
1102
1103 void
1104 command_lines (g, arguments)
1105       guestfs_h *g;
1106       char **arguments;
1107 PREINIT:
1108       char **lines;
1109       int i, n;
1110  PPCODE:
1111       lines = guestfs_command_lines (g, arguments);
1112       free (arguments);
1113       if (lines == NULL)
1114         croak ("command_lines: %s", guestfs_last_error (g));
1115       for (n = 0; lines[n] != NULL; ++n) /**/;
1116       EXTEND (SP, n);
1117       for (i = 0; i < n; ++i) {
1118         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
1119         free (lines[i]);
1120       }
1121       free (lines);
1122
1123 void
1124 stat (g, path)
1125       guestfs_h *g;
1126       char *path;
1127 PREINIT:
1128       struct guestfs_stat *statbuf;
1129  PPCODE:
1130       statbuf = guestfs_stat (g, path);
1131       if (statbuf == NULL)
1132         croak ("stat: %s", guestfs_last_error (g));
1133       EXTEND (SP, 13);
1134       PUSHs (sv_2mortal (my_newSVll (statbuf->dev)));
1135       PUSHs (sv_2mortal (my_newSVll (statbuf->ino)));
1136       PUSHs (sv_2mortal (my_newSVll (statbuf->mode)));
1137       PUSHs (sv_2mortal (my_newSVll (statbuf->nlink)));
1138       PUSHs (sv_2mortal (my_newSVll (statbuf->uid)));
1139       PUSHs (sv_2mortal (my_newSVll (statbuf->gid)));
1140       PUSHs (sv_2mortal (my_newSVll (statbuf->rdev)));
1141       PUSHs (sv_2mortal (my_newSVll (statbuf->size)));
1142       PUSHs (sv_2mortal (my_newSVll (statbuf->blksize)));
1143       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1144       PUSHs (sv_2mortal (my_newSVll (statbuf->atime)));
1145       PUSHs (sv_2mortal (my_newSVll (statbuf->mtime)));
1146       PUSHs (sv_2mortal (my_newSVll (statbuf->ctime)));
1147       free (statbuf);
1148
1149 void
1150 lstat (g, path)
1151       guestfs_h *g;
1152       char *path;
1153 PREINIT:
1154       struct guestfs_stat *statbuf;
1155  PPCODE:
1156       statbuf = guestfs_lstat (g, path);
1157       if (statbuf == NULL)
1158         croak ("lstat: %s", guestfs_last_error (g));
1159       EXTEND (SP, 13);
1160       PUSHs (sv_2mortal (my_newSVll (statbuf->dev)));
1161       PUSHs (sv_2mortal (my_newSVll (statbuf->ino)));
1162       PUSHs (sv_2mortal (my_newSVll (statbuf->mode)));
1163       PUSHs (sv_2mortal (my_newSVll (statbuf->nlink)));
1164       PUSHs (sv_2mortal (my_newSVll (statbuf->uid)));
1165       PUSHs (sv_2mortal (my_newSVll (statbuf->gid)));
1166       PUSHs (sv_2mortal (my_newSVll (statbuf->rdev)));
1167       PUSHs (sv_2mortal (my_newSVll (statbuf->size)));
1168       PUSHs (sv_2mortal (my_newSVll (statbuf->blksize)));
1169       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1170       PUSHs (sv_2mortal (my_newSVll (statbuf->atime)));
1171       PUSHs (sv_2mortal (my_newSVll (statbuf->mtime)));
1172       PUSHs (sv_2mortal (my_newSVll (statbuf->ctime)));
1173       free (statbuf);
1174
1175 void
1176 statvfs (g, path)
1177       guestfs_h *g;
1178       char *path;
1179 PREINIT:
1180       struct guestfs_statvfs *statbuf;
1181  PPCODE:
1182       statbuf = guestfs_statvfs (g, path);
1183       if (statbuf == NULL)
1184         croak ("statvfs: %s", guestfs_last_error (g));
1185       EXTEND (SP, 11);
1186       PUSHs (sv_2mortal (my_newSVll (statbuf->bsize)));
1187       PUSHs (sv_2mortal (my_newSVll (statbuf->frsize)));
1188       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1189       PUSHs (sv_2mortal (my_newSVll (statbuf->bfree)));
1190       PUSHs (sv_2mortal (my_newSVll (statbuf->bavail)));
1191       PUSHs (sv_2mortal (my_newSVll (statbuf->files)));
1192       PUSHs (sv_2mortal (my_newSVll (statbuf->ffree)));
1193       PUSHs (sv_2mortal (my_newSVll (statbuf->favail)));
1194       PUSHs (sv_2mortal (my_newSVll (statbuf->fsid)));
1195       PUSHs (sv_2mortal (my_newSVll (statbuf->flag)));
1196       PUSHs (sv_2mortal (my_newSVll (statbuf->namemax)));
1197       free (statbuf);
1198
1199 void
1200 tune2fs_l (g, device)
1201       guestfs_h *g;
1202       char *device;
1203 PREINIT:
1204       char **superblock;
1205       int i, n;
1206  PPCODE:
1207       superblock = guestfs_tune2fs_l (g, device);
1208       if (superblock == NULL)
1209         croak ("tune2fs_l: %s", guestfs_last_error (g));
1210       for (n = 0; superblock[n] != NULL; ++n) /**/;
1211       EXTEND (SP, n);
1212       for (i = 0; i < n; ++i) {
1213         PUSHs (sv_2mortal (newSVpv (superblock[i], 0)));
1214         free (superblock[i]);
1215       }
1216       free (superblock);
1217
1218 void
1219 blockdev_setro (g, device)
1220       guestfs_h *g;
1221       char *device;
1222 PREINIT:
1223       int r;
1224  PPCODE:
1225       r = guestfs_blockdev_setro (g, device);
1226       if (r == -1)
1227         croak ("blockdev_setro: %s", guestfs_last_error (g));
1228
1229 void
1230 blockdev_setrw (g, device)
1231       guestfs_h *g;
1232       char *device;
1233 PREINIT:
1234       int r;
1235  PPCODE:
1236       r = guestfs_blockdev_setrw (g, device);
1237       if (r == -1)
1238         croak ("blockdev_setrw: %s", guestfs_last_error (g));
1239
1240 SV *
1241 blockdev_getro (g, device)
1242       guestfs_h *g;
1243       char *device;
1244 PREINIT:
1245       int ro;
1246    CODE:
1247       ro = guestfs_blockdev_getro (g, device);
1248       if (ro == -1)
1249         croak ("blockdev_getro: %s", guestfs_last_error (g));
1250       RETVAL = newSViv (ro);
1251  OUTPUT:
1252       RETVAL
1253
1254 SV *
1255 blockdev_getss (g, device)
1256       guestfs_h *g;
1257       char *device;
1258 PREINIT:
1259       int sectorsize;
1260    CODE:
1261       sectorsize = guestfs_blockdev_getss (g, device);
1262       if (sectorsize == -1)
1263         croak ("blockdev_getss: %s", guestfs_last_error (g));
1264       RETVAL = newSViv (sectorsize);
1265  OUTPUT:
1266       RETVAL
1267
1268 SV *
1269 blockdev_getbsz (g, device)
1270       guestfs_h *g;
1271       char *device;
1272 PREINIT:
1273       int blocksize;
1274    CODE:
1275       blocksize = guestfs_blockdev_getbsz (g, device);
1276       if (blocksize == -1)
1277         croak ("blockdev_getbsz: %s", guestfs_last_error (g));
1278       RETVAL = newSViv (blocksize);
1279  OUTPUT:
1280       RETVAL
1281
1282 void
1283 blockdev_setbsz (g, device, blocksize)
1284       guestfs_h *g;
1285       char *device;
1286       int blocksize;
1287 PREINIT:
1288       int r;
1289  PPCODE:
1290       r = guestfs_blockdev_setbsz (g, device, blocksize);
1291       if (r == -1)
1292         croak ("blockdev_setbsz: %s", guestfs_last_error (g));
1293
1294 SV *
1295 blockdev_getsz (g, device)
1296       guestfs_h *g;
1297       char *device;
1298 PREINIT:
1299       int64_t sizeinsectors;
1300    CODE:
1301       sizeinsectors = guestfs_blockdev_getsz (g, device);
1302       if (sizeinsectors == -1)
1303         croak ("blockdev_getsz: %s", guestfs_last_error (g));
1304       RETVAL = my_newSVll (sizeinsectors);
1305  OUTPUT:
1306       RETVAL
1307
1308 SV *
1309 blockdev_getsize64 (g, device)
1310       guestfs_h *g;
1311       char *device;
1312 PREINIT:
1313       int64_t sizeinbytes;
1314    CODE:
1315       sizeinbytes = guestfs_blockdev_getsize64 (g, device);
1316       if (sizeinbytes == -1)
1317         croak ("blockdev_getsize64: %s", guestfs_last_error (g));
1318       RETVAL = my_newSVll (sizeinbytes);
1319  OUTPUT:
1320       RETVAL
1321
1322 void
1323 blockdev_flushbufs (g, device)
1324       guestfs_h *g;
1325       char *device;
1326 PREINIT:
1327       int r;
1328  PPCODE:
1329       r = guestfs_blockdev_flushbufs (g, device);
1330       if (r == -1)
1331         croak ("blockdev_flushbufs: %s", guestfs_last_error (g));
1332
1333 void
1334 blockdev_rereadpt (g, device)
1335       guestfs_h *g;
1336       char *device;
1337 PREINIT:
1338       int r;
1339  PPCODE:
1340       r = guestfs_blockdev_rereadpt (g, device);
1341       if (r == -1)
1342         croak ("blockdev_rereadpt: %s", guestfs_last_error (g));
1343
1344 void
1345 upload (g, filename, remotefilename)
1346       guestfs_h *g;
1347       char *filename;
1348       char *remotefilename;
1349 PREINIT:
1350       int r;
1351  PPCODE:
1352       r = guestfs_upload (g, filename, remotefilename);
1353       if (r == -1)
1354         croak ("upload: %s", guestfs_last_error (g));
1355
1356 void
1357 download (g, remotefilename, filename)
1358       guestfs_h *g;
1359       char *remotefilename;
1360       char *filename;
1361 PREINIT:
1362       int r;
1363  PPCODE:
1364       r = guestfs_download (g, remotefilename, filename);
1365       if (r == -1)
1366         croak ("download: %s", guestfs_last_error (g));
1367
1368 SV *
1369 checksum (g, csumtype, path)
1370       guestfs_h *g;
1371       char *csumtype;
1372       char *path;
1373 PREINIT:
1374       char *checksum;
1375    CODE:
1376       checksum = guestfs_checksum (g, csumtype, path);
1377       if (checksum == NULL)
1378         croak ("checksum: %s", guestfs_last_error (g));
1379       RETVAL = newSVpv (checksum, 0);
1380       free (checksum);
1381  OUTPUT:
1382       RETVAL
1383
1384 void
1385 tar_in (g, tarfile, directory)
1386       guestfs_h *g;
1387       char *tarfile;
1388       char *directory;
1389 PREINIT:
1390       int r;
1391  PPCODE:
1392       r = guestfs_tar_in (g, tarfile, directory);
1393       if (r == -1)
1394         croak ("tar_in: %s", guestfs_last_error (g));
1395
1396 void
1397 tar_out (g, directory, tarfile)
1398       guestfs_h *g;
1399       char *directory;
1400       char *tarfile;
1401 PREINIT:
1402       int r;
1403  PPCODE:
1404       r = guestfs_tar_out (g, directory, tarfile);
1405       if (r == -1)
1406         croak ("tar_out: %s", guestfs_last_error (g));
1407
1408 void
1409 tgz_in (g, tarball, directory)
1410       guestfs_h *g;
1411       char *tarball;
1412       char *directory;
1413 PREINIT:
1414       int r;
1415  PPCODE:
1416       r = guestfs_tgz_in (g, tarball, directory);
1417       if (r == -1)
1418         croak ("tgz_in: %s", guestfs_last_error (g));
1419
1420 void
1421 tgz_out (g, directory, tarball)
1422       guestfs_h *g;
1423       char *directory;
1424       char *tarball;
1425 PREINIT:
1426       int r;
1427  PPCODE:
1428       r = guestfs_tgz_out (g, directory, tarball);
1429       if (r == -1)
1430         croak ("tgz_out: %s", guestfs_last_error (g));
1431
1432 void
1433 mount_ro (g, device, mountpoint)
1434       guestfs_h *g;
1435       char *device;
1436       char *mountpoint;
1437 PREINIT:
1438       int r;
1439  PPCODE:
1440       r = guestfs_mount_ro (g, device, mountpoint);
1441       if (r == -1)
1442         croak ("mount_ro: %s", guestfs_last_error (g));
1443
1444 void
1445 mount_options (g, options, device, mountpoint)
1446       guestfs_h *g;
1447       char *options;
1448       char *device;
1449       char *mountpoint;
1450 PREINIT:
1451       int r;
1452  PPCODE:
1453       r = guestfs_mount_options (g, options, device, mountpoint);
1454       if (r == -1)
1455         croak ("mount_options: %s", guestfs_last_error (g));
1456
1457 void
1458 mount_vfs (g, options, vfstype, device, mountpoint)
1459       guestfs_h *g;
1460       char *options;
1461       char *vfstype;
1462       char *device;
1463       char *mountpoint;
1464 PREINIT:
1465       int r;
1466  PPCODE:
1467       r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1468       if (r == -1)
1469         croak ("mount_vfs: %s", guestfs_last_error (g));
1470