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.
5 # Copyright (C) 2009 Red Hat Inc.
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.
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.
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
21 u"""Python bindings for libguestfs
24 g = guestfs.GuestFS ()
25 g.add_drive ("guest.img")
28 parts = g.list_partitions ()
30 The guestfs module provides a Python binding to the libguestfs API
31 for examining and modifying virtual machine disk images.
33 Amongst the things this is good for: making batch configuration
34 changes to guests, getting disk used/free statistics (see also:
35 virt-df), migrating between virtualization systems (see also:
36 virt-p2v), performing partial backups, performing partial guest
37 clones, cloning guests and changing registry/UUID/hostname info, and
40 Libguestfs uses Linux kernel and qemu code, and can access any type of
41 guest filesystem that Linux and qemu can, including but not limited
42 to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition
43 schemes, qcow, qcow2, vmdk.
45 Libguestfs provides ways to enumerate guest storage (eg. partitions,
46 LVs, what filesystem is in each LV, etc.). It can also run commands
47 in the context of the guest. Also you can access filesystems over FTP.
49 Errors which happen while using the API are turned into Python
50 RuntimeError exceptions.
52 To create a guestfs handle you usually have to perform the following
55 # Create the handle, call add_drive at least once, and possibly
56 # several times if the guest has multiple block devices:
57 g = guestfs.GuestFS ()
58 g.add_drive ("guest.img")
60 # Launch the qemu subprocess and wait for it to become ready:
64 # Now you can issue commands, for example:
72 """Instances of this class are libguestfs API handles."""
75 """Create a new libguestfs handle."""
76 self._o = libguestfsmod.create ()
79 libguestfsmod.close (self._o)
81 def test0 (self, str, optstr, strlist, b, integer, filein, fileout):
82 return libguestfsmod.test0 (self._o, str, optstr, strlist, b, integer, filein, fileout)
84 def test0rint (self, val):
85 return libguestfsmod.test0rint (self._o, val)
87 def test0rinterr (self):
88 return libguestfsmod.test0rinterr (self._o)
90 def test0rint64 (self, val):
91 return libguestfsmod.test0rint64 (self._o, val)
93 def test0rint64err (self):
94 return libguestfsmod.test0rint64err (self._o)
96 def test0rbool (self, val):
97 return libguestfsmod.test0rbool (self._o, val)
99 def test0rboolerr (self):
100 return libguestfsmod.test0rboolerr (self._o)
102 def test0rconststring (self, val):
103 return libguestfsmod.test0rconststring (self._o, val)
105 def test0rconststringerr (self):
106 return libguestfsmod.test0rconststringerr (self._o)
108 def test0rstring (self, val):
109 return libguestfsmod.test0rstring (self._o, val)
111 def test0rstringerr (self):
112 return libguestfsmod.test0rstringerr (self._o)
114 def test0rstringlist (self, val):
115 return libguestfsmod.test0rstringlist (self._o, val)
117 def test0rstringlisterr (self):
118 return libguestfsmod.test0rstringlisterr (self._o)
120 def test0rintbool (self, val):
121 return libguestfsmod.test0rintbool (self._o, val)
123 def test0rintboolerr (self):
124 return libguestfsmod.test0rintboolerr (self._o)
126 def test0rpvlist (self, val):
127 return libguestfsmod.test0rpvlist (self._o, val)
129 def test0rpvlisterr (self):
130 return libguestfsmod.test0rpvlisterr (self._o)
132 def test0rvglist (self, val):
133 return libguestfsmod.test0rvglist (self._o, val)
135 def test0rvglisterr (self):
136 return libguestfsmod.test0rvglisterr (self._o)
138 def test0rlvlist (self, val):
139 return libguestfsmod.test0rlvlist (self._o, val)
141 def test0rlvlisterr (self):
142 return libguestfsmod.test0rlvlisterr (self._o)
144 def test0rstat (self, val):
145 return libguestfsmod.test0rstat (self._o, val)
147 def test0rstaterr (self):
148 return libguestfsmod.test0rstaterr (self._o)
150 def test0rstatvfs (self, val):
151 return libguestfsmod.test0rstatvfs (self._o, val)
153 def test0rstatvfserr (self):
154 return libguestfsmod.test0rstatvfserr (self._o)
156 def test0rhashtable (self, val):
157 return libguestfsmod.test0rhashtable (self._o, val)
159 def test0rhashtableerr (self):
160 return libguestfsmod.test0rhashtableerr (self._o)
163 u"""Internally libguestfs is implemented by running a
164 virtual machine using qemu(1).
166 You should call this after configuring the handle (eg.
167 adding drives) but before performing any actions.
169 return libguestfsmod.launch (self._o)
171 def wait_ready (self):
172 u"""Internally libguestfs is implemented by running a
173 virtual machine using qemu(1).
175 You should call this after "g.launch" to wait for the
178 return libguestfsmod.wait_ready (self._o)
180 def kill_subprocess (self):
181 u"""This kills the qemu subprocess. You should never need to
184 return libguestfsmod.kill_subprocess (self._o)
186 def add_drive (self, filename):
187 u"""This function adds a virtual machine disk image
188 "filename" to the guest. The first time you call this
189 function, the disk appears as IDE disk 0 ("/dev/sda") in
190 the guest, the second time as "/dev/sdb", and so on.
192 You don't necessarily need to be root when using
193 libguestfs. However you obviously do need sufficient
194 permissions to access the filename for whatever
195 operations you want to perform (ie. read access if you
196 just want to read the image or write access if you want
197 to modify the image).
199 This is equivalent to the qemu parameter "-drive
200 file=filename,cache=off,if=virtio".
202 Note that this call checks for the existence of
203 "filename". This stops you from specifying other types
204 of drive which are supported by qemu such as "nbd:" and
205 "http:" URLs. To specify those, use the general
206 "g.config" call instead.
208 return libguestfsmod.add_drive (self._o, filename)
210 def add_cdrom (self, filename):
211 u"""This function adds a virtual CD-ROM disk image to the
214 This is equivalent to the qemu parameter "-cdrom
217 Note that this call checks for the existence of
218 "filename". This stops you from specifying other types
219 of drive which are supported by qemu such as "nbd:" and
220 "http:" URLs. To specify those, use the general
221 "g.config" call instead.
223 return libguestfsmod.add_cdrom (self._o, filename)
225 def add_drive_ro (self, filename):
226 u"""This adds a drive in snapshot mode, making it
227 effectively read-only.
229 Note that writes to the device are allowed, and will be
230 seen for the duration of the guestfs handle, but they
231 are written to a temporary file which is discarded as
232 soon as the guestfs handle is closed. We don't currently
233 have any method to enable changes to be committed,
234 although qemu can support this.
236 This is equivalent to the qemu parameter "-drive
237 file=filename,snapshot=on,if=virtio".
239 Note that this call checks for the existence of
240 "filename". This stops you from specifying other types
241 of drive which are supported by qemu such as "nbd:" and
242 "http:" URLs. To specify those, use the general
243 "g.config" call instead.
245 return libguestfsmod.add_drive_ro (self._o, filename)
247 def config (self, qemuparam, qemuvalue):
248 u"""This can be used to add arbitrary qemu command line
249 parameters of the form "-param value". Actually it's not
250 quite arbitrary - we prevent you from setting some
251 parameters which would interfere with parameters that we
254 The first character of "param" string must be a "-"
259 return libguestfsmod.config (self._o, qemuparam, qemuvalue)
261 def set_qemu (self, qemu):
262 u"""Set the qemu binary that we will use.
264 The default is chosen when the library was compiled by
265 the configure script.
267 You can also override this by setting the
268 "LIBGUESTFS_QEMU" environment variable.
270 Setting "qemu" to "NULL" restores the default qemu
273 return libguestfsmod.set_qemu (self._o, qemu)
276 u"""Return the current qemu binary.
278 This is always non-NULL. If it wasn't set already, then
279 this will return the default qemu binary name.
281 return libguestfsmod.get_qemu (self._o)
283 def set_path (self, path):
284 u"""Set the path that libguestfs searches for kernel and
287 The default is "$libdir/guestfs" unless overridden by
288 setting "LIBGUESTFS_PATH" environment variable.
290 Setting "path" to "NULL" restores the default path.
292 return libguestfsmod.set_path (self._o, path)
295 u"""Return the current search path.
297 This is always non-NULL. If it wasn't set already, then
298 this will return the default path.
300 return libguestfsmod.get_path (self._o)
302 def set_append (self, append):
303 u"""This function is used to add additional options to the
304 guest kernel command line.
306 The default is "NULL" unless overridden by setting
307 "LIBGUESTFS_APPEND" environment variable.
309 Setting "append" to "NULL" means *no* additional options
310 are passed (libguestfs always adds a few of its own).
312 return libguestfsmod.set_append (self._o, append)
314 def get_append (self):
315 u"""Return the additional kernel options which are added to
316 the guest kernel command line.
318 If "NULL" then no options are added.
320 return libguestfsmod.get_append (self._o)
322 def set_autosync (self, autosync):
323 u"""If "autosync" is true, this enables autosync. Libguestfs
324 will make a best effort attempt to run "g.umount_all"
325 followed by "g.sync" when the handle is closed (also if
326 the program exits without closing handles).
328 This is disabled by default (except in guestfish where
329 it is enabled by default).
331 return libguestfsmod.set_autosync (self._o, autosync)
333 def get_autosync (self):
334 u"""Get the autosync flag.
336 return libguestfsmod.get_autosync (self._o)
338 def set_verbose (self, verbose):
339 u"""If "verbose" is true, this turns on verbose messages (to
342 Verbose messages are disabled unless the environment
343 variable "LIBGUESTFS_DEBUG" is defined and set to 1.
345 return libguestfsmod.set_verbose (self._o, verbose)
347 def get_verbose (self):
348 u"""This returns the verbose messages flag.
350 return libguestfsmod.get_verbose (self._o)
353 u"""This returns true iff this handle is ready to accept
354 commands (in the "READY" state).
356 For more information on states, see guestfs(3).
358 return libguestfsmod.is_ready (self._o)
360 def is_config (self):
361 u"""This returns true iff this handle is being configured
362 (in the "CONFIG" state).
364 For more information on states, see guestfs(3).
366 return libguestfsmod.is_config (self._o)
368 def is_launching (self):
369 u"""This returns true iff this handle is launching the
370 subprocess (in the "LAUNCHING" state).
372 For more information on states, see guestfs(3).
374 return libguestfsmod.is_launching (self._o)
377 u"""This returns true iff this handle is busy processing a
378 command (in the "BUSY" state).
380 For more information on states, see guestfs(3).
382 return libguestfsmod.is_busy (self._o)
384 def get_state (self):
385 u"""This returns the current state as an opaque integer.
386 This is only useful for printing debug and internal
389 For more information on states, see guestfs(3).
391 return libguestfsmod.get_state (self._o)
394 u"""This sets the state to "BUSY". This is only used when
395 implementing actions using the low-level API.
397 For more information on states, see guestfs(3).
399 return libguestfsmod.set_busy (self._o)
401 def set_ready (self):
402 u"""This sets the state to "READY". This is only used when
403 implementing actions using the low-level API.
405 For more information on states, see guestfs(3).
407 return libguestfsmod.set_ready (self._o)
410 u"""This sets the state to "READY", or if in "CONFIG" then
411 it leaves the state as is. This is only used when
412 implementing actions using the low-level API.
414 For more information on states, see guestfs(3).
416 return libguestfsmod.end_busy (self._o)
418 def set_memsize (self, memsize):
419 u"""This sets the memory size in megabytes allocated to the
420 qemu subprocess. This only has any effect if called
423 You can also change this by setting the environment
424 variable "LIBGUESTFS_MEMSIZE" before the handle is
427 For more information on the architecture of libguestfs,
430 return libguestfsmod.set_memsize (self._o, memsize)
432 def get_memsize (self):
433 u"""This gets the memory size in megabytes allocated to the
436 If "g.set_memsize" was not called on this handle, and if
437 "LIBGUESTFS_MEMSIZE" was not set, then this returns the
438 compiled-in default value for memsize.
440 For more information on the architecture of libguestfs,
443 return libguestfsmod.get_memsize (self._o)
445 def mount (self, device, mountpoint):
446 u"""Mount a guest disk at a position in the filesystem.
447 Block devices are named "/dev/sda", "/dev/sdb" and so
448 on, as they were added to the guest. If those block
449 devices contain partitions, they will have the usual
450 names (eg. "/dev/sda1"). Also LVM "/dev/VG/LV"-style
453 The rules are the same as for mount(2): A filesystem
454 must first be mounted on "/" before others can be
455 mounted. Other filesystems can only be mounted on
456 directories which already exist.
458 The mounted filesystem is writable, if we have
459 sufficient permissions on the underlying device.
461 The filesystem options "sync" and "noatime" are set with
462 this call, in order to improve reliability.
464 return libguestfsmod.mount (self._o, device, mountpoint)
467 u"""This syncs the disk, so that any writes are flushed
468 through to the underlying disk image.
470 You should always call this if you have modified a disk
471 image, before closing the handle.
473 return libguestfsmod.sync (self._o)
475 def touch (self, path):
476 u"""Touch acts like the touch(1) command. It can be used to
477 update the timestamps on a file, or, if the file does
478 not exist, to create a new zero-length file.
480 return libguestfsmod.touch (self._o, path)
482 def cat (self, path):
483 u"""Return the contents of the file named "path".
485 Note that this function cannot correctly handle binary
486 files (specifically, files containing "\\0" character
487 which is treated as end of string). For those you need
488 to use the "g.download" function which has a more
491 Because of the message protocol, there is a transfer
492 limit of somewhere between 2MB and 4MB. To transfer
493 large files you should use FTP.
495 return libguestfsmod.cat (self._o, path)
497 def ll (self, directory):
498 u"""List the files in "directory" (relative to the root
499 directory, there is no cwd) in the format of 'ls -la'.
501 This command is mostly useful for interactive sessions.
502 It is *not* intended that you try to parse the output
505 return libguestfsmod.ll (self._o, directory)
507 def ls (self, directory):
508 u"""List the files in "directory" (relative to the root
509 directory, there is no cwd). The '.' and '..' entries
510 are not returned, but hidden files are shown.
512 This command is mostly useful for interactive sessions.
513 Programs should probably use "g.readdir" instead.
515 This function returns a list of strings.
517 return libguestfsmod.ls (self._o, directory)
519 def list_devices (self):
520 u"""List all the block devices.
522 The full block device names are returned, eg. "/dev/sda"
524 This function returns a list of strings.
526 return libguestfsmod.list_devices (self._o)
528 def list_partitions (self):
529 u"""List all the partitions detected on all block devices.
531 The full partition device names are returned, eg.
534 This does not return logical volumes. For that you will
535 need to call "g.lvs".
537 This function returns a list of strings.
539 return libguestfsmod.list_partitions (self._o)
542 u"""List all the physical volumes detected. This is the
543 equivalent of the pvs(8) command.
545 This returns a list of just the device names that
546 contain PVs (eg. "/dev/sda2").
548 See also "g.pvs_full".
550 This function returns a list of strings.
552 return libguestfsmod.pvs (self._o)
555 u"""List all the volumes groups detected. This is the
556 equivalent of the vgs(8) command.
558 This returns a list of just the volume group names that
559 were detected (eg. "VolGroup00").
561 See also "g.vgs_full".
563 This function returns a list of strings.
565 return libguestfsmod.vgs (self._o)
568 u"""List all the logical volumes detected. This is the
569 equivalent of the lvs(8) command.
571 This returns a list of the logical volume device names
572 (eg. "/dev/VolGroup00/LogVol00").
574 See also "g.lvs_full".
576 This function returns a list of strings.
578 return libguestfsmod.lvs (self._o)
581 u"""List all the physical volumes detected. This is the
582 equivalent of the pvs(8) command. The "full" version
585 This function returns a list of PVs. Each PV is
586 represented as a dictionary.
588 return libguestfsmod.pvs_full (self._o)
591 u"""List all the volumes groups detected. This is the
592 equivalent of the vgs(8) command. The "full" version
595 This function returns a list of VGs. Each VG is
596 represented as a dictionary.
598 return libguestfsmod.vgs_full (self._o)
601 u"""List all the logical volumes detected. This is the
602 equivalent of the lvs(8) command. The "full" version
605 This function returns a list of LVs. Each LV is
606 represented as a dictionary.
608 return libguestfsmod.lvs_full (self._o)
610 def read_lines (self, path):
611 u"""Return the contents of the file named "path".
613 The file contents are returned as a list of lines.
614 Trailing "LF" and "CRLF" character sequences are *not*
617 Note that this function cannot correctly handle binary
618 files (specifically, files containing "\\0" character
619 which is treated as end of line). For those you need to
620 use the "g.read_file" function which has a more complex
623 This function returns a list of strings.
625 return libguestfsmod.read_lines (self._o, path)
627 def aug_init (self, root, flags):
628 u"""Create a new Augeas handle for editing configuration
629 files. If there was any previous Augeas handle
630 associated with this guestfs session, then it is closed.
632 You must call this before using any other "g.aug_*"
635 "root" is the filesystem root. "root" must not be NULL,
638 The flags are the same as the flags defined in
639 <augeas.h>, the logical *or* of the following integers:
641 "AUG_SAVE_BACKUP" = 1
642 Keep the original file with a ".augsave" extension.
644 "AUG_SAVE_NEWFILE" = 2
645 Save changes into a file with extension ".augnew",
646 and do not overwrite original. Overrides
650 Typecheck lenses (can be expensive).
653 Do not use standard load path for modules.
656 Make save a no-op, just record what would have been
660 Do not load the tree in "g.aug_init".
662 To close the handle, you can call "g.aug_close".
664 To find out more about Augeas, see <http://augeas.net/>.
666 return libguestfsmod.aug_init (self._o, root, flags)
668 def aug_close (self):
669 u"""Close the current Augeas handle and free up any
670 resources used by it. After calling this, you have to
671 call "g.aug_init" again before you can use any other
674 return libguestfsmod.aug_close (self._o)
676 def aug_defvar (self, name, expr):
677 u"""Defines an Augeas variable "name" whose value is the
678 result of evaluating "expr". If "expr" is NULL, then
681 On success this returns the number of nodes in "expr",
682 or 0 if "expr" evaluates to something which is not a
685 return libguestfsmod.aug_defvar (self._o, name, expr)
687 def aug_defnode (self, name, expr, val):
688 u"""Defines a variable "name" whose value is the result of
691 If "expr" evaluates to an empty nodeset, a node is
692 created, equivalent to calling "g.aug_set" "expr",
693 "value". "name" will be the nodeset containing that
696 On success this returns a pair containing the number of
697 nodes in the nodeset, and a boolean flag if a node was
700 This function returns a tuple (int, bool).
702 return libguestfsmod.aug_defnode (self._o, name, expr, val)
704 def aug_get (self, path):
705 u"""Look up the value associated with "path". If "path"
706 matches exactly one node, the "value" is returned.
708 return libguestfsmod.aug_get (self._o, path)
710 def aug_set (self, path, val):
711 u"""Set the value associated with "path" to "value".
713 return libguestfsmod.aug_set (self._o, path, val)
715 def aug_insert (self, path, label, before):
716 u"""Create a new sibling "label" for "path", inserting it
717 into the tree before or after "path" (depending on the
718 boolean flag "before").
720 "path" must match exactly one existing node in the tree,
721 and "label" must be a label, ie. not contain "/", "*" or
722 end with a bracketed index "[N]".
724 return libguestfsmod.aug_insert (self._o, path, label, before)
726 def aug_rm (self, path):
727 u"""Remove "path" and all of its children.
729 On success this returns the number of entries which were
732 return libguestfsmod.aug_rm (self._o, path)
734 def aug_mv (self, src, dest):
735 u"""Move the node "src" to "dest". "src" must match exactly
736 one node. "dest" is overwritten if it exists.
738 return libguestfsmod.aug_mv (self._o, src, dest)
740 def aug_match (self, path):
741 u"""Returns a list of paths which match the path expression
742 "path". The returned paths are sufficiently qualified so
743 that they match exactly one node in the current tree.
745 This function returns a list of strings.
747 return libguestfsmod.aug_match (self._o, path)
750 u"""This writes all pending changes to disk.
752 The flags which were passed to "g.aug_init" affect
753 exactly how files are saved.
755 return libguestfsmod.aug_save (self._o)
758 u"""Load files into the tree.
760 See "aug_load" in the Augeas documentation for the full
763 return libguestfsmod.aug_load (self._o)
765 def aug_ls (self, path):
766 u"""This is just a shortcut for listing "g.aug_match"
767 "path/*" and sorting the resulting nodes into
770 This function returns a list of strings.
772 return libguestfsmod.aug_ls (self._o, path)
775 u"""Remove the single file "path".
777 return libguestfsmod.rm (self._o, path)
779 def rmdir (self, path):
780 u"""Remove the single directory "path".
782 return libguestfsmod.rmdir (self._o, path)
784 def rm_rf (self, path):
785 u"""Remove the file or directory "path", recursively
786 removing the contents if its a directory. This is like
787 the "rm -rf" shell command.
789 return libguestfsmod.rm_rf (self._o, path)
791 def mkdir (self, path):
792 u"""Create a directory named "path".
794 return libguestfsmod.mkdir (self._o, path)
796 def mkdir_p (self, path):
797 u"""Create a directory named "path", creating any parent
798 directories as necessary. This is like the "mkdir -p"
801 return libguestfsmod.mkdir_p (self._o, path)
803 def chmod (self, mode, path):
804 u"""Change the mode (permissions) of "path" to "mode". Only
805 numeric modes are supported.
807 return libguestfsmod.chmod (self._o, mode, path)
809 def chown (self, owner, group, path):
810 u"""Change the file owner to "owner" and group to "group".
812 Only numeric uid and gid are supported. If you want to
813 use names, you will need to locate and parse the
814 password file yourself (Augeas support makes this
817 return libguestfsmod.chown (self._o, owner, group, path)
819 def exists (self, path):
820 u"""This returns "true" if and only if there is a file,
821 directory (or anything) with the given "path" name.
823 See also "g.is_file", "g.is_dir", "g.stat".
825 return libguestfsmod.exists (self._o, path)
827 def is_file (self, path):
828 u"""This returns "true" if and only if there is a file with
829 the given "path" name. Note that it returns false for
830 other objects like directories.
834 return libguestfsmod.is_file (self._o, path)
836 def is_dir (self, path):
837 u"""This returns "true" if and only if there is a directory
838 with the given "path" name. Note that it returns false
839 for other objects like files.
843 return libguestfsmod.is_dir (self._o, path)
845 def pvcreate (self, device):
846 u"""This creates an LVM physical volume on the named
847 "device", where "device" should usually be a partition
848 name such as "/dev/sda1".
850 return libguestfsmod.pvcreate (self._o, device)
852 def vgcreate (self, volgroup, physvols):
853 u"""This creates an LVM volume group called "volgroup" from
854 the non-empty list of physical volumes "physvols".
856 return libguestfsmod.vgcreate (self._o, volgroup, physvols)
858 def lvcreate (self, logvol, volgroup, mbytes):
859 u"""This creates an LVM volume group called "logvol" on the
860 volume group "volgroup", with "size" megabytes.
862 return libguestfsmod.lvcreate (self._o, logvol, volgroup, mbytes)
864 def mkfs (self, fstype, device):
865 u"""This creates a filesystem on "device" (usually a
866 partition or LVM logical volume). The filesystem type is
867 "fstype", for example "ext3".
869 return libguestfsmod.mkfs (self._o, fstype, device)
871 def sfdisk (self, device, cyls, heads, sectors, lines):
872 u"""This is a direct interface to the sfdisk(8) program for
873 creating partitions on block devices.
875 "device" should be a block device, for example
878 "cyls", "heads" and "sectors" are the number of
879 cylinders, heads and sectors on the device, which are
880 passed directly to sfdisk as the *-C*, *-H* and *-S*
881 parameters. If you pass 0 for any of these, then the
882 corresponding parameter is omitted. Usually for 'large'
883 disks, you can just pass 0 for these, but for small
884 (floppy-sized) disks, sfdisk (or rather, the kernel)
885 cannot work out the right geometry and you will need to
888 "lines" is a list of lines that we feed to "sfdisk". For
889 more information refer to the sfdisk(8) manpage.
891 To create a single partition occupying the whole disk,
892 you would pass "lines" as a single element list, when
893 the single element being the string "," (comma).
895 See also: "g.sfdisk_l", "g.sfdisk_N"
897 This command is dangerous. Without careful use you can
898 easily destroy all your data.
900 return libguestfsmod.sfdisk (self._o, device, cyls, heads, sectors, lines)
902 def write_file (self, path, content, size):
903 u"""This call creates a file called "path". The contents of
904 the file is the string "content" (which can contain any
905 8 bit data), with length "size".
907 As a special case, if "size" is 0 then the length is
908 calculated using "strlen" (so in this case the content
909 cannot contain embedded ASCII NULs).
911 *NB.* Owing to a bug, writing content containing ASCII
912 NUL characters does *not* work, even if the length is
913 specified. We hope to resolve this bug in a future
914 version. In the meantime use "g.upload".
916 Because of the message protocol, there is a transfer
917 limit of somewhere between 2MB and 4MB. To transfer
918 large files you should use FTP.
920 return libguestfsmod.write_file (self._o, path, content, size)
922 def umount (self, pathordevice):
923 u"""This unmounts the given filesystem. The filesystem may
924 be specified either by its mountpoint (path) or the
925 device which contains the filesystem.
927 return libguestfsmod.umount (self._o, pathordevice)
930 u"""This returns the list of currently mounted filesystems.
931 It returns the list of devices (eg. "/dev/sda1",
934 Some internal mounts are not shown.
936 This function returns a list of strings.
938 return libguestfsmod.mounts (self._o)
940 def umount_all (self):
941 u"""This unmounts all mounted filesystems.
943 Some internal mounts are not unmounted by this call.
945 return libguestfsmod.umount_all (self._o)
947 def lvm_remove_all (self):
948 u"""This command removes all LVM logical volumes, volume
949 groups and physical volumes.
951 This command is dangerous. Without careful use you can
952 easily destroy all your data.
954 return libguestfsmod.lvm_remove_all (self._o)
956 def file (self, path):
957 u"""This call uses the standard file(1) command to determine
958 the type or contents of the file. This also works on
959 devices, for example to find out whether a partition
960 contains a filesystem.
962 The exact command which runs is "file -bsL path". Note
963 in particular that the filename is not prepended to the
964 output (the "-b" option).
966 return libguestfsmod.file (self._o, path)
968 def command (self, arguments):
969 u"""This call runs a command from the guest filesystem. The
970 filesystem must be mounted, and must contain a
971 compatible operating system (ie. something Linux, with
972 the same or compatible processor architecture).
974 The single parameter is an argv-style list of arguments.
975 The first element is the name of the program to run.
976 Subsequent elements are parameters. The list must be
977 non-empty (ie. must contain a program name). Note that
978 the command runs directly, and is *not* invoked via the
981 The return value is anything printed to *stdout* by the
984 If the command returns a non-zero exit status, then this
985 function returns an error message. The error message
986 string is the content of *stderr* from the command.
988 The $PATH environment variable will contain at least
989 "/usr/bin" and "/bin". If you require a program from
990 another location, you should provide the full path in
993 Shared libraries and data files required by the program
994 must be available on filesystems which are mounted in
995 the correct places. It is the caller's responsibility to
996 ensure all filesystems that are needed are mounted at
999 Because of the message protocol, there is a transfer
1000 limit of somewhere between 2MB and 4MB. To transfer
1001 large files you should use FTP.
1003 return libguestfsmod.command (self._o, arguments)
1005 def command_lines (self, arguments):
1006 u"""This is the same as "g.command", but splits the result
1007 into a list of lines.
1009 See also: "g.sh_lines"
1011 This function returns a list of strings.
1013 Because of the message protocol, there is a transfer
1014 limit of somewhere between 2MB and 4MB. To transfer
1015 large files you should use FTP.
1017 return libguestfsmod.command_lines (self._o, arguments)
1019 def stat (self, path):
1020 u"""Returns file information for the given "path".
1022 This is the same as the stat(2) system call.
1024 This function returns a dictionary, with keys matching
1025 the various fields in the stat structure.
1027 return libguestfsmod.stat (self._o, path)
1029 def lstat (self, path):
1030 u"""Returns file information for the given "path".
1032 This is the same as "g.stat" except that if "path" is a
1033 symbolic link, then the link is stat-ed, not the file it
1036 This is the same as the lstat(2) system call.
1038 This function returns a dictionary, with keys matching
1039 the various fields in the stat structure.
1041 return libguestfsmod.lstat (self._o, path)
1043 def statvfs (self, path):
1044 u"""Returns file system statistics for any mounted file
1045 system. "path" should be a file or directory in the
1046 mounted file system (typically it is the mount point
1047 itself, but it doesn't need to be).
1049 This is the same as the statvfs(2) system call.
1051 This function returns a dictionary, with keys matching
1052 the various fields in the statvfs structure.
1054 return libguestfsmod.statvfs (self._o, path)
1056 def tune2fs_l (self, device):
1057 u"""This returns the contents of the ext2, ext3 or ext4
1058 filesystem superblock on "device".
1060 It is the same as running "tune2fs -l device". See
1061 tune2fs(8) manpage for more details. The list of fields
1062 returned isn't clearly defined, and depends on both the
1063 version of "tune2fs" that libguestfs was built against,
1064 and the filesystem itself.
1066 This function returns a dictionary.
1068 return libguestfsmod.tune2fs_l (self._o, device)
1070 def blockdev_setro (self, device):
1071 u"""Sets the block device named "device" to read-only.
1073 This uses the blockdev(8) command.
1075 return libguestfsmod.blockdev_setro (self._o, device)
1077 def blockdev_setrw (self, device):
1078 u"""Sets the block device named "device" to read-write.
1080 This uses the blockdev(8) command.
1082 return libguestfsmod.blockdev_setrw (self._o, device)
1084 def blockdev_getro (self, device):
1085 u"""Returns a boolean indicating if the block device is
1086 read-only (true if read-only, false if not).
1088 This uses the blockdev(8) command.
1090 return libguestfsmod.blockdev_getro (self._o, device)
1092 def blockdev_getss (self, device):
1093 u"""This returns the size of sectors on a block device.
1094 Usually 512, but can be larger for modern devices.
1096 (Note, this is not the size in sectors, use
1097 "g.blockdev_getsz" for that).
1099 This uses the blockdev(8) command.
1101 return libguestfsmod.blockdev_getss (self._o, device)
1103 def blockdev_getbsz (self, device):
1104 u"""This returns the block size of a device.
1106 (Note this is different from both *size in blocks* and
1107 *filesystem block size*).
1109 This uses the blockdev(8) command.
1111 return libguestfsmod.blockdev_getbsz (self._o, device)
1113 def blockdev_setbsz (self, device, blocksize):
1114 u"""This sets the block size of a device.
1116 (Note this is different from both *size in blocks* and
1117 *filesystem block size*).
1119 This uses the blockdev(8) command.
1121 return libguestfsmod.blockdev_setbsz (self._o, device, blocksize)
1123 def blockdev_getsz (self, device):
1124 u"""This returns the size of the device in units of 512-byte
1125 sectors (even if the sectorsize isn't 512 bytes ...
1128 See also "g.blockdev_getss" for the real sector size of
1129 the device, and "g.blockdev_getsize64" for the more
1130 useful *size in bytes*.
1132 This uses the blockdev(8) command.
1134 return libguestfsmod.blockdev_getsz (self._o, device)
1136 def blockdev_getsize64 (self, device):
1137 u"""This returns the size of the device in bytes.
1139 See also "g.blockdev_getsz".
1141 This uses the blockdev(8) command.
1143 return libguestfsmod.blockdev_getsize64 (self._o, device)
1145 def blockdev_flushbufs (self, device):
1146 u"""This tells the kernel to flush internal buffers
1147 associated with "device".
1149 This uses the blockdev(8) command.
1151 return libguestfsmod.blockdev_flushbufs (self._o, device)
1153 def blockdev_rereadpt (self, device):
1154 u"""Reread the partition table on "device".
1156 This uses the blockdev(8) command.
1158 return libguestfsmod.blockdev_rereadpt (self._o, device)
1160 def upload (self, filename, remotefilename):
1161 u"""Upload local file "filename" to "remotefilename" on the
1164 "filename" can also be a named pipe.
1166 See also "g.download".
1168 return libguestfsmod.upload (self._o, filename, remotefilename)
1170 def download (self, remotefilename, filename):
1171 u"""Download file "remotefilename" and save it as "filename"
1172 on the local machine.
1174 "filename" can also be a named pipe.
1176 See also "g.upload", "g.cat".
1178 return libguestfsmod.download (self._o, remotefilename, filename)
1180 def checksum (self, csumtype, path):
1181 u"""This call computes the MD5, SHAx or CRC checksum of the
1184 The type of checksum to compute is given by the
1185 "csumtype" parameter which must have one of the
1189 Compute the cyclic redundancy check (CRC) specified
1190 by POSIX for the "cksum" command.
1193 Compute the MD5 hash (using the "md5sum" program).
1196 Compute the SHA1 hash (using the "sha1sum" program).
1199 Compute the SHA224 hash (using the "sha224sum"
1203 Compute the SHA256 hash (using the "sha256sum"
1207 Compute the SHA384 hash (using the "sha384sum"
1211 Compute the SHA512 hash (using the "sha512sum"
1214 The checksum is returned as a printable string.
1216 return libguestfsmod.checksum (self._o, csumtype, path)
1218 def tar_in (self, tarfile, directory):
1219 u"""This command uploads and unpacks local file "tarfile"
1220 (an *uncompressed* tar file) into "directory".
1222 To upload a compressed tarball, use "g.tgz_in".
1224 return libguestfsmod.tar_in (self._o, tarfile, directory)
1226 def tar_out (self, directory, tarfile):
1227 u"""This command packs the contents of "directory" and
1228 downloads it to local file "tarfile".
1230 To download a compressed tarball, use "g.tgz_out".
1232 return libguestfsmod.tar_out (self._o, directory, tarfile)
1234 def tgz_in (self, tarball, directory):
1235 u"""This command uploads and unpacks local file "tarball" (a
1236 *gzip compressed* tar file) into "directory".
1238 To upload an uncompressed tarball, use "g.tar_in".
1240 return libguestfsmod.tgz_in (self._o, tarball, directory)
1242 def tgz_out (self, directory, tarball):
1243 u"""This command packs the contents of "directory" and
1244 downloads it to local file "tarball".
1246 To download an uncompressed tarball, use "g.tar_out".
1248 return libguestfsmod.tgz_out (self._o, directory, tarball)
1250 def mount_ro (self, device, mountpoint):
1251 u"""This is the same as the "g.mount" command, but it mounts
1252 the filesystem with the read-only (*-o ro*) flag.
1254 return libguestfsmod.mount_ro (self._o, device, mountpoint)
1256 def mount_options (self, options, device, mountpoint):
1257 u"""This is the same as the "g.mount" command, but it allows
1258 you to set the mount options as for the mount(8) *-o*
1261 return libguestfsmod.mount_options (self._o, options, device, mountpoint)
1263 def mount_vfs (self, options, vfstype, device, mountpoint):
1264 u"""This is the same as the "g.mount" command, but it allows
1265 you to set both the mount options and the vfstype as for
1266 the mount(8) *-o* and *-t* flags.
1268 return libguestfsmod.mount_vfs (self._o, options, vfstype, device, mountpoint)
1270 def debug (self, subcmd, extraargs):
1271 u"""The "g.debug" command exposes some internals of
1272 "guestfsd" (the guestfs daemon) that runs inside the
1275 There is no comprehensive help for this command. You
1276 have to look at the file "daemon/debug.c" in the
1277 libguestfs source to find out what you can do.
1279 return libguestfsmod.debug (self._o, subcmd, extraargs)
1281 def lvremove (self, device):
1282 u"""Remove an LVM logical volume "device", where "device" is
1283 the path to the LV, such as "/dev/VG/LV".
1285 You can also remove all LVs in a volume group by
1286 specifying the VG name, "/dev/VG".
1288 return libguestfsmod.lvremove (self._o, device)
1290 def vgremove (self, vgname):
1291 u"""Remove an LVM volume group "vgname", (for example "VG").
1293 This also forcibly removes all logical volumes in the
1294 volume group (if any).
1296 return libguestfsmod.vgremove (self._o, vgname)
1298 def pvremove (self, device):
1299 u"""This wipes a physical volume "device" so that LVM will
1300 no longer recognise it.
1302 The implementation uses the "pvremove" command which
1303 refuses to wipe physical volumes that contain any volume
1304 groups, so you have to remove those first.
1306 return libguestfsmod.pvremove (self._o, device)
1308 def set_e2label (self, device, label):
1309 u"""This sets the ext2/3/4 filesystem label of the
1310 filesystem on "device" to "label". Filesystem labels are
1311 limited to 16 characters.
1313 You can use either "g.tune2fs_l" or "g.get_e2label" to
1314 return the existing label on a filesystem.
1316 return libguestfsmod.set_e2label (self._o, device, label)
1318 def get_e2label (self, device):
1319 u"""This returns the ext2/3/4 filesystem label of the
1320 filesystem on "device".
1322 return libguestfsmod.get_e2label (self._o, device)
1324 def set_e2uuid (self, device, uuid):
1325 u"""This sets the ext2/3/4 filesystem UUID of the filesystem
1326 on "device" to "uuid". The format of the UUID and
1327 alternatives such as "clear", "random" and "time" are
1328 described in the tune2fs(8) manpage.
1330 You can use either "g.tune2fs_l" or "g.get_e2uuid" to
1331 return the existing UUID of a filesystem.
1333 return libguestfsmod.set_e2uuid (self._o, device, uuid)
1335 def get_e2uuid (self, device):
1336 u"""This returns the ext2/3/4 filesystem UUID of the
1337 filesystem on "device".
1339 return libguestfsmod.get_e2uuid (self._o, device)
1341 def fsck (self, fstype, device):
1342 u"""This runs the filesystem checker (fsck) on "device"
1343 which should have filesystem type "fstype".
1345 The returned integer is the status. See fsck(8) for the
1346 list of status codes from "fsck".
1350 * Multiple status codes can be summed together.
1352 * A non-zero return code can mean "success", for
1353 example if errors have been corrected on the
1356 * Checking or repairing NTFS volumes is not supported
1359 This command is entirely equivalent to running "fsck -a
1362 return libguestfsmod.fsck (self._o, fstype, device)
1364 def zero (self, device):
1365 u"""This command writes zeroes over the first few blocks of
1368 How many blocks are zeroed isn't specified (but it's
1369 *not* enough to securely wipe the device). It should be
1370 sufficient to remove any partition tables, filesystem
1371 superblocks and so on.
1373 See also: "g.scrub_device".
1375 return libguestfsmod.zero (self._o, device)
1377 def grub_install (self, root, device):
1378 u"""This command installs GRUB (the Grand Unified
1379 Bootloader) on "device", with the root directory being
1382 return libguestfsmod.grub_install (self._o, root, device)
1384 def cp (self, src, dest):
1385 u"""This copies a file from "src" to "dest" where "dest" is
1386 either a destination filename or destination directory.
1388 return libguestfsmod.cp (self._o, src, dest)
1390 def cp_a (self, src, dest):
1391 u"""This copies a file or directory from "src" to "dest"
1392 recursively using the "cp -a" command.
1394 return libguestfsmod.cp_a (self._o, src, dest)
1396 def mv (self, src, dest):
1397 u"""This moves a file from "src" to "dest" where "dest" is
1398 either a destination filename or destination directory.
1400 return libguestfsmod.mv (self._o, src, dest)
1402 def drop_caches (self, whattodrop):
1403 u"""This instructs the guest kernel to drop its page cache,
1404 and/or dentries and inode caches. The parameter
1405 "whattodrop" tells the kernel what precisely to drop,
1406 see <http://linux-mm.org/Drop_Caches>
1408 Setting "whattodrop" to 3 should drop everything.
1410 This automatically calls sync(2) before the operation,
1411 so that the maximum guest memory is freed.
1413 return libguestfsmod.drop_caches (self._o, whattodrop)
1416 u"""This returns the kernel messages ("dmesg" output) from
1417 the guest kernel. This is sometimes useful for extended
1418 debugging of problems.
1420 Another way to get the same information is to enable
1421 verbose messages with "g.set_verbose" or by setting the
1422 environment variable "LIBGUESTFS_DEBUG=1" before running
1425 return libguestfsmod.dmesg (self._o)
1427 def ping_daemon (self):
1428 u"""This is a test probe into the guestfs daemon running
1429 inside the qemu subprocess. Calling this function checks
1430 that the daemon responds to the ping message, without
1431 affecting the daemon or attached block device(s) in any
1434 return libguestfsmod.ping_daemon (self._o)
1436 def equal (self, file1, file2):
1437 u"""This compares the two files "file1" and "file2" and
1438 returns true if their content is exactly equal, or false
1441 The external cmp(1) program is used for the comparison.
1443 return libguestfsmod.equal (self._o, file1, file2)
1445 def strings (self, path):
1446 u"""This runs the strings(1) command on a file and returns
1447 the list of printable strings found.
1449 This function returns a list of strings.
1451 Because of the message protocol, there is a transfer
1452 limit of somewhere between 2MB and 4MB. To transfer
1453 large files you should use FTP.
1455 return libguestfsmod.strings (self._o, path)
1457 def strings_e (self, encoding, path):
1458 u"""This is like the "g.strings" command, but allows you to
1459 specify the encoding.
1461 See the strings(1) manpage for the full list of
1464 Commonly useful encodings are "l" (lower case L) which
1465 will show strings inside Windows/x86 files.
1467 The returned strings are transcoded to UTF-8.
1469 This function returns a list of strings.
1471 Because of the message protocol, there is a transfer
1472 limit of somewhere between 2MB and 4MB. To transfer
1473 large files you should use FTP.
1475 return libguestfsmod.strings_e (self._o, encoding, path)
1477 def hexdump (self, path):
1478 u"""This runs "hexdump -C" on the given "path". The result
1479 is the human-readable, canonical hex dump of the file.
1481 Because of the message protocol, there is a transfer
1482 limit of somewhere between 2MB and 4MB. To transfer
1483 large files you should use FTP.
1485 return libguestfsmod.hexdump (self._o, path)
1487 def zerofree (self, device):
1488 u"""This runs the *zerofree* program on "device". This
1489 program claims to zero unused inodes and disk blocks on
1490 an ext2/3 filesystem, thus making it possible to
1491 compress the filesystem more effectively.
1493 You should not run this program if the filesystem is
1496 It is possible that using this program can damage the
1497 filesystem or data on the filesystem.
1499 return libguestfsmod.zerofree (self._o, device)
1501 def pvresize (self, device):
1502 u"""This resizes (expands or shrinks) an existing LVM
1503 physical volume to match the new size of the underlying
1506 return libguestfsmod.pvresize (self._o, device)
1508 def sfdisk_N (self, device, partnum, cyls, heads, sectors, line):
1509 u"""This runs sfdisk(8) option to modify just the single
1510 partition "n" (note: "n" counts from 1).
1512 For other parameters, see "g.sfdisk". You should usually
1513 pass 0 for the cyls/heads/sectors parameters.
1515 This command is dangerous. Without careful use you can
1516 easily destroy all your data.
1518 return libguestfsmod.sfdisk_N (self._o, device, partnum, cyls, heads, sectors, line)
1520 def sfdisk_l (self, device):
1521 u"""This displays the partition table on "device", in the
1522 human-readable output of the sfdisk(8) command. It is
1523 not intended to be parsed.
1525 return libguestfsmod.sfdisk_l (self._o, device)
1527 def sfdisk_kernel_geometry (self, device):
1528 u"""This displays the kernel's idea of the geometry of
1531 The result is in human-readable format, and not designed
1534 return libguestfsmod.sfdisk_kernel_geometry (self._o, device)
1536 def sfdisk_disk_geometry (self, device):
1537 u"""This displays the disk geometry of "device" read from
1538 the partition table. Especially in the case where the
1539 underlying block device has been resized, this can be
1540 different from the kernel's idea of the geometry (see
1541 "g.sfdisk_kernel_geometry").
1543 The result is in human-readable format, and not designed
1546 return libguestfsmod.sfdisk_disk_geometry (self._o, device)
1548 def vg_activate_all (self, activate):
1549 u"""This command activates or (if "activate" is false)
1550 deactivates all logical volumes in all volume groups. If
1551 activated, then they are made known to the kernel, ie.
1552 they appear as "/dev/mapper" devices. If deactivated,
1553 then those devices disappear.
1555 This command is the same as running "vgchange -a y|n"
1557 return libguestfsmod.vg_activate_all (self._o, activate)
1559 def vg_activate (self, activate, volgroups):
1560 u"""This command activates or (if "activate" is false)
1561 deactivates all logical volumes in the listed volume
1562 groups "volgroups". If activated, then they are made
1563 known to the kernel, ie. they appear as "/dev/mapper"
1564 devices. If deactivated, then those devices disappear.
1566 This command is the same as running "vgchange -a y|n
1569 Note that if "volgroups" is an empty list then all
1570 volume groups are activated or deactivated.
1572 return libguestfsmod.vg_activate (self._o, activate, volgroups)
1574 def lvresize (self, device, mbytes):
1575 u"""This resizes (expands or shrinks) an existing LVM
1576 logical volume to "mbytes". When reducing, data in the
1577 reduced part is lost.
1579 return libguestfsmod.lvresize (self._o, device, mbytes)
1581 def resize2fs (self, device):
1582 u"""This resizes an ext2 or ext3 filesystem to match the
1583 size of the underlying device.
1585 *Note:* It is sometimes required that you run
1586 "g.e2fsck_f" on the "device" before calling this
1587 command. For unknown reasons "resize2fs" sometimes gives
1588 an error about this and sometimes not. In any case, it
1589 is always safe to call "g.e2fsck_f" before calling this
1592 return libguestfsmod.resize2fs (self._o, device)
1594 def find (self, directory):
1595 u"""This command lists out all files and directories,
1596 recursively, starting at "directory". It is essentially
1597 equivalent to running the shell command "find directory
1598 -print" but some post-processing happens on the output,
1601 This returns a list of strings *without any prefix*.
1602 Thus if the directory structure was:
1608 then the returned list from "g.find" "/tmp" would be 4
1616 If "directory" is not a directory, then this command
1619 The returned list is sorted.
1621 This function returns a list of strings.
1623 return libguestfsmod.find (self._o, directory)
1625 def e2fsck_f (self, device):
1626 u"""This runs "e2fsck -p -f device", ie. runs the ext2/ext3
1627 filesystem checker on "device", noninteractively ("-p"),
1628 even if the filesystem appears to be clean ("-f").
1630 This command is only needed because of "g.resize2fs"
1631 (q.v.). Normally you should use "g.fsck".
1633 return libguestfsmod.e2fsck_f (self._o, device)
1635 def sleep (self, secs):
1636 u"""Sleep for "secs" seconds.
1638 return libguestfsmod.sleep (self._o, secs)
1640 def ntfs_3g_probe (self, rw, device):
1641 u"""This command runs the ntfs-3g.probe(8) command which
1642 probes an NTFS "device" for mountability. (Not all NTFS
1643 volumes can be mounted read-write, and some cannot be
1646 "rw" is a boolean flag. Set it to true if you want to
1647 test if the volume can be mounted read-write. Set it to
1648 false if you want to test if the volume can be mounted
1651 The return value is an integer which 0 if the operation
1652 would succeed, or some non-zero value documented in the
1653 ntfs-3g.probe(8) manual page.
1655 return libguestfsmod.ntfs_3g_probe (self._o, rw, device)
1657 def sh (self, command):
1658 u"""This call runs a command from the guest filesystem via
1659 the guest's "/bin/sh".
1661 This is like "g.command", but passes the command to:
1663 /bin/sh -c "command"
1665 Depending on the guest's shell, this usually results in
1666 wildcards being expanded, shell expressions being
1667 interpolated and so on.
1669 All the provisos about "g.command" apply to this call.
1671 return libguestfsmod.sh (self._o, command)
1673 def sh_lines (self, command):
1674 u"""This is the same as "g.sh", but splits the result into a
1677 See also: "g.command_lines"
1679 This function returns a list of strings.
1681 return libguestfsmod.sh_lines (self._o, command)
1683 def glob_expand (self, pattern):
1684 u"""This command searches for all the pathnames matching
1685 "pattern" according to the wildcard expansion rules used
1688 If no paths match, then this returns an empty list
1689 (note: not an error).
1691 It is just a wrapper around the C glob(3) function with
1692 flags "GLOB_MARK|GLOB_BRACE". See that manual page for
1695 This function returns a list of strings.
1697 return libguestfsmod.glob_expand (self._o, pattern)
1699 def scrub_device (self, device):
1700 u"""This command writes patterns over "device" to make data
1701 retrieval more difficult.
1703 It is an interface to the scrub(1) program. See that
1704 manual page for more details.
1706 This command is dangerous. Without careful use you can
1707 easily destroy all your data.
1709 return libguestfsmod.scrub_device (self._o, device)
1711 def scrub_file (self, file):
1712 u"""This command writes patterns over a file to make data
1713 retrieval more difficult.
1715 The file is *removed* after scrubbing.
1717 It is an interface to the scrub(1) program. See that
1718 manual page for more details.
1720 return libguestfsmod.scrub_file (self._o, file)
1722 def scrub_freespace (self, dir):
1723 u"""This command creates the directory "dir" and then fills
1724 it with files until the filesystem is full, and scrubs
1725 the files as for "g.scrub_file", and deletes them. The
1726 intention is to scrub any free space on the partition
1729 It is an interface to the scrub(1) program. See that
1730 manual page for more details.
1732 return libguestfsmod.scrub_freespace (self._o, dir)
1734 def mkdtemp (self, template):
1735 u"""This command creates a temporary directory. The
1736 "template" parameter should be a full pathname for the
1737 temporary directory name with the final six characters
1740 For example: "/tmp/myprogXXXXXX" or
1741 "/Temp/myprogXXXXXX", the second one being suitable for
1742 Windows filesystems.
1744 The name of the temporary directory that was created is
1747 The temporary directory is created with mode 0700 and is
1750 The caller is responsible for deleting the temporary
1751 directory and its contents after use.
1753 See also: mkdtemp(3)
1755 return libguestfsmod.mkdtemp (self._o, template)
1757 def wc_l (self, path):
1758 u"""This command counts the lines in a file, using the "wc
1759 -l" external command.
1761 return libguestfsmod.wc_l (self._o, path)
1763 def wc_w (self, path):
1764 u"""This command counts the words in a file, using the "wc
1765 -w" external command.
1767 return libguestfsmod.wc_w (self._o, path)
1769 def wc_c (self, path):
1770 u"""This command counts the characters in a file, using the
1771 "wc -c" external command.
1773 return libguestfsmod.wc_c (self._o, path)
1775 def head (self, path):
1776 u"""This command returns up to the first 10 lines of a file
1777 as a list of strings.
1779 This function returns a list of strings.
1781 Because of the message protocol, there is a transfer
1782 limit of somewhere between 2MB and 4MB. To transfer
1783 large files you should use FTP.
1785 return libguestfsmod.head (self._o, path)
1787 def head_n (self, nrlines, path):
1788 u"""If the parameter "nrlines" is a positive number, this
1789 returns the first "nrlines" lines of the file "path".
1791 If the parameter "nrlines" is a negative number, this
1792 returns lines from the file "path", excluding the last
1795 If the parameter "nrlines" is zero, this returns an
1798 This function returns a list of strings.
1800 Because of the message protocol, there is a transfer
1801 limit of somewhere between 2MB and 4MB. To transfer
1802 large files you should use FTP.
1804 return libguestfsmod.head_n (self._o, nrlines, path)
1806 def tail (self, path):
1807 u"""This command returns up to the last 10 lines of a file
1808 as a list of strings.
1810 This function returns a list of strings.
1812 Because of the message protocol, there is a transfer
1813 limit of somewhere between 2MB and 4MB. To transfer
1814 large files you should use FTP.
1816 return libguestfsmod.tail (self._o, path)
1818 def tail_n (self, nrlines, path):
1819 u"""If the parameter "nrlines" is a positive number, this
1820 returns the last "nrlines" lines of the file "path".
1822 If the parameter "nrlines" is a negative number, this
1823 returns lines from the file "path", starting with the
1826 If the parameter "nrlines" is zero, this returns an
1829 This function returns a list of strings.
1831 Because of the message protocol, there is a transfer
1832 limit of somewhere between 2MB and 4MB. To transfer
1833 large files you should use FTP.
1835 return libguestfsmod.tail_n (self._o, nrlines, path)
1838 u"""This command runs the "df" command to report disk space
1841 This command is mostly useful for interactive sessions.
1842 It is *not* intended that you try to parse the output
1843 string. Use "statvfs" from programs.
1845 return libguestfsmod.df (self._o)
1848 u"""This command runs the "df -h" command to report disk
1849 space used in human-readable format.
1851 This command is mostly useful for interactive sessions.
1852 It is *not* intended that you try to parse the output
1853 string. Use "statvfs" from programs.
1855 return libguestfsmod.df_h (self._o)
1857 def du (self, path):
1858 u"""This command runs the "du -s" command to estimate file
1859 space usage for "path".
1861 "path" can be a file or a directory. If "path" is a
1862 directory then the estimate includes the contents of the
1863 directory and all subdirectories (recursively).
1865 The result is the estimated size in *kilobytes* (ie.
1866 units of 1024 bytes).
1868 return libguestfsmod.du (self._o, path)
1870 def initrd_list (self, path):
1871 u"""This command lists out files contained in an initrd.
1873 The files are listed without any initial "/" character.
1874 The files are listed in the order they appear (not
1875 necessarily alphabetical). Directory names are listed as
1878 Old Linux kernels (2.4 and earlier) used a compressed
1879 ext2 filesystem as initrd. We *only* support the newer
1880 initramfs format (compressed cpio files).
1882 This function returns a list of strings.
1884 return libguestfsmod.initrd_list (self._o, path)
1886 def mount_loop (self, file, mountpoint):
1887 u"""This command lets you mount "file" (a filesystem image
1888 in a file) on a mount point. It is entirely equivalent
1889 to the command "mount -o loop file mountpoint".
1891 return libguestfsmod.mount_loop (self._o, file, mountpoint)
1893 def mkswap (self, device):
1894 u"""Create a swap partition on "device".
1896 return libguestfsmod.mkswap (self._o, device)
1898 def mkswap_L (self, label, device):
1899 u"""Create a swap partition on "device" with label "label".
1901 return libguestfsmod.mkswap_L (self._o, label, device)
1903 def mkswap_U (self, uuid, device):
1904 u"""Create a swap partition on "device" with UUID "uuid".
1906 return libguestfsmod.mkswap_U (self._o, uuid, device)
1908 def mknod (self, mode, devmajor, devminor, path):
1909 u"""This call creates block or character special devices, or
1910 named pipes (FIFOs).
1912 The "mode" parameter should be the mode, using the
1913 standard constants. "devmajor" and "devminor" are the
1914 device major and minor numbers, only used when creating
1915 block and character special devices.
1917 return libguestfsmod.mknod (self._o, mode, devmajor, devminor, path)
1919 def mkfifo (self, mode, path):
1920 u"""This call creates a FIFO (named pipe) called "path" with
1921 mode "mode". It is just a convenient wrapper around
1924 return libguestfsmod.mkfifo (self._o, mode, path)
1926 def mknod_b (self, mode, devmajor, devminor, path):
1927 u"""This call creates a block device node called "path" with
1928 mode "mode" and device major/minor "devmajor" and
1929 "devminor". It is just a convenient wrapper around
1932 return libguestfsmod.mknod_b (self._o, mode, devmajor, devminor, path)
1934 def mknod_c (self, mode, devmajor, devminor, path):
1935 u"""This call creates a char device node called "path" with
1936 mode "mode" and device major/minor "devmajor" and
1937 "devminor". It is just a convenient wrapper around
1940 return libguestfsmod.mknod_c (self._o, mode, devmajor, devminor, path)
1942 def umask (self, mask):
1943 u"""This function sets the mask used for creating new files
1944 and device nodes to "mask & 0777".
1946 Typical umask values would be 022 which creates new
1947 files with permissions like "-rw-r--r--" or
1948 "-rwxr-xr-x", and 002 which creates new files with
1949 permissions like "-rw-rw-r--" or "-rwxrwxr-x".
1951 The default umask is 022. This is important because it
1952 means that directories and device nodes will be created
1953 with 0644 or 0755 mode even if you specify 0777.
1955 See also umask(2), "g.mknod", "g.mkdir".
1957 This call returns the previous umask.
1959 return libguestfsmod.umask (self._o, mask)