1Sys::Virt(3) User Contributed Perl Documentation Sys::Virt(3)
2
6 Sys::Virt - Represent and manage a libvirt hypervisor connection
7
9 my $conn = Sys::Virt->new(uri => $uri);
10 my @domains = $conn->list_domains();
12 foreach my $dom (@domains) {
14 print "Domain ", $dom->get_id, " ", $dom->get_name, "\n";
15 }
16
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
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 eval { my $conn = Sys::Virt->new(uri => $uri); };
28 if ($@) {
29 print STDERR "Unable to open connection to $addr" . $@->message . "\n";
30 }
31 For details of the information contained in the error objects, consult
33 the Sys::Virt::Error manual page.
34
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 xen:///
43 Xen on the local machine
44 test:///default
46 Dummy "in memory" driver for test suites
47 qemu:///system
49 System-wide driver for QEMU / KVM virtualization
50 qemu:///session
52 Per-user driver for QEMU virtualization
53 qemu+tls://somehost/system
55 System-wide QEMU driver on "somehost" using TLS security
56 xen+tcp://somehost/
58 Xen driver on "somehost" using TCP / SASL security
59 For further details consult "http://libvirt.org/uri.html"
61 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 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 As a simple example returning hardcoded credentials
88 my $uri = "qemu+tcp://192.168.122.1/system";
90 my $username = "test";
91 my $password = "123456";
92 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 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 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 $conn->set_identity($identity, $flags=0)
119 Change the identity that is used for access control over the
120 connection. Normally the remote daemon will use the identity
121 associated with the UNIX domain socket that the app opens. Only a
122 privileged client is usually able to override this. The $identity
123 should be a hash reference whose keys are one of the IDENTITY
124 constants. The $flags parameter is currently unused, and defaults
125 to 0 if omitted.
126 my $st = $conn->new_stream($flags)
128 Create a new stream, with the given flags
129 my $dom = $conn->create_domain($xml, $flags);
131 Create a new domain based on the XML description passed into the
132 $xml parameter. The returned object is an instance of the
133 Sys::Virt::Domain class. This method is not available with
134 unprivileged connections to the hypervisor. The $flags parameter
135 accepts one of the DOMAIN CREATION constants documented in
136 Sys::Virt::Domain, and defaults to 0 if omitted.
137 my $dom = $conn->create_domain_with_files($xml, $fds, $flags);
139 Create a new domain based on the XML description passed into the
140 $xml parameter. The returned object is an instance of the
141 Sys::Virt::Domain class. This method is not available with
142 unprivileged connections to the hypervisor. The $fds parameter is
143 an array of UNIX file descriptors which will be passed to the init
144 process of the container. This is only supported with container
145 based virtualization. The $flags parameter accepts one of the
146 DOMAIN CREATION constants documented in Sys::Virt::Domain, and
147 defaults to 0 if omitted.
148 my $dom = $conn->define_domain($xml, $flags=0);
150 Defines, but does not start, a new domain based on the XML
151 description passed into the $xml parameter. The returned object is
152 an instance of the Sys::Virt::Domain class. This method is not
153 available with unprivileged connections to the hypervisor. The
154 defined domain can be later started by calling the "create" method
155 on the returned "Sys::Virt::Domain" object.
156 my $net = $conn->create_network($xml, $flags=0);
158 Create a new network based on the XML description passed into the
159 $xml parameter. The returned object is an instance of the
160 Sys::Virt::Network class. This method is not available with
161 unprivileged connections to the hypervisor.
162 my $net = $conn->define_network($xml, $flags = 0);
164 Defines, but does not start, a new network based on the XML
165 description passed into the $xml parameter. The returned object is
166 an instance of the Sys::Virt::Network class. This method is not
167 available with unprivileged connections to the hypervisor. The
168 defined network can be later started by calling the "create" method
169 on the returned "Sys::Virt::Network" object.
170 my $nwfilter = $conn->define_nwfilter($xml, $flags=0);
172 Defines a new network filter based on the XML description passed
173 into the $xml parameter. The returned object is an instance of the
174 Sys::Virt::NWFilter class. This method is not available with
175 unprivileged connections to the hypervisor.
176 my $secret = $conn->define_secret($xml, $flags=0);
178 Defines a new secret based on the XML description passed into the
179 $xml parameter. The returned object is an instance of the
180 Sys::Virt::Secret class. This method is not available with
181 unprivileged connections to the hypervisor.
182 my $pool = $conn->create_storage_pool($xml);
184 Create a new storage pool based on the XML description passed into
185 the $xml parameter. The returned object is an instance of the
186 Sys::Virt::StoragePool class. This method is not available with
187 unprivileged connections to the hypervisor.
188 my $pool = $conn->define_storage_pool($xml, $flags=0);
190 Defines, but does not start, a new storage pol based on the XML
191 description passed into the $xml parameter. The returned object is
192 an instance of the Sys::Virt::StoragePool class. This method is not
193 available with unprivileged connections to the hypervisor. The
194 defined pool can be later started by calling the "create" method on
195 the returned "Sys::Virt::StoragePool" object.
196 my $pool = $conn->create_interface($xml);
198 Create a new interface based on the XML description passed into the
199 $xml parameter. The returned object is an instance of the
200 Sys::Virt::Interface class. This method is not available with
201 unprivileged connections to the hypervisor.
202 my $binding = $conn->create_nwfilter_binding($xml, $flags=0);
204 Create a new network filter binding based on the XML description
205 passed into the $xml parameter. The returned object is an instance
206 of the Sys::Virt::NWFilterBinding class.
207 my $iface = $conn->define_interface($xml, $flags=0);
209 Defines, but does not start, a new interface based on the XML
210 description passed into the $xml parameter. The returned object is
211 an instance of the Sys::Virt::Interface class. This method is not
212 available with unprivileged connections to the hypervisor. The
213 defined interface can be later started by calling the "create"
214 method on the returned "Sys::Virt::Interface" object.
215 my $dev = $conn->create_node_device($xml, $flags=0);
217 Create a new virtual node device based on the XML description
218 passed into the $xml parameter. The $flags parameter is currently
219 unused and defaults to zero. The returned object is an instance of
220 the Sys::Virt::NodeDevice class. This method is not available with
221 unprivileged connections to the hypervisor.
222 my $dev = $conn->define_node_device($xml, $flags=0);
224 Defines, but does not start, a new node dev based on the XML
225 description passed into the $xml parameter. The $flags parameter is
226 currently unused and defaults to zero. The returned object is an
227 instance of the Sys::Virt::NodeDevice class. This method is not
228 available with unprivileged connections to the hypervisor. The
229 defined node device can be later started by calling the "create"
230 method on the returned "Sys::Virt::NodeDevice" object.
231 my @doms = $conn->list_domains()
233 Return a list of all running domains currently known to the
234 hypervisor. The elements in the returned list are instances of the
235 Sys::Virt::Domain class. This method requires O(n) RPC calls, so
236 the "list_all_domains" method is recommended as a more efficient
237 alternative.
238 my $nids = $conn->num_of_domains()
240 Return the number of running domains known to the hypervisor. This
241 can be used as the "maxids" parameter to "list_domain_ids".
242 my @domIDs = $conn->list_domain_ids($maxids)
244 Return a list of all domain IDs currently known to the hypervisor.
245 The IDs can be used with the "get_domain_by_id" method.
246 my @doms = $conn->list_defined_domains()
248 Return a list of all domains defined, but not currently running, on
249 the hypervisor. The elements in the returned list are instances of
250 the Sys::Virt::Domain class. This method requires O(n) RPC calls,
251 so the "list_all_domains" method is recommended as a more efficient
252 alternative.
253 my $ndoms = $conn->num_of_defined_domains()
255 Return the number of running domains known to the hypervisor. This
256 can be used as the "maxnames" parameter to
257 "list_defined_domain_names".
258 my @names = $conn->list_defined_domain_names($maxnames)
260 Return a list of names of all domains defined, but not currently
261 running, on the hypervisor. The names can be used with the
262 "get_domain_by_name" method.
263 my @doms = $conn->list_all_domains($flags)
265 Return a list of all domains currently known to the hypervisor,
266 whether running or shutoff. The elements in the returned list are
267 instances of the Sys::Virt::Domain class. The $flags parameter can
268 be used to filter the list of returned domains.
269 my @nets = $conn->list_networks()
271 Return a list of all networks currently known to the hypervisor.
272 The elements in the returned list are instances of the
273 Sys::Virt::Network class. This method requires O(n) RPC calls, so
274 the "list_all_networks" method is recommended as a more efficient
275 alternative.
276 my $nnets = $conn->num_of_networks()
278 Return the number of running networks known to the hypervisor. This
279 can be used as the "maxids" parameter to "list_network_ids".
280 my @netNames = $conn->list_network_names($maxnames)
282 Return a list of all network names currently known to the
283 hypervisor. The names can be used with the "get_network_by_name"
284 method.
285 my @nets = $conn->list_defined_networks()
287 Return a list of all networks defined, but not currently running,
288 on the hypervisor. The elements in the returned list are instances
289 of the Sys::Virt::Network class. This method requires O(n) RPC
290 calls, so the "list_all_networks" method is recommended as a more
291 efficient alternative.
292 my $nnets = $conn->num_of_defined_networks()
294 Return the number of running networks known to the host. This can
295 be used as the "maxnames" parameter to
296 "list_defined_network_names".
297 my @names = $conn->list_defined_network_names($maxnames)
299 Return a list of names of all networks defined, but not currently
300 running, on the host. The names can be used with the
301 "get_network_by_name" method.
302 my @nets = $conn->list_all_networks($flags)
304 Return a list of all networks currently known to the hypervisor,
305 whether running or shutoff. The elements in the returned list are
306 instances of the Sys::Virt::Network class. The $flags parameter can
307 be used to filter the list of returned networks.
308 my @pools = $conn->list_storage_pools()
310 Return a list of all storage pools currently known to the host. The
311 elements in the returned list are instances of the
312 Sys::Virt::StoragePool class. This method requires O(n) RPC calls,
313 so the "list_all_storage_pools" method is recommended as a more
314 efficient alternative.
315 my $npools = $conn->num_of_storage_pools()
317 Return the number of running storage pools known to the hypervisor.
318 This can be used as the "maxids" parameter to
319 "list_storage_pool_names".
320 my @poolNames = $conn->list_storage_pool_names($maxnames)
322 Return a list of all storage pool names currently known to the
323 hypervisor. The IDs can be used with the "get_network_by_id"
324 method.
325 my @pools = $conn->list_defined_storage_pools()
327 Return a list of all storage pools defined, but not currently
328 running, on the host. The elements in the returned list are
329 instances of the Sys::Virt::StoragePool class. This method requires
330 O(n) RPC calls, so the "list_all_storage_pools" method is
331 recommended as a more efficient alternative.
332 my $npools = $conn->num_of_defined_storage_pools()
334 Return the number of running networks known to the host. This can
335 be used as the "maxnames" parameter to
336 "list_defined_storage_pool_names".
337 my @names = $conn->list_defined_storage_pool_names($maxnames)
339 Return a list of names of all storage pools defined, but not
340 currently running, on the host. The names can be used with the
341 "get_storage_pool_by_name" method.
342 my @pools = $conn->list_all_storage_pools($flags)
344 Return a list of all storage pools currently known to the
345 hypervisor, whether running or shutoff. The elements in the
346 returned list are instances of the Sys::Virt::StoragePool class.
347 The $flags parameter can be used to filter the list of returned
348 pools.
349 my @devs = $conn->list_node_devices($capability)
351 Return a list of all devices currently known to the host OS. The
352 elements in the returned list are instances of the
353 Sys::Virt::NodeDevice class. The optional "capability" parameter
354 allows the list to be restricted to only devices with a particular
355 capability type. This method requires O(n) RPC calls, so the
356 "list_all_node_devices" method is recommended as a more efficient
357 alternative.
358 my $ndevs = $conn->num_of_node_devices($capability[, $flags])
360 Return the number of host devices known to the hypervisor. This can
361 be used as the "maxids" parameter to "list_node_device_names". The
362 "capability" parameter allows the list to be restricted to only
363 devices with a particular capability type, and should be left as
364 "undef" if the full list is required. The optional <flags>
365 parameter is currently unused and defaults to 0 if omitted.
366 my @devNames = $conn->list_node_device_names($capability, $maxnames[,
368 $flags])
369 Return a list of all host device names currently known to the
370 hypervisor. The names can be used with the
371 "get_node_device_by_name" method. The "capability" parameter
372 allows the list to be restricted to only devices with a particular
373 capability type, and should be left as "undef" if the full list is
374 required. The optional <flags> parameter is currently unused and
375 defaults to 0 if omitted.
376 my @devs = $conn->list_all_node_devices($flags)
378 Return a list of all node devices currently known to the
379 hypervisor. The elements in the returned list are instances of the
380 Sys::Virt::NodeDevice class. The $flags parameter can be used to
381 filter the list of returned devices.
382 my @ifaces = $conn->list_interfaces()
384 Return a list of all network interfaces currently known to the
385 hypervisor. The elements in the returned list are instances of the
386 Sys::Virt::Interface class. This method requires O(n) RPC calls,
387 so the "list_all_interfaces" method is recommended as a more
388 efficient alternative.
389 my $nifaces = $conn->num_of_interfaces()
391 Return the number of running interfaces known to the hypervisor.
392 This can be used as the "maxnames" parameter to
393 "list_interface_names".
394 my @names = $conn->list_interface_names($maxnames)
396 Return a list of all interface names currently known to the
397 hypervisor. The names can be used with the "get_interface_by_name"
398 method.
399 my @ifaces = $conn->list_defined_interfaces()
401 Return a list of all network interfaces currently known to the
402 hypervisor. The elements in the returned list are instances of the
403 Sys::Virt::Interface class. This method requires O(n) RPC calls,
404 so the "list_all_interfaces" method is recommended as a more
405 efficient alternative.
406 my $nifaces = $conn->num_of_defined_interfaces()
408 Return the number of inactive interfaces known to the hypervisor.
409 This can be used as the "maxnames" parameter to
410 "list_defined_interface_names".
411 my @names = $conn->list_defined_interface_names($maxnames)
413 Return a list of inactive interface names currently known to the
414 hypervisor. The names can be used with the "get_interface_by_name"
415 method.
416 my @ifaces = $conn->list_all_interfaces($flags)
418 Return a list of all interfaces currently known to the hypervisor,
419 whether running or shutoff. The elements in the returned list are
420 instances of the Sys::Virt::Interface class. The $flags parameter
421 can be used to filter the list of returned interfaces.
422 my @ifaces = $conn->list_secrets()
424 Return a list of all secrets currently known to the hypervisor. The
425 elements in the returned list are instances of the
426 Sys::Virt::Secret class. This method requires O(n) RPC calls, so
427 the "list_all_secrets" method is recommended as a more efficient
428 alternative.
429 my $nuuids = $conn->num_of_secrets()
431 Return the number of secrets known to the hypervisor. This can be
432 used as the "maxuuids" parameter to "list_secrets".
433 my @uuids = $conn->list_secret_uuids($maxuuids)
435 Return a list of all secret uuids currently known to the
436 hypervisor. The uuids can be used with the "get_secret_by_uuid"
437 method.
438 my @secrets = $conn->list_all_secrets($flags)
440 Return a list of all secrets currently known to the hypervisor. The
441 elements in the returned list are instances of the
442 Sys::Virt::Network class. The $flags parameter can be used to
443 filter the list of returned secrets.
444 my @nwfilters = $conn->list_nwfilters()
446 Return a list of all nwfilters currently known to the hypervisor.
447 The elements in the returned list are instances of the
448 Sys::Virt::NWFilter class. This method requires O(n) RPC calls, so
449 the "list_all_nwfilters" method is recommended as a more efficient
450 alternative.
451 my $nnwfilters = $conn->num_of_nwfilters()
453 Return the number of running nwfilters known to the hypervisor.
454 This can be used as the "maxids" parameter to
455 "list_nwfilter_names".
456 my @filterNames = $conn->list_nwfilter_names($maxnames)
458 Return a list of all nwfilter names currently known to the
459 hypervisor. The names can be used with the "get_nwfilter_by_name"
460 method.
461 my @nwfilters = $conn->list_all_nwfilters($flags)
463 Return a list of all nwfilters currently known to the hypervisor.
464 The elements in the returned list are instances of the
465 Sys::Virt::NWFilter class. The $flags parameter is currently
466 unused and defaults to zero.
467 my @bindings = $conn->list_all_nwfilter_bindings($flags)
469 Return a list of all nwfilter bindings currently known to the
470 hypervisor. The elements in the returned list are instances of the
471 Sys::Virt::NWFilterBinding class. The $flags parameter is currently
472 unused and defaults to zero.
473 $conn->define_save_image_xml($file, $dxml, $flags=0)
475 Update the XML associated with a virtual machine's save image. The
476 $file parameter is the fully qualified path to the save image XML,
477 while $dxml is the new XML document to write. The $flags parameter
478 is currently unused and defaults to zero.
479 $xml = $conn->get_save_image_xml_description($file, $flags=1)
481 Retrieve the current XML configuration associated with the virtual
482 machine's save image identified by $file. The $flags parameter
483 accepts the same constants as
484 "Sys::Virt::Domain::managed_save_get_xml_description".
485 my $dom = $conn->get_domain_by_name($name)
487 Return the domain with a name of $name. The returned object is an
488 instance of the Sys::Virt::Domain class.
489 my $dom = $conn->get_domain_by_id($id)
491 Return the domain with a local id of $id. The returned object is an
492 instance of the Sys::Virt::Domain class.
493 my $dom = $conn->get_domain_by_uuid($uuid)
495 Return the domain with a globally unique id of $uuid. The returned
496 object is an instance of the Sys::Virt::Domain class.
497 my $net = $conn->get_network_by_name($name)
499 Return the network with a name of $name. The returned object is an
500 instance of the Sys::Virt::Network class.
501 my $net = $conn->get_network_by_uuid($uuid)
503 Return the network with a globally unique id of $uuid. The returned
504 object is an instance of the Sys::Virt::Network class.
505 my $pool = $conn->get_storage_pool_by_name($name)
507 Return the storage pool with a name of $name. The returned object
508 is an instance of the Sys::Virt::StoragePool class.
509 my $pool = $conn->get_storage_pool_by_uuid($uuid)
511 Return the storage pool with a globally unique id of $uuid. The
512 returned object is an instance of the Sys::Virt::StoragePool class.
513 my $pool = $conn->get_storage_pool_by_volume($vol)
515 Return the storage pool with a storage volume $vol. The $vol
516 parameter must be an instance of the Sys::Virt::StorageVol class.
517 The returned object is an instance of the Sys::Virt::StoragePool
518 class.
519 my $pool = $conn->get_storage_pool_by_target_path($path)
521 Return the storage pool with a target path of $path. The returned
522 object is an instance of the Sys::Virt::StoragePool class.
523 my $vol = $conn->get_storage_volume_by_path($path)
525 Return the storage volume with a location of $path. The returned
526 object is an instance of the Sys::Virt::StorageVol class.
527 my $vol = $conn->get_storage_volume_by_key($key)
529 Return the storage volume with a globally unique id of $key. The
530 returned object is an instance of the Sys::Virt::StorageVol class.
531 my $dev = $conn->get_node_device_by_name($name)
533 Return the node device with a name of $name. The returned object is
534 an instance of the Sys::Virt::NodeDevice class.
535 my $dev = $conn->get_node_device_scsihost_by_wwn($wwnn, $wwpn,
537 $flags=0)
538 Return the node device which is a SCSI host identified by $wwnn and
539 $wwpn. The $flags parameter is unused and defaults to zero. The
540 returned object is an instance of the Sys::Virt::NodeDevice class.
541 my $iface = $conn->get_interface_by_name($name)
543 Return the interface with a name of $name. The returned object is
544 an instance of the Sys::Virt::Interface class.
545 my $iface = $conn->get_interface_by_mac($mac)
547 Return the interface with a MAC address of $mac. The returned
548 object is an instance of the Sys::Virt::Interface class.
549 my $sec = $conn->get_secret_by_uuid($uuid)
551 Return the secret with a globally unique id of $uuid. The returned
552 object is an instance of the Sys::Virt::Secret class.
553 my $sec = $conn->get_secret_by_usage($usageType, $usageID)
555 Return the secret with a usage type of $usageType, identified by
556 $usageID. The returned object is an instance of the
557 Sys::Virt::Secret class.
558 my $nwfilter = $conn->get_nwfilter_by_name($name)
560 Return the domain with a name of $name. The returned object is an
561 instance of the Sys::Virt::NWFilter class.
562 my $nwfilter = $conn->get_nwfilter_by_uuid($uuid)
564 Return the nwfilter with a globally unique id of $uuid. The
565 returned object is an instance of the Sys::Virt::NWFilter class.
566 my $binding = $conn->get_nwfilter_binding_by_port_dev($name)
568 Return the network filter binding for the port device $name. The
569 returned object is an instance of the Sys::Virt::NWFilterBinding
570 class.
571 my $xml = $conn->find_storage_pool_sources($type, $srcspec[, $flags])
573 Probe for available storage pool sources for the pool of type
574 $type. The $srcspec parameter can be "undef", or a parameter to
575 refine the discovery process, for example a server hostname for NFS
576 discovery. The $flags parameter is optional, and if omitted
577 defaults to zero. The returned scalar is an XML document describing
578 the discovered storage pool sources.
579 my @stats = $conn->get_all_domain_stats($stats, \@doms=undef,
581 $flags=0);
582 Get a list of all statistics for domains known to the hypervisor.
583 The $stats parameter controls which data fields to return and
584 should be a combination of the DOMAIN STATS FIELD CONSTANTS.
585 The optional @doms parameter is a list of Sys::Virt::Domain objects
587 to return stats for. If this is undefined, then all domains will be
588 returned. The $flags method can be used to filter the list of
589 returned domains.
590 The return data for the method is a list, one element for each
592 domain. The element will be a hash with two keys, "dom" pointing
593 to an instance of "Sys::Virt::Domain" and "data" pointing to
594 another hash reference containing the actual statistics.
595 $conn->interface_change_begin($flags)
597 Begin a transaction for changing the configuration of one or more
598 network interfaces
599 $conn->interface_change_commit($flags)
601 Complete a transaction for changing the configuration of one or
602 more network interfaces
603 $conn->interface_change_rollback($flags)
605 Abort a transaction for changing the configuration of one or more
606 network interfaces
607 $conn->restore_domain($savefile)
609 Recreate a domain from the saved state file given in the $savefile
610 parameter.
611 $conn->get_max_vcpus($domtype)
613 Return the maximum number of vcpus that can be configured for a
614 domain of type $domtype
615 my $hostname = $conn->get_hostname()
617 Return the name of the host with which this connection is
618 associated.
619 my $uri = $conn->get_uri()
621 Return the URI associated with the open connection. This may be
622 different from the URI used when initially connecting to libvirt,
623 when 'auto-probing' or drivers occurrs.
624 my $xml = $conn->get_sysinfo()
626 Return an XML documenting representing the host system information,
627 typically obtained from SMBIOS tables.
628 my $type = $conn->get_type()
630 Return the type of virtualization backend accessed by this
631 hypervisor object. Currently the only supported type is "Xen".
632 my $xml = $conn->domain_xml_from_native($format, $config);
634 Convert the native hypervisor configuration $config which is in
635 format <$format> into libvirrt domain XML. Valid values of $format
636 vary between hypervisor drivers.
637 my $config = $conn->domain_xml_to_native($format, $xml)
639 Convert the libvirt domain XML configuration $xml to a native
640 hypervisor configuration in format $format
641 my $ver = $conn->get_version()
643 Return the complete version number as a string encoded in the
644 formula "(major * 1000000) + (minor * 1000) + micro".
645 my $ver = $conn->get_major_version
647 Return the major version number of the libvirt library.
648 my $ver = $conn->get_minor_version
650 Return the minor version number of the libvirt library.
651 my $ver = $conn->get_micro_version
653 Return the micro version number of the libvirt library.
654 my $ver = $conn->get_library_version
656 Return the version number of the API associated with the active
657 connection. This differs from "get_version" in that if the
658 connection is to a remote libvirtd daemon, it will return the API
659 version of the remote libvirt, rather than the local client.
660 $conn->is_secure()
662 Returns a true value if the current connection is secure against
663 network interception. This implies either use of UNIX sockets, or
664 encryption with a TCP stream.
665 $conn->is_encrypted()
667 Returns a true value if the current connection data stream is
668 encrypted.
669 $conn->is_alive()
671 Returns a true value if the connection is alive, as determined by
672 keep-alive packets or other recent RPC traffic.
673 $conn->set_keep_alive($interval, $count)
675 Change the operation of the keep alive protocol to send $count
676 packets spaced $interval seconds apart before considering the
677 connection dead.
678 my $info = $con->get_node_info()
680 Returns a hash reference summarising the capabilities of the host
681 node. The elements of the hash are as follows:
682 memory
684 The amount of physical memory in the host
685 model
687 The model of the CPU, eg x86_64
688 cpus
690 The total number of logical CPUs.
691 mhz The peak MHZ of the CPU
693 nodes
695 The number of NUMA cells
696 sockets
698 The number of CPU sockets
699 cores
701 The number of cores per socket
702 threads
704 The number of threads per core
705 NB, more accurate information about the total number of CPUs and
707 those online can be obtained using the "get_node_cpu_map" method.
708 my ($totcpus, $onlinemap, $totonline) = $con->get_node_cpu_map();
710 Returns an array containing information about the CPUs available on
711 the host. The first element, "totcpus", specifies the total number
712 of CPUs available to the host regardles of their online stat. The
713 second element, "onlinemap", provides a bitmap detailing which CPUs
714 are currently online. The third element, "totonline", specifies the
715 total number of online CPUs. The values in the bitmap can be
716 extracted using the "unpack" method as follows:
717 my @onlinemap = split(//, unpack("b*", $onlinemap));
719 my $info = $con->get_node_cpu_stats($cpuNum=-1, $flags=0)
721 Returns a hash reference providing information about the host CPU
722 statistics. If <$cpuNum> is omitted, it defaults to
723 "Sys::Virt::NODE_CPU_STATS_ALL_CPUS" which causes it to return
724 cumulative information for all CPUs in the host. If $cpuNum is zero
725 or larger, it returns information just for the specified number.
726 The $flags parameter is currently unused and defaults to zero. The
727 fields in the returned hash reference are
728 kernel
730 The time spent in kernelspace
731 user
733 The time spent in userspace
734 idle
736 The idle time
737 iowait
739 The I/O wait time
740 utilization
742 The overall percentage utilization.
743 my $info = $con->get_node_memory_stats($cellNum=-1, $flags=0)
745 Returns a hash reference providing information about the host
746 memory statistics. If <$cellNum> is omitted, it defaults to
747 "Sys::Virt::NODE_MEMORY_STATS_ALL_CELLS" which causes it to return
748 cumulative information for all NUMA cells in the host. If $cellNum
749 is zero or larger, it returns information just for the specified
750 number. The $flags parameter is currently unused and defaults to
751 zero. The fields in the returned hash reference are
752 total
754 The total memory
755 free
757 The free memory
758 buffers
760 The memory consumed by buffers
761 cached
763 The memory consumed for cache
764 my $params = $conn->get_node_memory_parameters($flags=0)
766 Return a hash reference containing the set of memory tunable
767 parameters for the node. The keys in the hash are one of the
768 constants MEMORY PARAMETERS described later. The $flags parameter
769 is currently unused, and defaults to 0 if omitted.
770 $conn->set_node_memory_parameters($params, $flags=0)
772 Update the memory tunable parameters for the node. The $params
773 should be a hash reference whose keys are one of the MEMORY
774 PARAMETERS constants. The $flags parameter is currently unused, and
775 defaults to 0 if omitted.
776 $info = $conn->get_node_sev_info($flags=0)
778 Get the AMD SEV information for the host. $flags is currently
779 unused and defaults to 0 if omitted. The returned hash contains the
780 following keys:
781 Sys::Virt::SEV_CBITPOS
783 The CBit position
784 Sys::Virt::SEV_CERT_CHAIN
786 The certificate chain
787 Sys::Virt::SEV_PDH
789 Platform diffie-hellman key
790 Sys::Virt::SEV_REDUCED_PHYS_BITS
792 The number of physical address bits used by SEV
793 Sys::Virt::SEV_MAX_GUESTS
795 Maximum number of SEV guests that can be launched
796 Sys::Virt::SEV_MAX_ES_GUESTS
798 Maximum number of SEV-ES guests that can be launched
799 $conn->node_suspend_for_duration($target, $duration, $flags=0)
801 Suspend the the host, using mode $target which is one of the NODE
802 SUSPEND constants listed later. The $duration parameter controls
803 how long the node is suspended for before waking up.
804 $conn->domain_event_register($callback)
806 Register a callback to received notifications of domain state
807 change events. Only a single callback can be registered with each
808 connection instance. The callback will be invoked with four
809 parameters, an instance of "Sys::Virt" for the connection, an
810 instance of "Sys::Virt::Domain" for the domain changing state, and
811 a "event" and "detail" arguments, corresponding to the event
812 constants defined in the "Sys::Virt::Domain" module. Before
813 discarding the connection object, the callback must be
814 deregistered, otherwise the connection object memory will never be
815 released in garbage collection.
816 $conn->domain_event_deregister()
818 Unregister a callback, allowing the connection object to be garbage
819 collected.
820 $callback = $conn->domain_event_register_any($dom, $eventID, $callback)
822 Register a callback to received notifications of domain events.
823 The $dom parameter can be "undef" to request events on all known
824 domains, or a specific "Sys::Virt::Domain" object to filter events.
825 The $eventID parameter is one of the EVENT ID constants described
826 later in this document. The $callback is a subroutine reference
827 that will receive the events.
828 All callbacks receive a "Sys::Virt" connection as the first
830 parameter and a "Sys::Virt::Domain" object indicating the domain on
831 which the event occurred as the second parameter. Subsequent
832 parameters vary according to the event type
833 EVENT_ID_LIFECYCLE
835 Extra "event" and "detail" parameters defining the lifecycle
836 transition that occurred.
837 EVENT_ID_REBOOT
839 No extra parameters
840 EVENT_ID_RTC_CHANGE
842 The "utcoffset" gives the offset from UTC in seconds
843 EVENT_ID_WATCHDOG
845 The "action" defines the action that is taken as a result of
846 the watchdog triggering. One of the WATCHDOG constants
847 described later
848 EVENT_ID_IO_ERROR
850 The "srcPath" is the file on the host which had the error. The
851 "devAlias" is the unique device alias from the guest
852 configuration associated with "srcPath". The "action" is the
853 action taken as a result of the error, one of the IO ERROR
854 constants described later
855 EVENT_ID_GRAPHICS
857 The "phase" is the stage of the connection, one of the GRAPHICS
858 PHASE constants described later. The "local" and "remote"
859 parameters follow with the details of the local and remote
860 network addresses. The "authScheme" describes how the user was
861 authenticated (if at all). Finally "identities" is an array ref
862 containing authenticated identities for the user, if any.
863 The return value is a unique callback ID that must be used when
865 unregistering the event.
866 $conn->domain_event_deregister_any($callbackID)
868 Unregister a callback, associated with the $callbackID previously
869 obtained from "domain_event_register_any".
870 $callback = $conn->network_event_register_any($net, $eventID,
872 $callback)
873 Register a callback to received notifications of network events.
874 The $net parameter can be "undef" to request events on all known
875 networks, or a specific "Sys::Virt::Network" object to filter
876 events. The $eventID parameter is one of the EVENT ID constants
877 described later in this document. The $callback is a subroutine
878 reference that will receive the events.
879 All callbacks receive a "Sys::Virt" connection as the first
881 parameter and a "Sys::Virt::Network" object indicating the network
882 on which the event occurred as the second parameter. Subsequent
883 parameters vary according to the event type
884 EVENT_ID_LIFECYCLE
886 Extra "event" and "detail" parameters defining the lifecycle
887 transition that occurred.
888 The return value is a unique callback ID that must be used when
890 unregistering the event.
891 $conn->network_event_deregister_any($callbackID)
893 Unregister a callback, associated with the $callbackID previously
894 obtained from "network_event_register_any".
895 $callback = $conn->storage_pool_event_register_any($pool, $eventID,
897 $callback)
898 Register a callback to received notifications of storage pool
899 events. The $pool parameter can be "undef" to request events on
900 all known storage pools, or a specific "Sys::Virt::StoragePool"
901 object to filter events. The $eventID parameter is one of the EVENT
902 ID constants described later in this document. The $callback is a
903 subroutine reference that will receive the events.
904 All callbacks receive a "Sys::Virt" connection as the first
906 parameter and a "Sys::Virt::StoragePool" object indicating the
907 storage pool on which the event occurred as the second parameter.
908 Subsequent parameters vary according to the event type
909 EVENT_ID_LIFECYCLE
911 Extra "event" and "detail" parameters defining the lifecycle
912 transition that occurred.
913 EVENT_ID_REFRESH
915 No extra parameters.
916 The return value is a unique callback ID that must be used when
918 unregistering the event.
919 $conn->storage_pool_event_deregister_any($callbackID)
921 Unregister a callback, associated with the $callbackID previously
922 obtained from "storage_pool_event_register_any".
923 $callback = $conn->node_device_event_register_any($dev, $eventID,
925 $callback)
926 Register a callback to received notifications of node device
927 events. The $dev parameter can be "undef" to request events on all
928 known node devices, or a specific "Sys::Virt::NodeDevice" object to
929 filter events. The $eventID parameter is one of the EVENT ID
930 constants described later in this document. The $callback is a
931 subroutine reference that will receive the events.
932 All callbacks receive a "Sys::Virt" connection as the first
934 parameter and a "Sys::Virt::NodeDevice" object indicating the node
935 device on which the event occurred as the second parameter.
936 Subsequent parameters vary according to the event type
937 EVENT_ID_LIFECYCLE
939 Extra "event" and "detail" parameters defining the lifecycle
940 transition that occurred.
941 The return value is a unique callback ID that must be used when
943 unregistering the event.
944 $conn->node_device_event_deregister_any($callbackID)
946 Unregister a callback, associated with the $callbackID previously
947 obtained from "node_device_event_register_any".
948 $callback = $conn->secret_event_register_any($secret, $eventID,
950 $callback)
951 Register a callback to received notifications of secret events.
952 The $secret parameter can be "undef" to request events on all known
953 secrets, or a specific "Sys::Virt::Secret" object to filter events.
954 The $eventID parameter is one of the EVENT ID constants described
955 later in this document. The $callback is a subroutine reference
956 that will receive the events.
957 All callbacks receive a "Sys::Virt" connection as the first
959 parameter and a "Sys::Virt::Secret" object indicating the secret on
960 which the event occurred as the second parameter. Subsequent
961 parameters vary according to the event type
962 EVENT_ID_LIFECYCLE
964 Extra "event" and "detail" parameters defining the lifecycle
965 transition that occurred.
966 EVENT_ID_VALUE_CHANGED
968 No extra parameters.
969 The return value is a unique callback ID that must be used when
971 unregistering the event.
972 $conn->secret_event_deregister_any($callbackID)
974 Unregister a callback, associated with the $callbackID previously
975 obtained from "secret_event_register_any".
976 $conn->register_close_callback($coderef);
978 Register a callback to be invoked when the connection is closed.
979 The callback will be invoked with two parameters, the $conn it was
980 registered against, and the reason for the close event. The reason
981 value will be one of the "CLOSE REASON CONSTANTS" listed later in
982 this document.
983 $conn->unregister_close_callback();
985 Remove the previously registered close callback.
986 my $xml = $con->baseline_cpu(\@xml, $flags=0)
988 Given an array ref whose elements are XML documents describing host
989 CPUs, compute the baseline CPU model that is operable across all
990 hosts. The XML for the baseline CPU model is returned. The optional
991 $flags parameter can take one of
992 Sys::Virt::BASELINE_CPU_EXPAND_FEATURES
994 Expand the CPU definition to list all feature flags, even those
995 implied by the model name.
996 Sys::Virt::BASELINE_CPU_MIGRATABLE
998 Only include features which can be live migrated.
999 my $xml = $con->baseline_hypervisor_cpu($emulator, $arch, $machine,
1001 $virttype, \@xml, $flags=0)
1002 Given an array ref whose elements are XML documents describing host
1003 CPUs, compute the baseline CPU model that is operable across all
1004 hosts. The XML for the baseline CPU model is returned. Either
1005 $emulator or $arch must be a valid string referring to an emulator
1006 binary or an architecture name respectively. The $machine parameter
1007 is an optional name of a guest machine, and $virttype is an
1008 optional name of the virtualization type. The optional $flags
1009 parameter accepts the same values as "baseline_cpu".
1010 @names = $con->get_cpu_model_names($arch, $flags=0)
1012 Get a list of valid CPU models names for the architecture given by
1013 $arch. The $arch value should be one of the architectures listed in
1014 the capabilities XML document. The $flags parameter is currently
1015 unused and defaults to 0.
1016 my $info = $con->get_node_security_model()
1018 Returns a hash reference summarising the security model of the host
1019 node. There are two keys in the hash, "model" specifying the name
1020 of the security model (eg 'selinux') and "doi" specifying the
1021 'domain of interpretation' for security labels.
1022 my $xml = $con->get_capabilities();
1024 Returns an XML document describing the hypervisor capabilities
1025 my $xml = $con->get_domain_capabilities($emulator, $arch, $machine,
1027 $virttype, flags=0);
1028 Returns an XML document describing the capabilities of the
1029 requested guest configuration. Either $emulator or $arch must be a
1030 valid string referring to an emulator binary or an architecture
1031 name respectively. The $machine parameter is an optional name of a
1032 guest machine, and $virttype is an optional name of the
1033 virtualization type. $flags is unused and defaults to zero.
1034 my $xml = $con->get_storage_pool_capabilities($flags=0);
1036 Returns an XML document describing the storage pool driver
1037 capabilities (e.g. which storage pool types are supported and so
1038 on). $flags is currently unused and defaults to zero.
1039 my $result = $con->compare_cpu($xml, $flags=0);
1041 Checks whether the CPU definition in $xml is compatible with the
1042 current hypervisor connection. This can be used to determine
1043 whether it is safe to migrate a guest to this host. The returned
1044 result is one of the constants listed later The optional $flags
1045 parameter can take one of the following constants
1046 Sys::Virt::COMPARE_CPU_FAIL_INCOMPATIBLE
1048 Raise a fatal error if the CPUs are not compatible, instead of
1049 just returning a special error code.
1050 Sys::Virt::COMPARE_CPU_VALIDATE_XML
1052 Validate input XML document against the RNG schema.
1053 my $result = $con->compare_hypervisor_cpu($emulator, $arch, $machine,
1055 $virttype, $xml, $flags=0);
1056 Checks whether the CPU definition in $xml is compatible with the
1057 current hypervisor connection. This can be used to determine
1058 whether it is safe to migrate a guest to this host. Either
1059 $emulator or $arch must be a valid string referring to an emulator
1060 binary or an architecture name respectively. The $machine parameter
1061 is an optional name of a guest machine, and $virttype is an
1062 optional name of the virtualization type. The returned result is
1063 one of the constants listed later The optional $flags parameter can
1064 take the same values as the "compare_cpu" method.
1065 $mem = $con->get_node_free_memory();
1067 Returns the current free memory on the host
1068 @mem = $con->get_node_cells_free_memory($start, $end);
1070 Returns the free memory on each NUMA cell between $start and $end.
1071 @pages = $con->get_node_free_pages(\@pagesizes, $start, $end);
1073 Returns information about the number of pages free on each NUMA
1074 cell between $start and $end inclusive. The @pagesizes parameter
1075 should be an arrayref specifying which pages sizes information
1076 should be returned for. Information about supported page sizes is
1077 available in the capabilities XML. The returned array has an
1078 element for each NUMA cell requested. The elements are hash
1079 references with two keys, 'cell' specifies the NUMA cell number and
1080 'pages' specifies the free page information for that cell. The
1081 'pages' value is another hash reference where the keys are the page
1082 sizes and the values are the free count for that size.
1083 $con->node_alloc_pages(\@pages, $start, $end, $flags=0)
1085 Allocate further huge pages for the reserved dev. The <\@pages>
1086 parameter is an array reference with one entry per page size to
1087 allocate for. Each entry is a further array reference where the
1088 first element is the page size and the second element is the page
1089 count. The same number of pages will be allocated on each NUMA node
1090 in the range $start to $end inclusive. The $flags parameter accepts
1091 two contants
1092 Sys::Virt::NODE_ALLOC_PAGES_ADD
1094 The requested number of pages will be added to the existing
1095 huge page reservation.
1096 Sys::Virt::NODE_ALLOC_PAGES_SET
1098 The huge page reservation will be set to exactly the requested
1099 number
1100
1102 The following sets of constants are useful when dealing with APIs in
1103 this package
1104 CONNECTION
1106 When opening a connection the following constants can be used:
1107 Sys::Virt::CONNECT_RO
1109 Request a read-only connection
1110 Sys::Virt::CONNECT_NO_ALIASES
1112 Prevent the resolution of URI aliases
1113 CREDENTIAL TYPES
1115 When providing authentication callbacks, the following constants
1116 indicate the type of credential being requested
1117 Sys::Virt::CRED_AUTHNAME
1119 Identity to act as
1120 Sys::Virt::CRED_USERNAME
1122 Identity to authorize as
1123 Sys::Virt::CRED_CNONCE
1125 Client supplies a nonce
1126 Sys::Virt::CRED_REALM
1128 Authentication realm
1129 Sys::Virt::CRED_ECHOPROMPT
1131 Challenge response non-secret
1132 Sys::Virt::CRED_NOECHOPROMPT
1134 Challenge response secret
1135 Sys::Virt::CRED_PASSPHRASE
1137 Passphrase secret
1138 Sys::Virt::CRED_LANGUAGE
1140 RFC 1766 language code
1141 Sys::Virt::CRED_EXTERNAL
1143 Externally provided credential
1144 IDENTITY CONSTANTS
1146 The following constants are useful to change the connection identity
1147 Sys::Virt::IDENTITY_USER_NAME
1149 The process user name
1150 Sys::Virt::IDENTITY_UNIX_USER_ID
1152 The process UNIX user ID
1153 Sys::Virt::IDENTITY_GROUP_NAME
1155 The process group name
1156 Sys::Virt::IDENTITY_UNIX_GROUP_ID
1158 The process UNIX group ID
1159 Sys::Virt::IDENTITY_PROCESS_ID
1161 The process ID.
1162 Sys::Virt::IDENTITY_PROCESS_TIME
1164 The process start time.
1165 Sys::Virt::IDENTITY_SASL_USER_NAME
1167 The SASL authenticated user name
1168 Sys::Virt::IDENTITY_X509_DISTINGUISHED_NAME
1170 The X509 certificate distinguished name for the TLS connection
1171 Sys::Virt::IDENTITY_SELINUX_CONTEXT
1173 The SELinux process context
1174 CPU COMPARISON CONSTANTS
1176 Sys::Virt::CPU_COMPARE_INCOMPATIBLE
1177 This host is missing one or more CPU features in the CPU
1178 description
1179 Sys::Virt::CPU_COMPARE_IDENTICAL
1181 The host has an identical CPU description
1182 Sys::Virt::CPU_COMPARE_SUPERSET
1184 The host offers a superset of the CPU descriptoon
1185 NODE SUSPEND CONSTANTS
1187 Sys::Virt::NODE_SUSPEND_TARGET_MEM
1188 Suspends to memory (equivalent of S3 on x86 architectures)
1189 Sys::Virt::NODE_SUSPEND_TARGET_DISK
1191 Suspends to disk (equivalent of S5 on x86 architectures)
1192 Sys::Virt::NODE_SUSPEND_TARGET_HYBRID
1194 Suspends to memory and disk (equivalent of S3+S5 on x86
1195 architectures)
1196 NODE VCPU CONSTANTS
1198 Sys::Virt::NODE_CPU_STATS_ALL_CPUS
1199 Request statistics for all CPUs
1200 NODE MEMORY CONSTANTS
1202 Sys::Virt::NODE_MEMORY_STATS_ALL_CELLS
1203 Request statistics for all memory cells
1204 MEMORY PARAMETERS
1206 The following constants are used to name memory parameters of the node
1207 Sys::Virt::NODE_MEMORY_SHARED_FULL_SCANS
1209 How many times all mergeable areas have been scanned.
1210 Sys::Virt::NODE_MEMORY_SHARED_PAGES_SHARED
1212 How many the shared memory pages are being used.
1213 Sys::Virt::NODE_MEMORY_SHARED_PAGES_SHARING
1215 How many sites are sharing the pages
1216 Sys::Virt::NODE_MEMORY_SHARED_PAGES_TO_SCAN
1218 How many present pages to scan before the shared memory service
1219 goes to sleep
1220 Sys::Virt::NODE_MEMORY_SHARED_PAGES_UNSHARED
1222 How many pages unique but repeatedly checked for merging.
1223 Sys::Virt::NODE_MEMORY_SHARED_PAGES_VOLATILE
1225 How many pages changing too fast to be placed in a tree.
1226 Sys::Virt::NODE_MEMORY_SHARED_SLEEP_MILLISECS
1228 How many milliseconds the shared memory service should sleep before
1229 next scan.
1230 Sys::Virt::NODE_MEMORY_SHARED_MERGE_ACROSS_NODES
1232 Whether pages can be merged across NUMA nodes
1233 CLOSE REASON CONSTANTS
1235 The following constants related to the connection close callback,
1236 describe the reason for the closing of the connection.
1237 Sys::Virt::CLOSE_REASON_CLIENT
1239 The client application requested the connection be closed
1240 Sys::Virt::CLOSE_REASON_EOF
1242 End-of-file was encountered reading data from the connection
1243 Sys::Virt::CLOSE_REASON_ERROR
1245 An I/O error was encountered reading/writing data from/to the
1246 connection
1247 Sys::Virt::CLOSE_REASON_KEEPALIVE
1249 The connection keepalive timer triggered due to lack of response
1250 from the server
1251 CPU STATS CONSTANTS
1253 The following constants provide the names of known CPU stats fields
1254 Sys::Virt::NODE_CPU_STATS_IDLE
1256 Time spent idle
1257 Sys::Virt::NODE_CPU_STATS_IOWAIT
1259 Time spent waiting for I/O to complete
1260 Sys::Virt::NODE_CPU_STATS_KERNEL
1262 Time spent executing kernel code
1263 Sys::Virt::NODE_CPU_STATS_USER
1265 Time spent executing user code
1266 Sys::Virt::NODE_CPU_STATS_INTR
1268 Time spent processing interrupts
1269 Sys::Virt::NODE_CPU_STATS_UTILIZATION
1271 Percentage utilization of the CPU.
1272 MEMORY STAS CONSTANTS
1274 The following constants provide the names of known memory stats fields
1275 Sys::Virt::NODE_MEMORY_STATS_BUFFERS
1277 The amount of memory consumed by I/O buffers
1278 Sys::Virt::NODE_MEMORY_STATS_CACHED
1280 The amount of memory consumed by disk cache
1281 Sys::Virt::NODE_MEMORY_STATS_FREE
1283 The amount of free memory
1284 Sys::Virt::NODE_MEMORY_STATS_TOTAL
1286 The total amount of memory
1287 IP address constants
1289 The following constants are used to interpret IP address types
1290 Sys::Virt::IP_ADDR_TYPE_IPV4
1292 An IPv4 address type
1293 Sys::Virt::IP_ADDR_TYPE_IPV6
1295 An IPv6 address type
1296
1298 Hopefully none, but the XS code needs to be audited to ensure it is not
1299 leaking memory.
1300
1302 Daniel P. Berrange <berrange@redhat.com>
1303
1305 Copyright (C) 2006-2009 Red Hat Copyright (C) 2006-2009 Daniel P.
1306 Berrange
1307
1309 This program is free software; you can redistribute it and/or modify it
1310 under the terms of either the GNU General Public License as published
1311 by the Free Software Foundation (either version 2 of the License, or at
1312 your option any later version), or, the Artistic License, as specified
1313 in the Perl README file.
1314
1316 Sys::Virt::Domain, Sys::Virt::Network, Sys::Virt::StoragePool,
1317 Sys::Virt::StorageVol, Sys::Virt::Error, "http://libvirt.org"
1318perl v5.34.0 2022-01-21 Sys::Virt(3)