Generated code for drop-caches command.
[libguestfs.git] / 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_qemu (PyObject *self, PyObject *args)
541 {
542   PyObject *py_g;
543   guestfs_h *g;
544   PyObject *py_r;
545   int r;
546   const char *qemu;
547
548   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_qemu",
549                          &py_g, &qemu))
550     return NULL;
551   g = get_handle (py_g);
552
553   r = guestfs_set_qemu (g, qemu);
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_qemu (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_qemu",
573                          &py_g))
574     return NULL;
575   g = get_handle (py_g);
576
577   r = guestfs_get_qemu (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_path (PyObject *self, PyObject *args)
589 {
590   PyObject *py_g;
591   guestfs_h *g;
592   PyObject *py_r;
593   int r;
594   const char *path;
595
596   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
597                          &py_g, &path))
598     return NULL;
599   g = get_handle (py_g);
600
601   r = guestfs_set_path (g, path);
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_path (PyObject *self, PyObject *args)
614 {
615   PyObject *py_g;
616   guestfs_h *g;
617   PyObject *py_r;
618   const char *r;
619
620   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
621                          &py_g))
622     return NULL;
623   g = get_handle (py_g);
624
625   r = guestfs_get_path (g);
626   if (r == NULL) {
627     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
628     return NULL;
629   }
630
631   py_r = PyString_FromString (r);
632   return py_r;
633 }
634
635 static PyObject *
636 py_guestfs_set_autosync (PyObject *self, PyObject *args)
637 {
638   PyObject *py_g;
639   guestfs_h *g;
640   PyObject *py_r;
641   int r;
642   int autosync;
643
644   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
645                          &py_g, &autosync))
646     return NULL;
647   g = get_handle (py_g);
648
649   r = guestfs_set_autosync (g, autosync);
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_autosync (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_autosync",
669                          &py_g))
670     return NULL;
671   g = get_handle (py_g);
672
673   r = guestfs_get_autosync (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_set_verbose (PyObject *self, PyObject *args)
685 {
686   PyObject *py_g;
687   guestfs_h *g;
688   PyObject *py_r;
689   int r;
690   int verbose;
691
692   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
693                          &py_g, &verbose))
694     return NULL;
695   g = get_handle (py_g);
696
697   r = guestfs_set_verbose (g, verbose);
698   if (r == -1) {
699     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
700     return NULL;
701   }
702
703   Py_INCREF (Py_None);
704   py_r = Py_None;
705   return py_r;
706 }
707
708 static PyObject *
709 py_guestfs_get_verbose (PyObject *self, PyObject *args)
710 {
711   PyObject *py_g;
712   guestfs_h *g;
713   PyObject *py_r;
714   int r;
715
716   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
717                          &py_g))
718     return NULL;
719   g = get_handle (py_g);
720
721   r = guestfs_get_verbose (g);
722   if (r == -1) {
723     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
724     return NULL;
725   }
726
727   py_r = PyInt_FromLong ((long) r);
728   return py_r;
729 }
730
731 static PyObject *
732 py_guestfs_is_ready (PyObject *self, PyObject *args)
733 {
734   PyObject *py_g;
735   guestfs_h *g;
736   PyObject *py_r;
737   int r;
738
739   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready",
740                          &py_g))
741     return NULL;
742   g = get_handle (py_g);
743
744   r = guestfs_is_ready (g);
745   if (r == -1) {
746     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
747     return NULL;
748   }
749
750   py_r = PyInt_FromLong ((long) r);
751   return py_r;
752 }
753
754 static PyObject *
755 py_guestfs_is_config (PyObject *self, PyObject *args)
756 {
757   PyObject *py_g;
758   guestfs_h *g;
759   PyObject *py_r;
760   int r;
761
762   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config",
763                          &py_g))
764     return NULL;
765   g = get_handle (py_g);
766
767   r = guestfs_is_config (g);
768   if (r == -1) {
769     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
770     return NULL;
771   }
772
773   py_r = PyInt_FromLong ((long) r);
774   return py_r;
775 }
776
777 static PyObject *
778 py_guestfs_is_launching (PyObject *self, PyObject *args)
779 {
780   PyObject *py_g;
781   guestfs_h *g;
782   PyObject *py_r;
783   int r;
784
785   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching",
786                          &py_g))
787     return NULL;
788   g = get_handle (py_g);
789
790   r = guestfs_is_launching (g);
791   if (r == -1) {
792     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
793     return NULL;
794   }
795
796   py_r = PyInt_FromLong ((long) r);
797   return py_r;
798 }
799
800 static PyObject *
801 py_guestfs_is_busy (PyObject *self, PyObject *args)
802 {
803   PyObject *py_g;
804   guestfs_h *g;
805   PyObject *py_r;
806   int r;
807
808   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy",
809                          &py_g))
810     return NULL;
811   g = get_handle (py_g);
812
813   r = guestfs_is_busy (g);
814   if (r == -1) {
815     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
816     return NULL;
817   }
818
819   py_r = PyInt_FromLong ((long) r);
820   return py_r;
821 }
822
823 static PyObject *
824 py_guestfs_get_state (PyObject *self, PyObject *args)
825 {
826   PyObject *py_g;
827   guestfs_h *g;
828   PyObject *py_r;
829   int r;
830
831   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state",
832                          &py_g))
833     return NULL;
834   g = get_handle (py_g);
835
836   r = guestfs_get_state (g);
837   if (r == -1) {
838     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
839     return NULL;
840   }
841
842   py_r = PyInt_FromLong ((long) r);
843   return py_r;
844 }
845
846 static PyObject *
847 py_guestfs_set_busy (PyObject *self, PyObject *args)
848 {
849   PyObject *py_g;
850   guestfs_h *g;
851   PyObject *py_r;
852   int r;
853
854   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy",
855                          &py_g))
856     return NULL;
857   g = get_handle (py_g);
858
859   r = guestfs_set_busy (g);
860   if (r == -1) {
861     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
862     return NULL;
863   }
864
865   Py_INCREF (Py_None);
866   py_r = Py_None;
867   return py_r;
868 }
869
870 static PyObject *
871 py_guestfs_set_ready (PyObject *self, PyObject *args)
872 {
873   PyObject *py_g;
874   guestfs_h *g;
875   PyObject *py_r;
876   int r;
877
878   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready",
879                          &py_g))
880     return NULL;
881   g = get_handle (py_g);
882
883   r = guestfs_set_ready (g);
884   if (r == -1) {
885     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
886     return NULL;
887   }
888
889   Py_INCREF (Py_None);
890   py_r = Py_None;
891   return py_r;
892 }
893
894 static PyObject *
895 py_guestfs_mount (PyObject *self, PyObject *args)
896 {
897   PyObject *py_g;
898   guestfs_h *g;
899   PyObject *py_r;
900   int r;
901   const char *device;
902   const char *mountpoint;
903
904   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
905                          &py_g, &device, &mountpoint))
906     return NULL;
907   g = get_handle (py_g);
908
909   r = guestfs_mount (g, device, mountpoint);
910   if (r == -1) {
911     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
912     return NULL;
913   }
914
915   Py_INCREF (Py_None);
916   py_r = Py_None;
917   return py_r;
918 }
919
920 static PyObject *
921 py_guestfs_sync (PyObject *self, PyObject *args)
922 {
923   PyObject *py_g;
924   guestfs_h *g;
925   PyObject *py_r;
926   int r;
927
928   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
929                          &py_g))
930     return NULL;
931   g = get_handle (py_g);
932
933   r = guestfs_sync (g);
934   if (r == -1) {
935     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
936     return NULL;
937   }
938
939   Py_INCREF (Py_None);
940   py_r = Py_None;
941   return py_r;
942 }
943
944 static PyObject *
945 py_guestfs_touch (PyObject *self, PyObject *args)
946 {
947   PyObject *py_g;
948   guestfs_h *g;
949   PyObject *py_r;
950   int r;
951   const char *path;
952
953   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
954                          &py_g, &path))
955     return NULL;
956   g = get_handle (py_g);
957
958   r = guestfs_touch (g, path);
959   if (r == -1) {
960     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
961     return NULL;
962   }
963
964   Py_INCREF (Py_None);
965   py_r = Py_None;
966   return py_r;
967 }
968
969 static PyObject *
970 py_guestfs_cat (PyObject *self, PyObject *args)
971 {
972   PyObject *py_g;
973   guestfs_h *g;
974   PyObject *py_r;
975   char *r;
976   const char *path;
977
978   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
979                          &py_g, &path))
980     return NULL;
981   g = get_handle (py_g);
982
983   r = guestfs_cat (g, path);
984   if (r == NULL) {
985     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
986     return NULL;
987   }
988
989   py_r = PyString_FromString (r);
990   free (r);
991   return py_r;
992 }
993
994 static PyObject *
995 py_guestfs_ll (PyObject *self, PyObject *args)
996 {
997   PyObject *py_g;
998   guestfs_h *g;
999   PyObject *py_r;
1000   char *r;
1001   const char *directory;
1002
1003   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
1004                          &py_g, &directory))
1005     return NULL;
1006   g = get_handle (py_g);
1007
1008   r = guestfs_ll (g, directory);
1009   if (r == NULL) {
1010     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1011     return NULL;
1012   }
1013
1014   py_r = PyString_FromString (r);
1015   free (r);
1016   return py_r;
1017 }
1018
1019 static PyObject *
1020 py_guestfs_ls (PyObject *self, PyObject *args)
1021 {
1022   PyObject *py_g;
1023   guestfs_h *g;
1024   PyObject *py_r;
1025   char **r;
1026   const char *directory;
1027
1028   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
1029                          &py_g, &directory))
1030     return NULL;
1031   g = get_handle (py_g);
1032
1033   r = guestfs_ls (g, directory);
1034   if (r == NULL) {
1035     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1036     return NULL;
1037   }
1038
1039   py_r = put_string_list (r);
1040   free_strings (r);
1041   return py_r;
1042 }
1043
1044 static PyObject *
1045 py_guestfs_list_devices (PyObject *self, PyObject *args)
1046 {
1047   PyObject *py_g;
1048   guestfs_h *g;
1049   PyObject *py_r;
1050   char **r;
1051
1052   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
1053                          &py_g))
1054     return NULL;
1055   g = get_handle (py_g);
1056
1057   r = guestfs_list_devices (g);
1058   if (r == NULL) {
1059     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1060     return NULL;
1061   }
1062
1063   py_r = put_string_list (r);
1064   free_strings (r);
1065   return py_r;
1066 }
1067
1068 static PyObject *
1069 py_guestfs_list_partitions (PyObject *self, PyObject *args)
1070 {
1071   PyObject *py_g;
1072   guestfs_h *g;
1073   PyObject *py_r;
1074   char **r;
1075
1076   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
1077                          &py_g))
1078     return NULL;
1079   g = get_handle (py_g);
1080
1081   r = guestfs_list_partitions (g);
1082   if (r == NULL) {
1083     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1084     return NULL;
1085   }
1086
1087   py_r = put_string_list (r);
1088   free_strings (r);
1089   return py_r;
1090 }
1091
1092 static PyObject *
1093 py_guestfs_pvs (PyObject *self, PyObject *args)
1094 {
1095   PyObject *py_g;
1096   guestfs_h *g;
1097   PyObject *py_r;
1098   char **r;
1099
1100   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
1101                          &py_g))
1102     return NULL;
1103   g = get_handle (py_g);
1104
1105   r = guestfs_pvs (g);
1106   if (r == NULL) {
1107     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1108     return NULL;
1109   }
1110
1111   py_r = put_string_list (r);
1112   free_strings (r);
1113   return py_r;
1114 }
1115
1116 static PyObject *
1117 py_guestfs_vgs (PyObject *self, PyObject *args)
1118 {
1119   PyObject *py_g;
1120   guestfs_h *g;
1121   PyObject *py_r;
1122   char **r;
1123
1124   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
1125                          &py_g))
1126     return NULL;
1127   g = get_handle (py_g);
1128
1129   r = guestfs_vgs (g);
1130   if (r == NULL) {
1131     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1132     return NULL;
1133   }
1134
1135   py_r = put_string_list (r);
1136   free_strings (r);
1137   return py_r;
1138 }
1139
1140 static PyObject *
1141 py_guestfs_lvs (PyObject *self, PyObject *args)
1142 {
1143   PyObject *py_g;
1144   guestfs_h *g;
1145   PyObject *py_r;
1146   char **r;
1147
1148   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
1149                          &py_g))
1150     return NULL;
1151   g = get_handle (py_g);
1152
1153   r = guestfs_lvs (g);
1154   if (r == NULL) {
1155     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1156     return NULL;
1157   }
1158
1159   py_r = put_string_list (r);
1160   free_strings (r);
1161   return py_r;
1162 }
1163
1164 static PyObject *
1165 py_guestfs_pvs_full (PyObject *self, PyObject *args)
1166 {
1167   PyObject *py_g;
1168   guestfs_h *g;
1169   PyObject *py_r;
1170   struct guestfs_lvm_pv_list *r;
1171
1172   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
1173                          &py_g))
1174     return NULL;
1175   g = get_handle (py_g);
1176
1177   r = guestfs_pvs_full (g);
1178   if (r == NULL) {
1179     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1180     return NULL;
1181   }
1182
1183   py_r = put_lvm_pv_list (r);
1184   guestfs_free_lvm_pv_list (r);
1185   return py_r;
1186 }
1187
1188 static PyObject *
1189 py_guestfs_vgs_full (PyObject *self, PyObject *args)
1190 {
1191   PyObject *py_g;
1192   guestfs_h *g;
1193   PyObject *py_r;
1194   struct guestfs_lvm_vg_list *r;
1195
1196   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
1197                          &py_g))
1198     return NULL;
1199   g = get_handle (py_g);
1200
1201   r = guestfs_vgs_full (g);
1202   if (r == NULL) {
1203     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1204     return NULL;
1205   }
1206
1207   py_r = put_lvm_vg_list (r);
1208   guestfs_free_lvm_vg_list (r);
1209   return py_r;
1210 }
1211
1212 static PyObject *
1213 py_guestfs_lvs_full (PyObject *self, PyObject *args)
1214 {
1215   PyObject *py_g;
1216   guestfs_h *g;
1217   PyObject *py_r;
1218   struct guestfs_lvm_lv_list *r;
1219
1220   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
1221                          &py_g))
1222     return NULL;
1223   g = get_handle (py_g);
1224
1225   r = guestfs_lvs_full (g);
1226   if (r == NULL) {
1227     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1228     return NULL;
1229   }
1230
1231   py_r = put_lvm_lv_list (r);
1232   guestfs_free_lvm_lv_list (r);
1233   return py_r;
1234 }
1235
1236 static PyObject *
1237 py_guestfs_read_lines (PyObject *self, PyObject *args)
1238 {
1239   PyObject *py_g;
1240   guestfs_h *g;
1241   PyObject *py_r;
1242   char **r;
1243   const char *path;
1244
1245   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
1246                          &py_g, &path))
1247     return NULL;
1248   g = get_handle (py_g);
1249
1250   r = guestfs_read_lines (g, path);
1251   if (r == NULL) {
1252     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1253     return NULL;
1254   }
1255
1256   py_r = put_string_list (r);
1257   free_strings (r);
1258   return py_r;
1259 }
1260
1261 static PyObject *
1262 py_guestfs_aug_init (PyObject *self, PyObject *args)
1263 {
1264   PyObject *py_g;
1265   guestfs_h *g;
1266   PyObject *py_r;
1267   int r;
1268   const char *root;
1269   int flags;
1270
1271   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
1272                          &py_g, &root, &flags))
1273     return NULL;
1274   g = get_handle (py_g);
1275
1276   r = guestfs_aug_init (g, root, flags);
1277   if (r == -1) {
1278     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1279     return NULL;
1280   }
1281
1282   Py_INCREF (Py_None);
1283   py_r = Py_None;
1284   return py_r;
1285 }
1286
1287 static PyObject *
1288 py_guestfs_aug_close (PyObject *self, PyObject *args)
1289 {
1290   PyObject *py_g;
1291   guestfs_h *g;
1292   PyObject *py_r;
1293   int r;
1294
1295   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
1296                          &py_g))
1297     return NULL;
1298   g = get_handle (py_g);
1299
1300   r = guestfs_aug_close (g);
1301   if (r == -1) {
1302     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1303     return NULL;
1304   }
1305
1306   Py_INCREF (Py_None);
1307   py_r = Py_None;
1308   return py_r;
1309 }
1310
1311 static PyObject *
1312 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
1313 {
1314   PyObject *py_g;
1315   guestfs_h *g;
1316   PyObject *py_r;
1317   int r;
1318   const char *name;
1319   const char *expr;
1320
1321   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1322                          &py_g, &name, &expr))
1323     return NULL;
1324   g = get_handle (py_g);
1325
1326   r = guestfs_aug_defvar (g, name, expr);
1327   if (r == -1) {
1328     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1329     return NULL;
1330   }
1331
1332   py_r = PyInt_FromLong ((long) r);
1333   return py_r;
1334 }
1335
1336 static PyObject *
1337 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1338 {
1339   PyObject *py_g;
1340   guestfs_h *g;
1341   PyObject *py_r;
1342   struct guestfs_int_bool *r;
1343   const char *name;
1344   const char *expr;
1345   const char *val;
1346
1347   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1348                          &py_g, &name, &expr, &val))
1349     return NULL;
1350   g = get_handle (py_g);
1351
1352   r = guestfs_aug_defnode (g, name, expr, val);
1353   if (r == NULL) {
1354     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1355     return NULL;
1356   }
1357
1358   py_r = PyTuple_New (2);
1359   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1360   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1361   guestfs_free_int_bool (r);
1362   return py_r;
1363 }
1364
1365 static PyObject *
1366 py_guestfs_aug_get (PyObject *self, PyObject *args)
1367 {
1368   PyObject *py_g;
1369   guestfs_h *g;
1370   PyObject *py_r;
1371   char *r;
1372   const char *path;
1373
1374   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1375                          &py_g, &path))
1376     return NULL;
1377   g = get_handle (py_g);
1378
1379   r = guestfs_aug_get (g, path);
1380   if (r == NULL) {
1381     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1382     return NULL;
1383   }
1384
1385   py_r = PyString_FromString (r);
1386   free (r);
1387   return py_r;
1388 }
1389
1390 static PyObject *
1391 py_guestfs_aug_set (PyObject *self, PyObject *args)
1392 {
1393   PyObject *py_g;
1394   guestfs_h *g;
1395   PyObject *py_r;
1396   int r;
1397   const char *path;
1398   const char *val;
1399
1400   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1401                          &py_g, &path, &val))
1402     return NULL;
1403   g = get_handle (py_g);
1404
1405   r = guestfs_aug_set (g, path, val);
1406   if (r == -1) {
1407     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1408     return NULL;
1409   }
1410
1411   Py_INCREF (Py_None);
1412   py_r = Py_None;
1413   return py_r;
1414 }
1415
1416 static PyObject *
1417 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1418 {
1419   PyObject *py_g;
1420   guestfs_h *g;
1421   PyObject *py_r;
1422   int r;
1423   const char *path;
1424   const char *label;
1425   int before;
1426
1427   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1428                          &py_g, &path, &label, &before))
1429     return NULL;
1430   g = get_handle (py_g);
1431
1432   r = guestfs_aug_insert (g, path, label, before);
1433   if (r == -1) {
1434     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1435     return NULL;
1436   }
1437
1438   Py_INCREF (Py_None);
1439   py_r = Py_None;
1440   return py_r;
1441 }
1442
1443 static PyObject *
1444 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1445 {
1446   PyObject *py_g;
1447   guestfs_h *g;
1448   PyObject *py_r;
1449   int r;
1450   const char *path;
1451
1452   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1453                          &py_g, &path))
1454     return NULL;
1455   g = get_handle (py_g);
1456
1457   r = guestfs_aug_rm (g, path);
1458   if (r == -1) {
1459     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1460     return NULL;
1461   }
1462
1463   py_r = PyInt_FromLong ((long) r);
1464   return py_r;
1465 }
1466
1467 static PyObject *
1468 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1469 {
1470   PyObject *py_g;
1471   guestfs_h *g;
1472   PyObject *py_r;
1473   int r;
1474   const char *src;
1475   const char *dest;
1476
1477   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1478                          &py_g, &src, &dest))
1479     return NULL;
1480   g = get_handle (py_g);
1481
1482   r = guestfs_aug_mv (g, src, dest);
1483   if (r == -1) {
1484     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1485     return NULL;
1486   }
1487
1488   Py_INCREF (Py_None);
1489   py_r = Py_None;
1490   return py_r;
1491 }
1492
1493 static PyObject *
1494 py_guestfs_aug_match (PyObject *self, PyObject *args)
1495 {
1496   PyObject *py_g;
1497   guestfs_h *g;
1498   PyObject *py_r;
1499   char **r;
1500   const char *path;
1501
1502   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1503                          &py_g, &path))
1504     return NULL;
1505   g = get_handle (py_g);
1506
1507   r = guestfs_aug_match (g, path);
1508   if (r == NULL) {
1509     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1510     return NULL;
1511   }
1512
1513   py_r = put_string_list (r);
1514   free_strings (r);
1515   return py_r;
1516 }
1517
1518 static PyObject *
1519 py_guestfs_aug_save (PyObject *self, PyObject *args)
1520 {
1521   PyObject *py_g;
1522   guestfs_h *g;
1523   PyObject *py_r;
1524   int r;
1525
1526   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1527                          &py_g))
1528     return NULL;
1529   g = get_handle (py_g);
1530
1531   r = guestfs_aug_save (g);
1532   if (r == -1) {
1533     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1534     return NULL;
1535   }
1536
1537   Py_INCREF (Py_None);
1538   py_r = Py_None;
1539   return py_r;
1540 }
1541
1542 static PyObject *
1543 py_guestfs_aug_load (PyObject *self, PyObject *args)
1544 {
1545   PyObject *py_g;
1546   guestfs_h *g;
1547   PyObject *py_r;
1548   int r;
1549
1550   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
1551                          &py_g))
1552     return NULL;
1553   g = get_handle (py_g);
1554
1555   r = guestfs_aug_load (g);
1556   if (r == -1) {
1557     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1558     return NULL;
1559   }
1560
1561   Py_INCREF (Py_None);
1562   py_r = Py_None;
1563   return py_r;
1564 }
1565
1566 static PyObject *
1567 py_guestfs_aug_ls (PyObject *self, PyObject *args)
1568 {
1569   PyObject *py_g;
1570   guestfs_h *g;
1571   PyObject *py_r;
1572   char **r;
1573   const char *path;
1574
1575   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
1576                          &py_g, &path))
1577     return NULL;
1578   g = get_handle (py_g);
1579
1580   r = guestfs_aug_ls (g, path);
1581   if (r == NULL) {
1582     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1583     return NULL;
1584   }
1585
1586   py_r = put_string_list (r);
1587   free_strings (r);
1588   return py_r;
1589 }
1590
1591 static PyObject *
1592 py_guestfs_rm (PyObject *self, PyObject *args)
1593 {
1594   PyObject *py_g;
1595   guestfs_h *g;
1596   PyObject *py_r;
1597   int r;
1598   const char *path;
1599
1600   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1601                          &py_g, &path))
1602     return NULL;
1603   g = get_handle (py_g);
1604
1605   r = guestfs_rm (g, path);
1606   if (r == -1) {
1607     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1608     return NULL;
1609   }
1610
1611   Py_INCREF (Py_None);
1612   py_r = Py_None;
1613   return py_r;
1614 }
1615
1616 static PyObject *
1617 py_guestfs_rmdir (PyObject *self, PyObject *args)
1618 {
1619   PyObject *py_g;
1620   guestfs_h *g;
1621   PyObject *py_r;
1622   int r;
1623   const char *path;
1624
1625   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1626                          &py_g, &path))
1627     return NULL;
1628   g = get_handle (py_g);
1629
1630   r = guestfs_rmdir (g, path);
1631   if (r == -1) {
1632     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1633     return NULL;
1634   }
1635
1636   Py_INCREF (Py_None);
1637   py_r = Py_None;
1638   return py_r;
1639 }
1640
1641 static PyObject *
1642 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1643 {
1644   PyObject *py_g;
1645   guestfs_h *g;
1646   PyObject *py_r;
1647   int r;
1648   const char *path;
1649
1650   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1651                          &py_g, &path))
1652     return NULL;
1653   g = get_handle (py_g);
1654
1655   r = guestfs_rm_rf (g, path);
1656   if (r == -1) {
1657     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1658     return NULL;
1659   }
1660
1661   Py_INCREF (Py_None);
1662   py_r = Py_None;
1663   return py_r;
1664 }
1665
1666 static PyObject *
1667 py_guestfs_mkdir (PyObject *self, PyObject *args)
1668 {
1669   PyObject *py_g;
1670   guestfs_h *g;
1671   PyObject *py_r;
1672   int r;
1673   const char *path;
1674
1675   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1676                          &py_g, &path))
1677     return NULL;
1678   g = get_handle (py_g);
1679
1680   r = guestfs_mkdir (g, path);
1681   if (r == -1) {
1682     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1683     return NULL;
1684   }
1685
1686   Py_INCREF (Py_None);
1687   py_r = Py_None;
1688   return py_r;
1689 }
1690
1691 static PyObject *
1692 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1693 {
1694   PyObject *py_g;
1695   guestfs_h *g;
1696   PyObject *py_r;
1697   int r;
1698   const char *path;
1699
1700   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1701                          &py_g, &path))
1702     return NULL;
1703   g = get_handle (py_g);
1704
1705   r = guestfs_mkdir_p (g, path);
1706   if (r == -1) {
1707     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1708     return NULL;
1709   }
1710
1711   Py_INCREF (Py_None);
1712   py_r = Py_None;
1713   return py_r;
1714 }
1715
1716 static PyObject *
1717 py_guestfs_chmod (PyObject *self, PyObject *args)
1718 {
1719   PyObject *py_g;
1720   guestfs_h *g;
1721   PyObject *py_r;
1722   int r;
1723   int mode;
1724   const char *path;
1725
1726   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1727                          &py_g, &mode, &path))
1728     return NULL;
1729   g = get_handle (py_g);
1730
1731   r = guestfs_chmod (g, mode, path);
1732   if (r == -1) {
1733     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1734     return NULL;
1735   }
1736
1737   Py_INCREF (Py_None);
1738   py_r = Py_None;
1739   return py_r;
1740 }
1741
1742 static PyObject *
1743 py_guestfs_chown (PyObject *self, PyObject *args)
1744 {
1745   PyObject *py_g;
1746   guestfs_h *g;
1747   PyObject *py_r;
1748   int r;
1749   int owner;
1750   int group;
1751   const char *path;
1752
1753   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1754                          &py_g, &owner, &group, &path))
1755     return NULL;
1756   g = get_handle (py_g);
1757
1758   r = guestfs_chown (g, owner, group, path);
1759   if (r == -1) {
1760     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1761     return NULL;
1762   }
1763
1764   Py_INCREF (Py_None);
1765   py_r = Py_None;
1766   return py_r;
1767 }
1768
1769 static PyObject *
1770 py_guestfs_exists (PyObject *self, PyObject *args)
1771 {
1772   PyObject *py_g;
1773   guestfs_h *g;
1774   PyObject *py_r;
1775   int r;
1776   const char *path;
1777
1778   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1779                          &py_g, &path))
1780     return NULL;
1781   g = get_handle (py_g);
1782
1783   r = guestfs_exists (g, path);
1784   if (r == -1) {
1785     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1786     return NULL;
1787   }
1788
1789   py_r = PyInt_FromLong ((long) r);
1790   return py_r;
1791 }
1792
1793 static PyObject *
1794 py_guestfs_is_file (PyObject *self, PyObject *args)
1795 {
1796   PyObject *py_g;
1797   guestfs_h *g;
1798   PyObject *py_r;
1799   int r;
1800   const char *path;
1801
1802   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
1803                          &py_g, &path))
1804     return NULL;
1805   g = get_handle (py_g);
1806
1807   r = guestfs_is_file (g, path);
1808   if (r == -1) {
1809     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1810     return NULL;
1811   }
1812
1813   py_r = PyInt_FromLong ((long) r);
1814   return py_r;
1815 }
1816
1817 static PyObject *
1818 py_guestfs_is_dir (PyObject *self, PyObject *args)
1819 {
1820   PyObject *py_g;
1821   guestfs_h *g;
1822   PyObject *py_r;
1823   int r;
1824   const char *path;
1825
1826   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
1827                          &py_g, &path))
1828     return NULL;
1829   g = get_handle (py_g);
1830
1831   r = guestfs_is_dir (g, path);
1832   if (r == -1) {
1833     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1834     return NULL;
1835   }
1836
1837   py_r = PyInt_FromLong ((long) r);
1838   return py_r;
1839 }
1840
1841 static PyObject *
1842 py_guestfs_pvcreate (PyObject *self, PyObject *args)
1843 {
1844   PyObject *py_g;
1845   guestfs_h *g;
1846   PyObject *py_r;
1847   int r;
1848   const char *device;
1849
1850   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1851                          &py_g, &device))
1852     return NULL;
1853   g = get_handle (py_g);
1854
1855   r = guestfs_pvcreate (g, device);
1856   if (r == -1) {
1857     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1858     return NULL;
1859   }
1860
1861   Py_INCREF (Py_None);
1862   py_r = Py_None;
1863   return py_r;
1864 }
1865
1866 static PyObject *
1867 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1868 {
1869   PyObject *py_g;
1870   guestfs_h *g;
1871   PyObject *py_r;
1872   int r;
1873   const char *volgroup;
1874   PyObject *py_physvols;
1875   const char **physvols;
1876
1877   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1878                          &py_g, &volgroup, &py_physvols))
1879     return NULL;
1880   g = get_handle (py_g);
1881   physvols = get_string_list (py_physvols);
1882   if (!physvols) return NULL;
1883
1884   r = guestfs_vgcreate (g, volgroup, physvols);
1885   free (physvols);
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_lvcreate (PyObject *self, PyObject *args)
1898 {
1899   PyObject *py_g;
1900   guestfs_h *g;
1901   PyObject *py_r;
1902   int r;
1903   const char *logvol;
1904   const char *volgroup;
1905   int mbytes;
1906
1907   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1908                          &py_g, &logvol, &volgroup, &mbytes))
1909     return NULL;
1910   g = get_handle (py_g);
1911
1912   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1913   if (r == -1) {
1914     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1915     return NULL;
1916   }
1917
1918   Py_INCREF (Py_None);
1919   py_r = Py_None;
1920   return py_r;
1921 }
1922
1923 static PyObject *
1924 py_guestfs_mkfs (PyObject *self, PyObject *args)
1925 {
1926   PyObject *py_g;
1927   guestfs_h *g;
1928   PyObject *py_r;
1929   int r;
1930   const char *fstype;
1931   const char *device;
1932
1933   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1934                          &py_g, &fstype, &device))
1935     return NULL;
1936   g = get_handle (py_g);
1937
1938   r = guestfs_mkfs (g, fstype, device);
1939   if (r == -1) {
1940     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1941     return NULL;
1942   }
1943
1944   Py_INCREF (Py_None);
1945   py_r = Py_None;
1946   return py_r;
1947 }
1948
1949 static PyObject *
1950 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1951 {
1952   PyObject *py_g;
1953   guestfs_h *g;
1954   PyObject *py_r;
1955   int r;
1956   const char *device;
1957   int cyls;
1958   int heads;
1959   int sectors;
1960   PyObject *py_lines;
1961   const char **lines;
1962
1963   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1964                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1965     return NULL;
1966   g = get_handle (py_g);
1967   lines = get_string_list (py_lines);
1968   if (!lines) return NULL;
1969
1970   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1971   free (lines);
1972   if (r == -1) {
1973     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1974     return NULL;
1975   }
1976
1977   Py_INCREF (Py_None);
1978   py_r = Py_None;
1979   return py_r;
1980 }
1981
1982 static PyObject *
1983 py_guestfs_write_file (PyObject *self, PyObject *args)
1984 {
1985   PyObject *py_g;
1986   guestfs_h *g;
1987   PyObject *py_r;
1988   int r;
1989   const char *path;
1990   const char *content;
1991   int size;
1992
1993   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
1994                          &py_g, &path, &content, &size))
1995     return NULL;
1996   g = get_handle (py_g);
1997
1998   r = guestfs_write_file (g, path, content, size);
1999   if (r == -1) {
2000     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2001     return NULL;
2002   }
2003
2004   Py_INCREF (Py_None);
2005   py_r = Py_None;
2006   return py_r;
2007 }
2008
2009 static PyObject *
2010 py_guestfs_umount (PyObject *self, PyObject *args)
2011 {
2012   PyObject *py_g;
2013   guestfs_h *g;
2014   PyObject *py_r;
2015   int r;
2016   const char *pathordevice;
2017
2018   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
2019                          &py_g, &pathordevice))
2020     return NULL;
2021   g = get_handle (py_g);
2022
2023   r = guestfs_umount (g, pathordevice);
2024   if (r == -1) {
2025     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2026     return NULL;
2027   }
2028
2029   Py_INCREF (Py_None);
2030   py_r = Py_None;
2031   return py_r;
2032 }
2033
2034 static PyObject *
2035 py_guestfs_mounts (PyObject *self, PyObject *args)
2036 {
2037   PyObject *py_g;
2038   guestfs_h *g;
2039   PyObject *py_r;
2040   char **r;
2041
2042   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
2043                          &py_g))
2044     return NULL;
2045   g = get_handle (py_g);
2046
2047   r = guestfs_mounts (g);
2048   if (r == NULL) {
2049     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2050     return NULL;
2051   }
2052
2053   py_r = put_string_list (r);
2054   free_strings (r);
2055   return py_r;
2056 }
2057
2058 static PyObject *
2059 py_guestfs_umount_all (PyObject *self, PyObject *args)
2060 {
2061   PyObject *py_g;
2062   guestfs_h *g;
2063   PyObject *py_r;
2064   int r;
2065
2066   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
2067                          &py_g))
2068     return NULL;
2069   g = get_handle (py_g);
2070
2071   r = guestfs_umount_all (g);
2072   if (r == -1) {
2073     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2074     return NULL;
2075   }
2076
2077   Py_INCREF (Py_None);
2078   py_r = Py_None;
2079   return py_r;
2080 }
2081
2082 static PyObject *
2083 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
2084 {
2085   PyObject *py_g;
2086   guestfs_h *g;
2087   PyObject *py_r;
2088   int r;
2089
2090   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
2091                          &py_g))
2092     return NULL;
2093   g = get_handle (py_g);
2094
2095   r = guestfs_lvm_remove_all (g);
2096   if (r == -1) {
2097     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2098     return NULL;
2099   }
2100
2101   Py_INCREF (Py_None);
2102   py_r = Py_None;
2103   return py_r;
2104 }
2105
2106 static PyObject *
2107 py_guestfs_file (PyObject *self, PyObject *args)
2108 {
2109   PyObject *py_g;
2110   guestfs_h *g;
2111   PyObject *py_r;
2112   char *r;
2113   const char *path;
2114
2115   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2116                          &py_g, &path))
2117     return NULL;
2118   g = get_handle (py_g);
2119
2120   r = guestfs_file (g, path);
2121   if (r == NULL) {
2122     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2123     return NULL;
2124   }
2125
2126   py_r = PyString_FromString (r);
2127   free (r);
2128   return py_r;
2129 }
2130
2131 static PyObject *
2132 py_guestfs_command (PyObject *self, PyObject *args)
2133 {
2134   PyObject *py_g;
2135   guestfs_h *g;
2136   PyObject *py_r;
2137   char *r;
2138   PyObject *py_arguments;
2139   const char **arguments;
2140
2141   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2142                          &py_g, &py_arguments))
2143     return NULL;
2144   g = get_handle (py_g);
2145   arguments = get_string_list (py_arguments);
2146   if (!arguments) return NULL;
2147
2148   r = guestfs_command (g, arguments);
2149   free (arguments);
2150   if (r == NULL) {
2151     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2152     return NULL;
2153   }
2154
2155   py_r = PyString_FromString (r);
2156   free (r);
2157   return py_r;
2158 }
2159
2160 static PyObject *
2161 py_guestfs_command_lines (PyObject *self, PyObject *args)
2162 {
2163   PyObject *py_g;
2164   guestfs_h *g;
2165   PyObject *py_r;
2166   char **r;
2167   PyObject *py_arguments;
2168   const char **arguments;
2169
2170   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
2171                          &py_g, &py_arguments))
2172     return NULL;
2173   g = get_handle (py_g);
2174   arguments = get_string_list (py_arguments);
2175   if (!arguments) return NULL;
2176
2177   r = guestfs_command_lines (g, arguments);
2178   free (arguments);
2179   if (r == NULL) {
2180     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2181     return NULL;
2182   }
2183
2184   py_r = put_string_list (r);
2185   free_strings (r);
2186   return py_r;
2187 }
2188
2189 static PyObject *
2190 py_guestfs_stat (PyObject *self, PyObject *args)
2191 {
2192   PyObject *py_g;
2193   guestfs_h *g;
2194   PyObject *py_r;
2195   struct guestfs_stat *r;
2196   const char *path;
2197
2198   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
2199                          &py_g, &path))
2200     return NULL;
2201   g = get_handle (py_g);
2202
2203   r = guestfs_stat (g, path);
2204   if (r == NULL) {
2205     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2206     return NULL;
2207   }
2208
2209   py_r = put_stat (r);
2210   free (r);
2211   return py_r;
2212 }
2213
2214 static PyObject *
2215 py_guestfs_lstat (PyObject *self, PyObject *args)
2216 {
2217   PyObject *py_g;
2218   guestfs_h *g;
2219   PyObject *py_r;
2220   struct guestfs_stat *r;
2221   const char *path;
2222
2223   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
2224                          &py_g, &path))
2225     return NULL;
2226   g = get_handle (py_g);
2227
2228   r = guestfs_lstat (g, path);
2229   if (r == NULL) {
2230     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2231     return NULL;
2232   }
2233
2234   py_r = put_stat (r);
2235   free (r);
2236   return py_r;
2237 }
2238
2239 static PyObject *
2240 py_guestfs_statvfs (PyObject *self, PyObject *args)
2241 {
2242   PyObject *py_g;
2243   guestfs_h *g;
2244   PyObject *py_r;
2245   struct guestfs_statvfs *r;
2246   const char *path;
2247
2248   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
2249                          &py_g, &path))
2250     return NULL;
2251   g = get_handle (py_g);
2252
2253   r = guestfs_statvfs (g, path);
2254   if (r == NULL) {
2255     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2256     return NULL;
2257   }
2258
2259   py_r = put_statvfs (r);
2260   free (r);
2261   return py_r;
2262 }
2263
2264 static PyObject *
2265 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
2266 {
2267   PyObject *py_g;
2268   guestfs_h *g;
2269   PyObject *py_r;
2270   char **r;
2271   const char *device;
2272
2273   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
2274                          &py_g, &device))
2275     return NULL;
2276   g = get_handle (py_g);
2277
2278   r = guestfs_tune2fs_l (g, device);
2279   if (r == NULL) {
2280     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2281     return NULL;
2282   }
2283
2284   py_r = put_table (r);
2285   free_strings (r);
2286   return py_r;
2287 }
2288
2289 static PyObject *
2290 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
2291 {
2292   PyObject *py_g;
2293   guestfs_h *g;
2294   PyObject *py_r;
2295   int r;
2296   const char *device;
2297
2298   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
2299                          &py_g, &device))
2300     return NULL;
2301   g = get_handle (py_g);
2302
2303   r = guestfs_blockdev_setro (g, device);
2304   if (r == -1) {
2305     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2306     return NULL;
2307   }
2308
2309   Py_INCREF (Py_None);
2310   py_r = Py_None;
2311   return py_r;
2312 }
2313
2314 static PyObject *
2315 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
2316 {
2317   PyObject *py_g;
2318   guestfs_h *g;
2319   PyObject *py_r;
2320   int r;
2321   const char *device;
2322
2323   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
2324                          &py_g, &device))
2325     return NULL;
2326   g = get_handle (py_g);
2327
2328   r = guestfs_blockdev_setrw (g, device);
2329   if (r == -1) {
2330     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2331     return NULL;
2332   }
2333
2334   Py_INCREF (Py_None);
2335   py_r = Py_None;
2336   return py_r;
2337 }
2338
2339 static PyObject *
2340 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
2341 {
2342   PyObject *py_g;
2343   guestfs_h *g;
2344   PyObject *py_r;
2345   int r;
2346   const char *device;
2347
2348   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
2349                          &py_g, &device))
2350     return NULL;
2351   g = get_handle (py_g);
2352
2353   r = guestfs_blockdev_getro (g, device);
2354   if (r == -1) {
2355     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2356     return NULL;
2357   }
2358
2359   py_r = PyInt_FromLong ((long) r);
2360   return py_r;
2361 }
2362
2363 static PyObject *
2364 py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
2365 {
2366   PyObject *py_g;
2367   guestfs_h *g;
2368   PyObject *py_r;
2369   int r;
2370   const char *device;
2371
2372   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
2373                          &py_g, &device))
2374     return NULL;
2375   g = get_handle (py_g);
2376
2377   r = guestfs_blockdev_getss (g, device);
2378   if (r == -1) {
2379     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2380     return NULL;
2381   }
2382
2383   py_r = PyInt_FromLong ((long) r);
2384   return py_r;
2385 }
2386
2387 static PyObject *
2388 py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
2389 {
2390   PyObject *py_g;
2391   guestfs_h *g;
2392   PyObject *py_r;
2393   int r;
2394   const char *device;
2395
2396   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
2397                          &py_g, &device))
2398     return NULL;
2399   g = get_handle (py_g);
2400
2401   r = guestfs_blockdev_getbsz (g, device);
2402   if (r == -1) {
2403     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2404     return NULL;
2405   }
2406
2407   py_r = PyInt_FromLong ((long) r);
2408   return py_r;
2409 }
2410
2411 static PyObject *
2412 py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
2413 {
2414   PyObject *py_g;
2415   guestfs_h *g;
2416   PyObject *py_r;
2417   int r;
2418   const char *device;
2419   int blocksize;
2420
2421   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
2422                          &py_g, &device, &blocksize))
2423     return NULL;
2424   g = get_handle (py_g);
2425
2426   r = guestfs_blockdev_setbsz (g, device, blocksize);
2427   if (r == -1) {
2428     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2429     return NULL;
2430   }
2431
2432   Py_INCREF (Py_None);
2433   py_r = Py_None;
2434   return py_r;
2435 }
2436
2437 static PyObject *
2438 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
2439 {
2440   PyObject *py_g;
2441   guestfs_h *g;
2442   PyObject *py_r;
2443   int64_t r;
2444   const char *device;
2445
2446   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
2447                          &py_g, &device))
2448     return NULL;
2449   g = get_handle (py_g);
2450
2451   r = guestfs_blockdev_getsz (g, device);
2452   if (r == -1) {
2453     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2454     return NULL;
2455   }
2456
2457   py_r = PyLong_FromLongLong (r);
2458   return py_r;
2459 }
2460
2461 static PyObject *
2462 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
2463 {
2464   PyObject *py_g;
2465   guestfs_h *g;
2466   PyObject *py_r;
2467   int64_t r;
2468   const char *device;
2469
2470   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
2471                          &py_g, &device))
2472     return NULL;
2473   g = get_handle (py_g);
2474
2475   r = guestfs_blockdev_getsize64 (g, device);
2476   if (r == -1) {
2477     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2478     return NULL;
2479   }
2480
2481   py_r = PyLong_FromLongLong (r);
2482   return py_r;
2483 }
2484
2485 static PyObject *
2486 py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
2487 {
2488   PyObject *py_g;
2489   guestfs_h *g;
2490   PyObject *py_r;
2491   int r;
2492   const char *device;
2493
2494   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
2495                          &py_g, &device))
2496     return NULL;
2497   g = get_handle (py_g);
2498
2499   r = guestfs_blockdev_flushbufs (g, device);
2500   if (r == -1) {
2501     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2502     return NULL;
2503   }
2504
2505   Py_INCREF (Py_None);
2506   py_r = Py_None;
2507   return py_r;
2508 }
2509
2510 static PyObject *
2511 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
2512 {
2513   PyObject *py_g;
2514   guestfs_h *g;
2515   PyObject *py_r;
2516   int r;
2517   const char *device;
2518
2519   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
2520                          &py_g, &device))
2521     return NULL;
2522   g = get_handle (py_g);
2523
2524   r = guestfs_blockdev_rereadpt (g, device);
2525   if (r == -1) {
2526     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2527     return NULL;
2528   }
2529
2530   Py_INCREF (Py_None);
2531   py_r = Py_None;
2532   return py_r;
2533 }
2534
2535 static PyObject *
2536 py_guestfs_upload (PyObject *self, PyObject *args)
2537 {
2538   PyObject *py_g;
2539   guestfs_h *g;
2540   PyObject *py_r;
2541   int r;
2542   const char *filename;
2543   const char *remotefilename;
2544
2545   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
2546                          &py_g, &filename, &remotefilename))
2547     return NULL;
2548   g = get_handle (py_g);
2549
2550   r = guestfs_upload (g, filename, remotefilename);
2551   if (r == -1) {
2552     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2553     return NULL;
2554   }
2555
2556   Py_INCREF (Py_None);
2557   py_r = Py_None;
2558   return py_r;
2559 }
2560
2561 static PyObject *
2562 py_guestfs_download (PyObject *self, PyObject *args)
2563 {
2564   PyObject *py_g;
2565   guestfs_h *g;
2566   PyObject *py_r;
2567   int r;
2568   const char *remotefilename;
2569   const char *filename;
2570
2571   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
2572                          &py_g, &remotefilename, &filename))
2573     return NULL;
2574   g = get_handle (py_g);
2575
2576   r = guestfs_download (g, remotefilename, filename);
2577   if (r == -1) {
2578     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2579     return NULL;
2580   }
2581
2582   Py_INCREF (Py_None);
2583   py_r = Py_None;
2584   return py_r;
2585 }
2586
2587 static PyObject *
2588 py_guestfs_checksum (PyObject *self, PyObject *args)
2589 {
2590   PyObject *py_g;
2591   guestfs_h *g;
2592   PyObject *py_r;
2593   char *r;
2594   const char *csumtype;
2595   const char *path;
2596
2597   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
2598                          &py_g, &csumtype, &path))
2599     return NULL;
2600   g = get_handle (py_g);
2601
2602   r = guestfs_checksum (g, csumtype, path);
2603   if (r == NULL) {
2604     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2605     return NULL;
2606   }
2607
2608   py_r = PyString_FromString (r);
2609   free (r);
2610   return py_r;
2611 }
2612
2613 static PyObject *
2614 py_guestfs_tar_in (PyObject *self, PyObject *args)
2615 {
2616   PyObject *py_g;
2617   guestfs_h *g;
2618   PyObject *py_r;
2619   int r;
2620   const char *tarfile;
2621   const char *directory;
2622
2623   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
2624                          &py_g, &tarfile, &directory))
2625     return NULL;
2626   g = get_handle (py_g);
2627
2628   r = guestfs_tar_in (g, tarfile, directory);
2629   if (r == -1) {
2630     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2631     return NULL;
2632   }
2633
2634   Py_INCREF (Py_None);
2635   py_r = Py_None;
2636   return py_r;
2637 }
2638
2639 static PyObject *
2640 py_guestfs_tar_out (PyObject *self, PyObject *args)
2641 {
2642   PyObject *py_g;
2643   guestfs_h *g;
2644   PyObject *py_r;
2645   int r;
2646   const char *directory;
2647   const char *tarfile;
2648
2649   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
2650                          &py_g, &directory, &tarfile))
2651     return NULL;
2652   g = get_handle (py_g);
2653
2654   r = guestfs_tar_out (g, directory, tarfile);
2655   if (r == -1) {
2656     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2657     return NULL;
2658   }
2659
2660   Py_INCREF (Py_None);
2661   py_r = Py_None;
2662   return py_r;
2663 }
2664
2665 static PyObject *
2666 py_guestfs_tgz_in (PyObject *self, PyObject *args)
2667 {
2668   PyObject *py_g;
2669   guestfs_h *g;
2670   PyObject *py_r;
2671   int r;
2672   const char *tarball;
2673   const char *directory;
2674
2675   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
2676                          &py_g, &tarball, &directory))
2677     return NULL;
2678   g = get_handle (py_g);
2679
2680   r = guestfs_tgz_in (g, tarball, directory);
2681   if (r == -1) {
2682     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2683     return NULL;
2684   }
2685
2686   Py_INCREF (Py_None);
2687   py_r = Py_None;
2688   return py_r;
2689 }
2690
2691 static PyObject *
2692 py_guestfs_tgz_out (PyObject *self, PyObject *args)
2693 {
2694   PyObject *py_g;
2695   guestfs_h *g;
2696   PyObject *py_r;
2697   int r;
2698   const char *directory;
2699   const char *tarball;
2700
2701   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
2702                          &py_g, &directory, &tarball))
2703     return NULL;
2704   g = get_handle (py_g);
2705
2706   r = guestfs_tgz_out (g, directory, tarball);
2707   if (r == -1) {
2708     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2709     return NULL;
2710   }
2711
2712   Py_INCREF (Py_None);
2713   py_r = Py_None;
2714   return py_r;
2715 }
2716
2717 static PyObject *
2718 py_guestfs_mount_ro (PyObject *self, PyObject *args)
2719 {
2720   PyObject *py_g;
2721   guestfs_h *g;
2722   PyObject *py_r;
2723   int r;
2724   const char *device;
2725   const char *mountpoint;
2726
2727   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro",
2728                          &py_g, &device, &mountpoint))
2729     return NULL;
2730   g = get_handle (py_g);
2731
2732   r = guestfs_mount_ro (g, device, mountpoint);
2733   if (r == -1) {
2734     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2735     return NULL;
2736   }
2737
2738   Py_INCREF (Py_None);
2739   py_r = Py_None;
2740   return py_r;
2741 }
2742
2743 static PyObject *
2744 py_guestfs_mount_options (PyObject *self, PyObject *args)
2745 {
2746   PyObject *py_g;
2747   guestfs_h *g;
2748   PyObject *py_r;
2749   int r;
2750   const char *options;
2751   const char *device;
2752   const char *mountpoint;
2753
2754   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options",
2755                          &py_g, &options, &device, &mountpoint))
2756     return NULL;
2757   g = get_handle (py_g);
2758
2759   r = guestfs_mount_options (g, options, device, mountpoint);
2760   if (r == -1) {
2761     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2762     return NULL;
2763   }
2764
2765   Py_INCREF (Py_None);
2766   py_r = Py_None;
2767   return py_r;
2768 }
2769
2770 static PyObject *
2771 py_guestfs_mount_vfs (PyObject *self, PyObject *args)
2772 {
2773   PyObject *py_g;
2774   guestfs_h *g;
2775   PyObject *py_r;
2776   int r;
2777   const char *options;
2778   const char *vfstype;
2779   const char *device;
2780   const char *mountpoint;
2781
2782   if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs",
2783                          &py_g, &options, &vfstype, &device, &mountpoint))
2784     return NULL;
2785   g = get_handle (py_g);
2786
2787   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2788   if (r == -1) {
2789     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2790     return NULL;
2791   }
2792
2793   Py_INCREF (Py_None);
2794   py_r = Py_None;
2795   return py_r;
2796 }
2797
2798 static PyObject *
2799 py_guestfs_debug (PyObject *self, PyObject *args)
2800 {
2801   PyObject *py_g;
2802   guestfs_h *g;
2803   PyObject *py_r;
2804   char *r;
2805   const char *subcmd;
2806   PyObject *py_extraargs;
2807   const char **extraargs;
2808
2809   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug",
2810                          &py_g, &subcmd, &py_extraargs))
2811     return NULL;
2812   g = get_handle (py_g);
2813   extraargs = get_string_list (py_extraargs);
2814   if (!extraargs) return NULL;
2815
2816   r = guestfs_debug (g, subcmd, extraargs);
2817   free (extraargs);
2818   if (r == NULL) {
2819     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2820     return NULL;
2821   }
2822
2823   py_r = PyString_FromString (r);
2824   free (r);
2825   return py_r;
2826 }
2827
2828 static PyObject *
2829 py_guestfs_lvremove (PyObject *self, PyObject *args)
2830 {
2831   PyObject *py_g;
2832   guestfs_h *g;
2833   PyObject *py_r;
2834   int r;
2835   const char *device;
2836
2837   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove",
2838                          &py_g, &device))
2839     return NULL;
2840   g = get_handle (py_g);
2841
2842   r = guestfs_lvremove (g, device);
2843   if (r == -1) {
2844     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2845     return NULL;
2846   }
2847
2848   Py_INCREF (Py_None);
2849   py_r = Py_None;
2850   return py_r;
2851 }
2852
2853 static PyObject *
2854 py_guestfs_vgremove (PyObject *self, PyObject *args)
2855 {
2856   PyObject *py_g;
2857   guestfs_h *g;
2858   PyObject *py_r;
2859   int r;
2860   const char *vgname;
2861
2862   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove",
2863                          &py_g, &vgname))
2864     return NULL;
2865   g = get_handle (py_g);
2866
2867   r = guestfs_vgremove (g, vgname);
2868   if (r == -1) {
2869     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2870     return NULL;
2871   }
2872
2873   Py_INCREF (Py_None);
2874   py_r = Py_None;
2875   return py_r;
2876 }
2877
2878 static PyObject *
2879 py_guestfs_pvremove (PyObject *self, PyObject *args)
2880 {
2881   PyObject *py_g;
2882   guestfs_h *g;
2883   PyObject *py_r;
2884   int r;
2885   const char *device;
2886
2887   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove",
2888                          &py_g, &device))
2889     return NULL;
2890   g = get_handle (py_g);
2891
2892   r = guestfs_pvremove (g, device);
2893   if (r == -1) {
2894     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2895     return NULL;
2896   }
2897
2898   Py_INCREF (Py_None);
2899   py_r = Py_None;
2900   return py_r;
2901 }
2902
2903 static PyObject *
2904 py_guestfs_set_e2label (PyObject *self, PyObject *args)
2905 {
2906   PyObject *py_g;
2907   guestfs_h *g;
2908   PyObject *py_r;
2909   int r;
2910   const char *device;
2911   const char *label;
2912
2913   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label",
2914                          &py_g, &device, &label))
2915     return NULL;
2916   g = get_handle (py_g);
2917
2918   r = guestfs_set_e2label (g, device, label);
2919   if (r == -1) {
2920     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2921     return NULL;
2922   }
2923
2924   Py_INCREF (Py_None);
2925   py_r = Py_None;
2926   return py_r;
2927 }
2928
2929 static PyObject *
2930 py_guestfs_get_e2label (PyObject *self, PyObject *args)
2931 {
2932   PyObject *py_g;
2933   guestfs_h *g;
2934   PyObject *py_r;
2935   char *r;
2936   const char *device;
2937
2938   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label",
2939                          &py_g, &device))
2940     return NULL;
2941   g = get_handle (py_g);
2942
2943   r = guestfs_get_e2label (g, device);
2944   if (r == NULL) {
2945     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2946     return NULL;
2947   }
2948
2949   py_r = PyString_FromString (r);
2950   free (r);
2951   return py_r;
2952 }
2953
2954 static PyObject *
2955 py_guestfs_set_e2uuid (PyObject *self, PyObject *args)
2956 {
2957   PyObject *py_g;
2958   guestfs_h *g;
2959   PyObject *py_r;
2960   int r;
2961   const char *device;
2962   const char *uuid;
2963
2964   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid",
2965                          &py_g, &device, &uuid))
2966     return NULL;
2967   g = get_handle (py_g);
2968
2969   r = guestfs_set_e2uuid (g, device, uuid);
2970   if (r == -1) {
2971     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2972     return NULL;
2973   }
2974
2975   Py_INCREF (Py_None);
2976   py_r = Py_None;
2977   return py_r;
2978 }
2979
2980 static PyObject *
2981 py_guestfs_get_e2uuid (PyObject *self, PyObject *args)
2982 {
2983   PyObject *py_g;
2984   guestfs_h *g;
2985   PyObject *py_r;
2986   char *r;
2987   const char *device;
2988
2989   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid",
2990                          &py_g, &device))
2991     return NULL;
2992   g = get_handle (py_g);
2993
2994   r = guestfs_get_e2uuid (g, device);
2995   if (r == NULL) {
2996     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2997     return NULL;
2998   }
2999
3000   py_r = PyString_FromString (r);
3001   free (r);
3002   return py_r;
3003 }
3004
3005 static PyObject *
3006 py_guestfs_fsck (PyObject *self, PyObject *args)
3007 {
3008   PyObject *py_g;
3009   guestfs_h *g;
3010   PyObject *py_r;
3011   int r;
3012   const char *fstype;
3013   const char *device;
3014
3015   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck",
3016                          &py_g, &fstype, &device))
3017     return NULL;
3018   g = get_handle (py_g);
3019
3020   r = guestfs_fsck (g, fstype, device);
3021   if (r == -1) {
3022     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3023     return NULL;
3024   }
3025
3026   py_r = PyInt_FromLong ((long) r);
3027   return py_r;
3028 }
3029
3030 static PyObject *
3031 py_guestfs_zero (PyObject *self, PyObject *args)
3032 {
3033   PyObject *py_g;
3034   guestfs_h *g;
3035   PyObject *py_r;
3036   int r;
3037   const char *device;
3038
3039   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero",
3040                          &py_g, &device))
3041     return NULL;
3042   g = get_handle (py_g);
3043
3044   r = guestfs_zero (g, device);
3045   if (r == -1) {
3046     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3047     return NULL;
3048   }
3049
3050   Py_INCREF (Py_None);
3051   py_r = Py_None;
3052   return py_r;
3053 }
3054
3055 static PyObject *
3056 py_guestfs_grub_install (PyObject *self, PyObject *args)
3057 {
3058   PyObject *py_g;
3059   guestfs_h *g;
3060   PyObject *py_r;
3061   int r;
3062   const char *root;
3063   const char *device;
3064
3065   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install",
3066                          &py_g, &root, &device))
3067     return NULL;
3068   g = get_handle (py_g);
3069
3070   r = guestfs_grub_install (g, root, device);
3071   if (r == -1) {
3072     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3073     return NULL;
3074   }
3075
3076   Py_INCREF (Py_None);
3077   py_r = Py_None;
3078   return py_r;
3079 }
3080
3081 static PyObject *
3082 py_guestfs_cp (PyObject *self, PyObject *args)
3083 {
3084   PyObject *py_g;
3085   guestfs_h *g;
3086   PyObject *py_r;
3087   int r;
3088   const char *src;
3089   const char *dest;
3090
3091   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp",
3092                          &py_g, &src, &dest))
3093     return NULL;
3094   g = get_handle (py_g);
3095
3096   r = guestfs_cp (g, src, dest);
3097   if (r == -1) {
3098     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3099     return NULL;
3100   }
3101
3102   Py_INCREF (Py_None);
3103   py_r = Py_None;
3104   return py_r;
3105 }
3106
3107 static PyObject *
3108 py_guestfs_cp_a (PyObject *self, PyObject *args)
3109 {
3110   PyObject *py_g;
3111   guestfs_h *g;
3112   PyObject *py_r;
3113   int r;
3114   const char *src;
3115   const char *dest;
3116
3117   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a",
3118                          &py_g, &src, &dest))
3119     return NULL;
3120   g = get_handle (py_g);
3121
3122   r = guestfs_cp_a (g, src, dest);
3123   if (r == -1) {
3124     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3125     return NULL;
3126   }
3127
3128   Py_INCREF (Py_None);
3129   py_r = Py_None;
3130   return py_r;
3131 }
3132
3133 static PyObject *
3134 py_guestfs_mv (PyObject *self, PyObject *args)
3135 {
3136   PyObject *py_g;
3137   guestfs_h *g;
3138   PyObject *py_r;
3139   int r;
3140   const char *src;
3141   const char *dest;
3142
3143   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv",
3144                          &py_g, &src, &dest))
3145     return NULL;
3146   g = get_handle (py_g);
3147
3148   r = guestfs_mv (g, src, dest);
3149   if (r == -1) {
3150     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3151     return NULL;
3152   }
3153
3154   Py_INCREF (Py_None);
3155   py_r = Py_None;
3156   return py_r;
3157 }
3158
3159 static PyObject *
3160 py_guestfs_drop_caches (PyObject *self, PyObject *args)
3161 {
3162   PyObject *py_g;
3163   guestfs_h *g;
3164   PyObject *py_r;
3165   int r;
3166   int whattodrop;
3167
3168   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches",
3169                          &py_g, &whattodrop))
3170     return NULL;
3171   g = get_handle (py_g);
3172
3173   r = guestfs_drop_caches (g, whattodrop);
3174   if (r == -1) {
3175     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3176     return NULL;
3177   }
3178
3179   Py_INCREF (Py_None);
3180   py_r = Py_None;
3181   return py_r;
3182 }
3183
3184 static PyMethodDef methods[] = {
3185   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
3186   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
3187   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
3188   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
3189   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
3190   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
3191   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
3192   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
3193   { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL },
3194   { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL },
3195   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
3196   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
3197   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
3198   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
3199   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
3200   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
3201   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
3202   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
3203   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
3204   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
3205   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
3206   { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
3207   { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
3208   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
3209   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
3210   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
3211   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
3212   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
3213   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
3214   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
3215   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
3216   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
3217   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
3218   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
3219   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
3220   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
3221   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
3222   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
3223   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
3224   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
3225   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
3226   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
3227   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
3228   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
3229   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
3230   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
3231   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
3232   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
3233   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
3234   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
3235   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
3236   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
3237   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
3238   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
3239   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
3240   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
3241   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
3242   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
3243   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
3244   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
3245   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
3246   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
3247   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
3248   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
3249   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
3250   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
3251   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
3252   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
3253   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
3254   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
3255   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
3256   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
3257   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
3258   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
3259   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
3260   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
3261   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
3262   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
3263   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
3264   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
3265   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
3266   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
3267   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
3268   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
3269   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
3270   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
3271   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
3272   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
3273   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
3274   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
3275   { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
3276   { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
3277   { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
3278   { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
3279   { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
3280   { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL },
3281   { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL },
3282   { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL },
3283   { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL },
3284   { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL },
3285   { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL },
3286   { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL },
3287   { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL },
3288   { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL },
3289   { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL },
3290   { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL },
3291   { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL },
3292   { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL },
3293   { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL },
3294   { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL },
3295   { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL },
3296   { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL },
3297   { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL },
3298   { NULL, NULL, 0, NULL }
3299 };
3300
3301 void
3302 initlibguestfsmod (void)
3303 {
3304   static int initialized = 0;
3305
3306   if (initialized) return;
3307   Py_InitModule ((char *) "libguestfsmod", methods);
3308   initialized = 1;
3309 }