if ($sync) {
&$worker();
- return undef;
+ return;
} else {
my $upid = $rpcenv->fork_worker('qmconfig', $vmid, $authuser, $worker);
if (!$running) {
my $status = PVE::Tools::upid_read_status($upid);
- return undef if $status eq 'OK';
+ return if $status eq 'OK';
die $status;
}
}
code => sub {
my ($param) = @_;
&$update_vm_api($param, 1);
- return undef;
+ return;
}
});
__PACKAGE__->update_vm($param);
- return undef;
+ return;
}});
# uses good entropy, each char is limited to 6 bit to get printable chars simply
};
PVE::QemuConfig->lock_config($vmid, $updatefn);
- return undef;
+ return;
}});
__PACKAGE__->register_method({
my $snapname = extract_param($param, 'snapname');
- return undef if !defined($param->{description});
+ return if !defined($param->{description});
my $updatefn = sub {
PVE::QemuConfig->lock_config($vmid, $updatefn);
- return undef;
+ return;
}});
__PACKAGE__->register_method({
};
PVE::QemuConfig->lock_config($vmid, $updatefn);
- return undef;
+ return;
}});
__PACKAGE__->register_method({
my $write = agent_cmd($vmid, "file-write", { handle => $qgafh, 'buf-b64' => $buf }, "can't write to file");
my $res = agent_cmd($vmid, "file-close", { handle => $qgafh }, "can't close file");
- return undef;
+ return;
}});
1;
print "$cmdline\n";
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
print "status: $status\n";
}
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
run_vnc_proxy($vnc_socket);
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
PVE::QemuConfig->write_config($vmid, $conf);
});
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
eval { PVE::QemuServer::nbd_stop($vmid) };
warn $@ if $@;
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
if (!PVE::Cluster::check_cfs_quorum(1)) {
print "no quorum\n";
- return undef;
+ return;
}
my $tunnel_write = sub {
}
}
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
die "wait failed - got timeout\n" if PVE::QemuServer::check_running ($vmid);
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
print "ERROR: $@" if $@;
}
- return undef;
+ return;
}});
PVE::QemuServer::rescan($param->{vmid}, 0, $dryrun);
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
my ($drive_id, $volid) = PVE::QemuServer::ImportDisk::do_import($source, $vmid, $storeid, { format => $format });
print "Successfully imported disk as '$drive_id:$volid'\n";
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
system($cmd);
- return undef;
+ return;
}});
__PACKAGE__->register_method ({
PVE::QemuConfig->remove_lock($vmid, "create");
- return undef;
+ return;
}
});
});
}
- return undef;
+ return;
}});
my $print_agent_result = sub {
&$push_cmd_to_queue($self, $vmid, $cmd);
- return undef;
+ return;
}
# execute a single command
my $queue_info = $self->{queue_lookup}->{$fh};
if (!$queue_info) {
warn "internal error - unable to lookup queue info" if !$noerr;
- return undef;
+ return;
}
return $queue_info;
};
if ($key eq 'vmstate') {
eval { PVE::JSONSchema::check_format('pve-volume-id', $volume_string) };
if (my $err = $@) {
- return undef if $noerr;
+ return if $noerr;
die $err;
}
$volume = { 'file' => $volume_string };
# if its neither 'none' nor 'cdrom' nor a path, check if its a volume-id
$volid = eval { PVE::JSONSchema::check_format('pve-volume-id', $volid, '') };
if ($@) {
- return undef if $noerr;
+ return if $noerr;
die $@;
}
return $volid;
return $dev if $check->("usb");
return $dev if $check->("hostpci");
- return undef if $noerr;
+ return if $noerr;
die "invalid boot device '$dev'\n";
}
return $kvm_api_version if $kvm_api_version;
open my $fh, '<', '/dev/kvm'
- or return undef;
+ or return;
# 0xae00 => KVM_GET_API_VERSION
$kvm_api_version = ioctl($fh, 0xae00, 0);
if (!($file eq 'none' || $file eq 'cdrom' ||
$file =~ m|^/dev/.+| || $file =~ m/^([^:]+):(.+)$/)) {
- return undef if $file =~ m|/|;
+ return if $file =~ m|/|;
if ($media && $media eq 'cdrom') {
$file = "local:iso/$file";
return $value if parse_hotplug_features($value);
- return undef if $noerr;
+ return if $noerr;
die "unable to parse hotplug option\n";
}
my $ret = ioctl($fh, $SG_GET_VERSION_NUM, $versionbuf);
if (!$ret) {
die "scsi ioctl SG_GET_VERSION_NUM failoed - $!\n" if !$noerr;
- return undef;
+ return;
}
my $version = unpack("I", $versionbuf);
if ($version < 30000) {
die "scsi generic interface too old\n" if !$noerr;
- return undef;
+ return;
}
my $buf = "\x00" x 36;
$ret = ioctl($fh, $SG_IO, $packet);
if (!$ret) {
die "scsi ioctl SG_IO failed - $!\n" if !$noerr;
- return undef;
+ return;
}
my @res = unpack($sg_io_hdr_t, $packet);
if ($res[17] || $res[18]) {
die "scsi ioctl SG_IO status error - $!\n" if !$noerr;
- return undef;
+ return;
}
my $res = {};
sub path_is_scsi {
my ($path) = @_;
- my $fh = IO::File->new("+<$path") || return undef;
+ my $fh = IO::File->new("+<$path") || return;
my $res = scsi_inquiry($fh, 1);
close($fh);
sub print_keyboarddevice_full {
my ($conf, $arch, $machine) = @_;
- return undef if $arch ne 'aarch64';
+ return if $arch ne 'aarch64';
return "usb-kbd,id=keyboard,bus=ehci.0,port=2";
}
sub get_initiator_name {
my $initiator;
- my $fh = IO::File->new('/etc/iscsi/initiatorname.iscsi') || return undef;
+ my $fh = IO::File->new('/etc/iscsi/initiatorname.iscsi') || return;
while (defined(my $line = <$fh>)) {
next if $line !~ m/^\s*InitiatorName\s*=\s*([\.\-:\w]+)/;
$initiator = $1;
my $res = eval { parse_property_string($net_fmt, $data) };
if ($@) {
warn $@;
- return undef;
+ return;
}
if (!defined($res->{macaddr})) {
my $dc = PVE::Cluster::cfs_read_file('datacenter.cfg');
my $res = eval { parse_property_string($ipconfig_fmt, $data) };
if ($@) {
warn $@;
- return undef;
+ return;
}
if ($res->{gw} && !$res->{ip}) {
warn 'gateway specified without specifying an IP address';
- return undef;
+ return;
}
if ($res->{gw6} && !$res->{ip6}) {
warn 'IPv6 gateway specified without specifying an IPv6 address';
- return undef;
+ return;
}
if ($res->{gw} && $res->{ip} eq 'dhcp') {
warn 'gateway specified together with DHCP';
- return undef;
+ return;
}
if ($res->{gw6} && $res->{ip6} !~ /^$IPV6RE/) {
# gw6 + auto/dhcp
warn "IPv6 gateway specified together with $res->{ip6} address";
- return undef;
+ return;
}
if (!$res->{ip} && !$res->{ip6}) {
}
}
- return undef;
+ return;
}
sub vmconfig_register_unused_drive {
sub parse_watchdog {
my ($value) = @_;
- return undef if !$value;
+ return if !$value;
my $res = eval { parse_property_string($watchdog_fmt, $value) };
warn $@ if $@;
sub parse_rng {
my ($value) = @_;
- return undef if !$value;
+ return if !$value;
my $res = eval { parse_property_string($rng_fmt, $value) };
warn $@ if $@;
return $value if parse_usb_device($value);
- return undef if $noerr;
+ return if $noerr;
die "unable to parse usb device\n";
}
sub parse_vm_config {
my ($filename, $raw) = @_;
- return undef if !defined($raw);
+ return if !defined($raw);
my $res = {
digest => Digest::SHA::sha1_hex($raw),
$id //= 0;
my $audio = $conf->{"audio$id"};
- return undef if !defined($audio);
+ return if !defined($audio);
my $audioproperties = parse_property_string($audio_fmt, $audio);
my $audiodriver = $audioproperties->{driver} // 'spice';
} elsif ($deviceid =~ m/^(net)(\d+)$/) {
- return undef if !qemu_netdevadd($vmid, $conf, $arch, $device, $deviceid);
+ return if !qemu_netdevadd($vmid, $conf, $arch, $device, $deviceid);
my $machine_type = PVE::QemuServer::Machine::qemu_machine_pxe($vmid, $conf);
my $use_old_bios_files = undef;
}
}
- return undef;
+ return;
}
sub vmconfig_delete_or_detach_drive {
return 1;
}
- return undef;
+ return;
}
sub qga_check_running {
die $error if !$noerr;
warn $error;
- return undef;
+ return;
}
return 1;
if (my $err = $@) {
die $err if !$noerr;
- return undef;
+ return;
}
return 1;
if ($str !~ m/^(host|\d{1,2})$/) {
die $err_msg if !$noerr;
- return undef;
+ return;
}
if ($str =~ m/^\d+$/ && (int($str) < 8 || int($str) > 64)) {
die $err_msg if !$noerr;
- return undef;
+ return;
}
return $str;
my ($type, $sectionId, $errmsg, $config) =
$class->SUPER::parse_section_header($line);
- return undef if !$type;
+ return if !$type;
return ($type, $sectionId, $errmsg, {
# name is given by section header, and we can always prepend 'custom-'
# since we're reading the custom CPU file
my $entry = $conf->{ids}->{$name};
if (!defined($entry)) {
die "Custom cputype '$name' not found\n" if !$noerr;
- return undef;
+ return;
}
my $model = {};
return $value if is_valid_drivename($value);
- return undef if $noerr;
+ return if $noerr;
die "invalid boot disk '$value'\n";
}
$interface = $1;
$index = $2;
} else {
- return undef;
+ return;
}
if (!defined($drivedesc_hash->{$key})) {
warn "invalid drive key: $key\n";
- return undef;
+ return;
}
my $desc = $drivedesc_hash->{$key}->{format};
my $res = eval { PVE::JSONSchema::parse_property_string($desc, $data) };
- return undef if !$res;
+ return if !$res;
$res->{interface} = $interface;
$res->{index} = $index;
}
}
- return undef if $error;
+ return if $error;
- return undef if $res->{mbps_rd} && $res->{mbps};
- return undef if $res->{mbps_wr} && $res->{mbps};
- return undef if $res->{iops_rd} && $res->{iops};
- return undef if $res->{iops_wr} && $res->{iops};
+ return if $res->{mbps_rd} && $res->{mbps};
+ return if $res->{mbps_wr} && $res->{mbps};
+ return if $res->{iops_rd} && $res->{iops};
+ return if $res->{iops_wr} && $res->{iops};
if ($res->{media} && ($res->{media} eq 'cdrom')) {
- return undef if $res->{snapshot} || $res->{trans} || $res->{format};
- return undef if $res->{heads} || $res->{secs} || $res->{cyls};
- return undef if $res->{interface} eq 'virtio';
+ return if $res->{snapshot} || $res->{trans} || $res->{format};
+ return if $res->{heads} || $res->{secs} || $res->{cyls};
+ return if $res->{interface} eq 'virtio';
}
if (my $size = $res->{size}) {
- return undef if !defined($res->{size} = PVE::JSONSchema::parse_size($size));
+ return if !defined($res->{size} = PVE::JSONSchema::parse_size($size));
}
return $res;
my ($storecfg, $conf) = @_;
my $bootdisks = get_bootdisks($conf);
- return undef if !@$bootdisks;
+ return if !@$bootdisks;
my $bootdisk = $bootdisks->[0];
- return undef if !is_valid_drivename($bootdisk);
+ return if !is_valid_drivename($bootdisk);
- return undef if !$conf->{$bootdisk};
+ return if !$conf->{$bootdisk};
my $drive = parse_drive($bootdisk, $conf->{$bootdisk});
- return undef if !defined($drive);
+ return if !defined($drive);
- return undef if drive_is_cdrom($drive);
+ return if drive_is_cdrom($drive);
my $volid = $drive->{file};
- return undef if !$volid;
+ return if !$volid;
return $drive->{size};
}
sub update_disksize {
my ($drive, $newsize) = @_;
- return undef if !defined($newsize);
+ return if !defined($newsize);
my $oldsize = $drive->{size} // 0;
return ($drive, $msg);
}
- return undef;
+ return;
}
sub is_volume_in_use {
next if drive_is_cdrom($disk) xor $cdrom;
return $ds;
}
- return undef;
+ return;
}
1;
if (defined($fh)) {
my $line = <$fh>;
$fh->close;
- return undef if !$line;
+ return if !$line;
my @param = split(/\0/, $line);
my $cmd = $param[0];
return $phash;
}
- return undef;
+ return;
}
sub vm_running_locally {
}
}
- return undef;
+ return;
}
sub min_version {
}
}
- return undef;
+ return;
}
sub machine_version {
return ($resource);
}
}
- return undef;
+ return;
}
sub dtmf_name_to_id {
if ($found) {
return $found->{id};
} else {
- return undef;
+ return;
}
}
if ($resource) {
return $resource->{pve_type};
} else {
- return undef;
+ return;
}
}
my ($map, $id) = @_;
my $d = $map->{$id};
- return undef if !defined($d) || !defined($d->{bus}) || !defined($d->{addr});
+ return if !defined($d) || !defined($d->{bus}) || !defined($d->{addr});
return { bus => $d->{bus}, addr => sprintf("0x%x", $d->{addr}) };
};
sub parse_hostpci {
my ($value) = @_;
- return undef if !$value;
+ return if !$value;
my $res = PVE::JSONSchema::parse_property_string($hostpci_fmt, $value);
sub parse_usb_device {
my ($value) = @_;
- return undef if !$value;
+ return if !$value;
my $res = {};
if ($value =~ m/^(0x)?([0-9A-Fa-f]{4}):(0x)?([0-9A-Fa-f]{4})$/) {
} elsif ($value =~ m/^spice$/i) {
$res->{spice} = 1;
} else {
- return undef;
+ return;
}
return $res;
# ignore existing replication config
my $repl_config_module = new Test::MockModule('PVE::ReplicationConfig');
$repl_config_module->mock('new' => sub { return bless {}, "PVE::ReplicationConfig" });
-$repl_config_module->mock('check_for_existing_jobs' => sub { return undef });
+$repl_config_module->mock('check_for_existing_jobs' => sub { return });
my $storage_module = new Test::MockModule('PVE::Storage');
-$storage_module->mock('config', sub { return undef; });
+$storage_module->mock('config', sub { return; });
$storage_module->mock('path', sub { return "/some/store/statefile/path"; });
$storage_module->mock('activate_volumes', \&mocked_activate_volumes);
$storage_module->mock('deactivate_volumes', \&mocked_deactivate_volumes);
projects / qemu-server.git / commitdiff