[pve-storage.git] / PVE / Diskmanage.pm

package PVE::Diskmanage;

use strict;
use warnings;
use PVE::ProcFSTools;
use Data::Dumper;
use Cwd qw(abs_path);

use PVE::Tools qw(extract_param run_command file_get_contents file_read_firstline dir_glob_regex dir_glob_foreach trim);

my $SMARTCTL = "/usr/sbin/smartctl";
my $ZPOOL = "/sbin/zpool";
my $SGDISK = "/sbin/sgdisk";
my $PVS = "/sbin/pvs";
my $UDEVADM = "/bin/udevadm";

sub verify_blockdev_path {
    my ($rel_path) = @_;

    die "missing path" if !$rel_path;
    my $path = abs_path($rel_path);
    die "failed to get absolute path to $rel_path\n" if !$path;

    die "got unusual device path '$path'\n" if $path !~  m|^/dev/(.*)$|;

    $path = "/dev/$1"; # untaint

    assert_blockdev($path);

    return $path;
}

sub assert_blockdev {
    my ($dev, $noerr) = @_;

    if ($dev !~ m|^/dev/| || !(-b $dev)) {
	return undef if $noerr;
	die "not a valid block device\n";
    }

    return 1;
}

sub init_disk {
    my ($disk, $uuid) = @_;

    assert_blockdev($disk);

    # we should already have checked if it is in use in the api call
    # but we check again for safety
    die "disk $disk is already in use\n" if disk_is_used($disk);

    my $id = $uuid || 'R';
    run_command([$SGDISK, $disk, '-U', $id]);
    return 1;
}

sub disk_is_used {
    my ($disk) = @_;

    my $dev = $disk;
    $dev =~ s|^/dev/||;

    my $disklist = get_disks($dev, 1);

    die "'$disk' is not a valid local disk\n" if !defined($disklist->{$dev});
    return 1 if $disklist->{$dev}->{used};

    return 0;
}

sub get_smart_data {
    my ($disk) = @_;

    assert_blockdev($disk);
    my $smartdata = {};
    my $type;

    my $returncode = 0;

    $disk =~ s/n\d+$//
        if $disk =~ m!^/dev/nvme\d+n\d+$!;

    eval {
	$returncode = run_command([$SMARTCTL, '-H', '-A', '-f', 'brief', $disk], noerr => 1, outfunc => sub{
	    my ($line) = @_;

# ATA SMART attributes, e.g.:
# ID# ATTRIBUTE_NAME          FLAGS    VALUE WORST THRESH FAIL RAW_VALUE
#   1 Raw_Read_Error_Rate     POSR-K   100   100   000    -    0
#
# SAS and NVME disks, e.g.:
# Data Units Written:                 5,584,952 [2.85 TB]
# Accumulated start-stop cycles:  34

	    if (defined($type) && $type eq 'ata' && $line =~ m/^([ \d]{2}\d)\s+(\S+)\s+(\S{6})\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/) {
		my $entry = {};
		$entry->{name} = $2 if defined $2;
		$entry->{flags} = $3 if defined $3;
		# the +0 makes a number out of the strings
		$entry->{value} = $4+0 if defined $4;
		$entry->{worst} = $5+0 if defined $5;
		$entry->{threshold} = $6+0 if defined $6;
		$entry->{fail} = $7 if defined $7;
		$entry->{raw} = $8 if defined $8;
		$entry->{id} = $1 if defined $1;
		push @{$smartdata->{attributes}}, $entry;
	    } elsif ($line =~ m/(?:Health Status|self\-assessment test result): (.*)$/ ) {
		$smartdata->{health} = $1;
	    } elsif ($line =~ m/Vendor Specific SMART Attributes with Thresholds:/) {
		$type = 'ata';
		delete $smartdata->{text};
	    } elsif ($line =~ m/=== START OF (READ )?SMART DATA SECTION ===/) {
		$type = 'text';
	    } elsif (defined($type) && $type eq 'text') {
		$smartdata->{text} = '' if !defined $smartdata->{text};
		$smartdata->{text} .= "$line\n";
	    }
	});
    };
    my $err = $@;

    # bit 0 and 1 mark an severe smartctl error
    # all others are for disk status, so ignore them
    # see smartctl(8)
    if ((defined($returncode) && ($returncode & 0b00000011)) || $err) {
	die "Error getting S.M.A.R.T. data: Exit code: $returncode\n";
    }

    $smartdata->{type} = $type;

    return $smartdata;
}

sub get_smart_health {
    my ($disk) = @_;

    return "NOT A DEVICE" if !assert_blockdev($disk, 1);

    my $message;
    $disk =~ s/n\d+$//
        if $disk =~ m!^/dev/nvme\d+n\d+$!;

    run_command([$SMARTCTL, '-H', $disk], noerr => 1, outfunc => sub {
	my ($line) = @_;

	if ($line =~ m/test result: (.*)$/) {
	    $message = $1;
	} elsif ($line =~ m/open device: (.*) failed: (.*)$/) {
	    $message = "FAILED TO OPEN";
	} elsif ($line =~ m/^SMART Disabled/) {
	    $message = "SMART DISABLED";
	}
    });

    return $message;
}

sub get_zfs_devices {
    my $list = {};

    # use zpool and parttype uuid,
    # because log and cache do not have
    # zfs type uuid
    eval {
	run_command([$ZPOOL, 'list', '-HPLv'], outfunc => sub {
	     my ($line) = @_;

	     if ($line =~ m|^\t([^\t]+)\t|) {
		$list->{$1} = 1;
	     }
	});
    };

    # only warn here,
    # because maybe zfs tools are not installed
    warn "$@\n" if $@;

    my $applezfsuuid = "6a898cc3-1dd2-11b2-99a6-080020736631";
    my $bsdzfsuuid = "516e7cba-6ecf-11d6-8ff8-00022d09712b";

    dir_glob_foreach('/dev/disk/by-parttypeuuid', "($applezfsuuid|$bsdzfsuuid)\..+", sub {
	my ($entry) = @_;
	my $real_dev = abs_path("/dev/disk/by-parttypeuuid/$entry");
	$list->{$real_dev} = 1;
    });

    return $list;
}

sub get_lvm_devices {
    my $list = {};
    eval {
	run_command([$PVS, '--noheadings', '--readonly', '-o', 'pv_name'], outfunc => sub{
	    my ($line) = @_;
	    $line = trim($line);
	    if ($line =~ m|^/dev/|) {
		$list->{$line} = 1;
	    }
	});
    };

    # if something goes wrong, we do not want
    # to give up, but indicate an error has occured
    warn "$@\n" if $@;

    my $lvmuuid = "e6d6d379-f507-44c2-a23c-238f2a3df928";

    dir_glob_foreach('/dev/disk/by-parttypeuuid', "$lvmuuid\..+", sub {
	my ($entry) = @_;
	my $real_dev = abs_path("/dev/disk/by-parttypeuuid/$entry");
	$list->{$real_dev} = 1;
    });

    return $list;
}

sub get_ceph_journals {
    my $journalhash = {};

    my $journal_uuid = '45b0969e-9b03-4f30-b4c6-b4b80ceff106';

    dir_glob_foreach('/dev/disk/by-parttypeuuid', "$journal_uuid\..+", sub {
	my ($entry) = @_;
	my $real_dev = abs_path("/dev/disk/by-parttypeuuid/$entry");
	$journalhash->{$real_dev} = 1;
    });

    return $journalhash;
}

sub get_udev_info {
    my ($dev) = @_;

    my $info = "";
    my $data = {};
    eval {
	run_command([$UDEVADM, 'info', '-n', $dev, '--query', 'all'], outfunc => sub {
	    my ($line) = @_;
	    $info .= "$line\n";
	});
    };
    warn $@ if $@;
    return undef if !$info;

    return undef if $info !~ m/^E: DEVTYPE=disk$/m;
    return undef if $info =~ m/^E: ID_CDROM/m;

    # we use this, because some disks are not simply in /dev
    # e.g. /dev/cciss/c0d0
    if ($info =~ m/^E: DEVNAME=(\S+)$/m) {
	$data->{devpath} = $1;
    }
    return if !defined($data->{devpath});

    $data->{serial} = 'unknown';
    if ($info =~ m/^E: ID_SERIAL_SHORT=(\S+)$/m) {
	$data->{serial} = $1;
    }

    $data->{gpt} = 0;
    if ($info =~ m/^E: ID_PART_TABLE_TYPE=gpt$/m) {
	$data->{gpt} = 1;
    }

    # detect SSD
    $data->{rpm} = -1;
    if ($info =~ m/^E: ID_ATA_ROTATION_RATE_RPM=(\d+)$/m) {
	$data->{rpm} = $1;
    }

    if ($info =~ m/^E: ID_BUS=usb$/m) {
	$data->{usb} = 1;
    }

    $data->{wwn} = 'unknown';
    if ($info =~ m/^E: ID_WWN=(.*)$/m) {
	$data->{wwn} = $1;
    }

    return $data;
}

sub get_sysdir_info {
    my ($sysdir) = @_;

    my $data = {};

    my $size = file_read_firstline("$sysdir/size");
    return undef if !$size;

    # linux always considers sectors to be 512 bytes,
    # independently of real block size
    $data->{size} = $size * 512;

    # dir/queue/rotational should be 1 for hdd, 0 for ssd
    $data->{rotational} = file_read_firstline("$sysdir/queue/rotational");

    $data->{vendor} = file_read_firstline("$sysdir/device/vendor") || 'unknown';
    $data->{model} = file_read_firstline("$sysdir/device/model") || 'unknown';

    return $data;
}

sub get_disks {
    my ($disk, $nosmart) = @_;
    my $disklist = {};

    my $mounted = {};

    my $mounts = PVE::ProcFSTools::parse_proc_mounts();

    foreach my $mount (@$mounts) {
	next if $mount->[0] !~ m|^/dev/|;
	$mounted->{abs_path($mount->[0])} = $mount->[1];
    };

    my $dev_is_mounted = sub {
	my ($dev) = @_;
	return $mounted->{$dev};
    };

    my $dir_is_empty = sub {
	my ($dir) = @_;

	my $dh = IO::Dir->new ($dir);
	return 1 if !$dh;

	while (defined(my $tmp = $dh->read)) {
	    next if $tmp eq '.' || $tmp eq '..';
	    $dh->close;
	    return 0;
	}
	$dh->close;
	return 1;
    };

    my $journalhash = get_ceph_journals();

    my $zfslist = get_zfs_devices();

    my $lvmlist = get_lvm_devices();

    dir_glob_foreach('/sys/block', '.*', sub {
	my ($dev) = @_;
	return if defined($disk) && $disk ne $dev;
	# whitelisting following devices
	# hdX: ide block device
	# sdX: sd block device
	# vdX: virtual block device
	# xvdX: xen virtual block device
	# nvmeXnY: nvme devices
	# cXnY: cciss devices
	return if $dev !~ m/^(h|s|x?v)d[a-z]+$/ &&
		  $dev !~ m/^nvme\d+n\d+$/ &&
		  $dev !~ m/^c\d+d\d+$/;

	my $data = get_udev_info($dev);
	return if !defined($data);
	my $devpath = $data->{devpath};

	my $sysdir = "/sys/block/$dev";

	return if ! -d "$sysdir/device";

	# we do not want iscsi devices
	return if readlink($sysdir) =~ m|host[^/]*/session[^/]*|;

	my $sysdata = get_sysdir_info($sysdir);
	return if !defined($sysdata);

	my $type = 'unknown';

	if ($sysdata->{rotational} == 0) {
	    $type = 'ssd';
	    $data->{rpm} = 0;
	} elsif ($sysdata->{rotational} == 1) {
	    if ($data->{rpm} != -1) {
		$type = 'hdd';
	    } elsif ($data->{usb}) {
		$type = 'usb';
		$data->{rpm} = 0;
	    }
	}

	my $health = 'UNKNOWN';
	my $wearout;

	if (!$nosmart) {
	    eval {
		if ($type eq 'ssd') {
		    # if we have an ssd we try to get the wearout indicator
		    $wearout = 'N/A';
		    my $smartdata = get_smart_data($devpath);
		    $health = $smartdata->{health};
		    foreach my $attr (@{$smartdata->{attributes}}) {
			# ID 233 is media wearout indicator on intel and sandisk
			# ID 177 is media wearout indicator on samsung
			next if ($attr->{id} != 233 && $attr->{id} != 177);
			next if ($attr->{name} !~ m/wear/i);
			$wearout = $attr->{value};

			# prefer the 233 value
			last if ($attr->{id} == 233);
		    }
		} else {
		    # else we just get the health
		    $health = get_smart_health($devpath);
		}
	    };
	}

	my $used;

	$used = 'LVM' if $lvmlist->{$devpath};

	$used = 'mounted' if &$dev_is_mounted($devpath);

	$used = 'ZFS' if $zfslist->{$devpath};

	$disklist->{$dev} = {
	    vendor => $sysdata->{vendor},
	    model => $sysdata->{model},
	    size => $sysdata->{size},
	    serial => $data->{serial},
	    gpt => $data->{gpt},
	    rpm => $data->{rpm},
	    type =>  $type,
	    wwn => $data->{wwn},
	    health => $health,
	    devpath => $devpath,
	    wearout => $wearout,
	};

	my $osdid = -1;

	my $journal_count = 0;

	my $found_partitions;
	my $found_lvm;
	my $found_mountpoints;
	my $found_zfs;
	my $found_dm;
	my $partpath = $devpath;

	# remove part after last / to
	# get the base path for the partitions
	# e.g. from /dev/cciss/c0d0 get /dev/cciss
	$partpath =~ s/\/[^\/]+$//;

	dir_glob_foreach("$sysdir", "$dev.+", sub {
	    my ($part) = @_;

	    $found_partitions = 1;

	    if (my $mp = &$dev_is_mounted("$partpath/$part")) {
		$found_mountpoints = 1;
		if ($mp =~ m|^/var/lib/ceph/osd/ceph-(\d+)$|) {
		    $osdid = $1;
		}
	    }

	    if ($lvmlist->{"$partpath/$part"}) {
		$found_lvm = 1;
	    }

	    if ($zfslist->{"$partpath/$part"}) {
		$found_zfs = 1;
	    }

	    $journal_count++ if $journalhash->{"$partpath/$part"};

	    if (!&$dir_is_empty("$sysdir/$part/holders") && !$found_lvm)  {
		$found_dm = 1;
	    }
	});

	$used = 'mounted' if $found_mountpoints && !$used;
	$used = 'LVM' if $found_lvm && !$used;
	$used = 'ZFS' if $found_zfs && !$used;
	$used = 'Device Mapper' if $found_dm && !$used;
	$used = 'partitions' if $found_partitions && !$used;

	# multipath, software raid, etc.
	# this check comes in last, to show more specific info
	# if we have it
	$used = 'Device Mapper' if !$used && !&$dir_is_empty("$sysdir/holders");

	$disklist->{$dev}->{used} = $used if $used;
	$disklist->{$dev}->{osdid} = $osdid;
	$disklist->{$dev}->{journals} = $journal_count;
    });

    return $disklist;

}

1;
Commit	Line	Data
cbba9b5b DC	1	package PVE::Diskmanage;
	2
	3	use strict;
	4	use warnings;
	5	use PVE::ProcFSTools;
	6	use Data::Dumper;
	7	use Cwd qw(abs_path);
	8
	9	use PVE::Tools qw(extract_param run_command file_get_contents file_read_firstline dir_glob_regex dir_glob_foreach trim);
	10
	11	my $SMARTCTL = "/usr/sbin/smartctl";
	12	my $ZPOOL = "/sbin/zpool";
	13	my $SGDISK = "/sbin/sgdisk";
	14	my $PVS = "/sbin/pvs";
	15	my $UDEVADM = "/bin/udevadm";
	16
	17	sub verify_blockdev_path {
	18	my ($rel_path) = @_;
	19
	20	die "missing path" if !$rel_path;
	21	my $path = abs_path($rel_path);
	22	die "failed to get absolute path to $rel_path\n" if !$path;
	23
	24	die "got unusual device path '$path'\n" if $path !~ m\|^/dev/(.*)$\|;
	25
	26	$path = "/dev/$1"; # untaint
	27
	28	assert_blockdev($path);
	29
	30	return $path;
	31	}
	32
	33	sub assert_blockdev {
	34	my ($dev, $noerr) = @_;
	35
	36	if ($dev !~ m\|^/dev/\| \|\| !(-b $dev)) {
	37	return undef if $noerr;
	38	die "not a valid block device\n";
	39	}
	40
	41	return 1;
	42	}
	43
	44	sub init_disk {
	45	my ($disk, $uuid) = @_;
	46
	47	assert_blockdev($disk);
	48
	49	# we should already have checked if it is in use in the api call
	50	# but we check again for safety
	51	die "disk $disk is already in use\n" if disk_is_used($disk);
	52
	53	my $id = $uuid \|\| 'R';
	54	run_command([$SGDISK, $disk, '-U', $id]);
	55	return 1;
	56	}
	57
	58	sub disk_is_used {
	59	my ($disk) = @_;
	60
	61	my $dev = $disk;
	62	$dev =~ s\|^/dev/\|\|;
	63
7a98a62d	64	my $disklist = get_disks($dev, 1);
cbba9b5b DC	65
	66	die "'$disk' is not a valid local disk\n" if !defined($disklist->{$dev});
	67	return 1 if $disklist->{$dev}->{used};
	68
	69	return 0;
	70	}
	71
	72	sub get_smart_data {
	73	my ($disk) = @_;
	74
	75	assert_blockdev($disk);
	76	my $smartdata = {};
dc1311cb	77	my $type;
cbba9b5b	78
9018a4e6	79	my $returncode = 0;
c9bd3d22 FG	80
	81	$disk =~ s/n\d+$//
	82	if $disk =~ m!^/dev/nvme\d+n\d+$!;
	83
cbba9b5b	84	eval {
0c486b09	85	$returncode = run_command([$SMARTCTL, '-H', '-A', '-f', 'brief', $disk], noerr => 1, outfunc => sub{
cbba9b5b DC	86	my ($line) = @_;
cbba9b5b DC	87
1c999553 FG	88	# ATA SMART attributes, e.g.:
	89	# ID# ATTRIBUTE_NAME FLAGS VALUE WORST THRESH FAIL RAW_VALUE
	90	# 1 Raw_Read_Error_Rate POSR-K 100 100 000 - 0
dc1311cb FG	91	#
	92	# SAS and NVME disks, e.g.:
	93	# Data Units Written: 5,584,952 [2.85 TB]
	94	# Accumulated start-stop cycles: 34
	95
	96	if (defined($type) && $type eq 'ata' && $line =~ m/^([ \d]{2}\d)\s+(\S+)\s+(\S{6})\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/) {
cbba9b5b	97	my $entry = {};
1c999553 FG	98	$entry->{name} = $2 if defined $2;
1c999553 FG	99	$entry->{flags} = $3 if defined $3;
cbba9b5b	100	# the +0 makes a number out of the strings
1c999553 FG	101	$entry->{value} = $4+0 if defined $4;
	102	$entry->{worst} = $5+0 if defined $5;
	103	$entry->{threshold} = $6+0 if defined $6;
	104	$entry->{fail} = $7 if defined $7;
	105	$entry->{raw} = $8 if defined $8;
	106	$entry->{id} = $1 if defined $1;
cbba9b5b	107	push @{$smartdata->{attributes}}, $entry;
5db2d529	108	} elsif ($line =~ m/(?:Health Status\|self\-assessment test result): (.*)$/ ) {
cbba9b5b DC	109	$smartdata->{health} = $1;
cbba9b5b DC	110	} elsif ($line =~ m/Vendor Specific SMART Attributes with Thresholds:/) {
dc1311cb FG	111	$type = 'ata';
	112	delete $smartdata->{text};
	113	} elsif ($line =~ m/=== START OF (READ )?SMART DATA SECTION ===/) {
	114	$type = 'text';
	115	} elsif (defined($type) && $type eq 'text') {
	116	$smartdata->{text} = '' if !defined $smartdata->{text};
	117	$smartdata->{text} .= "$line\n";
cbba9b5b DC	118	}
	119	});
	120	};
9018a4e6 DC	121	my $err = $@;
	122
	123	# bit 0 and 1 mark an severe smartctl error
	124	# all others are for disk status, so ignore them
	125	# see smartctl(8)
	126	if ((defined($returncode) && ($returncode & 0b00000011)) \|\| $err) {
	127	die "Error getting S.M.A.R.T. data: Exit code: $returncode\n";
	128	}
dc1311cb FG	129
	130	$smartdata->{type} = $type;
	131
cbba9b5b DC	132	return $smartdata;
	133	}
	134
	135	sub get_smart_health {
	136	my ($disk) = @_;
	137
	138	return "NOT A DEVICE" if !assert_blockdev($disk, 1);
	139
acd3d916	140	my $message;
c9bd3d22 FG	141	$disk =~ s/n\d+$//
c9bd3d22 FG	142	if $disk =~ m!^/dev/nvme\d+n\d+$!;
cbba9b5b	143
acd3d916 FG	144	run_command([$SMARTCTL, '-H', $disk], noerr => 1, outfunc => sub {
acd3d916 FG	145	my ($line) = @_;
cbba9b5b	146
acd3d916 FG	147	if ($line =~ m/test result: (.*)$/) {
	148	$message = $1;
	149	} elsif ($line =~ m/open device: (.) failed: (.)$/) {
	150	$message = "FAILED TO OPEN";
	151	} elsif ($line =~ m/^SMART Disabled/) {
	152	$message = "SMART DISABLED";
	153	}
	154	});
cbba9b5b DC	155
	156	return $message;
	157	}
	158
	159	sub get_zfs_devices {
	160	my $list = {};
	161
	162	# use zpool and parttype uuid,
	163	# because log and cache do not have
	164	# zfs type uuid
	165	eval {
	166	run_command([$ZPOOL, 'list', '-HPLv'], outfunc => sub {
	167	my ($line) = @_;
	168
	169	if ($line =~ m\|^\t([^\t]+)\t\|) {
	170	$list->{$1} = 1;
	171	}
	172	});
	173	};
	174
	175	# only warn here,
	176	# because maybe zfs tools are not installed
	177	warn "$@\n" if $@;
	178
	179	my $applezfsuuid = "6a898cc3-1dd2-11b2-99a6-080020736631";
	180	my $bsdzfsuuid = "516e7cba-6ecf-11d6-8ff8-00022d09712b";
	181
	182	dir_glob_foreach('/dev/disk/by-parttypeuuid', "($applezfsuuid\|$bsdzfsuuid)\..+", sub {
	183	my ($entry) = @_;
	184	my $real_dev = abs_path("/dev/disk/by-parttypeuuid/$entry");
	185	$list->{$real_dev} = 1;
	186	});
	187
	188	return $list;
	189	}
	190
	191	sub get_lvm_devices {
	192	my $list = {};
	193	eval {
	194	run_command([$PVS, '--noheadings', '--readonly', '-o', 'pv_name'], outfunc => sub{
	195	my ($line) = @_;
	196	$line = trim($line);
	197	if ($line =~ m\|^/dev/\|) {
	198	$list->{$line} = 1;
	199	}
	200	});
	201	};
	202
	203	# if something goes wrong, we do not want
	204	# to give up, but indicate an error has occured
	205	warn "$@\n" if $@;
	206
	207	my $lvmuuid = "e6d6d379-f507-44c2-a23c-238f2a3df928";
	208
	209	dir_glob_foreach('/dev/disk/by-parttypeuuid', "$lvmuuid\..+", sub {
	210	my ($entry) = @_;
	211	my $real_dev = abs_path("/dev/disk/by-parttypeuuid/$entry");
	212	$list->{$real_dev} = 1;
	213	});
	214
	215	return $list;
	216	}
	217
	218	sub get_ceph_journals {
219	my $journalhash = {};
220
221	my $journal_uuid = '45b0969e-9b03-4f30-b4c6-b4b80ceff106';
222
223	dir_glob_foreach('/dev/disk/by-parttypeuuid', "$journal_uuid\..+", sub {
224	my ($entry) = @_;
225	my $real_dev = abs_path("/dev/disk/by-parttypeuuid/$entry");
226	$journalhash->{$real_dev} = 1;
227	});
228
229	return $journalhash;
230	}
231
232	sub get_udev_info {
233	my ($dev) = @_;
234
235	my $info = "";
236	my $data = {};
237	eval {
238	run_command([$UDEVADM, 'info', '-n', $dev, '--query', 'all'], outfunc => sub {
239	my ($line) = @_;
240	$info .= "$line\n";
241	});
242	};
243	warn $@ if $@;
244	return undef if !$info;
245
246	return undef if $info !~ m/^E: DEVTYPE=disk$/m;
247	return undef if $info =~ m/^E: ID_CDROM/m;
248
249	# we use this, because some disks are not simply in /dev
250	# e.g. /dev/cciss/c0d0
251	if ($info =~ m/^E: DEVNAME=(\S+)$/m) {
252	$data->{devpath} = $1;
253	}
254	return if !defined($data->{devpath});
255
256	$data->{serial} = 'unknown';
257	if ($info =~ m/^E: ID_SERIAL_SHORT=(\S+)$/m) {
258	$data->{serial} = $1;
259	}
260
261	$data->{gpt} = 0;
262	if ($info =~ m/^E: ID_PART_TABLE_TYPE=gpt$/m) {
263	$data->{gpt} = 1;
264	}
265
266	# detect SSD
267	$data->{rpm} = -1;
268	if ($info =~ m/^E: ID_ATA_ROTATION_RATE_RPM=(\d+)$/m) {
269	$data->{rpm} = $1;
270	}
271
272	if ($info =~ m/^E: ID_BUS=usb$/m) {
273	$data->{usb} = 1;
274	}
275
276	$data->{wwn} = 'unknown';
277	if ($info =~ m/^E: ID_WWN=(.*)$/m) {
278	$data->{wwn} = $1;
279	}
280
281	return $data;
282	}
283
284	sub get_sysdir_info {
285	my ($sysdir) = @_;
286
287	my $data = {};
288
289	my $size = file_read_firstline("$sysdir/size");
290	return undef if !$size;
291
292	# linux always considers sectors to be 512 bytes,
293	# independently of real block size
294	$data->{size} = $size * 512;
295
296	# dir/queue/rotational should be 1 for hdd, 0 for ssd
297	$data->{rotational} = file_read_firstline("$sysdir/queue/rotational");
298
299	$data->{vendor} = file_read_firstline("$sysdir/device/vendor") \|\| 'unknown';
300	$data->{model} = file_read_firstline("$sysdir/device/model") \|\| 'unknown';
301
302	return $data;
303	}
304
305	sub get_disks {
7a98a62d	306	my ($disk, $nosmart) = @_;
cbba9b5b DC	307	my $disklist = {};
	308
	309	my $mounted = {};
	310
	311	my $mounts = PVE::ProcFSTools::parse_proc_mounts();
	312
	313	foreach my $mount (@$mounts) {
	314	next if $mount->[0] !~ m\|^/dev/\|;
	315	$mounted->{abs_path($mount->[0])} = $mount->[1];
	316	};
	317
	318	my $dev_is_mounted = sub {
	319	my ($dev) = @_;
	320	return $mounted->{$dev};
	321	};
	322
	323	my $dir_is_empty = sub {
	324	my ($dir) = @_;
	325
	326	my $dh = IO::Dir->new ($dir);
	327	return 1 if !$dh;
	328
	329	while (defined(my $tmp = $dh->read)) {
	330	next if $tmp eq '.' \|\| $tmp eq '..';
	331	$dh->close;
	332	return 0;
	333	}
	334	$dh->close;
	335	return 1;
	336	};
	337
	338	my $journalhash = get_ceph_journals();
	339
	340	my $zfslist = get_zfs_devices();
	341
	342	my $lvmlist = get_lvm_devices();
	343
	344	dir_glob_foreach('/sys/block', '.*', sub {
	345	my ($dev) = @_;
	346	return if defined($disk) && $disk ne $dev;
	347	# whitelisting following devices
	348	# hdX: ide block device
	349	# sdX: sd block device
	350	# vdX: virtual block device
	351	# xvdX: xen virtual block device
	352	# nvmeXnY: nvme devices
	353	# cXnY: cciss devices
	354	return if $dev !~ m/^(h\|s\|x?v)d[a-z]+$/ &&
	355	$dev !~ m/^nvme\d+n\d+$/ &&
	356	$dev !~ m/^c\d+d\d+$/;
	357
	358	my $data = get_udev_info($dev);
	359	return if !defined($data);
	360	my $devpath = $data->{devpath};
	361
	362	my $sysdir = "/sys/block/$dev";
	363
	364	return if ! -d "$sysdir/device";
	365
	366	# we do not want iscsi devices
	367	return if readlink($sysdir) =~ m\|host[^/]/session[^/]\|;
	368
	369	my $sysdata = get_sysdir_info($sysdir);
	370	return if !defined($sysdata);
371
372	my $type = 'unknown';
373
374	if ($sysdata->{rotational} == 0) {
375	$type = 'ssd';
376	$data->{rpm} = 0;
377	} elsif ($sysdata->{rotational} == 1) {
378	if ($data->{rpm} != -1) {
379	$type = 'hdd';
380	} elsif ($data->{usb}) {
381	$type = 'usb';
382	$data->{rpm} = 0;
383	}
384	}
385
acd3d916	386	my $health = 'UNKNOWN';
cbba9b5b	387	my $wearout;
7a98a62d FG	388
	389	if (!$nosmart) {
	390	eval {
	391	if ($type eq 'ssd') {
	392	# if we have an ssd we try to get the wearout indicator
	393	$wearout = 'N/A';
	394	my $smartdata = get_smart_data($devpath);
	395	$health = $smartdata->{health};
	396	foreach my $attr (@{$smartdata->{attributes}}) {
	397	# ID 233 is media wearout indicator on intel and sandisk
	398	# ID 177 is media wearout indicator on samsung
	399	next if ($attr->{id} != 233 && $attr->{id} != 177);
	400	next if ($attr->{name} !~ m/wear/i);
	401	$wearout = $attr->{value};
	402
	403	# prefer the 233 value
	404	last if ($attr->{id} == 233);
	405	}
	406	} else {
	407	# else we just get the health
	408	$health = get_smart_health($devpath);
acd3d916	409	}
7a98a62d FG	410	};
7a98a62d FG	411	}
cbba9b5b DC	412
	413	my $used;
	414
	415	$used = 'LVM' if $lvmlist->{$devpath};
	416
	417	$used = 'mounted' if &$dev_is_mounted($devpath);
	418
	419	$used = 'ZFS' if $zfslist->{$devpath};
	420
	421	$disklist->{$dev} = {
	422	vendor => $sysdata->{vendor},
	423	model => $sysdata->{model},
	424	size => $sysdata->{size},
	425	serial => $data->{serial},
	426	gpt => $data->{gpt},
	427	rpm => $data->{rpm},
	428	type => $type,
	429	wwn => $data->{wwn},
	430	health => $health,
	431	devpath => $devpath,
	432	wearout => $wearout,
	433	};
	434
	435	my $osdid = -1;
	436
	437	my $journal_count = 0;
	438
	439	my $found_partitions;
	440	my $found_lvm;
	441	my $found_mountpoints;
	442	my $found_zfs;
	443	my $found_dm;
	444	my $partpath = $devpath;
	445
	446	# remove part after last / to
	447	# get the base path for the partitions
	448	# e.g. from /dev/cciss/c0d0 get /dev/cciss
	449	$partpath =~ s/\/[^\/]+$//;
	450
	451	dir_glob_foreach("$sysdir", "$dev.+", sub {
	452	my ($part) = @_;
	453
	454	$found_partitions = 1;
	455
	456	if (my $mp = &$dev_is_mounted("$partpath/$part")) {
	457	$found_mountpoints = 1;
	458	if ($mp =~ m\|^/var/lib/ceph/osd/ceph-(\d+)$\|) {
	459	$osdid = $1;
	460	}
	461	}
	462
	463	if ($lvmlist->{"$partpath/$part"}) {
	464	$found_lvm = 1;
	465	}
	466
	467	if ($zfslist->{"$partpath/$part"}) {
	468	$found_zfs = 1;
	469	}
	470
	471	$journal_count++ if $journalhash->{"$partpath/$part"};
	472
	473	if (!&$dir_is_empty("$sysdir/$part/holders") && !$found_lvm) {
	474	$found_dm = 1;
	475	}
476	});
477
478	$used = 'mounted' if $found_mountpoints && !$used;
479	$used = 'LVM' if $found_lvm && !$used;
480	$used = 'ZFS' if $found_zfs && !$used;
481	$used = 'Device Mapper' if $found_dm && !$used;
482	$used = 'partitions' if $found_partitions && !$used;
483
484	# multipath, software raid, etc.
485	# this check comes in last, to show more specific info
486	# if we have it
487	$used = 'Device Mapper' if !$used && !&$dir_is_empty("$sysdir/holders");
488
489	$disklist->{$dev}->{used} = $used if $used;
490	$disklist->{$dev}->{osdid} = $osdid;
491	$disklist->{$dev}->{journals} = $journal_count;
492	});
493
494	return $disklist;
495
496	}
497
498	1;