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   av = (AV *)SvRV (arg);
  71   ret = malloc ((av_len (av) + 1 + 1) * sizeof (char *));
  72   if (!ret)
  73     croak ("malloc failed");
  74
  75   for (i = 0; i <= av_len (av); i++) {
  76     SV **elem = av_fetch (av, i, 0);
  77
  78     if (!elem || !*elem)
  79       croak ("missing element in list");
  80
  81     ret[i] = SvPV_nolen (*elem);
  82   }
  83
  84   ret[i] = NULL;
  85
  86   return ret;
  87 }
  88
  89 MODULE = Sys::Guestfs  PACKAGE = Sys::Guestfs
  90
  91 PROTOTYPES: ENABLE
  92
  93 guestfs_h *
  94 _create ()
  95    CODE:
  96       RETVAL = guestfs_create ();
  97       if (!RETVAL)
  98         croak ("could not create guestfs handle");
  99       guestfs_set_error_handler (RETVAL, NULL, NULL);
 100  OUTPUT:
 101       RETVAL
 102
 103 void
 104 DESTROY (g)
 105       guestfs_h *g;
 106  PPCODE:
 107       guestfs_close (g);
 108
 109 void
 110 launch (g)
 111       guestfs_h *g;
 112 PREINIT:
 113       int r;
 114  PPCODE:
 115       r = guestfs_launch (g);
 116       if (r == -1)
 117         croak ("launch: %s", guestfs_last_error (g));
 118
 119 void
 120 wait_ready (g)
 121       guestfs_h *g;
 122 PREINIT:
 123       int r;
 124  PPCODE:
 125       r = guestfs_wait_ready (g);
 126       if (r == -1)
 127         croak ("wait_ready: %s", guestfs_last_error (g));
 128
 129 void
 130 kill_subprocess (g)
 131       guestfs_h *g;
 132 PREINIT:
 133       int r;
 134  PPCODE:
 135       r = guestfs_kill_subprocess (g);
 136       if (r == -1)
 137         croak ("kill_subprocess: %s", guestfs_last_error (g));
 138
 139 void
 140 add_drive (g, filename)
 141       guestfs_h *g;
 142       char *filename;
 143 PREINIT:
 144       int r;
 145  PPCODE:
 146       r = guestfs_add_drive (g, filename);
 147       if (r == -1)
 148         croak ("add_drive: %s", guestfs_last_error (g));
 149
 150 void
 151 add_cdrom (g, filename)
 152       guestfs_h *g;
 153       char *filename;
 154 PREINIT:
 155       int r;
 156  PPCODE:
 157       r = guestfs_add_cdrom (g, filename);
 158       if (r == -1)
 159         croak ("add_cdrom: %s", guestfs_last_error (g));
 160
 161 void
 162 config (g, qemuparam, qemuvalue)
 163       guestfs_h *g;
 164       char *qemuparam;
 165       char *qemuvalue;
 166 PREINIT:
 167       int r;
 168  PPCODE:
 169       r = guestfs_config (g, qemuparam, qemuvalue);
 170       if (r == -1)
 171         croak ("config: %s", guestfs_last_error (g));
 172
 173 void
 174 set_qemu (g, qemu)
 175       guestfs_h *g;
 176       char *qemu;
 177 PREINIT:
 178       int r;
 179  PPCODE:
 180       r = guestfs_set_qemu (g, qemu);
 181       if (r == -1)
 182         croak ("set_qemu: %s", guestfs_last_error (g));
 183
 184 SV *
 185 get_qemu (g)
 186       guestfs_h *g;
 187 PREINIT:
 188       const char *qemu;
 189    CODE:
 190       qemu = guestfs_get_qemu (g);
 191       if (qemu == NULL)
 192         croak ("get_qemu: %s", guestfs_last_error (g));
 193       RETVAL = newSVpv (qemu, 0);
 194  OUTPUT:
 195       RETVAL
 196
 197 void
 198 set_path (g, path)
 199       guestfs_h *g;
 200       char *path;
 201 PREINIT:
 202       int r;
 203  PPCODE:
 204       r = guestfs_set_path (g, path);
 205       if (r == -1)
 206         croak ("set_path: %s", guestfs_last_error (g));
 207
 208 SV *
 209 get_path (g)
 210       guestfs_h *g;
 211 PREINIT:
 212       const char *path;
 213    CODE:
 214       path = guestfs_get_path (g);
 215       if (path == NULL)
 216         croak ("get_path: %s", guestfs_last_error (g));
 217       RETVAL = newSVpv (path, 0);
 218  OUTPUT:
 219       RETVAL
 220
 221 void
 222 set_append (g, append)
 223       guestfs_h *g;
 224       char *append;
 225 PREINIT:
 226       int r;
 227  PPCODE:
 228       r = guestfs_set_append (g, append);
 229       if (r == -1)
 230         croak ("set_append: %s", guestfs_last_error (g));
 231
 232 SV *
 233 get_append (g)
 234       guestfs_h *g;
 235 PREINIT:
 236       const char *append;
 237    CODE:
 238       append = guestfs_get_append (g);
 239       if (append == NULL)
 240         croak ("get_append: %s", guestfs_last_error (g));
 241       RETVAL = newSVpv (append, 0);
 242  OUTPUT:
 243       RETVAL
 244
 245 void
 246 set_autosync (g, autosync)
 247       guestfs_h *g;
 248       int autosync;
 249 PREINIT:
 250       int r;
 251  PPCODE:
 252       r = guestfs_set_autosync (g, autosync);
 253       if (r == -1)
 254         croak ("set_autosync: %s", guestfs_last_error (g));
 255
 256 SV *
 257 get_autosync (g)
 258       guestfs_h *g;
 259 PREINIT:
 260       int autosync;
 261    CODE:
 262       autosync = guestfs_get_autosync (g);
 263       if (autosync == -1)
 264         croak ("get_autosync: %s", guestfs_last_error (g));
 265       RETVAL = newSViv (autosync);
 266  OUTPUT:
 267       RETVAL
 268
 269 void
 270 set_verbose (g, verbose)
 271       guestfs_h *g;
 272       int verbose;
 273 PREINIT:
 274       int r;
 275  PPCODE:
 276       r = guestfs_set_verbose (g, verbose);
 277       if (r == -1)
 278         croak ("set_verbose: %s", guestfs_last_error (g));
 279
 280 SV *
 281 get_verbose (g)
 282       guestfs_h *g;
 283 PREINIT:
 284       int verbose;
 285    CODE:
 286       verbose = guestfs_get_verbose (g);
 287       if (verbose == -1)
 288         croak ("get_verbose: %s", guestfs_last_error (g));
 289       RETVAL = newSViv (verbose);
 290  OUTPUT:
 291       RETVAL
 292
 293 SV *
 294 is_ready (g)
 295       guestfs_h *g;
 296 PREINIT:
 297       int ready;
 298    CODE:
 299       ready = guestfs_is_ready (g);
 300       if (ready == -1)
 301         croak ("is_ready: %s", guestfs_last_error (g));
 302       RETVAL = newSViv (ready);
 303  OUTPUT:
 304       RETVAL
 305
 306 SV *
 307 is_config (g)
 308       guestfs_h *g;
 309 PREINIT:
 310       int config;
 311    CODE:
 312       config = guestfs_is_config (g);
 313       if (config == -1)
 314         croak ("is_config: %s", guestfs_last_error (g));
 315       RETVAL = newSViv (config);
 316  OUTPUT:
 317       RETVAL
 318
 319 SV *
 320 is_launching (g)
 321       guestfs_h *g;
 322 PREINIT:
 323       int launching;
 324    CODE:
 325       launching = guestfs_is_launching (g);
 326       if (launching == -1)
 327         croak ("is_launching: %s", guestfs_last_error (g));
 328       RETVAL = newSViv (launching);
 329  OUTPUT:
 330       RETVAL
 331
 332 SV *
 333 is_busy (g)
 334       guestfs_h *g;
 335 PREINIT:
 336       int busy;
 337    CODE:
 338       busy = guestfs_is_busy (g);
 339       if (busy == -1)
 340         croak ("is_busy: %s", guestfs_last_error (g));
 341       RETVAL = newSViv (busy);
 342  OUTPUT:
 343       RETVAL
 344
 345 SV *
 346 get_state (g)
 347       guestfs_h *g;
 348 PREINIT:
 349       int state;
 350    CODE:
 351       state = guestfs_get_state (g);
 352       if (state == -1)
 353         croak ("get_state: %s", guestfs_last_error (g));
 354       RETVAL = newSViv (state);
 355  OUTPUT:
 356       RETVAL
 357
 358 void
 359 set_busy (g)
 360       guestfs_h *g;
 361 PREINIT:
 362       int r;
 363  PPCODE:
 364       r = guestfs_set_busy (g);
 365       if (r == -1)
 366         croak ("set_busy: %s", guestfs_last_error (g));
 367
 368 void
 369 set_ready (g)
 370       guestfs_h *g;
 371 PREINIT:
 372       int r;
 373  PPCODE:
 374       r = guestfs_set_ready (g);
 375       if (r == -1)
 376         croak ("set_ready: %s", guestfs_last_error (g));
 377
 378 void
 379 end_busy (g)
 380       guestfs_h *g;
 381 PREINIT:
 382       int r;
 383  PPCODE:
 384       r = guestfs_end_busy (g);
 385       if (r == -1)
 386         croak ("end_busy: %s", guestfs_last_error (g));
 387
 388 void
 389 mount (g, device, mountpoint)
 390       guestfs_h *g;
 391       char *device;
 392       char *mountpoint;
 393 PREINIT:
 394       int r;
 395  PPCODE:
 396       r = guestfs_mount (g, device, mountpoint);
 397       if (r == -1)
 398         croak ("mount: %s", guestfs_last_error (g));
 399
 400 void
 401 sync (g)
 402       guestfs_h *g;
 403 PREINIT:
 404       int r;
 405  PPCODE:
 406       r = guestfs_sync (g);
 407       if (r == -1)
 408         croak ("sync: %s", guestfs_last_error (g));
 409
 410 void
 411 touch (g, path)
 412       guestfs_h *g;
 413       char *path;
 414 PREINIT:
 415       int r;
 416  PPCODE:
 417       r = guestfs_touch (g, path);
 418       if (r == -1)
 419         croak ("touch: %s", guestfs_last_error (g));
 420
 421 SV *
 422 cat (g, path)
 423       guestfs_h *g;
 424       char *path;
 425 PREINIT:
 426       char *content;
 427    CODE:
 428       content = guestfs_cat (g, path);
 429       if (content == NULL)
 430         croak ("cat: %s", guestfs_last_error (g));
 431       RETVAL = newSVpv (content, 0);
 432       free (content);
 433  OUTPUT:
 434       RETVAL
 435
 436 SV *
 437 ll (g, directory)
 438       guestfs_h *g;
 439       char *directory;
 440 PREINIT:
 441       char *listing;
 442    CODE:
 443       listing = guestfs_ll (g, directory);
 444       if (listing == NULL)
 445         croak ("ll: %s", guestfs_last_error (g));
 446       RETVAL = newSVpv (listing, 0);
 447       free (listing);
 448  OUTPUT:
 449       RETVAL
 450
 451 void
 452 ls (g, directory)
 453       guestfs_h *g;
 454       char *directory;
 455 PREINIT:
 456       char **listing;
 457       int i, n;
 458  PPCODE:
 459       listing = guestfs_ls (g, directory);
 460       if (listing == NULL)
 461         croak ("ls: %s", guestfs_last_error (g));
 462       for (n = 0; listing[n] != NULL; ++n) /**/;
 463       EXTEND (SP, n);
 464       for (i = 0; i < n; ++i) {
 465         PUSHs (sv_2mortal (newSVpv (listing[i], 0)));
 466         free (listing[i]);
 467       }
 468       free (listing);
 469
 470 void
 471 list_devices (g)
 472       guestfs_h *g;
 473 PREINIT:
 474       char **devices;
 475       int i, n;
 476  PPCODE:
 477       devices = guestfs_list_devices (g);
 478       if (devices == NULL)
 479         croak ("list_devices: %s", guestfs_last_error (g));
 480       for (n = 0; devices[n] != NULL; ++n) /**/;
 481       EXTEND (SP, n);
 482       for (i = 0; i < n; ++i) {
 483         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
 484         free (devices[i]);
 485       }
 486       free (devices);
 487
 488 void
 489 list_partitions (g)
 490       guestfs_h *g;
 491 PREINIT:
 492       char **partitions;
 493       int i, n;
 494  PPCODE:
 495       partitions = guestfs_list_partitions (g);
 496       if (partitions == NULL)
 497         croak ("list_partitions: %s", guestfs_last_error (g));
 498       for (n = 0; partitions[n] != NULL; ++n) /**/;
 499       EXTEND (SP, n);
 500       for (i = 0; i < n; ++i) {
 501         PUSHs (sv_2mortal (newSVpv (partitions[i], 0)));
 502         free (partitions[i]);
 503       }
 504       free (partitions);
 505
 506 void
 507 pvs (g)
 508       guestfs_h *g;
 509 PREINIT:
 510       char **physvols;
 511       int i, n;
 512  PPCODE:
 513       physvols = guestfs_pvs (g);
 514       if (physvols == NULL)
 515         croak ("pvs: %s", guestfs_last_error (g));
 516       for (n = 0; physvols[n] != NULL; ++n) /**/;
 517       EXTEND (SP, n);
 518       for (i = 0; i < n; ++i) {
 519         PUSHs (sv_2mortal (newSVpv (physvols[i], 0)));
 520         free (physvols[i]);
 521       }
 522       free (physvols);
 523
 524 void
 525 vgs (g)
 526       guestfs_h *g;
 527 PREINIT:
 528       char **volgroups;
 529       int i, n;
 530  PPCODE:
 531       volgroups = guestfs_vgs (g);
 532       if (volgroups == NULL)
 533         croak ("vgs: %s", guestfs_last_error (g));
 534       for (n = 0; volgroups[n] != NULL; ++n) /**/;
 535       EXTEND (SP, n);
 536       for (i = 0; i < n; ++i) {
 537         PUSHs (sv_2mortal (newSVpv (volgroups[i], 0)));
 538         free (volgroups[i]);
 539       }
 540       free (volgroups);
 541
 542 void
 543 lvs (g)
 544       guestfs_h *g;
 545 PREINIT:
 546       char **logvols;
 547       int i, n;
 548  PPCODE:
 549       logvols = guestfs_lvs (g);
 550       if (logvols == NULL)
 551         croak ("lvs: %s", guestfs_last_error (g));
 552       for (n = 0; logvols[n] != NULL; ++n) /**/;
 553       EXTEND (SP, n);
 554       for (i = 0; i < n; ++i) {
 555         PUSHs (sv_2mortal (newSVpv (logvols[i], 0)));
 556         free (logvols[i]);
 557       }
 558       free (logvols);
 559
 560 void
 561 pvs_full (g)
 562       guestfs_h *g;
 563 PREINIT:
 564       struct guestfs_lvm_pv_list *physvols;
 565       int i;
 566       HV *hv;
 567  PPCODE:
 568       physvols = guestfs_pvs_full (g);
 569       if (physvols == NULL)
 570         croak ("pvs_full: %s", guestfs_last_error (g));
 571       EXTEND (SP, physvols->len);
 572       for (i = 0; i < physvols->len; ++i) {
 573         hv = newHV ();
 574         (void) hv_store (hv, "pv_name", 7, newSVpv (physvols->val[i].pv_name, 0), 0);
 575         (void) hv_store (hv, "pv_uuid", 7, newSVpv (physvols->val[i].pv_uuid, 32), 0);
 576         (void) hv_store (hv, "pv_fmt", 6, newSVpv (physvols->val[i].pv_fmt, 0), 0);
 577         (void) hv_store (hv, "pv_size", 7, my_newSVull (physvols->val[i].pv_size), 0);
 578         (void) hv_store (hv, "dev_size", 8, my_newSVull (physvols->val[i].dev_size), 0);
 579         (void) hv_store (hv, "pv_free", 7, my_newSVull (physvols->val[i].pv_free), 0);
 580         (void) hv_store (hv, "pv_used", 7, my_newSVull (physvols->val[i].pv_used), 0);
 581         (void) hv_store (hv, "pv_attr", 7, newSVpv (physvols->val[i].pv_attr, 0), 0);
 582         (void) hv_store (hv, "pv_pe_count", 11, my_newSVll (physvols->val[i].pv_pe_count), 0);
 583         (void) hv_store (hv, "pv_pe_alloc_count", 17, my_newSVll (physvols->val[i].pv_pe_alloc_count), 0);
 584         (void) hv_store (hv, "pv_tags", 7, newSVpv (physvols->val[i].pv_tags, 0), 0);
 585         (void) hv_store (hv, "pe_start", 8, my_newSVull (physvols->val[i].pe_start), 0);
 586         (void) hv_store (hv, "pv_mda_count", 12, my_newSVll (physvols->val[i].pv_mda_count), 0);
 587         (void) hv_store (hv, "pv_mda_free", 11, my_newSVull (physvols->val[i].pv_mda_free), 0);
 588         PUSHs (sv_2mortal ((SV *) hv));
 589       }
 590       guestfs_free_lvm_pv_list (physvols);
 591
 592 void
 593 vgs_full (g)
 594       guestfs_h *g;
 595 PREINIT:
 596       struct guestfs_lvm_vg_list *volgroups;
 597       int i;
 598       HV *hv;
 599  PPCODE:
 600       volgroups = guestfs_vgs_full (g);
 601       if (volgroups == NULL)
 602         croak ("vgs_full: %s", guestfs_last_error (g));
 603       EXTEND (SP, volgroups->len);
 604       for (i = 0; i < volgroups->len; ++i) {
 605         hv = newHV ();
 606         (void) hv_store (hv, "vg_name", 7, newSVpv (volgroups->val[i].vg_name, 0), 0);
 607         (void) hv_store (hv, "vg_uuid", 7, newSVpv (volgroups->val[i].vg_uuid, 32), 0);
 608         (void) hv_store (hv, "vg_fmt", 6, newSVpv (volgroups->val[i].vg_fmt, 0), 0);
 609         (void) hv_store (hv, "vg_attr", 7, newSVpv (volgroups->val[i].vg_attr, 0), 0);
 610         (void) hv_store (hv, "vg_size", 7, my_newSVull (volgroups->val[i].vg_size), 0);
 611         (void) hv_store (hv, "vg_free", 7, my_newSVull (volgroups->val[i].vg_free), 0);
 612         (void) hv_store (hv, "vg_sysid", 8, newSVpv (volgroups->val[i].vg_sysid, 0), 0);
 613         (void) hv_store (hv, "vg_extent_size", 14, my_newSVull (volgroups->val[i].vg_extent_size), 0);
 614         (void) hv_store (hv, "vg_extent_count", 15, my_newSVll (volgroups->val[i].vg_extent_count), 0);
 615         (void) hv_store (hv, "vg_free_count", 13, my_newSVll (volgroups->val[i].vg_free_count), 0);
 616         (void) hv_store (hv, "max_lv", 6, my_newSVll (volgroups->val[i].max_lv), 0);
 617         (void) hv_store (hv, "max_pv", 6, my_newSVll (volgroups->val[i].max_pv), 0);
 618         (void) hv_store (hv, "pv_count", 8, my_newSVll (volgroups->val[i].pv_count), 0);
 619         (void) hv_store (hv, "lv_count", 8, my_newSVll (volgroups->val[i].lv_count), 0);
 620         (void) hv_store (hv, "snap_count", 10, my_newSVll (volgroups->val[i].snap_count), 0);
 621         (void) hv_store (hv, "vg_seqno", 8, my_newSVll (volgroups->val[i].vg_seqno), 0);
 622         (void) hv_store (hv, "vg_tags", 7, newSVpv (volgroups->val[i].vg_tags, 0), 0);
 623         (void) hv_store (hv, "vg_mda_count", 12, my_newSVll (volgroups->val[i].vg_mda_count), 0);
 624         (void) hv_store (hv, "vg_mda_free", 11, my_newSVull (volgroups->val[i].vg_mda_free), 0);
 625         PUSHs (sv_2mortal ((SV *) hv));
 626       }
 627       guestfs_free_lvm_vg_list (volgroups);
 628
 629 void
 630 lvs_full (g)
 631       guestfs_h *g;
 632 PREINIT:
 633       struct guestfs_lvm_lv_list *logvols;
 634       int i;
 635       HV *hv;
 636  PPCODE:
 637       logvols = guestfs_lvs_full (g);
 638       if (logvols == NULL)
 639         croak ("lvs_full: %s", guestfs_last_error (g));
 640       EXTEND (SP, logvols->len);
 641       for (i = 0; i < logvols->len; ++i) {
 642         hv = newHV ();
 643         (void) hv_store (hv, "lv_name", 7, newSVpv (logvols->val[i].lv_name, 0), 0);
 644         (void) hv_store (hv, "lv_uuid", 7, newSVpv (logvols->val[i].lv_uuid, 32), 0);
 645         (void) hv_store (hv, "lv_attr", 7, newSVpv (logvols->val[i].lv_attr, 0), 0);
 646         (void) hv_store (hv, "lv_major", 8, my_newSVll (logvols->val[i].lv_major), 0);
 647         (void) hv_store (hv, "lv_minor", 8, my_newSVll (logvols->val[i].lv_minor), 0);
 648         (void) hv_store (hv, "lv_kernel_major", 15, my_newSVll (logvols->val[i].lv_kernel_major), 0);
 649         (void) hv_store (hv, "lv_kernel_minor", 15, my_newSVll (logvols->val[i].lv_kernel_minor), 0);
 650         (void) hv_store (hv, "lv_size", 7, my_newSVull (logvols->val[i].lv_size), 0);
 651         (void) hv_store (hv, "seg_count", 9, my_newSVll (logvols->val[i].seg_count), 0);
 652         (void) hv_store (hv, "origin", 6, newSVpv (logvols->val[i].origin, 0), 0);
 653         (void) hv_store (hv, "snap_percent", 12, newSVnv (logvols->val[i].snap_percent), 0);
 654         (void) hv_store (hv, "copy_percent", 12, newSVnv (logvols->val[i].copy_percent), 0);
 655         (void) hv_store (hv, "move_pv", 7, newSVpv (logvols->val[i].move_pv, 0), 0);
 656         (void) hv_store (hv, "lv_tags", 7, newSVpv (logvols->val[i].lv_tags, 0), 0);
 657         (void) hv_store (hv, "mirror_log", 10, newSVpv (logvols->val[i].mirror_log, 0), 0);
 658         (void) hv_store (hv, "modules", 7, newSVpv (logvols->val[i].modules, 0), 0);
 659         PUSHs (sv_2mortal ((SV *) hv));
 660       }
 661       guestfs_free_lvm_lv_list (logvols);
 662
 663 void
 664 read_lines (g, path)
 665       guestfs_h *g;
 666       char *path;
 667 PREINIT:
 668       char **lines;
 669       int i, n;
 670  PPCODE:
 671       lines = guestfs_read_lines (g, path);
 672       if (lines == NULL)
 673         croak ("read_lines: %s", guestfs_last_error (g));
 674       for (n = 0; lines[n] != NULL; ++n) /**/;
 675       EXTEND (SP, n);
 676       for (i = 0; i < n; ++i) {
 677         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
 678         free (lines[i]);
 679       }
 680       free (lines);
 681
 682 void
 683 aug_init (g, root, flags)
 684       guestfs_h *g;
 685       char *root;
 686       int flags;
 687 PREINIT:
 688       int r;
 689  PPCODE:
 690       r = guestfs_aug_init (g, root, flags);
 691       if (r == -1)
 692         croak ("aug_init: %s", guestfs_last_error (g));
 693
 694 void
 695 aug_close (g)
 696       guestfs_h *g;
 697 PREINIT:
 698       int r;
 699  PPCODE:
 700       r = guestfs_aug_close (g);
 701       if (r == -1)
 702         croak ("aug_close: %s", guestfs_last_error (g));
 703
 704 SV *
 705 aug_defvar (g, name, expr)
 706       guestfs_h *g;
 707       char *name;
 708       char *expr;
 709 PREINIT:
 710       int nrnodes;
 711    CODE:
 712       nrnodes = guestfs_aug_defvar (g, name, expr);
 713       if (nrnodes == -1)
 714         croak ("aug_defvar: %s", guestfs_last_error (g));
 715       RETVAL = newSViv (nrnodes);
 716  OUTPUT:
 717       RETVAL
 718
 719 void
 720 aug_defnode (g, name, expr, val)
 721       guestfs_h *g;
 722       char *name;
 723       char *expr;
 724       char *val;
 725 PREINIT:
 726       struct guestfs_int_bool *r;
 727  PPCODE:
 728       r = guestfs_aug_defnode (g, name, expr, val);
 729       if (r == NULL)
 730         croak ("aug_defnode: %s", guestfs_last_error (g));
 731       EXTEND (SP, 2);
 732       PUSHs (sv_2mortal (newSViv (r->i)));
 733       PUSHs (sv_2mortal (newSViv (r->b)));
 734       guestfs_free_int_bool (r);
 735
 736 SV *
 737 aug_get (g, path)
 738       guestfs_h *g;
 739       char *path;
 740 PREINIT:
 741       char *val;
 742    CODE:
 743       val = guestfs_aug_get (g, path);
 744       if (val == NULL)
 745         croak ("aug_get: %s", guestfs_last_error (g));
 746       RETVAL = newSVpv (val, 0);
 747       free (val);
 748  OUTPUT:
 749       RETVAL
 750
 751 void
 752 aug_set (g, path, val)
 753       guestfs_h *g;
 754       char *path;
 755       char *val;
 756 PREINIT:
 757       int r;
 758  PPCODE:
 759       r = guestfs_aug_set (g, path, val);
 760       if (r == -1)
 761         croak ("aug_set: %s", guestfs_last_error (g));
 762
 763 void
 764 aug_insert (g, path, label, before)
 765       guestfs_h *g;
 766       char *path;
 767       char *label;
 768       int before;
 769 PREINIT:
 770       int r;
 771  PPCODE:
 772       r = guestfs_aug_insert (g, path, label, before);
 773       if (r == -1)
 774         croak ("aug_insert: %s", guestfs_last_error (g));
 775
 776 SV *
 777 aug_rm (g, path)
 778       guestfs_h *g;
 779       char *path;
 780 PREINIT:
 781       int nrnodes;
 782    CODE:
 783       nrnodes = guestfs_aug_rm (g, path);
 784       if (nrnodes == -1)
 785         croak ("aug_rm: %s", guestfs_last_error (g));
 786       RETVAL = newSViv (nrnodes);
 787  OUTPUT:
 788       RETVAL
 789
 790 void
 791 aug_mv (g, src, dest)
 792       guestfs_h *g;
 793       char *src;
 794       char *dest;
 795 PREINIT:
 796       int r;
 797  PPCODE:
 798       r = guestfs_aug_mv (g, src, dest);
 799       if (r == -1)
 800         croak ("aug_mv: %s", guestfs_last_error (g));
 801
 802 void
 803 aug_match (g, path)
 804       guestfs_h *g;
 805       char *path;
 806 PREINIT:
 807       char **matches;
 808       int i, n;
 809  PPCODE:
 810       matches = guestfs_aug_match (g, path);
 811       if (matches == NULL)
 812         croak ("aug_match: %s", guestfs_last_error (g));
 813       for (n = 0; matches[n] != NULL; ++n) /**/;
 814       EXTEND (SP, n);
 815       for (i = 0; i < n; ++i) {
 816         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 817         free (matches[i]);
 818       }
 819       free (matches);
 820
 821 void
 822 aug_save (g)
 823       guestfs_h *g;
 824 PREINIT:
 825       int r;
 826  PPCODE:
 827       r = guestfs_aug_save (g);
 828       if (r == -1)
 829         croak ("aug_save: %s", guestfs_last_error (g));
 830
 831 void
 832 aug_load (g)
 833       guestfs_h *g;
 834 PREINIT:
 835       int r;
 836  PPCODE:
 837       r = guestfs_aug_load (g);
 838       if (r == -1)
 839         croak ("aug_load: %s", guestfs_last_error (g));
 840
 841 void
 842 aug_ls (g, path)
 843       guestfs_h *g;
 844       char *path;
 845 PREINIT:
 846       char **matches;
 847       int i, n;
 848  PPCODE:
 849       matches = guestfs_aug_ls (g, path);
 850       if (matches == NULL)
 851         croak ("aug_ls: %s", guestfs_last_error (g));
 852       for (n = 0; matches[n] != NULL; ++n) /**/;
 853       EXTEND (SP, n);
 854       for (i = 0; i < n; ++i) {
 855         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 856         free (matches[i]);
 857       }
 858       free (matches);
 859
 860 void
 861 rm (g, path)
 862       guestfs_h *g;
 863       char *path;
 864 PREINIT:
 865       int r;
 866  PPCODE:
 867       r = guestfs_rm (g, path);
 868       if (r == -1)
 869         croak ("rm: %s", guestfs_last_error (g));
 870
 871 void
 872 rmdir (g, path)
 873       guestfs_h *g;
 874       char *path;
 875 PREINIT:
 876       int r;
 877  PPCODE:
 878       r = guestfs_rmdir (g, path);
 879       if (r == -1)
 880         croak ("rmdir: %s", guestfs_last_error (g));
 881
 882 void
 883 rm_rf (g, path)
 884       guestfs_h *g;
 885       char *path;
 886 PREINIT:
 887       int r;
 888  PPCODE:
 889       r = guestfs_rm_rf (g, path);
 890       if (r == -1)
 891         croak ("rm_rf: %s", guestfs_last_error (g));
 892
 893 void
 894 mkdir (g, path)
 895       guestfs_h *g;
 896       char *path;
 897 PREINIT:
 898       int r;
 899  PPCODE:
 900       r = guestfs_mkdir (g, path);
 901       if (r == -1)
 902         croak ("mkdir: %s", guestfs_last_error (g));
 903
 904 void
 905 mkdir_p (g, path)
 906       guestfs_h *g;
 907       char *path;
 908 PREINIT:
 909       int r;
 910  PPCODE:
 911       r = guestfs_mkdir_p (g, path);
 912       if (r == -1)
 913         croak ("mkdir_p: %s", guestfs_last_error (g));
 914
 915 void
 916 chmod (g, mode, path)
 917       guestfs_h *g;
 918       int mode;
 919       char *path;
 920 PREINIT:
 921       int r;
 922  PPCODE:
 923       r = guestfs_chmod (g, mode, path);
 924       if (r == -1)
 925         croak ("chmod: %s", guestfs_last_error (g));
 926
 927 void
 928 chown (g, owner, group, path)
 929       guestfs_h *g;
 930       int owner;
 931       int group;
 932       char *path;
 933 PREINIT:
 934       int r;
 935  PPCODE:
 936       r = guestfs_chown (g, owner, group, path);
 937       if (r == -1)
 938         croak ("chown: %s", guestfs_last_error (g));
 939
 940 SV *
 941 exists (g, path)
 942       guestfs_h *g;
 943       char *path;
 944 PREINIT:
 945       int existsflag;
 946    CODE:
 947       existsflag = guestfs_exists (g, path);
 948       if (existsflag == -1)
 949         croak ("exists: %s", guestfs_last_error (g));
 950       RETVAL = newSViv (existsflag);
 951  OUTPUT:
 952       RETVAL
 953
 954 SV *
 955 is_file (g, path)
 956       guestfs_h *g;
 957       char *path;
 958 PREINIT:
 959       int fileflag;
 960    CODE:
 961       fileflag = guestfs_is_file (g, path);
 962       if (fileflag == -1)
 963         croak ("is_file: %s", guestfs_last_error (g));
 964       RETVAL = newSViv (fileflag);
 965  OUTPUT:
 966       RETVAL
 967
 968 SV *
 969 is_dir (g, path)
 970       guestfs_h *g;
 971       char *path;
 972 PREINIT:
 973       int dirflag;
 974    CODE:
 975       dirflag = guestfs_is_dir (g, path);
 976       if (dirflag == -1)
 977         croak ("is_dir: %s", guestfs_last_error (g));
 978       RETVAL = newSViv (dirflag);
 979  OUTPUT:
 980       RETVAL
 981
 982 void
 983 pvcreate (g, device)
 984       guestfs_h *g;
 985       char *device;
 986 PREINIT:
 987       int r;
 988  PPCODE:
 989       r = guestfs_pvcreate (g, device);
 990       if (r == -1)
 991         croak ("pvcreate: %s", guestfs_last_error (g));
 992
 993 void
 994 vgcreate (g, volgroup, physvols)
 995       guestfs_h *g;
 996       char *volgroup;
 997       char **physvols;
 998 PREINIT:
 999       int r;
1000  PPCODE:
1001       r = guestfs_vgcreate (g, volgroup, physvols);
1002       free (physvols);
1003       if (r == -1)
1004         croak ("vgcreate: %s", guestfs_last_error (g));
1005
1006 void
1007 lvcreate (g, logvol, volgroup, mbytes)
1008       guestfs_h *g;
1009       char *logvol;
1010       char *volgroup;
1011       int mbytes;
1012 PREINIT:
1013       int r;
1014  PPCODE:
1015       r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1016       if (r == -1)
1017         croak ("lvcreate: %s", guestfs_last_error (g));
1018
1019 void
1020 mkfs (g, fstype, device)
1021       guestfs_h *g;
1022       char *fstype;
1023       char *device;
1024 PREINIT:
1025       int r;
1026  PPCODE:
1027       r = guestfs_mkfs (g, fstype, device);
1028       if (r == -1)
1029         croak ("mkfs: %s", guestfs_last_error (g));
1030
1031 void
1032 sfdisk (g, device, cyls, heads, sectors, lines)
1033       guestfs_h *g;
1034       char *device;
1035       int cyls;
1036       int heads;
1037       int sectors;
1038       char **lines;
1039 PREINIT:
1040       int r;
1041  PPCODE:
1042       r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1043       free (lines);
1044       if (r == -1)
1045         croak ("sfdisk: %s", guestfs_last_error (g));
1046
1047 void
1048 write_file (g, path, content, size)
1049       guestfs_h *g;
1050       char *path;
1051       char *content;
1052       int size;
1053 PREINIT:
1054       int r;
1055  PPCODE:
1056       r = guestfs_write_file (g, path, content, size);
1057       if (r == -1)
1058         croak ("write_file: %s", guestfs_last_error (g));
1059
1060 void
1061 umount (g, pathordevice)
1062       guestfs_h *g;
1063       char *pathordevice;
1064 PREINIT:
1065       int r;
1066  PPCODE:
1067       r = guestfs_umount (g, pathordevice);
1068       if (r == -1)
1069         croak ("umount: %s", guestfs_last_error (g));
1070
1071 void
1072 mounts (g)
1073       guestfs_h *g;
1074 PREINIT:
1075       char **devices;
1076       int i, n;
1077  PPCODE:
1078       devices = guestfs_mounts (g);
1079       if (devices == NULL)
1080         croak ("mounts: %s", guestfs_last_error (g));
1081       for (n = 0; devices[n] != NULL; ++n) /**/;
1082       EXTEND (SP, n);
1083       for (i = 0; i < n; ++i) {
1084         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
1085         free (devices[i]);
1086       }
1087       free (devices);
1088
1089 void
1090 umount_all (g)
1091       guestfs_h *g;
1092 PREINIT:
1093       int r;
1094  PPCODE:
1095       r = guestfs_umount_all (g);
1096       if (r == -1)
1097         croak ("umount_all: %s", guestfs_last_error (g));
1098
1099 void
1100 lvm_remove_all (g)
1101       guestfs_h *g;
1102 PREINIT:
1103       int r;
1104  PPCODE:
1105       r = guestfs_lvm_remove_all (g);
1106       if (r == -1)
1107         croak ("lvm_remove_all: %s", guestfs_last_error (g));
1108
1109 SV *
1110 file (g, path)
1111       guestfs_h *g;
1112       char *path;
1113 PREINIT:
1114       char *description;
1115    CODE:
1116       description = guestfs_file (g, path);
1117       if (description == NULL)
1118         croak ("file: %s", guestfs_last_error (g));
1119       RETVAL = newSVpv (description, 0);
1120       free (description);
1121  OUTPUT:
1122       RETVAL
1123
1124 SV *
1125 command (g, arguments)
1126       guestfs_h *g;
1127       char **arguments;
1128 PREINIT:
1129       char *output;
1130    CODE:
1131       output = guestfs_command (g, arguments);
1132       free (arguments);
1133       if (output == NULL)
1134         croak ("command: %s", guestfs_last_error (g));
1135       RETVAL = newSVpv (output, 0);
1136       free (output);
1137  OUTPUT:
1138       RETVAL
1139
1140 void
1141 command_lines (g, arguments)
1142       guestfs_h *g;
1143       char **arguments;
1144 PREINIT:
1145       char **lines;
1146       int i, n;
1147  PPCODE:
1148       lines = guestfs_command_lines (g, arguments);
1149       free (arguments);
1150       if (lines == NULL)
1151         croak ("command_lines: %s", guestfs_last_error (g));
1152       for (n = 0; lines[n] != NULL; ++n) /**/;
1153       EXTEND (SP, n);
1154       for (i = 0; i < n; ++i) {
1155         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
1156         free (lines[i]);
1157       }
1158       free (lines);
1159
1160 void
1161 stat (g, path)
1162       guestfs_h *g;
1163       char *path;
1164 PREINIT:
1165       struct guestfs_stat *statbuf;
1166  PPCODE:
1167       statbuf = guestfs_stat (g, path);
1168       if (statbuf == NULL)
1169         croak ("stat: %s", guestfs_last_error (g));
1170       EXTEND (SP, 13);
1171       PUSHs (sv_2mortal (my_newSVll (statbuf->dev)));
1172       PUSHs (sv_2mortal (my_newSVll (statbuf->ino)));
1173       PUSHs (sv_2mortal (my_newSVll (statbuf->mode)));
1174       PUSHs (sv_2mortal (my_newSVll (statbuf->nlink)));
1175       PUSHs (sv_2mortal (my_newSVll (statbuf->uid)));
1176       PUSHs (sv_2mortal (my_newSVll (statbuf->gid)));
1177       PUSHs (sv_2mortal (my_newSVll (statbuf->rdev)));
1178       PUSHs (sv_2mortal (my_newSVll (statbuf->size)));
1179       PUSHs (sv_2mortal (my_newSVll (statbuf->blksize)));
1180       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1181       PUSHs (sv_2mortal (my_newSVll (statbuf->atime)));
1182       PUSHs (sv_2mortal (my_newSVll (statbuf->mtime)));
1183       PUSHs (sv_2mortal (my_newSVll (statbuf->ctime)));
1184       free (statbuf);
1185
1186 void
1187 lstat (g, path)
1188       guestfs_h *g;
1189       char *path;
1190 PREINIT:
1191       struct guestfs_stat *statbuf;
1192  PPCODE:
1193       statbuf = guestfs_lstat (g, path);
1194       if (statbuf == NULL)
1195         croak ("lstat: %s", guestfs_last_error (g));
1196       EXTEND (SP, 13);
1197       PUSHs (sv_2mortal (my_newSVll (statbuf->dev)));
1198       PUSHs (sv_2mortal (my_newSVll (statbuf->ino)));
1199       PUSHs (sv_2mortal (my_newSVll (statbuf->mode)));
1200       PUSHs (sv_2mortal (my_newSVll (statbuf->nlink)));
1201       PUSHs (sv_2mortal (my_newSVll (statbuf->uid)));
1202       PUSHs (sv_2mortal (my_newSVll (statbuf->gid)));
1203       PUSHs (sv_2mortal (my_newSVll (statbuf->rdev)));
1204       PUSHs (sv_2mortal (my_newSVll (statbuf->size)));
1205       PUSHs (sv_2mortal (my_newSVll (statbuf->blksize)));
1206       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1207       PUSHs (sv_2mortal (my_newSVll (statbuf->atime)));
1208       PUSHs (sv_2mortal (my_newSVll (statbuf->mtime)));
1209       PUSHs (sv_2mortal (my_newSVll (statbuf->ctime)));
1210       free (statbuf);
1211
1212 void
1213 statvfs (g, path)
1214       guestfs_h *g;
1215       char *path;
1216 PREINIT:
1217       struct guestfs_statvfs *statbuf;
1218  PPCODE:
1219       statbuf = guestfs_statvfs (g, path);
1220       if (statbuf == NULL)
1221         croak ("statvfs: %s", guestfs_last_error (g));
1222       EXTEND (SP, 11);
1223       PUSHs (sv_2mortal (my_newSVll (statbuf->bsize)));
1224       PUSHs (sv_2mortal (my_newSVll (statbuf->frsize)));
1225       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1226       PUSHs (sv_2mortal (my_newSVll (statbuf->bfree)));
1227       PUSHs (sv_2mortal (my_newSVll (statbuf->bavail)));
1228       PUSHs (sv_2mortal (my_newSVll (statbuf->files)));
1229       PUSHs (sv_2mortal (my_newSVll (statbuf->ffree)));
1230       PUSHs (sv_2mortal (my_newSVll (statbuf->favail)));
1231       PUSHs (sv_2mortal (my_newSVll (statbuf->fsid)));
1232       PUSHs (sv_2mortal (my_newSVll (statbuf->flag)));
1233       PUSHs (sv_2mortal (my_newSVll (statbuf->namemax)));
1234       free (statbuf);
1235
1236 void
1237 tune2fs_l (g, device)
1238       guestfs_h *g;
1239       char *device;
1240 PREINIT:
1241       char **superblock;
1242       int i, n;
1243  PPCODE:
1244       superblock = guestfs_tune2fs_l (g, device);
1245       if (superblock == NULL)
1246         croak ("tune2fs_l: %s", guestfs_last_error (g));
1247       for (n = 0; superblock[n] != NULL; ++n) /**/;
1248       EXTEND (SP, n);
1249       for (i = 0; i < n; ++i) {
1250         PUSHs (sv_2mortal (newSVpv (superblock[i], 0)));
1251         free (superblock[i]);
1252       }
1253       free (superblock);
1254
1255 void
1256 blockdev_setro (g, device)
1257       guestfs_h *g;
1258       char *device;
1259 PREINIT:
1260       int r;
1261  PPCODE:
1262       r = guestfs_blockdev_setro (g, device);
1263       if (r == -1)
1264         croak ("blockdev_setro: %s", guestfs_last_error (g));
1265
1266 void
1267 blockdev_setrw (g, device)
1268       guestfs_h *g;
1269       char *device;
1270 PREINIT:
1271       int r;
1272  PPCODE:
1273       r = guestfs_blockdev_setrw (g, device);
1274       if (r == -1)
1275         croak ("blockdev_setrw: %s", guestfs_last_error (g));
1276
1277 SV *
1278 blockdev_getro (g, device)
1279       guestfs_h *g;
1280       char *device;
1281 PREINIT:
1282       int ro;
1283    CODE:
1284       ro = guestfs_blockdev_getro (g, device);
1285       if (ro == -1)
1286         croak ("blockdev_getro: %s", guestfs_last_error (g));
1287       RETVAL = newSViv (ro);
1288  OUTPUT:
1289       RETVAL
1290
1291 SV *
1292 blockdev_getss (g, device)
1293       guestfs_h *g;
1294       char *device;
1295 PREINIT:
1296       int sectorsize;
1297    CODE:
1298       sectorsize = guestfs_blockdev_getss (g, device);
1299       if (sectorsize == -1)
1300         croak ("blockdev_getss: %s", guestfs_last_error (g));
1301       RETVAL = newSViv (sectorsize);
1302  OUTPUT:
1303       RETVAL
1304
1305 SV *
1306 blockdev_getbsz (g, device)
1307       guestfs_h *g;
1308       char *device;
1309 PREINIT:
1310       int blocksize;
1311    CODE:
1312       blocksize = guestfs_blockdev_getbsz (g, device);
1313       if (blocksize == -1)
1314         croak ("blockdev_getbsz: %s", guestfs_last_error (g));
1315       RETVAL = newSViv (blocksize);
1316  OUTPUT:
1317       RETVAL
1318
1319 void
1320 blockdev_setbsz (g, device, blocksize)
1321       guestfs_h *g;
1322       char *device;
1323       int blocksize;
1324 PREINIT:
1325       int r;
1326  PPCODE:
1327       r = guestfs_blockdev_setbsz (g, device, blocksize);
1328       if (r == -1)
1329         croak ("blockdev_setbsz: %s", guestfs_last_error (g));
1330
1331 SV *
1332 blockdev_getsz (g, device)
1333       guestfs_h *g;
1334       char *device;
1335 PREINIT:
1336       int64_t sizeinsectors;
1337    CODE:
1338       sizeinsectors = guestfs_blockdev_getsz (g, device);
1339       if (sizeinsectors == -1)
1340         croak ("blockdev_getsz: %s", guestfs_last_error (g));
1341       RETVAL = my_newSVll (sizeinsectors);
1342  OUTPUT:
1343       RETVAL
1344
1345 SV *
1346 blockdev_getsize64 (g, device)
1347       guestfs_h *g;
1348       char *device;
1349 PREINIT:
1350       int64_t sizeinbytes;
1351    CODE:
1352       sizeinbytes = guestfs_blockdev_getsize64 (g, device);
1353       if (sizeinbytes == -1)
1354         croak ("blockdev_getsize64: %s", guestfs_last_error (g));
1355       RETVAL = my_newSVll (sizeinbytes);
1356  OUTPUT:
1357       RETVAL
1358
1359 void
1360 blockdev_flushbufs (g, device)
1361       guestfs_h *g;
1362       char *device;
1363 PREINIT:
1364       int r;
1365  PPCODE:
1366       r = guestfs_blockdev_flushbufs (g, device);
1367       if (r == -1)
1368         croak ("blockdev_flushbufs: %s", guestfs_last_error (g));
1369
1370 void
1371 blockdev_rereadpt (g, device)
1372       guestfs_h *g;
1373       char *device;
1374 PREINIT:
1375       int r;
1376  PPCODE:
1377       r = guestfs_blockdev_rereadpt (g, device);
1378       if (r == -1)
1379         croak ("blockdev_rereadpt: %s", guestfs_last_error (g));
1380
1381 void
1382 upload (g, filename, remotefilename)
1383       guestfs_h *g;
1384       char *filename;
1385       char *remotefilename;
1386 PREINIT:
1387       int r;
1388  PPCODE:
1389       r = guestfs_upload (g, filename, remotefilename);
1390       if (r == -1)
1391         croak ("upload: %s", guestfs_last_error (g));
1392
1393 void
1394 download (g, remotefilename, filename)
1395       guestfs_h *g;
1396       char *remotefilename;
1397       char *filename;
1398 PREINIT:
1399       int r;
1400  PPCODE:
1401       r = guestfs_download (g, remotefilename, filename);
1402       if (r == -1)
1403         croak ("download: %s", guestfs_last_error (g));
1404
1405 SV *
1406 checksum (g, csumtype, path)
1407       guestfs_h *g;
1408       char *csumtype;
1409       char *path;
1410 PREINIT:
1411       char *checksum;
1412    CODE:
1413       checksum = guestfs_checksum (g, csumtype, path);
1414       if (checksum == NULL)
1415         croak ("checksum: %s", guestfs_last_error (g));
1416       RETVAL = newSVpv (checksum, 0);
1417       free (checksum);
1418  OUTPUT:
1419       RETVAL
1420
1421 void
1422 tar_in (g, tarfile, directory)
1423       guestfs_h *g;
1424       char *tarfile;
1425       char *directory;
1426 PREINIT:
1427       int r;
1428  PPCODE:
1429       r = guestfs_tar_in (g, tarfile, directory);
1430       if (r == -1)
1431         croak ("tar_in: %s", guestfs_last_error (g));
1432
1433 void
1434 tar_out (g, directory, tarfile)
1435       guestfs_h *g;
1436       char *directory;
1437       char *tarfile;
1438 PREINIT:
1439       int r;
1440  PPCODE:
1441       r = guestfs_tar_out (g, directory, tarfile);
1442       if (r == -1)
1443         croak ("tar_out: %s", guestfs_last_error (g));
1444
1445 void
1446 tgz_in (g, tarball, directory)
1447       guestfs_h *g;
1448       char *tarball;
1449       char *directory;
1450 PREINIT:
1451       int r;
1452  PPCODE:
1453       r = guestfs_tgz_in (g, tarball, directory);
1454       if (r == -1)
1455         croak ("tgz_in: %s", guestfs_last_error (g));
1456
1457 void
1458 tgz_out (g, directory, tarball)
1459       guestfs_h *g;
1460       char *directory;
1461       char *tarball;
1462 PREINIT:
1463       int r;
1464  PPCODE:
1465       r = guestfs_tgz_out (g, directory, tarball);
1466       if (r == -1)
1467         croak ("tgz_out: %s", guestfs_last_error (g));
1468
1469 void
1470 mount_ro (g, device, mountpoint)
1471       guestfs_h *g;
1472       char *device;
1473       char *mountpoint;
1474 PREINIT:
1475       int r;
1476  PPCODE:
1477       r = guestfs_mount_ro (g, device, mountpoint);
1478       if (r == -1)
1479         croak ("mount_ro: %s", guestfs_last_error (g));
1480
1481 void
1482 mount_options (g, options, device, mountpoint)
1483       guestfs_h *g;
1484       char *options;
1485       char *device;
1486       char *mountpoint;
1487 PREINIT:
1488       int r;
1489  PPCODE:
1490       r = guestfs_mount_options (g, options, device, mountpoint);
1491       if (r == -1)
1492         croak ("mount_options: %s", guestfs_last_error (g));
1493
1494 void
1495 mount_vfs (g, options, vfstype, device, mountpoint)
1496       guestfs_h *g;
1497       char *options;
1498       char *vfstype;
1499       char *device;
1500       char *mountpoint;
1501 PREINIT:
1502       int r;
1503  PPCODE:
1504       r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1505       if (r == -1)
1506         croak ("mount_vfs: %s", guestfs_last_error (g));
1507
1508 SV *
1509 debug (g, subcmd, extraargs)
1510       guestfs_h *g;
1511       char *subcmd;
1512       char **extraargs;
1513 PREINIT:
1514       char *result;
1515    CODE:
1516       result = guestfs_debug (g, subcmd, extraargs);
1517       free (extraargs);
1518       if (result == NULL)
1519         croak ("debug: %s", guestfs_last_error (g));
1520       RETVAL = newSVpv (result, 0);
1521       free (result);
1522  OUTPUT:
1523       RETVAL
1524
1525 void
1526 lvremove (g, device)
1527       guestfs_h *g;
1528       char *device;
1529 PREINIT:
1530       int r;
1531  PPCODE:
1532       r = guestfs_lvremove (g, device);
1533       if (r == -1)
1534         croak ("lvremove: %s", guestfs_last_error (g));
1535
1536 void
1537 vgremove (g, vgname)
1538       guestfs_h *g;
1539       char *vgname;
1540 PREINIT:
1541       int r;
1542  PPCODE:
1543       r = guestfs_vgremove (g, vgname);
1544       if (r == -1)
1545         croak ("vgremove: %s", guestfs_last_error (g));
1546
1547 void
1548 pvremove (g, device)
1549       guestfs_h *g;
1550       char *device;
1551 PREINIT:
1552       int r;
1553  PPCODE:
1554       r = guestfs_pvremove (g, device);
1555       if (r == -1)
1556         croak ("pvremove: %s", guestfs_last_error (g));
1557
1558 void
1559 set_e2label (g, device, label)
1560       guestfs_h *g;
1561       char *device;
1562       char *label;
1563 PREINIT:
1564       int r;
1565  PPCODE:
1566       r = guestfs_set_e2label (g, device, label);
1567       if (r == -1)
1568         croak ("set_e2label: %s", guestfs_last_error (g));
1569
1570 SV *
1571 get_e2label (g, device)
1572       guestfs_h *g;
1573       char *device;
1574 PREINIT:
1575       char *label;
1576    CODE:
1577       label = guestfs_get_e2label (g, device);
1578       if (label == NULL)
1579         croak ("get_e2label: %s", guestfs_last_error (g));
1580       RETVAL = newSVpv (label, 0);
1581       free (label);
1582  OUTPUT:
1583       RETVAL
1584
1585 void
1586 set_e2uuid (g, device, uuid)
1587       guestfs_h *g;
1588       char *device;
1589       char *uuid;
1590 PREINIT:
1591       int r;
1592  PPCODE:
1593       r = guestfs_set_e2uuid (g, device, uuid);
1594       if (r == -1)
1595         croak ("set_e2uuid: %s", guestfs_last_error (g));
1596
1597 SV *
1598 get_e2uuid (g, device)
1599       guestfs_h *g;
1600       char *device;
1601 PREINIT:
1602       char *uuid;
1603    CODE:
1604       uuid = guestfs_get_e2uuid (g, device);
1605       if (uuid == NULL)
1606         croak ("get_e2uuid: %s", guestfs_last_error (g));
1607       RETVAL = newSVpv (uuid, 0);
1608       free (uuid);
1609  OUTPUT:
1610       RETVAL
1611
1612 SV *
1613 fsck (g, fstype, device)
1614       guestfs_h *g;
1615       char *fstype;
1616       char *device;
1617 PREINIT:
1618       int status;
1619    CODE:
1620       status = guestfs_fsck (g, fstype, device);
1621       if (status == -1)
1622         croak ("fsck: %s", guestfs_last_error (g));
1623       RETVAL = newSViv (status);
1624  OUTPUT:
1625       RETVAL
1626
1627 void
1628 zero (g, device)
1629       guestfs_h *g;
1630       char *device;
1631 PREINIT:
1632       int r;
1633  PPCODE:
1634       r = guestfs_zero (g, device);
1635       if (r == -1)
1636         croak ("zero: %s", guestfs_last_error (g));
1637
1638 void
1639 grub_install (g, root, device)
1640       guestfs_h *g;
1641       char *root;
1642       char *device;
1643 PREINIT:
1644       int r;
1645  PPCODE:
1646       r = guestfs_grub_install (g, root, device);
1647       if (r == -1)
1648         croak ("grub_install: %s", guestfs_last_error (g));
1649
1650 void
1651 cp (g, src, dest)
1652       guestfs_h *g;
1653       char *src;
1654       char *dest;
1655 PREINIT:
1656       int r;
1657  PPCODE:
1658       r = guestfs_cp (g, src, dest);
1659       if (r == -1)
1660         croak ("cp: %s", guestfs_last_error (g));
1661
1662 void
1663 cp_a (g, src, dest)
1664       guestfs_h *g;
1665       char *src;
1666       char *dest;
1667 PREINIT:
1668       int r;
1669  PPCODE:
1670       r = guestfs_cp_a (g, src, dest);
1671       if (r == -1)
1672         croak ("cp_a: %s", guestfs_last_error (g));
1673
1674 void
1675 mv (g, src, dest)
1676       guestfs_h *g;
1677       char *src;
1678       char *dest;
1679 PREINIT:
1680       int r;
1681  PPCODE:
1682       r = guestfs_mv (g, src, dest);
1683       if (r == -1)
1684         croak ("mv: %s", guestfs_last_error (g));
1685
1686 void
1687 drop_caches (g, whattodrop)
1688       guestfs_h *g;
1689       int whattodrop;
1690 PREINIT:
1691       int r;
1692  PPCODE:
1693       r = guestfs_drop_caches (g, whattodrop);
1694       if (r == -1)
1695         croak ("drop_caches: %s", guestfs_last_error (g));
1696
1697 SV *
1698 dmesg (g)
1699       guestfs_h *g;
1700 PREINIT:
1701       char *kmsgs;
1702    CODE:
1703       kmsgs = guestfs_dmesg (g);
1704       if (kmsgs == NULL)
1705         croak ("dmesg: %s", guestfs_last_error (g));
1706       RETVAL = newSVpv (kmsgs, 0);
1707       free (kmsgs);
1708  OUTPUT:
1709       RETVAL
1710
1711 void
1712 ping_daemon (g)
1713       guestfs_h *g;
1714 PREINIT:
1715       int r;
1716  PPCODE:
1717       r = guestfs_ping_daemon (g);
1718       if (r == -1)
1719         croak ("ping_daemon: %s", guestfs_last_error (g));
1720
1721 SV *
1722 equal (g, file1, file2)
1723       guestfs_h *g;
1724       char *file1;
1725       char *file2;
1726 PREINIT:
1727       int equality;
1728    CODE:
1729       equality = guestfs_equal (g, file1, file2);
1730       if (equality == -1)
1731         croak ("equal: %s", guestfs_last_error (g));
1732       RETVAL = newSViv (equality);
1733  OUTPUT:
1734       RETVAL
1735
1736 void
1737 strings (g, path)
1738       guestfs_h *g;
1739       char *path;
1740 PREINIT:
1741       char **stringsout;
1742       int i, n;
1743  PPCODE:
1744       stringsout = guestfs_strings (g, path);
1745       if (stringsout == NULL)
1746         croak ("strings: %s", guestfs_last_error (g));
1747       for (n = 0; stringsout[n] != NULL; ++n) /**/;
1748       EXTEND (SP, n);
1749       for (i = 0; i < n; ++i) {
1750         PUSHs (sv_2mortal (newSVpv (stringsout[i], 0)));
1751         free (stringsout[i]);
1752       }
1753       free (stringsout);
1754
1755 void
1756 strings_e (g, encoding, path)
1757       guestfs_h *g;
1758       char *encoding;
1759       char *path;
1760 PREINIT:
1761       char **stringsout;
1762       int i, n;
1763  PPCODE:
1764       stringsout = guestfs_strings_e (g, encoding, path);
1765       if (stringsout == NULL)
1766         croak ("strings_e: %s", guestfs_last_error (g));
1767       for (n = 0; stringsout[n] != NULL; ++n) /**/;
1768       EXTEND (SP, n);
1769       for (i = 0; i < n; ++i) {
1770         PUSHs (sv_2mortal (newSVpv (stringsout[i], 0)));
1771         free (stringsout[i]);
1772       }
1773       free (stringsout);
1774
1775 SV *
1776 hexdump (g, path)
1777       guestfs_h *g;
1778       char *path;
1779 PREINIT:
1780       char *dump;
1781    CODE:
1782       dump = guestfs_hexdump (g, path);
1783       if (dump == NULL)
1784         croak ("hexdump: %s", guestfs_last_error (g));
1785       RETVAL = newSVpv (dump, 0);
1786       free (dump);
1787  OUTPUT:
1788       RETVAL
1789
1790 void
1791 zerofree (g, device)
1792       guestfs_h *g;
1793       char *device;
1794 PREINIT:
1795       int r;
1796  PPCODE:
1797       r = guestfs_zerofree (g, device);
1798       if (r == -1)
1799         croak ("zerofree: %s", guestfs_last_error (g));
1800
1801 void
1802 pvresize (g, device)
1803       guestfs_h *g;
1804       char *device;
1805 PREINIT:
1806       int r;
1807  PPCODE:
1808       r = guestfs_pvresize (g, device);
1809       if (r == -1)
1810         croak ("pvresize: %s", guestfs_last_error (g));
1811
1812 void
1813 sfdisk_N (g, device, n, cyls, heads, sectors, line)
1814       guestfs_h *g;
1815       char *device;
1816       int n;
1817       int cyls;
1818       int heads;
1819       int sectors;
1820       char *line;
1821 PREINIT:
1822       int r;
1823  PPCODE:
1824       r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
1825       if (r == -1)
1826         croak ("sfdisk_N: %s", guestfs_last_error (g));
1827
1828 SV *
1829 sfdisk_l (g, device)
1830       guestfs_h *g;
1831       char *device;
1832 PREINIT:
1833       char *partitions;
1834    CODE:
1835       partitions = guestfs_sfdisk_l (g, device);
1836       if (partitions == NULL)
1837         croak ("sfdisk_l: %s", guestfs_last_error (g));
1838       RETVAL = newSVpv (partitions, 0);
1839       free (partitions);
1840  OUTPUT:
1841       RETVAL
1842
1843 SV *
1844 sfdisk_kernel_geometry (g, device)
1845       guestfs_h *g;
1846       char *device;
1847 PREINIT:
1848       char *partitions;
1849    CODE:
1850       partitions = guestfs_sfdisk_kernel_geometry (g, device);
1851       if (partitions == NULL)
1852         croak ("sfdisk_kernel_geometry: %s", guestfs_last_error (g));
1853       RETVAL = newSVpv (partitions, 0);
1854       free (partitions);
1855  OUTPUT:
1856       RETVAL
1857
1858 SV *
1859 sfdisk_disk_geometry (g, device)
1860       guestfs_h *g;
1861       char *device;
1862 PREINIT:
1863       char *partitions;
1864    CODE:
1865       partitions = guestfs_sfdisk_disk_geometry (g, device);
1866       if (partitions == NULL)
1867         croak ("sfdisk_disk_geometry: %s", guestfs_last_error (g));
1868       RETVAL = newSVpv (partitions, 0);
1869       free (partitions);
1870  OUTPUT:
1871       RETVAL
1872
1873 void
1874 vg_activate_all (g, activate)
1875       guestfs_h *g;
1876       int activate;
1877 PREINIT:
1878       int r;
1879  PPCODE:
1880       r = guestfs_vg_activate_all (g, activate);
1881       if (r == -1)
1882         croak ("vg_activate_all: %s", guestfs_last_error (g));
1883
1884 void
1885 vg_activate (g, activate, volgroups)
1886       guestfs_h *g;
1887       int activate;
1888       char **volgroups;
1889 PREINIT:
1890       int r;
1891  PPCODE:
1892       r = guestfs_vg_activate (g, activate, volgroups);
1893       free (volgroups);
1894       if (r == -1)
1895         croak ("vg_activate: %s", guestfs_last_error (g));
1896