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