1Sys::Virt(3)          User Contributed Perl Documentation         Sys::Virt(3)
2
3
4

NAME

6       Sys::Virt - Represent and manage a libvirt hypervisor connection
7

SYNOPSIS

9         my $conn = Sys::Virt->new(uri => $uri);
10
11         my @domains = $conn->list_domains();
12
13         foreach my $dom (@domains) {
14           print "Domain ", $dom->get_id, " ", $dom->get_name, "\n";
15         }
16

DESCRIPTION

18       The Sys::Virt module provides a Perl XS binding to the libvirt virtual
19       machine management APIs. This allows machines running within arbitrary
20       virtualization containers to be managed with a consistent API.
21

ERROR HANDLING

23       Any operations in the Sys::Virt API which have failure scenarios will
24       result in an instance of the Sys::Virt::Error module being thrown. To
25       catch these errors, simply wrap the method in an eval block:
26
27         eval { my $conn = Sys::Virt->new(uri => $uri); };
28         if ($@) {
29           print STDERR "Unable to open connection to $addr" . $@->message . "\n";
30         }
31
32       For details of the information contained in the error objects, consult
33       the Sys::Virt::Error manual page.
34

METHODS

36       my $conn = Sys::Virt->new(uri => $uri, readonly => $ro, flags =>
37       $flags);
38           Attach to the virtualization host identified by "uri". The "uri"
39           parameter may be omitted, in which case the default connection made
40           will be to the local Xen hypervisor. Some example URIs include:
41
42           xen:///
43               Xen on the local machine
44
45           test:///default
46               Dummy "in memory" driver for test suites
47
48           qemu:///system
49               System-wide driver for QEMU / KVM virtualization
50
51           qemu:///session
52               Per-user driver for QEMU virtualization
53
54           qemu+tls://somehost/system
55               System-wide QEMU driver on "somehost" using TLS security
56
57           xen+tcp://somehost/
58               Xen driver on "somehost" using TCP / SASL security
59
60           For further details consult "http://libvirt.org/uri.html"
61
62           If the optional "readonly" parameter is supplied, then an
63           unprivileged connection to the hypervisor will be attempted. If it
64           is not supplied, then it defaults to making a fully privileged
65           connection to the hypervisor. If the calling application is not
66           running as root, it may be necessary to provide authentication
67           callbacks.
68
69           If the optional "auth" parameter is set to a non-zero value,
70           authentication will be enabled during connection, using the default
71           set of credential gathering callbacks. The default callbacks prompt
72           for credentials on the console, so are not suitable for graphical
73           applications. For such apps a custom implementation should be
74           supplied. The "credlist" parameter should be an array reference
75           listing the set of credential types that will be supported. The
76           credential constants in this module can be used as values in this
77           list. The "callback" parameter should be a subroutine reference
78           containing the code necessary to gather the credentials. When
79           invoked it will be supplied with a single parameter, an array
80           reference of requested credentials. The elements of the array are
81           hash references, with keys "type" giving the type of credential,
82           "prompt" giving a user descriptive user prompt, "challenge" giving
83           name of the credential required. The answer should be collected
84           from the user, and returned by setting the "result" key. This key
85           may already be set with a default result if applicable
86
87           As a simple example returning hardcoded credentials
88
89               my $uri  = "qemu+tcp://192.168.122.1/system";
90               my $username = "test";
91               my $password = "123456";
92
93               my $con = Sys::Virt->new(uri => $uri,
94                                        auth => 1,
95                                        credlist => [
96                                          Sys::Virt::CRED_AUTHNAME,
97                                          Sys::Virt::CRED_PASSPHRASE,
98                                        ],
99                                        callback =>
100                    sub {
101                          my $creds = shift;
102
103                          foreach my $cred (@{$creds}) {
104                             if ($cred->{type} == Sys::Virt::CRED_AUTHNAME) {
105                                 $cred->{result} = $username;
106                             }
107                             if ($cred->{type} == Sys::Virt::CRED_PASSPHRASE) {
108                                 $cred->{result} = $password;
109                             }
110                          }
111                          return 0;
112                    });
113
114           For backwards compatibility with earlier releases, the "address"
115           parameter is accepted as a synonym for the "uri" parameter. The use
116           of "uri" is recommended for all newly written code.
117
118       my $st = $conn->new_stream($flags)
119           Create a new stream, with the given flags
120
121       my $dom = $conn->create_domain($xml, $flags);
122           Create a new domain based on the XML description passed into the
123           $xml parameter. The returned object is an instance of the
124           Sys::Virt::Domain class. This method is not available with
125           unprivileged connections to the hypervisor. The $flags parameter
126           accepts one of the DOMAIN CREATION constants documented in
127           Sys::Virt::Domain, and defaults to 0 if omitted.
128
129       my $dom = $conn->create_domain_with_files($xml, $fds, $flags);
130           Create a new domain based on the XML description passed into the
131           $xml parameter. The returned object is an instance of the
132           Sys::Virt::Domain class. This method is not available with
133           unprivileged connections to the hypervisor. The $fds parameter is
134           an array of UNIX file descriptors which will be passed to the init
135           process of the container. This is only supported with container
136           based virtualization. The $flags parameter accepts one of the
137           DOMAIN CREATION constants documented in Sys::Virt::Domain, and
138           defaults to 0 if omitted.
139
140       my $dom = $conn->define_domain($xml, $flags=0);
141           Defines, but does not start, a new domain based on the XML
142           description passed into the $xml parameter. The returned object is
143           an instance of the Sys::Virt::Domain class. This method is not
144           available with unprivileged connections to the hypervisor. The
145           defined domain can be later started by calling the "create" method
146           on the returned "Sys::Virt::Domain" object.
147
148       my $net = $conn->create_network($xml);
149           Create a new network based on the XML description passed into the
150           $xml parameter. The returned object is an instance of the
151           Sys::Virt::Network class. This method is not available with
152           unprivileged connections to the hypervisor.
153
154       my $net = $conn->define_network($xml);
155           Defines, but does not start, a new network based on the XML
156           description passed into the $xml parameter. The returned object is
157           an instance of the Sys::Virt::Network class. This method is not
158           available with unprivileged connections to the hypervisor. The
159           defined network can be later started by calling the "create" method
160           on the returned "Sys::Virt::Network" object.
161
162       my $nwfilter = $conn->define_nwfilter($xml);
163           Defines a new network filter based on the XML description passed
164           into the $xml parameter. The returned object is an instance of the
165           Sys::Virt::NWFilter class. This method is not available with
166           unprivileged connections to the hypervisor.
167
168       my $secret = $conn->define_secret($xml);
169           Defines a new secret based on the XML description passed into the
170           $xml parameter. The returned object is an instance of the
171           Sys::Virt::Secret class. This method is not available with
172           unprivileged connections to the hypervisor.
173
174       my $pool = $conn->create_storage_pool($xml);
175           Create a new storage pool based on the XML description passed into
176           the $xml parameter. The returned object is an instance of the
177           Sys::Virt::StoragePool class. This method is not available with
178           unprivileged connections to the hypervisor.
179
180       my $pool = $conn->define_storage_pool($xml);
181           Defines, but does not start, a new storage pol based on the XML
182           description passed into the $xml parameter. The returned object is
183           an instance of the Sys::Virt::StoragePool class. This method is not
184           available with unprivileged connections to the hypervisor. The
185           defined pool can be later started by calling the "create" method on
186           the returned "Sys::Virt::StoragePool" object.
187
188       my $pool = $conn->create_interface($xml);
189           Create a new interface based on the XML description passed into the
190           $xml parameter. The returned object is an instance of the
191           Sys::Virt::Interface class. This method is not available with
192           unprivileged connections to the hypervisor.
193
194       my $binding = $conn->create_nwfilter_binding($xml);
195           Create a new network filter binding based on the XML description
196           passed into the $xml parameter. The returned object is an instance
197           of the Sys::Virt::NWFilterBinding class.
198
199       my $iface = $conn->define_interface($xml);
200           Defines, but does not start, a new interface based on the XML
201           description passed into the $xml parameter. The returned object is
202           an instance of the Sys::Virt::Interface class. This method is not
203           available with unprivileged connections to the hypervisor. The
204           defined interface can be later started by calling the "create"
205           method on the returned "Sys::Virt::Interface" object.
206
207       my $dev = $conn->create_node_device($xml);
208           Create a new virtual node device based on the XML description
209           passed into the $xml parameter. The returned object is an instance
210           of the Sys::Virt::NodeDevice class. This method is not available
211           with unprivileged connections to the hypervisor.
212
213       my @doms = $conn->list_domains()
214           Return a list of all running domains currently known to the
215           hypervisor. The elements in the returned list are instances of the
216           Sys::Virt::Domain class. This method requires O(n) RPC calls, so
217           the "list_all_domains" method is recommended as a more efficient
218           alternative.
219
220       my $nids = $conn->num_of_domains()
221           Return the number of running domains known to the hypervisor. This
222           can be used as the "maxids" parameter to "list_domain_ids".
223
224       my @domIDs = $conn->list_domain_ids($maxids)
225           Return a list of all domain IDs currently known to the hypervisor.
226           The IDs can be used with the "get_domain_by_id" method.
227
228       my @doms = $conn->list_defined_domains()
229           Return a list of all domains defined, but not currently running, on
230           the hypervisor. The elements in the returned list are instances of
231           the Sys::Virt::Domain class. This method requires O(n) RPC calls,
232           so the "list_all_domains" method is recommended as a more efficient
233           alternative.
234
235       my $ndoms = $conn->num_of_defined_domains()
236           Return the number of running domains known to the hypervisor. This
237           can be used as the "maxnames" parameter to
238           "list_defined_domain_names".
239
240       my @names = $conn->list_defined_domain_names($maxnames)
241           Return a list of names of all domains defined, but not currently
242           running, on the hypervisor. The names can be used with the
243           "get_domain_by_name" method.
244
245       my @doms = $conn->list_all_domains($flags)
246           Return a list of all domains currently known to the hypervisor,
247           whether running or shutoff. The elements in the returned list are
248           instances of the Sys::Virt::Domain class. The $flags parameter can
249           be used to filter the list of returned domains.
250
251       my @nets = $conn->list_networks()
252           Return a list of all networks currently known to the hypervisor.
253           The elements in the returned list are instances of the
254           Sys::Virt::Network class.  This method requires O(n) RPC calls, so
255           the "list_all_networks" method is recommended as a more efficient
256           alternative.
257
258       my $nnets = $conn->num_of_networks()
259           Return the number of running networks known to the hypervisor. This
260           can be used as the "maxids" parameter to "list_network_ids".
261
262       my @netNames = $conn->list_network_names($maxnames)
263           Return a list of all network names currently known to the
264           hypervisor. The names can be used with the "get_network_by_name"
265           method.
266
267       my @nets = $conn->list_defined_networks()
268           Return a list of all networks defined, but not currently running,
269           on the hypervisor. The elements in the returned list are instances
270           of the Sys::Virt::Network class. This method requires O(n) RPC
271           calls, so the "list_all_networks" method is recommended as a more
272           efficient alternative.
273
274       my $nnets = $conn->num_of_defined_networks()
275           Return the number of running networks known to the host. This can
276           be used as the "maxnames" parameter to
277           "list_defined_network_names".
278
279       my @names = $conn->list_defined_network_names($maxnames)
280           Return a list of names of all networks defined, but not currently
281           running, on the host. The names can be used with the
282           "get_network_by_name" method.
283
284       my @nets = $conn->list_all_networks($flags)
285           Return a list of all networks currently known to the hypervisor,
286           whether running or shutoff. The elements in the returned list are
287           instances of the Sys::Virt::Network class. The $flags parameter can
288           be used to filter the list of returned networks.
289
290       my @pools = $conn->list_storage_pools()
291           Return a list of all storage pools currently known to the host. The
292           elements in the returned list are instances of the
293           Sys::Virt::StoragePool class.  This method requires O(n) RPC calls,
294           so the "list_all_storage_pools" method is recommended as a more
295           efficient alternative.
296
297       my $npools = $conn->num_of_storage_pools()
298           Return the number of running storage pools known to the hypervisor.
299           This can be used as the "maxids" parameter to
300           "list_storage_pool_names".
301
302       my @poolNames = $conn->list_storage_pool_names($maxnames)
303           Return a list of all storage pool names currently known to the
304           hypervisor. The IDs can be used with the "get_network_by_id"
305           method.
306
307       my @pools = $conn->list_defined_storage_pools()
308           Return a list of all storage pools defined, but not currently
309           running, on the host. The elements in the returned list are
310           instances of the Sys::Virt::StoragePool class. This method requires
311           O(n) RPC calls, so the "list_all_storage_pools" method is
312           recommended as a more efficient alternative.
313
314       my $npools = $conn->num_of_defined_storage_pools()
315           Return the number of running networks known to the host. This can
316           be used as the "maxnames" parameter to
317           "list_defined_storage_pool_names".
318
319       my @names = $conn->list_defined_storage_pool_names($maxnames)
320           Return a list of names of all storage pools defined, but not
321           currently running, on the host. The names can be used with the
322           "get_storage_pool_by_name" method.
323
324       my @pools = $conn->list_all_storage_pools($flags)
325           Return a list of all storage pools currently known to the
326           hypervisor, whether running or shutoff. The elements in the
327           returned list are instances of the Sys::Virt::StoragePool class.
328           The $flags parameter can be used to filter the list of returned
329           pools.
330
331       my @devs = $conn->list_node_devices($capability)
332           Return a list of all devices currently known to the host OS. The
333           elements in the returned list are instances of the
334           Sys::Virt::NodeDevice class.  The optional "capability" parameter
335           allows the list to be restricted to only devices with a particular
336           capability type. This method requires O(n) RPC calls, so the
337           "list_all_node_devices" method is recommended as a more efficient
338           alternative.
339
340       my $ndevs = $conn->num_of_node_devices($capability[, $flags])
341           Return the number of host devices known to the hypervisor. This can
342           be used as the "maxids" parameter to "list_node_device_names".  The
343           "capability" parameter allows the list to be restricted to only
344           devices with a particular capability type, and should be left as
345           "undef" if the full list is required. The optional <flags>
346           parameter is currently unused and defaults to 0 if omitted.
347
348       my @devNames = $conn->list_node_device_names($capability, $maxnames[,
349       $flags])
350           Return a list of all host device names currently known to the
351           hypervisor. The names can be used with the
352           "get_node_device_by_name" method.  The "capability" parameter
353           allows the list to be restricted to only devices with a particular
354           capability type, and should be left as "undef" if the full list is
355           required. The optional <flags> parameter is currently unused and
356           defaults to 0 if omitted.
357
358       my @devs = $conn->list_all_node_devices($flags)
359           Return a list of all node devices currently known to the
360           hypervisor. The elements in the returned list are instances of the
361           Sys::Virt::NodeDevice class. The $flags parameter can be used to
362           filter the list of returned devices.
363
364       my @ifaces = $conn->list_interfaces()
365           Return a list of all network interfaces currently known to the
366           hypervisor. The elements in the returned list are instances of the
367           Sys::Virt::Interface class.  This method requires O(n) RPC calls,
368           so the "list_all_interfaces" method is recommended as a more
369           efficient alternative.
370
371       my $nifaces = $conn->num_of_interfaces()
372           Return the number of running interfaces known to the hypervisor.
373           This can be used as the "maxnames" parameter to
374           "list_interface_names".
375
376       my @names = $conn->list_interface_names($maxnames)
377           Return a list of all interface names currently known to the
378           hypervisor. The names can be used with the "get_interface_by_name"
379           method.
380
381       my @ifaces = $conn->list_defined_interfaces()
382           Return a list of all network interfaces currently known to the
383           hypervisor. The elements in the returned list are instances of the
384           Sys::Virt::Interface class.  This method requires O(n) RPC calls,
385           so the "list_all_interfaces" method is recommended as a more
386           efficient alternative.
387
388       my $nifaces = $conn->num_of_defined_interfaces()
389           Return the number of inactive interfaces known to the hypervisor.
390           This can be used as the "maxnames" parameter to
391           "list_defined_interface_names".
392
393       my @names = $conn->list_defined_interface_names($maxnames)
394           Return a list of inactive interface names currently known to the
395           hypervisor. The names can be used with the "get_interface_by_name"
396           method.
397
398       my @ifaces = $conn->list_all_interfaces($flags)
399           Return a list of all interfaces currently known to the hypervisor,
400           whether running or shutoff. The elements in the returned list are
401           instances of the Sys::Virt::Interface class. The $flags parameter
402           can be used to filter the list of returned interfaces.
403
404       my @ifaces = $conn->list_secrets()
405           Return a list of all secrets currently known to the hypervisor. The
406           elements in the returned list are instances of the
407           Sys::Virt::Secret class.  This method requires O(n) RPC calls, so
408           the "list_all_secrets" method is recommended as a more efficient
409           alternative.
410
411       my $nuuids = $conn->num_of_secrets()
412           Return the number of secrets known to the hypervisor. This can be
413           used as the "maxuuids" parameter to "list_secrets".
414
415       my @uuids = $conn->list_secret_uuids($maxuuids)
416           Return a list of all secret uuids currently known to the
417           hypervisor. The uuids can be used with the "get_secret_by_uuid"
418           method.
419
420       my @secrets = $conn->list_all_secrets($flags)
421           Return a list of all secrets currently known to the hypervisor. The
422           elements in the returned list are instances of the
423           Sys::Virt::Network class.  The $flags parameter can be used to
424           filter the list of returned secrets.
425
426       my @nwfilters = $conn->list_nwfilters()
427           Return a list of all nwfilters currently known to the hypervisor.
428           The elements in the returned list are instances of the
429           Sys::Virt::NWFilter class.  This method requires O(n) RPC calls, so
430           the "list_all_nwfilters" method is recommended as a more efficient
431           alternative.
432
433       my $nnwfilters = $conn->num_of_nwfilters()
434           Return the number of running nwfilters known to the hypervisor.
435           This can be used as the "maxids" parameter to
436           "list_nwfilter_names".
437
438       my @filterNames = $conn->list_nwfilter_names($maxnames)
439           Return a list of all nwfilter names currently known to the
440           hypervisor. The names can be used with the "get_nwfilter_by_name"
441           method.
442
443       my @nwfilters = $conn->list_all_nwfilters($flags)
444           Return a list of all nwfilters currently known to the hypervisor.
445           The elements in the returned list are instances of the
446           Sys::Virt::NWFilter class.  The $flags parameter is currently
447           unused and defaults to zero.
448
449       my @bindings = $conn->list_all_nwfilter_bindings($flags)
450           Return a list of all nwfilter bindings currently known to the
451           hypervisor. The elements in the returned list are instances of the
452           Sys::Virt::NWFilterBinding class. The $flags parameter is currently
453           unused and defaults to zero.
454
455       $conn->define_save_image_xml($file, $dxml, $flags=0)
456           Update the XML associated with a virtual machine's save image. The
457           $file parameter is the fully qualified path to the save image XML,
458           while $dxml is the new XML document to write. The $flags parameter
459           is currently unused and defaults to zero.
460
461       $xml = $conn->get_save_image_xml_description($file, $flags=1)
462           Retrieve the current XML configuration associated with the virtual
463           machine's save image identified by $file. The $flags parameter is
464           currently unused and defaults to zero.
465
466       my $dom = $conn->get_domain_by_name($name)
467           Return the domain with a name of $name. The returned object is an
468           instance of the Sys::Virt::Domain class.
469
470       my $dom = $conn->get_domain_by_id($id)
471           Return the domain with a local id of $id. The returned object is an
472           instance of the Sys::Virt::Domain class.
473
474       my $dom = $conn->get_domain_by_uuid($uuid)
475           Return the domain with a globally unique id of $uuid. The returned
476           object is an instance of the Sys::Virt::Domain class.
477
478       my $net = $conn->get_network_by_name($name)
479           Return the network with a name of $name. The returned object is an
480           instance of the Sys::Virt::Network class.
481
482       my $net = $conn->get_network_by_uuid($uuid)
483           Return the network with a globally unique id of $uuid. The returned
484           object is an instance of the Sys::Virt::Network class.
485
486       my $pool = $conn->get_storage_pool_by_name($name)
487           Return the storage pool with a name of $name. The returned object
488           is an instance of the Sys::Virt::StoragePool class.
489
490       my $pool = $conn->get_storage_pool_by_uuid($uuid)
491           Return the storage pool with a globally unique id of $uuid. The
492           returned object is an instance of the Sys::Virt::StoragePool class.
493
494       my $pool = $conn->get_storage_pool_by_volume($vol)
495           Return the storage pool with a storage volume $vol. The $vol
496           parameter must be an instance of the Sys::Virt::StorageVol class.
497           The returned object is an instance of the Sys::Virt::StoragePool
498           class.
499
500       my $pool = $conn->get_storage_pool_by_target_path($path)
501           Return the storage pool with a target path of $path. The returned
502           object is an instance of the Sys::Virt::StoragePool class.
503
504       my $vol = $conn->get_storage_volume_by_path($path)
505           Return the storage volume with a location of $path. The returned
506           object is an instance of the Sys::Virt::StorageVol class.
507
508       my $vol = $conn->get_storage_volume_by_key($key)
509           Return the storage volume with a globally unique id of $key. The
510           returned object is an instance of the Sys::Virt::StorageVol class.
511
512       my $dev = $conn->get_node_device_by_name($name)
513           Return the node device with a name of $name. The returned object is
514           an instance of the Sys::Virt::NodeDevice class.
515
516       my $dev = $conn->get_node_device_scsihost_by_wwn($wwnn, $wwpn,
517       $flags=0)
518           Return the node device which is a SCSI host identified by $wwnn and
519           $wwpn.  The $flags parameter is unused and defaults to zero.  The
520           returned object is an instance of the Sys::Virt::NodeDevice class.
521
522       my $iface = $conn->get_interface_by_name($name)
523           Return the interface with a name of $name. The returned object is
524           an instance of the Sys::Virt::Interface class.
525
526       my $iface = $conn->get_interface_by_mac($mac)
527           Return the interface with a MAC address of $mac. The returned
528           object is an instance of the Sys::Virt::Interface class.
529
530       my $sec = $conn->get_secret_by_uuid($uuid)
531           Return the secret with a globally unique id of $uuid. The returned
532           object is an instance of the Sys::Virt::Secret class.
533
534       my $sec = $conn->get_secret_by_usage($usageType, $usageID)
535           Return the secret with a usage type of $usageType, identified by
536           $usageID. The returned object is an instance of the
537           Sys::Virt::Secret class.
538
539       my $nwfilter = $conn->get_nwfilter_by_name($name)
540           Return the domain with a name of $name. The returned object is an
541           instance of the Sys::Virt::NWFilter class.
542
543       my $nwfilter = $conn->get_nwfilter_by_uuid($uuid)
544           Return the nwfilter with a globally unique id of $uuid. The
545           returned object is an instance of the Sys::Virt::NWFilter class.
546
547       my $binding = $conn->get_nwfilter_binding_by_port_dev($name)
548           Return the network filter binding for the port device $name. The
549           returned object is an instance of the Sys::Virt::NWFilterBinding
550           class.
551
552       my $xml = $conn->find_storage_pool_sources($type, $srcspec[, $flags])
553           Probe for available storage pool sources for the pool of type
554           $type.  The $srcspec parameter can be "undef", or a parameter to
555           refine the discovery process, for example a server hostname for NFS
556           discovery. The $flags parameter is optional, and if omitted
557           defaults to zero. The returned scalar is an XML document describing
558           the discovered storage pool sources.
559
560       my @stats = $conn->get_all_domain_stats($stats, \@doms=undef,
561       $flags=0);
562           Get a list of all statistics for domains known to the hypervisor.
563           The $stats parameter controls which data fields to return and
564           should be a combination of the DOMAIN STATS FIELD CONSTANTS.
565
566           The optional @doms parameter is a list of Sys::Virt::Domain objects
567           to return stats for. If this is undefined, then all domains will be
568           returned. The $flags method can be used to filter the list of
569           returned domains.
570
571           The return data for the method is a list, one element for each
572           domain.  The element will be a hash with two keys, "dom" pointing
573           to an instance of "Sys::Virt::Domain" and "data" pointing to
574           another hash reference containing the actual statistics.
575
576       $conn->interface_change_begin($flags)
577           Begin a transaction for changing the configuration of one or more
578           network interfaces
579
580       $conn->interface_change_commit($flags)
581           Complete a transaction for changing the configuration of one or
582           more network interfaces
583
584       $conn->interface_change_rollback($flags)
585           Abort a transaction for changing the configuration of one or more
586           network interfaces
587
588       $conn->restore_domain($savefile)
589           Recreate a domain from the saved state file given in the $savefile
590           parameter.
591
592       $conn->get_max_vcpus($domtype)
593           Return the maximum number of vcpus that can be configured for a
594           domain of type $domtype
595
596       my $hostname = $conn->get_hostname()
597           Return the name of the host with which this connection is
598           associated.
599
600       my $uri = $conn->get_uri()
601           Return the URI associated with the open connection. This may be
602           different from the URI used when initially connecting to libvirt,
603           when 'auto-probing' or drivers occurrs.
604
605       my $xml = $conn->get_sysinfo()
606           Return an XML documenting representing the host system information,
607           typically obtained from SMBIOS tables.
608
609       my $type = $conn->get_type()
610           Return the type of virtualization backend accessed by this
611           hypervisor object. Currently the only supported type is "Xen".
612
613       my $xml = $conn->domain_xml_from_native($format, $config);
614           Convert the native hypervisor configuration $config which is in
615           format <$format> into libvirrt domain XML. Valid values of $format
616           vary between hypervisor drivers.
617
618       my $config = $conn->domain_xml_to_native($format, $xml)
619           Convert the libvirt domain XML configuration $xml to a native
620           hypervisor configuration in format $format
621
622       my $ver = $conn->get_version()
623           Return the complete version number as a string encoded in the
624           formula "(major * 1000000) + (minor * 1000) + micro".
625
626       my $ver = $conn->get_major_version
627           Return the major version number of the libvirt library.
628
629       my $ver = $conn->get_minor_version
630           Return the minor version number of the libvirt library.
631
632       my $ver = $conn->get_micro_version
633           Return the micro version number of the libvirt library.
634
635       my $ver = $conn->get_library_version
636           Return the version number of the API associated with the active
637           connection. This differs from "get_version" in that if the
638           connection is to a remote libvirtd daemon, it will return the API
639           version of the remote libvirt, rather than the local client.
640
641       $conn->is_secure()
642           Returns a true value if the current connection is secure against
643           network interception. This implies either use of UNIX sockets, or
644           encryption with a TCP stream.
645
646       $conn->is_encrypted()
647           Returns a true value if the current connection data stream is
648           encrypted.
649
650       $conn->is_alive()
651           Returns a true value if the connection is alive, as determined by
652           keep-alive packets or other recent RPC traffic.
653
654       $conn->set_keep_alive($interval, $count)
655           Change the operation of the keep alive protocol to send $count
656           packets spaced $interval seconds apart before considering the
657           connection dead.
658
659       my $info = $con->get_node_info()
660           Returns a hash reference summarising the capabilities of the host
661           node. The elements of the hash are as follows:
662
663           memory
664               The amount of physical memory in the host
665
666           model
667               The model of the CPU, eg x86_64
668
669           cpus
670               The total number of logical CPUs.
671
672           mhz The peak MHZ of the CPU
673
674           nodes
675               The number of NUMA cells
676
677           sockets
678               The number of CPU sockets
679
680           cores
681               The number of cores per socket
682
683           threads
684               The number of threads per core
685
686           NB, more accurate information about the total number of CPUs and
687           those online can be obtained using the "get_node_cpu_map" method.
688
689       my ($totcpus, $onlinemap, $totonline) = $con->get_node_cpu_map();
690           Returns an array containing information about the CPUs available on
691           the host. The first element, "totcpus", specifies the total number
692           of CPUs available to the host regardles of their online stat. The
693           second element, "onlinemap", provides a bitmap detailing which CPUs
694           are currently online. The third element, "totonline", specifies the
695           total number of online CPUs. The values in the bitmap can be
696           extracted using the "unpack" method as follows:
697
698             my @onlinemap = split(//, unpack("b*", $onlinemap));
699
700       my $info = $con->get_node_cpu_stats($cpuNum=-1, $flags=0)
701           Returns a hash reference providing information about the host CPU
702           statistics. If <$cpuNum> is omitted, it defaults to
703           "Sys::Virt::NODE_CPU_STATS_ALL_CPUS" which causes it to return
704           cumulative information for all CPUs in the host. If $cpuNum is zero
705           or larger, it returns information just for the specified number.
706           The $flags parameter is currently unused and defaults to zero. The
707           fields in the returned hash reference are
708
709           kernel
710               The time spent in kernelspace
711
712           user
713               The time spent in userspace
714
715           idle
716               The idle time
717
718           iowait
719               The I/O wait time
720
721           utilization
722               The overall percentage utilization.
723
724       my $info = $con->get_node_memory_stats($cellNum=-1, $flags=0)
725           Returns a hash reference providing information about the host
726           memory statistics. If <$cellNum> is omitted, it defaults to
727           "Sys::Virt::NODE_MEMORY_STATS_ALL_CELLS" which causes it to return
728           cumulative information for all NUMA cells in the host. If $cellNum
729           is zero or larger, it returns information just for the specified
730           number. The $flags parameter is currently unused and defaults to
731           zero. The fields in the returned hash reference are
732
733           total
734               The total memory
735
736           free
737               The free memory
738
739           buffers
740               The memory consumed by buffers
741
742           cached
743               The memory consumed for cache
744
745       my $params = $conn->get_node_memory_parameters($flags=0)
746           Return a hash reference containing the set of memory tunable
747           parameters for the node. The keys in the hash are one of the
748           constants MEMORY PARAMETERS described later. The $flags parameter
749           is currently unused, and defaults to 0 if omitted.
750
751       $conn->set_node_memory_parameters($params, $flags=0)
752           Update the memory tunable parameters for the node. The $params
753           should be a hash reference whose keys are one of the MEMORY
754           PARAMETERS constants. The $flags parameter is currently unused, and
755           defaults to 0 if omitted.
756
757       $info = $conn->get_node_sev_info($flags=0)
758           Get the AMD SEV information for the host. $flags is currently
759           unused and defaults to 0 if omitted. The returned hash contains the
760           following keys:
761
762           Sys::Virt::SEV_CBITPOS
763               The CBit position
764
765           Sys::Virt::SEV_CERT_CHAIN
766               The certificate chain
767
768           Sys::Virt::SEV_PDH
769               Platform diffie-hellman key
770
771           Sys::Virt::SEV_REDUCED_PHYS_BITS
772               The number of physical address bits used by SEV
773
774       $conn->node_suspend_for_duration($target, $duration, $flags=0)
775           Suspend the the host, using mode $target which is one of the NODE
776           SUSPEND constants listed later. The $duration parameter controls
777           how long the node is suspended for before waking up.
778
779       $conn->domain_event_register($callback)
780           Register a callback to received notifications of domain state
781           change events. Only a single callback can be registered with each
782           connection instance. The callback will be invoked with four
783           parameters, an instance of "Sys::Virt" for the connection, an
784           instance of "Sys::Virt::Domain" for the domain changing state, and
785           a "event" and "detail" arguments, corresponding to the event
786           constants defined in the "Sys::Virt::Domain" module. Before
787           discarding the connection object, the callback must be
788           deregistered, otherwise the connection object memory will never be
789           released in garbage collection.
790
791       $conn->domain_event_deregister()
792           Unregister a callback, allowing the connection object to be garbage
793           collected.
794
795       $callback = $conn->domain_event_register_any($dom, $eventID, $callback)
796           Register a callback to received notifications of domain events.
797           The $dom parameter can be "undef" to request events on all known
798           domains, or a specific "Sys::Virt::Domain" object to filter events.
799           The $eventID parameter is one of the EVENT ID constants described
800           later in this document. The $callback is a subroutine reference
801           that will receive the events.
802
803           All callbacks receive a "Sys::Virt" connection as the first
804           parameter and a "Sys::Virt::Domain" object indicating the domain on
805           which the event occurred as the second parameter. Subsequent
806           parameters vary according to the event type
807
808           EVENT_ID_LIFECYCLE
809               Extra "event" and "detail" parameters defining the lifecycle
810               transition that occurred.
811
812           EVENT_ID_REBOOT
813               No extra parameters
814
815           EVENT_ID_RTC_CHANGE
816               The "utcoffset" gives the offset from UTC in seconds
817
818           EVENT_ID_WATCHDOG
819               The "action" defines the action that is taken as a result of
820               the watchdog triggering. One of the WATCHDOG constants
821               described later
822
823           EVENT_ID_IO_ERROR
824               The "srcPath" is the file on the host which had the error.  The
825               "devAlias" is the unique device alias from the guest
826               configuration associated with "srcPath". The "action" is the
827               action taken as a result of the error, one of the IO ERROR
828               constants described later
829
830           EVENT_ID_GRAPHICS
831               The "phase" is the stage of the connection, one of the GRAPHICS
832               PHASE constants described later. The "local" and "remote"
833               parameters follow with the details of the local and remote
834               network addresses. The "authScheme" describes how the user was
835               authenticated (if at all). Finally "identities" is an array ref
836               containing authenticated identities for the user, if any.
837
838           The return value is a unique callback ID that must be used when
839           unregistering the event.
840
841       $conn->domain_event_deregister_any($callbackID)
842           Unregister a callback, associated with the $callbackID previously
843           obtained from "domain_event_register_any".
844
845       $callback = $conn->network_event_register_any($net, $eventID,
846       $callback)
847           Register a callback to received notifications of network events.
848           The $net parameter can be "undef" to request events on all known
849           networks, or a specific "Sys::Virt::Network" object to filter
850           events. The $eventID parameter is one of the EVENT ID constants
851           described later in this document. The $callback is a subroutine
852           reference that will receive the events.
853
854           All callbacks receive a "Sys::Virt" connection as the first
855           parameter and a "Sys::Virt::Network" object indicating the network
856           on which the event occurred as the second parameter. Subsequent
857           parameters vary according to the event type
858
859           EVENT_ID_LIFECYCLE
860               Extra "event" and "detail" parameters defining the lifecycle
861               transition that occurred.
862
863           The return value is a unique callback ID that must be used when
864           unregistering the event.
865
866       $conn->network_event_deregister_any($callbackID)
867           Unregister a callback, associated with the $callbackID previously
868           obtained from "network_event_register_any".
869
870       $callback = $conn->storage_pool_event_register_any($pool, $eventID,
871       $callback)
872           Register a callback to received notifications of storage pool
873           events.  The $pool parameter can be "undef" to request events on
874           all known storage pools, or a specific "Sys::Virt::StoragePool"
875           object to filter events. The $eventID parameter is one of the EVENT
876           ID constants described later in this document. The $callback is a
877           subroutine reference that will receive the events.
878
879           All callbacks receive a "Sys::Virt" connection as the first
880           parameter and a "Sys::Virt::StoragePool" object indicating the
881           storage pool on which the event occurred as the second parameter.
882           Subsequent parameters vary according to the event type
883
884           EVENT_ID_LIFECYCLE
885               Extra "event" and "detail" parameters defining the lifecycle
886               transition that occurred.
887
888           EVENT_ID_REFRESH
889               No extra parameters.
890
891           The return value is a unique callback ID that must be used when
892           unregistering the event.
893
894       $conn->storage_pool_event_deregister_any($callbackID)
895           Unregister a callback, associated with the $callbackID previously
896           obtained from "storage_pool_event_register_any".
897
898       $callback = $conn->node_device_event_register_any($dev, $eventID,
899       $callback)
900           Register a callback to received notifications of node device
901           events.  The $dev parameter can be "undef" to request events on all
902           known node devices, or a specific "Sys::Virt::NodeDevice" object to
903           filter events. The $eventID parameter is one of the EVENT ID
904           constants described later in this document. The $callback is a
905           subroutine reference that will receive the events.
906
907           All callbacks receive a "Sys::Virt" connection as the first
908           parameter and a "Sys::Virt::NodeDevice" object indicating the node
909           device on which the event occurred as the second parameter.
910           Subsequent parameters vary according to the event type
911
912           EVENT_ID_LIFECYCLE
913               Extra "event" and "detail" parameters defining the lifecycle
914               transition that occurred.
915
916           The return value is a unique callback ID that must be used when
917           unregistering the event.
918
919       $conn->node_device_event_deregister_any($callbackID)
920           Unregister a callback, associated with the $callbackID previously
921           obtained from "node_device_event_register_any".
922
923       $callback = $conn->secret_event_register_any($secret, $eventID,
924       $callback)
925           Register a callback to received notifications of secret events.
926           The $secret parameter can be "undef" to request events on all known
927           secrets, or a specific "Sys::Virt::Secret" object to filter events.
928           The $eventID parameter is one of the EVENT ID constants described
929           later in this document. The $callback is a subroutine reference
930           that will receive the events.
931
932           All callbacks receive a "Sys::Virt" connection as the first
933           parameter and a "Sys::Virt::Secret" object indicating the secret on
934           which the event occurred as the second parameter. Subsequent
935           parameters vary according to the event type
936
937           EVENT_ID_LIFECYCLE
938               Extra "event" and "detail" parameters defining the lifecycle
939               transition that occurred.
940
941           EVENT_ID_VALUE_CHANGED
942               No extra parameters.
943
944           The return value is a unique callback ID that must be used when
945           unregistering the event.
946
947       $conn->secret_event_deregister_any($callbackID)
948           Unregister a callback, associated with the $callbackID previously
949           obtained from "secret_event_register_any".
950
951       $conn->register_close_callback($coderef);
952           Register a callback to be invoked when the connection is closed.
953           The callback will be invoked with two parameters, the $conn it was
954           registered against, and the reason for the close event.  The reason
955           value will be one of the "CLOSE REASON CONSTANTS" listed later in
956           this document.
957
958       $conn->unregister_close_callback();
959           Remove the previously registered close callback.
960
961       my $xml = $con->baseline_cpu(\@xml, $flags=0)
962           Given an array ref whose elements are XML documents describing host
963           CPUs, compute the baseline CPU model that is operable across all
964           hosts. The XML for the baseline CPU model is returned. The optional
965           $flags parameter can take one of
966
967           Sys::Virt::BASELINE_CPU_EXPAND_FEATURES
968               Expand the CPU definition to list all feature flags, even those
969               implied by the model name.
970
971           Sys::Virt::BASELINE_CPU_MIGRATABLE
972               Only include features which can be live migrated.
973
974       my $xml = $con->baseline_hypervisor_cpu($emulator, $arch, $machine,
975       $virttype, \@xml, $flags=0)
976           Given an array ref whose elements are XML documents describing host
977           CPUs, compute the baseline CPU model that is operable across all
978           hosts. The XML for the baseline CPU model is returned. Either
979           $emulator or $arch must be a valid string referring to an emulator
980           binary or an architecture name respectively. The $machine parameter
981           is an optional name of a guest machine, and $virttype is an
982           optional name of the virtualization type. The optional $flags
983           parameter accepts the same values as "baseline_cpu".
984
985       @names = $con->get_cpu_model_names($arch, $flags=0)
986           Get a list of valid CPU models names for the architecture given by
987           $arch. The $arch value should be one of the architectures listed in
988           the capabilities XML document.  The $flags parameter is currently
989           unused and defaults to 0.
990
991       my $info = $con->get_node_security_model()
992           Returns a hash reference summarising the security model of the host
993           node. There are two keys in the hash, "model" specifying the name
994           of the security model (eg 'selinux') and "doi" specifying the
995           'domain of interpretation' for security labels.
996
997       my $xml = $con->get_capabilities();
998           Returns an XML document describing the hypervisor capabilities
999
1000       my $xml = $con->get_domain_capabilities($emulator, $arch, $machine,
1001       $virttype, flags=0);
1002           Returns an XML document describing the capabilities of the
1003           requested guest configuration. Either $emulator or $arch must be a
1004           valid string referring to an emulator binary or an architecture
1005           name respectively. The $machine parameter is an optional name of a
1006           guest machine, and $virttype is an optional name of the
1007           virtualization type. $flags is unused and defaults to zero.
1008
1009       my $result = $con->compare_cpu($xml, $flags=0);
1010           Checks whether the CPU definition in $xml is compatible with the
1011           current hypervisor connection. This can be used to determine
1012           whether it is safe to migrate a guest to this host. The returned
1013           result is one of the constants listed later The optional $flags
1014           parameter can take one of the following constants
1015
1016           Sys::Virt::COMPARE_CPU_FAIL_INCOMPATIBLE
1017               Raise a fatal error if the CPUs are not compatible, instead of
1018               just returning a special error code.
1019
1020       my $result = $con->compare_hypervisor_cpu($emulator, $arch, $machine,
1021       $virttype, $xml, $flags=0);
1022           Checks whether the CPU definition in $xml is compatible with the
1023           current hypervisor connection. This can be used to determine
1024           whether it is safe to migrate a guest to this host. Either
1025           $emulator or $arch must be a valid string referring to an emulator
1026           binary or an architecture name respectively. The $machine parameter
1027           is an optional name of a guest machine, and $virttype is an
1028           optional name of the virtualization type. The returned result is
1029           one of the constants listed later The optional $flags parameter can
1030           take the same values as the "compare_cpu" method.
1031
1032       $mem = $con->get_node_free_memory();
1033           Returns the current free memory on the host
1034
1035       @mem = $con->get_node_cells_free_memory($start, $end);
1036           Returns the free memory on each NUMA cell between $start and $end.
1037
1038       @pages = $con->get_node_free_pages(\@pagesizes, $start, $end);
1039           Returns information about the number of pages free on each NUMA
1040           cell between $start and $end inclusive. The @pagesizes parameter
1041           should be an arrayref specifying which pages sizes information
1042           should be returned for. Information about supported page sizes is
1043           available in the capabilities XML. The returned array has an
1044           element for each NUMA cell requested. The elements are hash
1045           references with two keys, 'cell' specifies the NUMA cell number and
1046           'pages' specifies the free page information for that cell. The
1047           'pages' value is another hash reference where the keys are the page
1048           sizes and the values are the free count for that size.
1049
1050       $con->node_alloc_pages(\@pages, $start, $end, $flags=0)
1051           Allocate further huge pages for the reserved dev. The <\@pages>
1052           parameter is an array reference with one entry per page size to
1053           allocate for. Each entry is a further array reference where the
1054           first element is the page size and the second element is the page
1055           count. The same number of pages will be allocated on each NUMA node
1056           in the range $start to $end inclusive. The $flags parameter accepts
1057           two contants
1058
1059           Sys::Virt::NODE_ALLOC_PAGES_ADD
1060               The requested number of pages will be added to the existing
1061               huge page reservation.
1062
1063           Sys::Virt::NODE_ALLOC_PAGES_SET
1064               The huge page reservation will be set to exactly the requested
1065               number
1066

CONSTANTS

1068       The following sets of constants are useful when dealing with APIs in
1069       this package
1070
1071   CONNECTION
1072       When opening a connection the following constants can be used:
1073
1074       Sys::Virt::CONNECT_RO
1075           Request a read-only connection
1076
1077       Sys::Virt::CONNECT_NO_ALIASES
1078           Prevent the resolution of URI aliases
1079
1080   CREDENTIAL TYPES
1081       When providing authentication callbacks, the following constants
1082       indicate the type of credential being requested
1083
1084       Sys::Virt::CRED_AUTHNAME
1085           Identity to act as
1086
1087       Sys::Virt::CRED_USERNAME
1088           Identity to authorize as
1089
1090       Sys::Virt::CRED_CNONCE
1091           Client supplies a nonce
1092
1093       Sys::Virt::CRED_REALM
1094           Authentication realm
1095
1096       Sys::Virt::CRED_ECHOPROMPT
1097           Challenge response non-secret
1098
1099       Sys::Virt::CRED_NOECHOPROMPT
1100           Challenge response secret
1101
1102       Sys::Virt::CRED_PASSPHRASE
1103           Passphrase secret
1104
1105       Sys::Virt::CRED_LANGUAGE
1106           RFC 1766 language code
1107
1108       Sys::Virt::CRED_EXTERNAL
1109           Externally provided credential
1110
1111   CPU COMPARISON CONSTANTS
1112       Sys::Virt::CPU_COMPARE_INCOMPATIBLE
1113           This host is missing one or more CPU features in the CPU
1114           description
1115
1116       Sys::Virt::CPU_COMPARE_IDENTICAL
1117           The host has an identical CPU description
1118
1119       Sys::Virt::CPU_COMPARE_SUPERSET
1120           The host offers a superset of the CPU descriptoon
1121
1122   NODE SUSPEND CONSTANTS
1123       Sys::Virt::NODE_SUSPEND_TARGET_MEM
1124           Suspends to memory (equivalent of S3 on x86 architectures)
1125
1126       Sys::Virt::NODE_SUSPEND_TARGET_DISK
1127           Suspends to disk (equivalent of S5 on x86 architectures)
1128
1129       Sys::Virt::NODE_SUSPEND_TARGET_HYBRID
1130           Suspends to memory and disk (equivalent of S3+S5 on x86
1131           architectures)
1132
1133   NODE VCPU CONSTANTS
1134       Sys::Virt::NODE_CPU_STATS_ALL_CPUS
1135           Request statistics for all CPUs
1136
1137   NODE MEMORY CONSTANTS
1138       Sys::Virt::NODE_MEMORY_STATS_ALL_CELLS
1139           Request statistics for all memory cells
1140
1141   MEMORY PARAMETERS
1142       The following constants are used to name memory parameters of the node
1143
1144       Sys::Virt::NODE_MEMORY_SHARED_FULL_SCANS
1145           How many times all mergeable areas have been scanned.
1146
1147       Sys::Virt::NODE_MEMORY_SHARED_PAGES_SHARED
1148           How many the shared memory pages are being used.
1149
1150       Sys::Virt::NODE_MEMORY_SHARED_PAGES_SHARING
1151           How many sites are sharing the pages
1152
1153       Sys::Virt::NODE_MEMORY_SHARED_PAGES_TO_SCAN
1154           How many present pages to scan before the shared memory service
1155           goes to sleep
1156
1157       Sys::Virt::NODE_MEMORY_SHARED_PAGES_UNSHARED
1158           How many pages unique but repeatedly checked for merging.
1159
1160       Sys::Virt::NODE_MEMORY_SHARED_PAGES_VOLATILE
1161           How many pages changing too fast to be placed in a tree.
1162
1163       Sys::Virt::NODE_MEMORY_SHARED_SLEEP_MILLISECS
1164           How many milliseconds the shared memory service should sleep before
1165           next scan.
1166
1167       Sys::Virt::NODE_MEMORY_SHARED_MERGE_ACROSS_NODES
1168           Whether pages can be merged across NUMA nodes
1169
1170   CLOSE REASON CONSTANTS
1171       The following constants related to the connection close callback,
1172       describe the reason for the closing of the connection.
1173
1174       Sys::Virt::CLOSE_REASON_CLIENT
1175           The client application requested the connection be closed
1176
1177       Sys::Virt::CLOSE_REASON_EOF
1178           End-of-file was encountered reading data from the connection
1179
1180       Sys::Virt::CLOSE_REASON_ERROR
1181           An I/O error was encountered reading/writing data from/to the
1182           connection
1183
1184       Sys::Virt::CLOSE_REASON_KEEPALIVE
1185           The connection keepalive timer triggered due to lack of response
1186           from the server
1187
1188   CPU STATS CONSTANTS
1189       The following constants provide the names of known CPU stats fields
1190
1191       Sys::Virt::NODE_CPU_STATS_IDLE
1192           Time spent idle
1193
1194       Sys::Virt::NODE_CPU_STATS_IOWAIT
1195           Time spent waiting for I/O to complete
1196
1197       Sys::Virt::NODE_CPU_STATS_KERNEL
1198           Time spent executing kernel code
1199
1200       Sys::Virt::NODE_CPU_STATS_USER
1201           Time spent executing user code
1202
1203       Sys::Virt::NODE_CPU_STATS_INTR
1204           Time spent processing interrupts
1205
1206       Sys::Virt::NODE_CPU_STATS_UTILIZATION
1207           Percentage utilization of the CPU.
1208
1209   MEMORY STAS CONSTANTS
1210       The following constants provide the names of known memory stats fields
1211
1212       Sys::Virt::NODE_MEMORY_STATS_BUFFERS
1213           The amount of memory consumed by I/O buffers
1214
1215       Sys::Virt::NODE_MEMORY_STATS_CACHED
1216           The amount of memory consumed by disk cache
1217
1218       Sys::Virt::NODE_MEMORY_STATS_FREE
1219           The amount of free memory
1220
1221       Sys::Virt::NODE_MEMORY_STATS_TOTAL
1222           The total amount of memory
1223
1224   IP address constants
1225       The following constants are used to interpret IP address types
1226
1227       Sys::Virt::IP_ADDR_TYPE_IPV4
1228           An IPv4 address type
1229
1230       Sys::Virt::IP_ADDR_TYPE_IPV6
1231           An IPv6 address type
1232

BUGS

1234       Hopefully none, but the XS code needs to be audited to ensure it is not
1235       leaking memory.
1236

AUTHORS

1238       Daniel P. Berrange <berrange@redhat.com>
1239
1241       Copyright (C) 2006-2009 Red Hat Copyright (C) 2006-2009 Daniel P.
1242       Berrange
1243

LICENSE

1245       This program is free software; you can redistribute it and/or modify it
1246       under the terms of either the GNU General Public License as published
1247       by the Free Software Foundation (either version 2 of the License, or at
1248       your option any later version), or, the Artistic License, as specified
1249       in the Perl README file.
1250

SEE ALSO

1252       Sys::Virt::Domain, Sys::Virt::Network, Sys::Virt::StoragePool,
1253       Sys::Virt::StorageVol, Sys::Virt::Error, "http://libvirt.org"
1254
1255
1256
1257perl v5.28.0                      2018-09-04                      Sys::Virt(3)
Impressum