python/guestfs-py.c

   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 <stdio.h>
  23 #include <stdlib.h>
  24 #include <assert.h>
  25
  26 #include <Python.h>
  27
  28 #include "guestfs.h"
  29
  30 typedef struct {
  31   PyObject_HEAD
  32   guestfs_h *g;
  33 } Pyguestfs_Object;
  34
  35 static guestfs_h *
  36 get_handle (PyObject *obj)
  37 {
  38   assert (obj);
  39   assert (obj != Py_None);
  40   return ((Pyguestfs_Object *) obj)->g;
  41 }
  42
  43 static PyObject *
  44 put_handle (guestfs_h *g)
  45 {
  46   assert (g);
  47   return
  48     PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) "guestfs_h", NULL);
  49 }
  50
  51 /* This list should be freed (but not the strings) after use. */
  52 static const char **
  53 get_string_list (PyObject *obj)
  54 {
  55   int i, len;
  56   const char **r;
  57
  58   assert (obj);
  59
  60   if (!PyList_Check (obj)) {
  61     PyErr_SetString (PyExc_RuntimeError, "expecting a list parameter");
  62     return NULL;
  63   }
  64
  65   len = PyList_Size (obj);
  66   r = malloc (sizeof (char *) * (len+1));
  67   if (r == NULL) {
  68     PyErr_SetString (PyExc_RuntimeError, "get_string_list: out of memory");
  69     return NULL;
  70   }
  71
  72   for (i = 0; i < len; ++i)
  73     r[i] = PyString_AsString (PyList_GetItem (obj, i));
  74   r[len] = NULL;
  75
  76   return r;
  77 }
  78
  79 static PyObject *
  80 put_string_list (char * const * const argv)
  81 {
  82   PyObject *list;
  83   int argc, i;
  84
  85   for (argc = 0; argv[argc] != NULL; ++argc)
  86     ;
  87
  88   list = PyList_New (argc);
  89   for (i = 0; i < argc; ++i)
  90     PyList_SetItem (list, i, PyString_FromString (argv[i]));
  91
  92   return list;
  93 }
  94
  95 static PyObject *
  96 put_table (char * const * const argv)
  97 {
  98   PyObject *list, *item;
  99   int argc, i;
 100
 101   for (argc = 0; argv[argc] != NULL; ++argc)
 102     ;
 103
 104   list = PyList_New (argc >> 1);
 105   for (i = 0; i < argc; i += 2) {
 106     item = PyTuple_New (2);
 107     PyTuple_SetItem (item, 0, PyString_FromString (argv[i]));
 108     PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1]));
 109     PyList_SetItem (list, i >> 1, item);
 110   }
 111
 112   return list;
 113 }
 114
 115 static void
 116 free_strings (char **argv)
 117 {
 118   int argc;
 119
 120   for (argc = 0; argv[argc] != NULL; ++argc)
 121     free (argv[argc]);
 122   free (argv);
 123 }
 124
 125 static PyObject *
 126 py_guestfs_create (PyObject *self, PyObject *args)
 127 {
 128   guestfs_h *g;
 129
 130   g = guestfs_create ();
 131   if (g == NULL) {
 132     PyErr_SetString (PyExc_RuntimeError,
 133                      "guestfs.create: failed to allocate handle");
 134     return NULL;
 135   }
 136   guestfs_set_error_handler (g, NULL, NULL);
 137   return put_handle (g);
 138 }
 139
 140 static PyObject *
 141 py_guestfs_close (PyObject *self, PyObject *args)
 142 {
 143   PyObject *py_g;
 144   guestfs_h *g;
 145
 146   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_close", &py_g))
 147     return NULL;
 148   g = get_handle (py_g);
 149
 150   guestfs_close (g);
 151
 152   Py_INCREF (Py_None);
 153   return Py_None;
 154 }
 155
 156 static PyObject *
 157 put_lvm_pv (struct guestfs_lvm_pv *pv)
 158 {
 159   PyObject *dict;
 160
 161   dict = PyDict_New ();
 162   PyDict_SetItemString (dict, "pv_name",
 163                         PyString_FromString (pv->pv_name));
 164   PyDict_SetItemString (dict, "pv_uuid",
 165                         PyString_FromStringAndSize (pv->pv_uuid, 32));
 166   PyDict_SetItemString (dict, "pv_fmt",
 167                         PyString_FromString (pv->pv_fmt));
 168   PyDict_SetItemString (dict, "pv_size",
 169                         PyLong_FromUnsignedLongLong (pv->pv_size));
 170   PyDict_SetItemString (dict, "dev_size",
 171                         PyLong_FromUnsignedLongLong (pv->dev_size));
 172   PyDict_SetItemString (dict, "pv_free",
 173                         PyLong_FromUnsignedLongLong (pv->pv_free));
 174   PyDict_SetItemString (dict, "pv_used",
 175                         PyLong_FromUnsignedLongLong (pv->pv_used));
 176   PyDict_SetItemString (dict, "pv_attr",
 177                         PyString_FromString (pv->pv_attr));
 178   PyDict_SetItemString (dict, "pv_pe_count",
 179                         PyLong_FromLongLong (pv->pv_pe_count));
 180   PyDict_SetItemString (dict, "pv_pe_alloc_count",
 181                         PyLong_FromLongLong (pv->pv_pe_alloc_count));
 182   PyDict_SetItemString (dict, "pv_tags",
 183                         PyString_FromString (pv->pv_tags));
 184   PyDict_SetItemString (dict, "pe_start",
 185                         PyLong_FromUnsignedLongLong (pv->pe_start));
 186   PyDict_SetItemString (dict, "pv_mda_count",
 187                         PyLong_FromLongLong (pv->pv_mda_count));
 188   PyDict_SetItemString (dict, "pv_mda_free",
 189                         PyLong_FromUnsignedLongLong (pv->pv_mda_free));
 190   return dict;
 191 };
 192
 193 static PyObject *
 194 put_lvm_pv_list (struct guestfs_lvm_pv_list *pvs)
 195 {
 196   PyObject *list;
 197   int i;
 198
 199   list = PyList_New (pvs->len);
 200   for (i = 0; i < pvs->len; ++i)
 201     PyList_SetItem (list, i, put_lvm_pv (&pvs->val[i]));
 202   return list;
 203 };
 204
 205 static PyObject *
 206 put_lvm_vg (struct guestfs_lvm_vg *vg)
 207 {
 208   PyObject *dict;
 209
 210   dict = PyDict_New ();
 211   PyDict_SetItemString (dict, "vg_name",
 212                         PyString_FromString (vg->vg_name));
 213   PyDict_SetItemString (dict, "vg_uuid",
 214                         PyString_FromStringAndSize (vg->vg_uuid, 32));
 215   PyDict_SetItemString (dict, "vg_fmt",
 216                         PyString_FromString (vg->vg_fmt));
 217   PyDict_SetItemString (dict, "vg_attr",
 218                         PyString_FromString (vg->vg_attr));
 219   PyDict_SetItemString (dict, "vg_size",
 220                         PyLong_FromUnsignedLongLong (vg->vg_size));
 221   PyDict_SetItemString (dict, "vg_free",
 222                         PyLong_FromUnsignedLongLong (vg->vg_free));
 223   PyDict_SetItemString (dict, "vg_sysid",
 224                         PyString_FromString (vg->vg_sysid));
 225   PyDict_SetItemString (dict, "vg_extent_size",
 226                         PyLong_FromUnsignedLongLong (vg->vg_extent_size));
 227   PyDict_SetItemString (dict, "vg_extent_count",
 228                         PyLong_FromLongLong (vg->vg_extent_count));
 229   PyDict_SetItemString (dict, "vg_free_count",
 230                         PyLong_FromLongLong (vg->vg_free_count));
 231   PyDict_SetItemString (dict, "max_lv",
 232                         PyLong_FromLongLong (vg->max_lv));
 233   PyDict_SetItemString (dict, "max_pv",
 234                         PyLong_FromLongLong (vg->max_pv));
 235   PyDict_SetItemString (dict, "pv_count",
 236                         PyLong_FromLongLong (vg->pv_count));
 237   PyDict_SetItemString (dict, "lv_count",
 238                         PyLong_FromLongLong (vg->lv_count));
 239   PyDict_SetItemString (dict, "snap_count",
 240                         PyLong_FromLongLong (vg->snap_count));
 241   PyDict_SetItemString (dict, "vg_seqno",
 242                         PyLong_FromLongLong (vg->vg_seqno));
 243   PyDict_SetItemString (dict, "vg_tags",
 244                         PyString_FromString (vg->vg_tags));
 245   PyDict_SetItemString (dict, "vg_mda_count",
 246                         PyLong_FromLongLong (vg->vg_mda_count));
 247   PyDict_SetItemString (dict, "vg_mda_free",
 248                         PyLong_FromUnsignedLongLong (vg->vg_mda_free));
 249   return dict;
 250 };
 251
 252 static PyObject *
 253 put_lvm_vg_list (struct guestfs_lvm_vg_list *vgs)
 254 {
 255   PyObject *list;
 256   int i;
 257
 258   list = PyList_New (vgs->len);
 259   for (i = 0; i < vgs->len; ++i)
 260     PyList_SetItem (list, i, put_lvm_vg (&vgs->val[i]));
 261   return list;
 262 };
 263
 264 static PyObject *
 265 put_lvm_lv (struct guestfs_lvm_lv *lv)
 266 {
 267   PyObject *dict;
 268
 269   dict = PyDict_New ();
 270   PyDict_SetItemString (dict, "lv_name",
 271                         PyString_FromString (lv->lv_name));
 272   PyDict_SetItemString (dict, "lv_uuid",
 273                         PyString_FromStringAndSize (lv->lv_uuid, 32));
 274   PyDict_SetItemString (dict, "lv_attr",
 275                         PyString_FromString (lv->lv_attr));
 276   PyDict_SetItemString (dict, "lv_major",
 277                         PyLong_FromLongLong (lv->lv_major));
 278   PyDict_SetItemString (dict, "lv_minor",
 279                         PyLong_FromLongLong (lv->lv_minor));
 280   PyDict_SetItemString (dict, "lv_kernel_major",
 281                         PyLong_FromLongLong (lv->lv_kernel_major));
 282   PyDict_SetItemString (dict, "lv_kernel_minor",
 283                         PyLong_FromLongLong (lv->lv_kernel_minor));
 284   PyDict_SetItemString (dict, "lv_size",
 285                         PyLong_FromUnsignedLongLong (lv->lv_size));
 286   PyDict_SetItemString (dict, "seg_count",
 287                         PyLong_FromLongLong (lv->seg_count));
 288   PyDict_SetItemString (dict, "origin",
 289                         PyString_FromString (lv->origin));
 290   if (lv->snap_percent >= 0)
 291     PyDict_SetItemString (dict, "snap_percent",
 292                           PyFloat_FromDouble ((double) lv->snap_percent));
 293   else {
 294     Py_INCREF (Py_None);
 295     PyDict_SetItemString (dict, "snap_percent", Py_None);  }
 296   if (lv->copy_percent >= 0)
 297     PyDict_SetItemString (dict, "copy_percent",
 298                           PyFloat_FromDouble ((double) lv->copy_percent));
 299   else {
 300     Py_INCREF (Py_None);
 301     PyDict_SetItemString (dict, "copy_percent", Py_None);  }
 302   PyDict_SetItemString (dict, "move_pv",
 303                         PyString_FromString (lv->move_pv));
 304   PyDict_SetItemString (dict, "lv_tags",
 305                         PyString_FromString (lv->lv_tags));
 306   PyDict_SetItemString (dict, "mirror_log",
 307                         PyString_FromString (lv->mirror_log));
 308   PyDict_SetItemString (dict, "modules",
 309                         PyString_FromString (lv->modules));
 310   return dict;
 311 };
 312
 313 static PyObject *
 314 put_lvm_lv_list (struct guestfs_lvm_lv_list *lvs)
 315 {
 316   PyObject *list;
 317   int i;
 318
 319   list = PyList_New (lvs->len);
 320   for (i = 0; i < lvs->len; ++i)
 321     PyList_SetItem (list, i, put_lvm_lv (&lvs->val[i]));
 322   return list;
 323 };
 324
 325 static PyObject *
 326 put_stat (struct guestfs_stat *stat)
 327 {
 328   PyObject *dict;
 329
 330   dict = PyDict_New ();
 331   PyDict_SetItemString (dict, "dev",
 332                         PyLong_FromLongLong (stat->dev));
 333   PyDict_SetItemString (dict, "ino",
 334                         PyLong_FromLongLong (stat->ino));
 335   PyDict_SetItemString (dict, "mode",
 336                         PyLong_FromLongLong (stat->mode));
 337   PyDict_SetItemString (dict, "nlink",
 338                         PyLong_FromLongLong (stat->nlink));
 339   PyDict_SetItemString (dict, "uid",
 340                         PyLong_FromLongLong (stat->uid));
 341   PyDict_SetItemString (dict, "gid",
 342                         PyLong_FromLongLong (stat->gid));
 343   PyDict_SetItemString (dict, "rdev",
 344                         PyLong_FromLongLong (stat->rdev));
 345   PyDict_SetItemString (dict, "size",
 346                         PyLong_FromLongLong (stat->size));
 347   PyDict_SetItemString (dict, "blksize",
 348                         PyLong_FromLongLong (stat->blksize));
 349   PyDict_SetItemString (dict, "blocks",
 350                         PyLong_FromLongLong (stat->blocks));
 351   PyDict_SetItemString (dict, "atime",
 352                         PyLong_FromLongLong (stat->atime));
 353   PyDict_SetItemString (dict, "mtime",
 354                         PyLong_FromLongLong (stat->mtime));
 355   PyDict_SetItemString (dict, "ctime",
 356                         PyLong_FromLongLong (stat->ctime));
 357   return dict;
 358 };
 359
 360 static PyObject *
 361 put_statvfs (struct guestfs_statvfs *statvfs)
 362 {
 363   PyObject *dict;
 364
 365   dict = PyDict_New ();
 366   PyDict_SetItemString (dict, "bsize",
 367                         PyLong_FromLongLong (statvfs->bsize));
 368   PyDict_SetItemString (dict, "frsize",
 369                         PyLong_FromLongLong (statvfs->frsize));
 370   PyDict_SetItemString (dict, "blocks",
 371                         PyLong_FromLongLong (statvfs->blocks));
 372   PyDict_SetItemString (dict, "bfree",
 373                         PyLong_FromLongLong (statvfs->bfree));
 374   PyDict_SetItemString (dict, "bavail",
 375                         PyLong_FromLongLong (statvfs->bavail));
 376   PyDict_SetItemString (dict, "files",
 377                         PyLong_FromLongLong (statvfs->files));
 378   PyDict_SetItemString (dict, "ffree",
 379                         PyLong_FromLongLong (statvfs->ffree));
 380   PyDict_SetItemString (dict, "favail",
 381                         PyLong_FromLongLong (statvfs->favail));
 382   PyDict_SetItemString (dict, "fsid",
 383                         PyLong_FromLongLong (statvfs->fsid));
 384   PyDict_SetItemString (dict, "flag",
 385                         PyLong_FromLongLong (statvfs->flag));
 386   PyDict_SetItemString (dict, "namemax",
 387                         PyLong_FromLongLong (statvfs->namemax));
 388   return dict;
 389 };
 390
 391 static PyObject *
 392 py_guestfs_launch (PyObject *self, PyObject *args)
 393 {
 394   PyObject *py_g;
 395   guestfs_h *g;
 396   PyObject *py_r;
 397   int r;
 398
 399   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch",
 400                          &py_g))
 401     return NULL;
 402   g = get_handle (py_g);
 403
 404   r = guestfs_launch (g);
 405   if (r == -1) {
 406     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 407     return NULL;
 408   }
 409
 410   Py_INCREF (Py_None);
 411   py_r = Py_None;
 412   return py_r;
 413 }
 414
 415 static PyObject *
 416 py_guestfs_wait_ready (PyObject *self, PyObject *args)
 417 {
 418   PyObject *py_g;
 419   guestfs_h *g;
 420   PyObject *py_r;
 421   int r;
 422
 423   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready",
 424                          &py_g))
 425     return NULL;
 426   g = get_handle (py_g);
 427
 428   r = guestfs_wait_ready (g);
 429   if (r == -1) {
 430     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 431     return NULL;
 432   }
 433
 434   Py_INCREF (Py_None);
 435   py_r = Py_None;
 436   return py_r;
 437 }
 438
 439 static PyObject *
 440 py_guestfs_kill_subprocess (PyObject *self, PyObject *args)
 441 {
 442   PyObject *py_g;
 443   guestfs_h *g;
 444   PyObject *py_r;
 445   int r;
 446
 447   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess",
 448                          &py_g))
 449     return NULL;
 450   g = get_handle (py_g);
 451
 452   r = guestfs_kill_subprocess (g);
 453   if (r == -1) {
 454     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 455     return NULL;
 456   }
 457
 458   Py_INCREF (Py_None);
 459   py_r = Py_None;
 460   return py_r;
 461 }
 462
 463 static PyObject *
 464 py_guestfs_add_drive (PyObject *self, PyObject *args)
 465 {
 466   PyObject *py_g;
 467   guestfs_h *g;
 468   PyObject *py_r;
 469   int r;
 470   const char *filename;
 471
 472   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive",
 473                          &py_g, &filename))
 474     return NULL;
 475   g = get_handle (py_g);
 476
 477   r = guestfs_add_drive (g, filename);
 478   if (r == -1) {
 479     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 480     return NULL;
 481   }
 482
 483   Py_INCREF (Py_None);
 484   py_r = Py_None;
 485   return py_r;
 486 }
 487
 488 static PyObject *
 489 py_guestfs_add_cdrom (PyObject *self, PyObject *args)
 490 {
 491   PyObject *py_g;
 492   guestfs_h *g;
 493   PyObject *py_r;
 494   int r;
 495   const char *filename;
 496
 497   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom",
 498                          &py_g, &filename))
 499     return NULL;
 500   g = get_handle (py_g);
 501
 502   r = guestfs_add_cdrom (g, filename);
 503   if (r == -1) {
 504     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 505     return NULL;
 506   }
 507
 508   Py_INCREF (Py_None);
 509   py_r = Py_None;
 510   return py_r;
 511 }
 512
 513 static PyObject *
 514 py_guestfs_config (PyObject *self, PyObject *args)
 515 {
 516   PyObject *py_g;
 517   guestfs_h *g;
 518   PyObject *py_r;
 519   int r;
 520   const char *qemuparam;
 521   const char *qemuvalue;
 522
 523   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
 524                          &py_g, &qemuparam, &qemuvalue))
 525     return NULL;
 526   g = get_handle (py_g);
 527
 528   r = guestfs_config (g, qemuparam, qemuvalue);
 529   if (r == -1) {
 530     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 531     return NULL;
 532   }
 533
 534   Py_INCREF (Py_None);
 535   py_r = Py_None;
 536   return py_r;
 537 }
 538
 539 static PyObject *
 540 py_guestfs_set_path (PyObject *self, PyObject *args)
 541 {
 542   PyObject *py_g;
 543   guestfs_h *g;
 544   PyObject *py_r;
 545   int r;
 546   const char *path;
 547
 548   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
 549                          &py_g, &path))
 550     return NULL;
 551   g = get_handle (py_g);
 552
 553   r = guestfs_set_path (g, path);
 554   if (r == -1) {
 555     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 556     return NULL;
 557   }
 558
 559   Py_INCREF (Py_None);
 560   py_r = Py_None;
 561   return py_r;
 562 }
 563
 564 static PyObject *
 565 py_guestfs_get_path (PyObject *self, PyObject *args)
 566 {
 567   PyObject *py_g;
 568   guestfs_h *g;
 569   PyObject *py_r;
 570   const char *r;
 571
 572   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
 573                          &py_g))
 574     return NULL;
 575   g = get_handle (py_g);
 576
 577   r = guestfs_get_path (g);
 578   if (r == NULL) {
 579     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 580     return NULL;
 581   }
 582
 583   py_r = PyString_FromString (r);
 584   return py_r;
 585 }
 586
 587 static PyObject *
 588 py_guestfs_set_autosync (PyObject *self, PyObject *args)
 589 {
 590   PyObject *py_g;
 591   guestfs_h *g;
 592   PyObject *py_r;
 593   int r;
 594   int autosync;
 595
 596   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
 597                          &py_g, &autosync))
 598     return NULL;
 599   g = get_handle (py_g);
 600
 601   r = guestfs_set_autosync (g, autosync);
 602   if (r == -1) {
 603     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 604     return NULL;
 605   }
 606
 607   Py_INCREF (Py_None);
 608   py_r = Py_None;
 609   return py_r;
 610 }
 611
 612 static PyObject *
 613 py_guestfs_get_autosync (PyObject *self, PyObject *args)
 614 {
 615   PyObject *py_g;
 616   guestfs_h *g;
 617   PyObject *py_r;
 618   int r;
 619
 620   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
 621                          &py_g))
 622     return NULL;
 623   g = get_handle (py_g);
 624
 625   r = guestfs_get_autosync (g);
 626   if (r == -1) {
 627     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 628     return NULL;
 629   }
 630
 631   py_r = PyInt_FromLong ((long) r);
 632   return py_r;
 633 }
 634
 635 static PyObject *
 636 py_guestfs_set_verbose (PyObject *self, PyObject *args)
 637 {
 638   PyObject *py_g;
 639   guestfs_h *g;
 640   PyObject *py_r;
 641   int r;
 642   int verbose;
 643
 644   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
 645                          &py_g, &verbose))
 646     return NULL;
 647   g = get_handle (py_g);
 648
 649   r = guestfs_set_verbose (g, verbose);
 650   if (r == -1) {
 651     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 652     return NULL;
 653   }
 654
 655   Py_INCREF (Py_None);
 656   py_r = Py_None;
 657   return py_r;
 658 }
 659
 660 static PyObject *
 661 py_guestfs_get_verbose (PyObject *self, PyObject *args)
 662 {
 663   PyObject *py_g;
 664   guestfs_h *g;
 665   PyObject *py_r;
 666   int r;
 667
 668   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
 669                          &py_g))
 670     return NULL;
 671   g = get_handle (py_g);
 672
 673   r = guestfs_get_verbose (g);
 674   if (r == -1) {
 675     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 676     return NULL;
 677   }
 678
 679   py_r = PyInt_FromLong ((long) r);
 680   return py_r;
 681 }
 682
 683 static PyObject *
 684 py_guestfs_mount (PyObject *self, PyObject *args)
 685 {
 686   PyObject *py_g;
 687   guestfs_h *g;
 688   PyObject *py_r;
 689   int r;
 690   const char *device;
 691   const char *mountpoint;
 692
 693   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
 694                          &py_g, &device, &mountpoint))
 695     return NULL;
 696   g = get_handle (py_g);
 697
 698   r = guestfs_mount (g, device, mountpoint);
 699   if (r == -1) {
 700     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 701     return NULL;
 702   }
 703
 704   Py_INCREF (Py_None);
 705   py_r = Py_None;
 706   return py_r;
 707 }
 708
 709 static PyObject *
 710 py_guestfs_sync (PyObject *self, PyObject *args)
 711 {
 712   PyObject *py_g;
 713   guestfs_h *g;
 714   PyObject *py_r;
 715   int r;
 716
 717   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
 718                          &py_g))
 719     return NULL;
 720   g = get_handle (py_g);
 721
 722   r = guestfs_sync (g);
 723   if (r == -1) {
 724     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 725     return NULL;
 726   }
 727
 728   Py_INCREF (Py_None);
 729   py_r = Py_None;
 730   return py_r;
 731 }
 732
 733 static PyObject *
 734 py_guestfs_touch (PyObject *self, PyObject *args)
 735 {
 736   PyObject *py_g;
 737   guestfs_h *g;
 738   PyObject *py_r;
 739   int r;
 740   const char *path;
 741
 742   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
 743                          &py_g, &path))
 744     return NULL;
 745   g = get_handle (py_g);
 746
 747   r = guestfs_touch (g, path);
 748   if (r == -1) {
 749     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 750     return NULL;
 751   }
 752
 753   Py_INCREF (Py_None);
 754   py_r = Py_None;
 755   return py_r;
 756 }
 757
 758 static PyObject *
 759 py_guestfs_cat (PyObject *self, PyObject *args)
 760 {
 761   PyObject *py_g;
 762   guestfs_h *g;
 763   PyObject *py_r;
 764   char *r;
 765   const char *path;
 766
 767   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
 768                          &py_g, &path))
 769     return NULL;
 770   g = get_handle (py_g);
 771
 772   r = guestfs_cat (g, path);
 773   if (r == NULL) {
 774     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 775     return NULL;
 776   }
 777
 778   py_r = PyString_FromString (r);
 779   free (r);
 780   return py_r;
 781 }
 782
 783 static PyObject *
 784 py_guestfs_ll (PyObject *self, PyObject *args)
 785 {
 786   PyObject *py_g;
 787   guestfs_h *g;
 788   PyObject *py_r;
 789   char *r;
 790   const char *directory;
 791
 792   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
 793                          &py_g, &directory))
 794     return NULL;
 795   g = get_handle (py_g);
 796
 797   r = guestfs_ll (g, directory);
 798   if (r == NULL) {
 799     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 800     return NULL;
 801   }
 802
 803   py_r = PyString_FromString (r);
 804   free (r);
 805   return py_r;
 806 }
 807
 808 static PyObject *
 809 py_guestfs_ls (PyObject *self, PyObject *args)
 810 {
 811   PyObject *py_g;
 812   guestfs_h *g;
 813   PyObject *py_r;
 814   char **r;
 815   const char *directory;
 816
 817   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
 818                          &py_g, &directory))
 819     return NULL;
 820   g = get_handle (py_g);
 821
 822   r = guestfs_ls (g, directory);
 823   if (r == NULL) {
 824     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 825     return NULL;
 826   }
 827
 828   py_r = put_string_list (r);
 829   free_strings (r);
 830   return py_r;
 831 }
 832
 833 static PyObject *
 834 py_guestfs_list_devices (PyObject *self, PyObject *args)
 835 {
 836   PyObject *py_g;
 837   guestfs_h *g;
 838   PyObject *py_r;
 839   char **r;
 840
 841   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
 842                          &py_g))
 843     return NULL;
 844   g = get_handle (py_g);
 845
 846   r = guestfs_list_devices (g);
 847   if (r == NULL) {
 848     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 849     return NULL;
 850   }
 851
 852   py_r = put_string_list (r);
 853   free_strings (r);
 854   return py_r;
 855 }
 856
 857 static PyObject *
 858 py_guestfs_list_partitions (PyObject *self, PyObject *args)
 859 {
 860   PyObject *py_g;
 861   guestfs_h *g;
 862   PyObject *py_r;
 863   char **r;
 864
 865   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
 866                          &py_g))
 867     return NULL;
 868   g = get_handle (py_g);
 869
 870   r = guestfs_list_partitions (g);
 871   if (r == NULL) {
 872     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 873     return NULL;
 874   }
 875
 876   py_r = put_string_list (r);
 877   free_strings (r);
 878   return py_r;
 879 }
 880
 881 static PyObject *
 882 py_guestfs_pvs (PyObject *self, PyObject *args)
 883 {
 884   PyObject *py_g;
 885   guestfs_h *g;
 886   PyObject *py_r;
 887   char **r;
 888
 889   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
 890                          &py_g))
 891     return NULL;
 892   g = get_handle (py_g);
 893
 894   r = guestfs_pvs (g);
 895   if (r == NULL) {
 896     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 897     return NULL;
 898   }
 899
 900   py_r = put_string_list (r);
 901   free_strings (r);
 902   return py_r;
 903 }
 904
 905 static PyObject *
 906 py_guestfs_vgs (PyObject *self, PyObject *args)
 907 {
 908   PyObject *py_g;
 909   guestfs_h *g;
 910   PyObject *py_r;
 911   char **r;
 912
 913   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
 914                          &py_g))
 915     return NULL;
 916   g = get_handle (py_g);
 917
 918   r = guestfs_vgs (g);
 919   if (r == NULL) {
 920     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 921     return NULL;
 922   }
 923
 924   py_r = put_string_list (r);
 925   free_strings (r);
 926   return py_r;
 927 }
 928
 929 static PyObject *
 930 py_guestfs_lvs (PyObject *self, PyObject *args)
 931 {
 932   PyObject *py_g;
 933   guestfs_h *g;
 934   PyObject *py_r;
 935   char **r;
 936
 937   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
 938                          &py_g))
 939     return NULL;
 940   g = get_handle (py_g);
 941
 942   r = guestfs_lvs (g);
 943   if (r == NULL) {
 944     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 945     return NULL;
 946   }
 947
 948   py_r = put_string_list (r);
 949   free_strings (r);
 950   return py_r;
 951 }
 952
 953 static PyObject *
 954 py_guestfs_pvs_full (PyObject *self, PyObject *args)
 955 {
 956   PyObject *py_g;
 957   guestfs_h *g;
 958   PyObject *py_r;
 959   struct guestfs_lvm_pv_list *r;
 960
 961   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
 962                          &py_g))
 963     return NULL;
 964   g = get_handle (py_g);
 965
 966   r = guestfs_pvs_full (g);
 967   if (r == NULL) {
 968     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 969     return NULL;
 970   }
 971
 972   py_r = put_lvm_pv_list (r);
 973   guestfs_free_lvm_pv_list (r);
 974   return py_r;
 975 }
 976
 977 static PyObject *
 978 py_guestfs_vgs_full (PyObject *self, PyObject *args)
 979 {
 980   PyObject *py_g;
 981   guestfs_h *g;
 982   PyObject *py_r;
 983   struct guestfs_lvm_vg_list *r;
 984
 985   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
 986                          &py_g))
 987     return NULL;
 988   g = get_handle (py_g);
 989
 990   r = guestfs_vgs_full (g);
 991   if (r == NULL) {
 992     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 993     return NULL;
 994   }
 995
 996   py_r = put_lvm_vg_list (r);
 997   guestfs_free_lvm_vg_list (r);
 998   return py_r;
 999 }
1000
1001 static PyObject *
1002 py_guestfs_lvs_full (PyObject *self, PyObject *args)
1003 {
1004   PyObject *py_g;
1005   guestfs_h *g;
1006   PyObject *py_r;
1007   struct guestfs_lvm_lv_list *r;
1008
1009   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
1010                          &py_g))
1011     return NULL;
1012   g = get_handle (py_g);
1013
1014   r = guestfs_lvs_full (g);
1015   if (r == NULL) {
1016     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1017     return NULL;
1018   }
1019
1020   py_r = put_lvm_lv_list (r);
1021   guestfs_free_lvm_lv_list (r);
1022   return py_r;
1023 }
1024
1025 static PyObject *
1026 py_guestfs_read_lines (PyObject *self, PyObject *args)
1027 {
1028   PyObject *py_g;
1029   guestfs_h *g;
1030   PyObject *py_r;
1031   char **r;
1032   const char *path;
1033
1034   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
1035                          &py_g, &path))
1036     return NULL;
1037   g = get_handle (py_g);
1038
1039   r = guestfs_read_lines (g, path);
1040   if (r == NULL) {
1041     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1042     return NULL;
1043   }
1044
1045   py_r = put_string_list (r);
1046   free_strings (r);
1047   return py_r;
1048 }
1049
1050 static PyObject *
1051 py_guestfs_aug_init (PyObject *self, PyObject *args)
1052 {
1053   PyObject *py_g;
1054   guestfs_h *g;
1055   PyObject *py_r;
1056   int r;
1057   const char *root;
1058   int flags;
1059
1060   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
1061                          &py_g, &root, &flags))
1062     return NULL;
1063   g = get_handle (py_g);
1064
1065   r = guestfs_aug_init (g, root, flags);
1066   if (r == -1) {
1067     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1068     return NULL;
1069   }
1070
1071   Py_INCREF (Py_None);
1072   py_r = Py_None;
1073   return py_r;
1074 }
1075
1076 static PyObject *
1077 py_guestfs_aug_close (PyObject *self, PyObject *args)
1078 {
1079   PyObject *py_g;
1080   guestfs_h *g;
1081   PyObject *py_r;
1082   int r;
1083
1084   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
1085                          &py_g))
1086     return NULL;
1087   g = get_handle (py_g);
1088
1089   r = guestfs_aug_close (g);
1090   if (r == -1) {
1091     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1092     return NULL;
1093   }
1094
1095   Py_INCREF (Py_None);
1096   py_r = Py_None;
1097   return py_r;
1098 }
1099
1100 static PyObject *
1101 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
1102 {
1103   PyObject *py_g;
1104   guestfs_h *g;
1105   PyObject *py_r;
1106   int r;
1107   const char *name;
1108   const char *expr;
1109
1110   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1111                          &py_g, &name, &expr))
1112     return NULL;
1113   g = get_handle (py_g);
1114
1115   r = guestfs_aug_defvar (g, name, expr);
1116   if (r == -1) {
1117     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1118     return NULL;
1119   }
1120
1121   py_r = PyInt_FromLong ((long) r);
1122   return py_r;
1123 }
1124
1125 static PyObject *
1126 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1127 {
1128   PyObject *py_g;
1129   guestfs_h *g;
1130   PyObject *py_r;
1131   struct guestfs_int_bool *r;
1132   const char *name;
1133   const char *expr;
1134   const char *val;
1135
1136   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1137                          &py_g, &name, &expr, &val))
1138     return NULL;
1139   g = get_handle (py_g);
1140
1141   r = guestfs_aug_defnode (g, name, expr, val);
1142   if (r == NULL) {
1143     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1144     return NULL;
1145   }
1146
1147   py_r = PyTuple_New (2);
1148   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1149   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1150   guestfs_free_int_bool (r);
1151   return py_r;
1152 }
1153
1154 static PyObject *
1155 py_guestfs_aug_get (PyObject *self, PyObject *args)
1156 {
1157   PyObject *py_g;
1158   guestfs_h *g;
1159   PyObject *py_r;
1160   char *r;
1161   const char *path;
1162
1163   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1164                          &py_g, &path))
1165     return NULL;
1166   g = get_handle (py_g);
1167
1168   r = guestfs_aug_get (g, path);
1169   if (r == NULL) {
1170     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1171     return NULL;
1172   }
1173
1174   py_r = PyString_FromString (r);
1175   free (r);
1176   return py_r;
1177 }
1178
1179 static PyObject *
1180 py_guestfs_aug_set (PyObject *self, PyObject *args)
1181 {
1182   PyObject *py_g;
1183   guestfs_h *g;
1184   PyObject *py_r;
1185   int r;
1186   const char *path;
1187   const char *val;
1188
1189   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1190                          &py_g, &path, &val))
1191     return NULL;
1192   g = get_handle (py_g);
1193
1194   r = guestfs_aug_set (g, path, val);
1195   if (r == -1) {
1196     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1197     return NULL;
1198   }
1199
1200   Py_INCREF (Py_None);
1201   py_r = Py_None;
1202   return py_r;
1203 }
1204
1205 static PyObject *
1206 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1207 {
1208   PyObject *py_g;
1209   guestfs_h *g;
1210   PyObject *py_r;
1211   int r;
1212   const char *path;
1213   const char *label;
1214   int before;
1215
1216   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1217                          &py_g, &path, &label, &before))
1218     return NULL;
1219   g = get_handle (py_g);
1220
1221   r = guestfs_aug_insert (g, path, label, before);
1222   if (r == -1) {
1223     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1224     return NULL;
1225   }
1226
1227   Py_INCREF (Py_None);
1228   py_r = Py_None;
1229   return py_r;
1230 }
1231
1232 static PyObject *
1233 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1234 {
1235   PyObject *py_g;
1236   guestfs_h *g;
1237   PyObject *py_r;
1238   int r;
1239   const char *path;
1240
1241   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1242                          &py_g, &path))
1243     return NULL;
1244   g = get_handle (py_g);
1245
1246   r = guestfs_aug_rm (g, path);
1247   if (r == -1) {
1248     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1249     return NULL;
1250   }
1251
1252   py_r = PyInt_FromLong ((long) r);
1253   return py_r;
1254 }
1255
1256 static PyObject *
1257 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1258 {
1259   PyObject *py_g;
1260   guestfs_h *g;
1261   PyObject *py_r;
1262   int r;
1263   const char *src;
1264   const char *dest;
1265
1266   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1267                          &py_g, &src, &dest))
1268     return NULL;
1269   g = get_handle (py_g);
1270
1271   r = guestfs_aug_mv (g, src, dest);
1272   if (r == -1) {
1273     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1274     return NULL;
1275   }
1276
1277   Py_INCREF (Py_None);
1278   py_r = Py_None;
1279   return py_r;
1280 }
1281
1282 static PyObject *
1283 py_guestfs_aug_match (PyObject *self, PyObject *args)
1284 {
1285   PyObject *py_g;
1286   guestfs_h *g;
1287   PyObject *py_r;
1288   char **r;
1289   const char *path;
1290
1291   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1292                          &py_g, &path))
1293     return NULL;
1294   g = get_handle (py_g);
1295
1296   r = guestfs_aug_match (g, path);
1297   if (r == NULL) {
1298     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1299     return NULL;
1300   }
1301
1302   py_r = put_string_list (r);
1303   free_strings (r);
1304   return py_r;
1305 }
1306
1307 static PyObject *
1308 py_guestfs_aug_save (PyObject *self, PyObject *args)
1309 {
1310   PyObject *py_g;
1311   guestfs_h *g;
1312   PyObject *py_r;
1313   int r;
1314
1315   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1316                          &py_g))
1317     return NULL;
1318   g = get_handle (py_g);
1319
1320   r = guestfs_aug_save (g);
1321   if (r == -1) {
1322     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1323     return NULL;
1324   }
1325
1326   Py_INCREF (Py_None);
1327   py_r = Py_None;
1328   return py_r;
1329 }
1330
1331 static PyObject *
1332 py_guestfs_aug_load (PyObject *self, PyObject *args)
1333 {
1334   PyObject *py_g;
1335   guestfs_h *g;
1336   PyObject *py_r;
1337   int r;
1338
1339   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
1340                          &py_g))
1341     return NULL;
1342   g = get_handle (py_g);
1343
1344   r = guestfs_aug_load (g);
1345   if (r == -1) {
1346     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1347     return NULL;
1348   }
1349
1350   Py_INCREF (Py_None);
1351   py_r = Py_None;
1352   return py_r;
1353 }
1354
1355 static PyObject *
1356 py_guestfs_aug_ls (PyObject *self, PyObject *args)
1357 {
1358   PyObject *py_g;
1359   guestfs_h *g;
1360   PyObject *py_r;
1361   char **r;
1362   const char *path;
1363
1364   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
1365                          &py_g, &path))
1366     return NULL;
1367   g = get_handle (py_g);
1368
1369   r = guestfs_aug_ls (g, path);
1370   if (r == NULL) {
1371     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1372     return NULL;
1373   }
1374
1375   py_r = put_string_list (r);
1376   free_strings (r);
1377   return py_r;
1378 }
1379
1380 static PyObject *
1381 py_guestfs_rm (PyObject *self, PyObject *args)
1382 {
1383   PyObject *py_g;
1384   guestfs_h *g;
1385   PyObject *py_r;
1386   int r;
1387   const char *path;
1388
1389   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1390                          &py_g, &path))
1391     return NULL;
1392   g = get_handle (py_g);
1393
1394   r = guestfs_rm (g, path);
1395   if (r == -1) {
1396     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1397     return NULL;
1398   }
1399
1400   Py_INCREF (Py_None);
1401   py_r = Py_None;
1402   return py_r;
1403 }
1404
1405 static PyObject *
1406 py_guestfs_rmdir (PyObject *self, PyObject *args)
1407 {
1408   PyObject *py_g;
1409   guestfs_h *g;
1410   PyObject *py_r;
1411   int r;
1412   const char *path;
1413
1414   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1415                          &py_g, &path))
1416     return NULL;
1417   g = get_handle (py_g);
1418
1419   r = guestfs_rmdir (g, path);
1420   if (r == -1) {
1421     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1422     return NULL;
1423   }
1424
1425   Py_INCREF (Py_None);
1426   py_r = Py_None;
1427   return py_r;
1428 }
1429
1430 static PyObject *
1431 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1432 {
1433   PyObject *py_g;
1434   guestfs_h *g;
1435   PyObject *py_r;
1436   int r;
1437   const char *path;
1438
1439   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1440                          &py_g, &path))
1441     return NULL;
1442   g = get_handle (py_g);
1443
1444   r = guestfs_rm_rf (g, path);
1445   if (r == -1) {
1446     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1447     return NULL;
1448   }
1449
1450   Py_INCREF (Py_None);
1451   py_r = Py_None;
1452   return py_r;
1453 }
1454
1455 static PyObject *
1456 py_guestfs_mkdir (PyObject *self, PyObject *args)
1457 {
1458   PyObject *py_g;
1459   guestfs_h *g;
1460   PyObject *py_r;
1461   int r;
1462   const char *path;
1463
1464   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1465                          &py_g, &path))
1466     return NULL;
1467   g = get_handle (py_g);
1468
1469   r = guestfs_mkdir (g, path);
1470   if (r == -1) {
1471     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1472     return NULL;
1473   }
1474
1475   Py_INCREF (Py_None);
1476   py_r = Py_None;
1477   return py_r;
1478 }
1479
1480 static PyObject *
1481 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1482 {
1483   PyObject *py_g;
1484   guestfs_h *g;
1485   PyObject *py_r;
1486   int r;
1487   const char *path;
1488
1489   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1490                          &py_g, &path))
1491     return NULL;
1492   g = get_handle (py_g);
1493
1494   r = guestfs_mkdir_p (g, path);
1495   if (r == -1) {
1496     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1497     return NULL;
1498   }
1499
1500   Py_INCREF (Py_None);
1501   py_r = Py_None;
1502   return py_r;
1503 }
1504
1505 static PyObject *
1506 py_guestfs_chmod (PyObject *self, PyObject *args)
1507 {
1508   PyObject *py_g;
1509   guestfs_h *g;
1510   PyObject *py_r;
1511   int r;
1512   int mode;
1513   const char *path;
1514
1515   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1516                          &py_g, &mode, &path))
1517     return NULL;
1518   g = get_handle (py_g);
1519
1520   r = guestfs_chmod (g, mode, path);
1521   if (r == -1) {
1522     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1523     return NULL;
1524   }
1525
1526   Py_INCREF (Py_None);
1527   py_r = Py_None;
1528   return py_r;
1529 }
1530
1531 static PyObject *
1532 py_guestfs_chown (PyObject *self, PyObject *args)
1533 {
1534   PyObject *py_g;
1535   guestfs_h *g;
1536   PyObject *py_r;
1537   int r;
1538   int owner;
1539   int group;
1540   const char *path;
1541
1542   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1543                          &py_g, &owner, &group, &path))
1544     return NULL;
1545   g = get_handle (py_g);
1546
1547   r = guestfs_chown (g, owner, group, path);
1548   if (r == -1) {
1549     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1550     return NULL;
1551   }
1552
1553   Py_INCREF (Py_None);
1554   py_r = Py_None;
1555   return py_r;
1556 }
1557
1558 static PyObject *
1559 py_guestfs_exists (PyObject *self, PyObject *args)
1560 {
1561   PyObject *py_g;
1562   guestfs_h *g;
1563   PyObject *py_r;
1564   int r;
1565   const char *path;
1566
1567   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1568                          &py_g, &path))
1569     return NULL;
1570   g = get_handle (py_g);
1571
1572   r = guestfs_exists (g, path);
1573   if (r == -1) {
1574     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1575     return NULL;
1576   }
1577
1578   py_r = PyInt_FromLong ((long) r);
1579   return py_r;
1580 }
1581
1582 static PyObject *
1583 py_guestfs_is_file (PyObject *self, PyObject *args)
1584 {
1585   PyObject *py_g;
1586   guestfs_h *g;
1587   PyObject *py_r;
1588   int r;
1589   const char *path;
1590
1591   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
1592                          &py_g, &path))
1593     return NULL;
1594   g = get_handle (py_g);
1595
1596   r = guestfs_is_file (g, path);
1597   if (r == -1) {
1598     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1599     return NULL;
1600   }
1601
1602   py_r = PyInt_FromLong ((long) r);
1603   return py_r;
1604 }
1605
1606 static PyObject *
1607 py_guestfs_is_dir (PyObject *self, PyObject *args)
1608 {
1609   PyObject *py_g;
1610   guestfs_h *g;
1611   PyObject *py_r;
1612   int r;
1613   const char *path;
1614
1615   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
1616                          &py_g, &path))
1617     return NULL;
1618   g = get_handle (py_g);
1619
1620   r = guestfs_is_dir (g, path);
1621   if (r == -1) {
1622     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1623     return NULL;
1624   }
1625
1626   py_r = PyInt_FromLong ((long) r);
1627   return py_r;
1628 }
1629
1630 static PyObject *
1631 py_guestfs_pvcreate (PyObject *self, PyObject *args)
1632 {
1633   PyObject *py_g;
1634   guestfs_h *g;
1635   PyObject *py_r;
1636   int r;
1637   const char *device;
1638
1639   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1640                          &py_g, &device))
1641     return NULL;
1642   g = get_handle (py_g);
1643
1644   r = guestfs_pvcreate (g, device);
1645   if (r == -1) {
1646     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1647     return NULL;
1648   }
1649
1650   Py_INCREF (Py_None);
1651   py_r = Py_None;
1652   return py_r;
1653 }
1654
1655 static PyObject *
1656 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1657 {
1658   PyObject *py_g;
1659   guestfs_h *g;
1660   PyObject *py_r;
1661   int r;
1662   const char *volgroup;
1663   PyObject *py_physvols;
1664   const char **physvols;
1665
1666   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1667                          &py_g, &volgroup, &py_physvols))
1668     return NULL;
1669   g = get_handle (py_g);
1670   physvols = get_string_list (py_physvols);
1671   if (!physvols) return NULL;
1672
1673   r = guestfs_vgcreate (g, volgroup, physvols);
1674   free (physvols);
1675   if (r == -1) {
1676     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1677     return NULL;
1678   }
1679
1680   Py_INCREF (Py_None);
1681   py_r = Py_None;
1682   return py_r;
1683 }
1684
1685 static PyObject *
1686 py_guestfs_lvcreate (PyObject *self, PyObject *args)
1687 {
1688   PyObject *py_g;
1689   guestfs_h *g;
1690   PyObject *py_r;
1691   int r;
1692   const char *logvol;
1693   const char *volgroup;
1694   int mbytes;
1695
1696   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1697                          &py_g, &logvol, &volgroup, &mbytes))
1698     return NULL;
1699   g = get_handle (py_g);
1700
1701   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1702   if (r == -1) {
1703     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1704     return NULL;
1705   }
1706
1707   Py_INCREF (Py_None);
1708   py_r = Py_None;
1709   return py_r;
1710 }
1711
1712 static PyObject *
1713 py_guestfs_mkfs (PyObject *self, PyObject *args)
1714 {
1715   PyObject *py_g;
1716   guestfs_h *g;
1717   PyObject *py_r;
1718   int r;
1719   const char *fstype;
1720   const char *device;
1721
1722   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1723                          &py_g, &fstype, &device))
1724     return NULL;
1725   g = get_handle (py_g);
1726
1727   r = guestfs_mkfs (g, fstype, device);
1728   if (r == -1) {
1729     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1730     return NULL;
1731   }
1732
1733   Py_INCREF (Py_None);
1734   py_r = Py_None;
1735   return py_r;
1736 }
1737
1738 static PyObject *
1739 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1740 {
1741   PyObject *py_g;
1742   guestfs_h *g;
1743   PyObject *py_r;
1744   int r;
1745   const char *device;
1746   int cyls;
1747   int heads;
1748   int sectors;
1749   PyObject *py_lines;
1750   const char **lines;
1751
1752   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1753                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1754     return NULL;
1755   g = get_handle (py_g);
1756   lines = get_string_list (py_lines);
1757   if (!lines) return NULL;
1758
1759   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1760   free (lines);
1761   if (r == -1) {
1762     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1763     return NULL;
1764   }
1765
1766   Py_INCREF (Py_None);
1767   py_r = Py_None;
1768   return py_r;
1769 }
1770
1771 static PyObject *
1772 py_guestfs_write_file (PyObject *self, PyObject *args)
1773 {
1774   PyObject *py_g;
1775   guestfs_h *g;
1776   PyObject *py_r;
1777   int r;
1778   const char *path;
1779   const char *content;
1780   int size;
1781
1782   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
1783                          &py_g, &path, &content, &size))
1784     return NULL;
1785   g = get_handle (py_g);
1786
1787   r = guestfs_write_file (g, path, content, size);
1788   if (r == -1) {
1789     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1790     return NULL;
1791   }
1792
1793   Py_INCREF (Py_None);
1794   py_r = Py_None;
1795   return py_r;
1796 }
1797
1798 static PyObject *
1799 py_guestfs_umount (PyObject *self, PyObject *args)
1800 {
1801   PyObject *py_g;
1802   guestfs_h *g;
1803   PyObject *py_r;
1804   int r;
1805   const char *pathordevice;
1806
1807   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
1808                          &py_g, &pathordevice))
1809     return NULL;
1810   g = get_handle (py_g);
1811
1812   r = guestfs_umount (g, pathordevice);
1813   if (r == -1) {
1814     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1815     return NULL;
1816   }
1817
1818   Py_INCREF (Py_None);
1819   py_r = Py_None;
1820   return py_r;
1821 }
1822
1823 static PyObject *
1824 py_guestfs_mounts (PyObject *self, PyObject *args)
1825 {
1826   PyObject *py_g;
1827   guestfs_h *g;
1828   PyObject *py_r;
1829   char **r;
1830
1831   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
1832                          &py_g))
1833     return NULL;
1834   g = get_handle (py_g);
1835
1836   r = guestfs_mounts (g);
1837   if (r == NULL) {
1838     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1839     return NULL;
1840   }
1841
1842   py_r = put_string_list (r);
1843   free_strings (r);
1844   return py_r;
1845 }
1846
1847 static PyObject *
1848 py_guestfs_umount_all (PyObject *self, PyObject *args)
1849 {
1850   PyObject *py_g;
1851   guestfs_h *g;
1852   PyObject *py_r;
1853   int r;
1854
1855   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
1856                          &py_g))
1857     return NULL;
1858   g = get_handle (py_g);
1859
1860   r = guestfs_umount_all (g);
1861   if (r == -1) {
1862     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1863     return NULL;
1864   }
1865
1866   Py_INCREF (Py_None);
1867   py_r = Py_None;
1868   return py_r;
1869 }
1870
1871 static PyObject *
1872 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
1873 {
1874   PyObject *py_g;
1875   guestfs_h *g;
1876   PyObject *py_r;
1877   int r;
1878
1879   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
1880                          &py_g))
1881     return NULL;
1882   g = get_handle (py_g);
1883
1884   r = guestfs_lvm_remove_all (g);
1885   if (r == -1) {
1886     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1887     return NULL;
1888   }
1889
1890   Py_INCREF (Py_None);
1891   py_r = Py_None;
1892   return py_r;
1893 }
1894
1895 static PyObject *
1896 py_guestfs_file (PyObject *self, PyObject *args)
1897 {
1898   PyObject *py_g;
1899   guestfs_h *g;
1900   PyObject *py_r;
1901   char *r;
1902   const char *path;
1903
1904   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
1905                          &py_g, &path))
1906     return NULL;
1907   g = get_handle (py_g);
1908
1909   r = guestfs_file (g, path);
1910   if (r == NULL) {
1911     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1912     return NULL;
1913   }
1914
1915   py_r = PyString_FromString (r);
1916   free (r);
1917   return py_r;
1918 }
1919
1920 static PyObject *
1921 py_guestfs_command (PyObject *self, PyObject *args)
1922 {
1923   PyObject *py_g;
1924   guestfs_h *g;
1925   PyObject *py_r;
1926   char *r;
1927   PyObject *py_arguments;
1928   const char **arguments;
1929
1930   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
1931                          &py_g, &py_arguments))
1932     return NULL;
1933   g = get_handle (py_g);
1934   arguments = get_string_list (py_arguments);
1935   if (!arguments) return NULL;
1936
1937   r = guestfs_command (g, arguments);
1938   free (arguments);
1939   if (r == NULL) {
1940     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1941     return NULL;
1942   }
1943
1944   py_r = PyString_FromString (r);
1945   free (r);
1946   return py_r;
1947 }
1948
1949 static PyObject *
1950 py_guestfs_command_lines (PyObject *self, PyObject *args)
1951 {
1952   PyObject *py_g;
1953   guestfs_h *g;
1954   PyObject *py_r;
1955   char **r;
1956   PyObject *py_arguments;
1957   const char **arguments;
1958
1959   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
1960                          &py_g, &py_arguments))
1961     return NULL;
1962   g = get_handle (py_g);
1963   arguments = get_string_list (py_arguments);
1964   if (!arguments) return NULL;
1965
1966   r = guestfs_command_lines (g, arguments);
1967   free (arguments);
1968   if (r == NULL) {
1969     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1970     return NULL;
1971   }
1972
1973   py_r = put_string_list (r);
1974   free_strings (r);
1975   return py_r;
1976 }
1977
1978 static PyObject *
1979 py_guestfs_stat (PyObject *self, PyObject *args)
1980 {
1981   PyObject *py_g;
1982   guestfs_h *g;
1983   PyObject *py_r;
1984   struct guestfs_stat *r;
1985   const char *path;
1986
1987   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
1988                          &py_g, &path))
1989     return NULL;
1990   g = get_handle (py_g);
1991
1992   r = guestfs_stat (g, path);
1993   if (r == NULL) {
1994     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1995     return NULL;
1996   }
1997
1998   py_r = put_stat (r);
1999   free (r);
2000   return py_r;
2001 }
2002
2003 static PyObject *
2004 py_guestfs_lstat (PyObject *self, PyObject *args)
2005 {
2006   PyObject *py_g;
2007   guestfs_h *g;
2008   PyObject *py_r;
2009   struct guestfs_stat *r;
2010   const char *path;
2011
2012   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
2013                          &py_g, &path))
2014     return NULL;
2015   g = get_handle (py_g);
2016
2017   r = guestfs_lstat (g, path);
2018   if (r == NULL) {
2019     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2020     return NULL;
2021   }
2022
2023   py_r = put_stat (r);
2024   free (r);
2025   return py_r;
2026 }
2027
2028 static PyObject *
2029 py_guestfs_statvfs (PyObject *self, PyObject *args)
2030 {
2031   PyObject *py_g;
2032   guestfs_h *g;
2033   PyObject *py_r;
2034   struct guestfs_statvfs *r;
2035   const char *path;
2036
2037   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
2038                          &py_g, &path))
2039     return NULL;
2040   g = get_handle (py_g);
2041
2042   r = guestfs_statvfs (g, path);
2043   if (r == NULL) {
2044     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2045     return NULL;
2046   }
2047
2048   py_r = put_statvfs (r);
2049   free (r);
2050   return py_r;
2051 }
2052
2053 static PyObject *
2054 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
2055 {
2056   PyObject *py_g;
2057   guestfs_h *g;
2058   PyObject *py_r;
2059   char **r;
2060   const char *device;
2061
2062   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
2063                          &py_g, &device))
2064     return NULL;
2065   g = get_handle (py_g);
2066
2067   r = guestfs_tune2fs_l (g, device);
2068   if (r == NULL) {
2069     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2070     return NULL;
2071   }
2072
2073   py_r = put_table (r);
2074   free_strings (r);
2075   return py_r;
2076 }
2077
2078 static PyObject *
2079 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
2080 {
2081   PyObject *py_g;
2082   guestfs_h *g;
2083   PyObject *py_r;
2084   int r;
2085   const char *device;
2086
2087   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
2088                          &py_g, &device))
2089     return NULL;
2090   g = get_handle (py_g);
2091
2092   r = guestfs_blockdev_setro (g, device);
2093   if (r == -1) {
2094     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2095     return NULL;
2096   }
2097
2098   Py_INCREF (Py_None);
2099   py_r = Py_None;
2100   return py_r;
2101 }
2102
2103 static PyObject *
2104 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
2105 {
2106   PyObject *py_g;
2107   guestfs_h *g;
2108   PyObject *py_r;
2109   int r;
2110   const char *device;
2111
2112   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
2113                          &py_g, &device))
2114     return NULL;
2115   g = get_handle (py_g);
2116
2117   r = guestfs_blockdev_setrw (g, device);
2118   if (r == -1) {
2119     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2120     return NULL;
2121   }
2122
2123   Py_INCREF (Py_None);
2124   py_r = Py_None;
2125   return py_r;
2126 }
2127
2128 static PyObject *
2129 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
2130 {
2131   PyObject *py_g;
2132   guestfs_h *g;
2133   PyObject *py_r;
2134   int r;
2135   const char *device;
2136
2137   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
2138                          &py_g, &device))
2139     return NULL;
2140   g = get_handle (py_g);
2141
2142   r = guestfs_blockdev_getro (g, device);
2143   if (r == -1) {
2144     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2145     return NULL;
2146   }
2147
2148   py_r = PyInt_FromLong ((long) r);
2149   return py_r;
2150 }
2151
2152 static PyObject *
2153 py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
2154 {
2155   PyObject *py_g;
2156   guestfs_h *g;
2157   PyObject *py_r;
2158   int r;
2159   const char *device;
2160
2161   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
2162                          &py_g, &device))
2163     return NULL;
2164   g = get_handle (py_g);
2165
2166   r = guestfs_blockdev_getss (g, device);
2167   if (r == -1) {
2168     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2169     return NULL;
2170   }
2171
2172   py_r = PyInt_FromLong ((long) r);
2173   return py_r;
2174 }
2175
2176 static PyObject *
2177 py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
2178 {
2179   PyObject *py_g;
2180   guestfs_h *g;
2181   PyObject *py_r;
2182   int r;
2183   const char *device;
2184
2185   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
2186                          &py_g, &device))
2187     return NULL;
2188   g = get_handle (py_g);
2189
2190   r = guestfs_blockdev_getbsz (g, device);
2191   if (r == -1) {
2192     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2193     return NULL;
2194   }
2195
2196   py_r = PyInt_FromLong ((long) r);
2197   return py_r;
2198 }
2199
2200 static PyObject *
2201 py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
2202 {
2203   PyObject *py_g;
2204   guestfs_h *g;
2205   PyObject *py_r;
2206   int r;
2207   const char *device;
2208   int blocksize;
2209
2210   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
2211                          &py_g, &device, &blocksize))
2212     return NULL;
2213   g = get_handle (py_g);
2214
2215   r = guestfs_blockdev_setbsz (g, device, blocksize);
2216   if (r == -1) {
2217     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2218     return NULL;
2219   }
2220
2221   Py_INCREF (Py_None);
2222   py_r = Py_None;
2223   return py_r;
2224 }
2225
2226 static PyObject *
2227 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
2228 {
2229   PyObject *py_g;
2230   guestfs_h *g;
2231   PyObject *py_r;
2232   int64_t r;
2233   const char *device;
2234
2235   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
2236                          &py_g, &device))
2237     return NULL;
2238   g = get_handle (py_g);
2239
2240   r = guestfs_blockdev_getsz (g, device);
2241   if (r == -1) {
2242     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2243     return NULL;
2244   }
2245
2246   py_r = PyLong_FromLongLong (r);
2247   return py_r;
2248 }
2249
2250 static PyObject *
2251 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
2252 {
2253   PyObject *py_g;
2254   guestfs_h *g;
2255   PyObject *py_r;
2256   int64_t r;
2257   const char *device;
2258
2259   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
2260                          &py_g, &device))
2261     return NULL;
2262   g = get_handle (py_g);
2263
2264   r = guestfs_blockdev_getsize64 (g, device);
2265   if (r == -1) {
2266     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2267     return NULL;
2268   }
2269
2270   py_r = PyLong_FromLongLong (r);
2271   return py_r;
2272 }
2273
2274 static PyObject *
2275 py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
2276 {
2277   PyObject *py_g;
2278   guestfs_h *g;
2279   PyObject *py_r;
2280   int r;
2281   const char *device;
2282
2283   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
2284                          &py_g, &device))
2285     return NULL;
2286   g = get_handle (py_g);
2287
2288   r = guestfs_blockdev_flushbufs (g, device);
2289   if (r == -1) {
2290     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2291     return NULL;
2292   }
2293
2294   Py_INCREF (Py_None);
2295   py_r = Py_None;
2296   return py_r;
2297 }
2298
2299 static PyObject *
2300 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
2301 {
2302   PyObject *py_g;
2303   guestfs_h *g;
2304   PyObject *py_r;
2305   int r;
2306   const char *device;
2307
2308   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
2309                          &py_g, &device))
2310     return NULL;
2311   g = get_handle (py_g);
2312
2313   r = guestfs_blockdev_rereadpt (g, device);
2314   if (r == -1) {
2315     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2316     return NULL;
2317   }
2318
2319   Py_INCREF (Py_None);
2320   py_r = Py_None;
2321   return py_r;
2322 }
2323
2324 static PyMethodDef methods[] = {
2325   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
2326   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
2327   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
2328   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
2329   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
2330   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
2331   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
2332   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
2333   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
2334   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
2335   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
2336   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
2337   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
2338   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
2339   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
2340   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
2341   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
2342   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
2343   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
2344   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
2345   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
2346   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
2347   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
2348   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
2349   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
2350   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
2351   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
2352   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
2353   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
2354   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
2355   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
2356   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
2357   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
2358   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
2359   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
2360   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
2361   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
2362   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
2363   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
2364   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
2365   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
2366   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
2367   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
2368   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
2369   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
2370   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
2371   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
2372   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
2373   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
2374   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
2375   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
2376   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
2377   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
2378   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
2379   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
2380   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
2381   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
2382   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
2383   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
2384   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
2385   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
2386   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
2387   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
2388   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
2389   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
2390   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
2391   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
2392   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
2393   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
2394   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
2395   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
2396   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
2397   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
2398   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
2399   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
2400   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
2401   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
2402   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
2403   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
2404   { NULL, NULL, 0, NULL }
2405 };
2406
2407 void
2408 initlibguestfsmod (void)
2409 {
2410   static int initialized = 0;
2411
2412   if (initialized) return;
2413   Py_InitModule ((char *) "libguestfsmod", methods);
2414   initialized = 1;
2415 }