use strict;

use warnings;

use 5.010; # because if //

use List::Util qw( max );

use XML::Simple; # for config file

my %disks;

my %slots;

my %locations;

my $cfgfile="/etc/luninfo.cfg";

my $cfg; #configuration hash

if ( -e $cfgfile ) {

$cfg=XMLin($cfgfile, ForceArray => 1);

}

foreach my $location ( keys %{$cfg->{'location'}} ) {

foreach my $element ( keys %{$cfg->{'location'}->{$location}} ) {

for ( $element) {

if ( /storage/ ) {

foreach my $box ( keys %{$cfg->{'location'}->{$location}->{$element}} ) {

if ( defined $locations{$box} ) {

print STDERR "ERROR in $cfgfile: Duplicate use of storage serial $box! Using first definition.\n";

next;

}

$locations{$box}=$location;

}

}

}

}

}

open(CMD,"/usr/sbin/lsdev -c disk -F'name subclass type status'|") or die "Error running lsdev -c disk -F'name subclass type'!";

while(<CMD>) {

chomp;

if ( m/(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/ ) {

$disks{$1}->{'name'}=$1;

$disks{$1}->{'subclass'}=$2;

$disks{$1}->{'type'}=$3;

$disks{$1}->{'status'}=$4;

}

}

close(CMD);

open(CMD,"/usr/sbin/lspv|") or die "Error running /usr/sbin/lspv!";

while(<CMD>) {

chomp;

if ( m/(\S+)\s+(\S+)\s+(\S+)/ ) {

#$disks{$1}->{'name'}=$1;

$disks{$1}->{'pvid'}=$2;

$disks{$1}->{'vg_name'}=$3;

my $disk=$1;

# get size of each available disk... this is the most time consuming part

if ( $disks{$disk}->{'status'} eq "Available" ) {

open(CMD1,"/usr/bin/getconf DISK_SIZE /dev/$disk 2>/dev/null|") or die "Error getting disk size for disk $disk\n";

while(<CMD1>) {

chomp;

$disks{$disk}->{'size'}=$_;

}

close(CMD1);

# check error of finished process (shift right by 8)

my $rc=$? >> 8;

if ( $rc != 0 ) {

# disksize -> none if getconf gives error

$disks{$disk}->{'size'}="none";

}

} else {

# disksize -> none for defined disks

$disks{$disk}->{'size'}="none";

}

}

}

close(CMD);

my @vtd_list;

{

local $/="\n\n"; # record delimiter is 2 new lines = paragraph

@vtd_list=qx { /usr/bin/odmget -q "attribute=aix_tdev" CuAt };

}

foreach my $vtd ( @vtd_list ) {

my $vtd_name="";

my $vtd_disk="";

if ( $vtd =~ m/\s+name\s+=\s+"(\S+)"/m ) { $vtd_name = $1; }

if ( $vtd =~ m/\s+value\s+=\s+"(\S+)"/m ) { $vtd_disk = $1; }

if ( $vtd_disk ne "" and $vtd_name ne "" ) {

$disks{$vtd_disk}->{'vtd'}=$vtd_name;

}

}

undef @vtd_list;

open(CMD,'/usr/sbin/lsdev -Cc adapter -t IBM,v-scsi-host -F name,status,physloc|') or die "Error running /usr/sbin/lsdev -Cc adapter -t IBM,v-scsi-host -F name,status,physloc !\n";

while(<CMD>) {

chomp;

my ($device,$status,$hwpath) = split(/,/);

if ( $hwpath =~ /[^-]+\-V[0-9]+\-(C[0-9]+)/ ) {

$slots{$device}=$1;

}

}

my %vhost2lpar;

my @vtd_vhost_list;

{

local $/="\n\n";

@vtd_vhost_list=qx { /usr/bin/odmget -q PdDvLn="virtual_target/vtdev/scdisk" CuDv };

}

foreach my $vtd ( @vtd_vhost_list ) {

my $vtd_name="";

my $vtd_parent="";

if ( $vtd =~ m/\s+name\s+=\s+"(\S+)"/m ) { $vtd_name = $1; }

if ( $vtd =~ m/\s+parent\s+=\s+"(\S+)"/m ) { $vtd_parent = $1; }

if ( $vtd_parent ne "" and $vtd_name ne "" ) {

$vhost2lpar{$vtd_parent}->{'vhost'}=$vtd_parent; # will be filled later, only available/configured vhosts will be put here

foreach my $disk ( keys %disks ) {

if ( defined $disks{$disk}->{'vtd'} and $disks{$disk}->{'vtd'} eq $vtd_name ) {

$disks{$disk}->{'vhost'}=$vtd_parent;

last;

}

}

}

}

undef @vtd_vhost_list;

my @uuid_list;

{

local $/="\n\n";

@uuid_list=qx { /usr/bin/odmget -q "attribute=unique_id" CuAt };

}

foreach my $uuid ( @uuid_list ) {

my $unique_id="";

my $name="";

if ( $uuid =~ m/\s+name\s+=\s+"(\S+)"/m ) { $name=$1; }

if ( $uuid =~ m/\s+value\s+=\s+"(\S+)"/m ) { $unique_id=$1; }

if ( $name ne "" and $unique_id ne "" and defined $disks{$name} ) {

$disks{$name}->{'unique_id'}=$unique_id;

}

}

undef @uuid_list;

my @lunid_list;

{

local $/="\n\n";

@lunid_list=qx { /usr/bin/odmget -q "attribute=lun_id" CuAt };

}

foreach my $luid ( @lunid_list ) {

my $lun_id="";

my $name="";

if ( $luid =~ m/\s+name\s+=\s+"(\S+)"/m ) { $name=$1; }

if ( $luid =~ m/\s+value\s+=\s+"(\S+)"/m ) { $lun_id=$1; }

if ( $name ne "" and $lun_id ne "" and defined $disks{$name} ) {

$disks{$name}->{'lun_id'}=$lun_id;

}

}

undef @uuid_list;

sub identify_2145 {

my $disksref = shift;

my $d = shift;

# SVC disks:

# 3321360050768019081CFD800000000000A8404214503IBMfcp

# SVC LUNs visible directly via FC or NPIV but without SDDPCM:

# 33213600507680180867968000000000006E804214503IBMfcp

# SVC LUNs visible through VIO:

# 48333321360050768019081CFD8000000000009D804214503IBMfcp05VDASD03AIXvscsi

# IBM storage WWN always start with 6005076

if ( defined $disksref->{$d}->{'unique_id'} and $disksref->{$d}->{'unique_id'} =~ m/^\S+(6005076......(.....)..........(..)(..))..2145..IBMfcp/ ) {

$disksref->{$d}->{'uuid'}=$1;

$disksref->{$d}->{'box'}=$2;

$disksref->{$d}->{'suid'}="$3:$4";

$disksref->{$d}->{'box_type'}="2145";

if ( defined $disksref->{$d}->{'lun_id'} ) {

if ( $disksref->{$d}->{'lun_id'} =~ m/0x(?:([\da-f]+)0{12}|0)\b/ ) { # either 0 or value without 12 zeros

$disksref->{$d}->{'scsi_id'}= defined $1 ? hex($1):0;

}

}

# This should work from AIX 5.3 upwards for 2145

# This might work for DS5000 (type 1818) too, although I don't have a machine to test with

return 1; # true

}

return 0; # false

}

sub identify_2107 {

my $disksref = shift;

my $d = shift;

# DS8000 family LUN

# 200B75G6831015607210790003IBMfcp

if ( defined $disksref->{$d}->{'unique_id'} and $disksref->{$d}->{'unique_id'}=~m/^....(.......)((..)(..))..2107900..IBMfcp/ ) {

$disksref->{$d}->{'box'}=$1;

$disksref->{$d}->{'uuid'}="$1_$2"; # this is normally $2 ONLY, but we don't print the box

$disksref->{$d}->{'suid'}="$3:$4";

$disksref->{$d}->{'box_type'}="2107";

# There is a lun_id for DS8000 too, but this contains the same info as $3$4 (0x40XX40XX00000000)

return 1; # true

}

return 0; # false

}

sub identify_htc_vsp_gx00 {

my $disksref = shift;

my $d = shift;

# may also work with Hitachi boxes that use those disk types:

# htc9900mpio

# htchusvmmpio

# htcuspmpio

# htcuspvmpio

# htcvspg1000mpio

# htcvspmpio

# tested with Hitachi VSP G200 without HDLM, just AIX MPIO

# 240C504138FE013006OPEN-V07HITACHIfcp

if ( defined $disksref->{$d}->{'unique_id'} and $disksref->{$d}->{'unique_id'}=~ m/........(....)((..)(..))..OPEN-...HITACHIfcp/ ) {

$disksref->{$d}->{'box'}=$1;

$disksref->{$d}->{'uuid'}="$1_$2";

$disksref->{$d}->{'suid'}="$3:$4";

$disksref->{$d}->{'box_type'}="HTC";

if ( defined $disksref->{$d}->{'lun_id'} ) {

if ( $disksref->{$d}->{'lun_id'} =~ m/0x(?:([\da-f]+)0{12}|0)\b/ ) { # either 0 or value without 12 zeros

$disksref->{$d}->{'scsi_id'}= defined $1 ? hex($1):0;

}

}

return 1; # true

}

return 0; # false

}

sub identify_purestorage {

my $disksref = shift;

my $d = shift;

# puredisk

# tested with Purestorage, box type unknown

# 3A213624A93708D4089CD6DB5405A000113E70AFlashArray04PUREfcp

# Important: The box or array id does not change when a lun is moved later on to another box! Take care!

# see https://www.codyhosterman.com/2016/01/vmfs-snapshots-and-the-flasharray-part-iv-how-to-correlate-a-vmfs-to-a-flasharray-volume/

# and https://www.codyhosterman.com/2018/02/volume-matching-via-the-api-in-purity-5-0/

if ( defined $disksref->{$d}->{'unique_id'} and $disksref->{$d}->{'unique_id'}=~ m/.....624A9370((................)(........))..FlashArray04PUREfcp/ ) {

$disksref->{$d}->{'box'}=$2; # ????

$disksref->{$d}->{'uuid'}="$1";

my $tmpsuid=$3;

$tmpsuid=~ s/^0+//g; # remove leading zeros

$disksref->{$d}->{'suid'}="$tmpsuid";

$disksref->{$d}->{'box_type'}="PURE";

if ( defined $disksref->{$d}->{'lun_id'} ) {

if ( $disksref->{$d}->{'lun_id'} =~ m/0x(?:([\da-f]+)0{12}|0)\b/ ) { # either 0 or value without 12 zeros

$disksref->{$d}->{'scsi_id'}= defined $1 ? hex($1):0;

}

}

return 1; # true

}

return 0; # false

}

sub identify_nimblevolume {

my $disksref = shift;

my $d = shift;

# nimblevolume

# tested with Nimble box (unknown version). ODM package necessary!

# 372024b0c462a17e9aa76c9ce9004c7b937406Server06Nimblefcp

# the numbers in front of Server and Nimble seem to be the length of the following string, let's not depend on that 8-)

if ( defined $disksref->{$d}->{'unique_id'} and $disksref->{$d}->{'unique_id'}=~ m/....((................)6c9ce(...........))..Server..Nimblefcp/ ) {

$disksref->{$d}->{'box'}=$3;

$disksref->{$d}->{'uuid'}="$1";

$disksref->{$d}->{'suid'}="$2";

$disksref->{$d}->{'box_type'}="NIMB";

if ( defined $disksref->{$d}->{'lun_id'} ) {

if ( $disksref->{$d}->{'lun_id'} =~ m/0x(?:([\da-f]+)0{12}|0)\b/ ) { # either 0 or value without 12 zeros

$disksref->{$d}->{'scsi_id'}= defined $1 ? hex($1):0;

}

}

return 1; # true

}

return 0; # false

}

foreach my $disk ( keys %disks ) {

#open(CMD,"/usr/sbin/lsattr -El $disk|") or die "Error running /usr/sbin/lsattr -El $disk !\n";

#while(<CMD>) {

# if ( /^lun_id\s+(\S+)/ ) { $disks{$disk}->{'lun_id'}=$1; } # only for some physical disks (e.g. 2145, 1818..)

#}

#close(CMD);

#

# use type and subclass to separate disks

for ($disks{$disk}{'type'}) {

#2105 - 2105 models (ESS)

#2145 - 2145 models (SVC)

#2147 - 2147 models (SVC)

#1750 - 1750 devices (DS 6000)

#2107 - 2107 devices (DS 8000)

#1724 - 1724 devices (DS 4100)

#1814 - 1814 devices (DS 4200 and DS 4700)

#1722 - 1722 devices (DS 4300)

#1742 - 1742 devices (DS 4400 and DS 4500)

#1815 - 1815 devices (DS 4800)

#1818 - 1818 devices (DS 5000)

if (/2145/) {

identify_2145(\%disks, $disk);

}

elsif (/2107/) {

identify_2107(\%disks, $disk);

}

elsif (/puredisk/) {

identify_purestorage(\%disks, $disk);

}

elsif (/nimblevolume/) {

identify_nimblevolume(\%disks, $disk);

}

elsif (/vdisk/) {

identify_2145(\%disks, $disk) or

identify_purestorage(\%disks, $disk) or

identify_nimblevolume(\%disks, $disk) or

identify_2107(\%disks, $disk);

}

elsif (/mpioosdisk/) { # generic AIX MPIO

identify_2145(\%disks, $disk) or

identify_purestorage(\%disks, $disk) or

identify_nimblevolume(\%disks, $disk) or

identify_2107(\%disks, $disk);

}

elsif (/htcvspgx00mpio/) { # Hitachi VSP GX00 MPIO

identify_htc_vsp_gx00(\%disks, $disk);

}

elsif (/scsd/) { # parallel or serial SCSI disk (subclass would be scsi and sas)

delete $disks{$disk}; # we are not interested in those -> remove from hash

}

elsif (/osdisk/) { # generic disk without ODM package or driver

print STDERR "Generic $disks{$disk}->{'type'} for disk $disk is not supported! Please install MPIO ODM or driver!\n";

delete $disks{$disk}; # we are not interested in those -> remove from hash

}

elsif (/sisarray/) { # SAS RAID arrays

delete $disks{$disk}; # we are (currently) not interested in those -> remove from hash

} else {

print STDERR "Unknown disk type $disks{$disk}{'type'} for disk $disk found!\n";

undef $disks{$disk};

}

}

}

my $parallel_kdb_queries=15; # 15 queries in 1 kdb call. Reduce if you see errors or missin lpar names

my $kdb_count=0;

my $number_of_vhosts= scalar(keys %vhost2lpar);

my $initial_kdb_command= "svCmdIni; svPrQs; ";

my $kdb_command=$initial_kdb_command;

foreach my $vhost ( keys %vhost2lpar ) {

$kdb_count++; $number_of_vhosts--;

$kdb_command .= "svva $vhost; ";

if ( $kdb_count == $parallel_kdb_queries or $number_of_vhosts == 0 ) {

my $vhost_name="";

my $lpar_name="";

my $lpar_number="";

open(CMD,"echo \"$kdb_command\" \|/usr/sbin/kdb -script|" ) or die "Error running /usr/sbin/kdb -script !\n";

while(<CMD>) {

if ( m/\s+Target vSCSI Adapter Structure\s+(\S+)\b/ ) {

$vhost_name=$1;

}

if ( m/client_data.srp_version:\s+\S+\s+client_data.partition_name:\s+(\S+)\b/ ) {

$lpar_name=$1;

}

if ( m/client_data.srp_version:\s+client_data.partition_name:\s+$/ ) {

$lpar_name='none'; # special case of empty vhost

}

if ( m/client_data.partition_number:\s+([\da-fA-F]+)\b/ ) {

$lpar_number=$1; # 0 means "any partition" -> vhost is empty

# this reflects HMC profile values (partition id).

}

if ( $lpar_name ne "" and $vhost_name ne "" and $lpar_number ne "" ) {

$vhost2lpar{$vhost_name}->{'lpar_name'}=$lpar_name;

$vhost2lpar{$vhost_name}->{'lpar_number'}=hex($lpar_number);

$vhost_name=""; $lpar_name=""; $lpar_number="";

}

}

close(CMD);

$kdb_count=0; $kdb_command=$initial_kdb_command;

}

}

sub disks_numerically {

$a=~ /\D+(\d+)/;

my $aa=$1;

$b=~ /\D+(\d+)/;

my $bb=$1;

$aa <=> $bb;

}

my $max_box_len=max(3, map length($_->{'box'}//""), values %disks);

my $max_uuid_len=max(5, map length($_->{'uuid'}//""), values %disks);

my $max_uid_len=max(5, map length($_->{'suid'}//""), values %disks);

printf("%-9s %*s %*s %8s %-*s %7s %4s %18s %-4s %8s %16s %12s %6s\n",

"#DISK",

$max_uuid_len,"UUID",

$max_uid_len,"SUID",

"SIZE",

$max_box_len,"BOX",

"LOC",

"SCSI",

"PVID",

"SLOT",

"VHOST",

"VTD",

"LPAR",

"LPARID");

foreach my $disk ( sort disks_numerically keys %disks) {

# for now just look at available disk...

if ( defined $disks{$disk}->{'status'} and $disks{$disk}->{'status'} eq "Available" ) {

printf("%-9s %*s %*s %8s %-*s %7s %4s %18s %-4s %8s %16s %12s %6s\n",

$disks{$disk}->{'name'},

$max_uuid_len, $disks{$disk}->{'uuid'} // "-",

$max_uid_len, $disks{$disk}->{'suid'} // "-",

$disks{$disk}->{'size'} // "-",

$max_box_len, $disks{$disk}->{'box'} // "-",

$locations{$disks{$disk}->{'box'}} // "UNKN",

$disks{$disk}->{'scsi_id'} // "-",

$disks{$disk}->{'pvid'} // "-",

(defined $disks{$disk}->{'vhost'} and $slots{$disks{$disk}->{'vhost'}} ) ? $slots{$disks{$disk}->{'vhost'}} : "-",

$disks{$disk}->{'vhost'} // "-",

$disks{$disk}->{'vtd'} // "-",

(defined $disks{$disk}->{'vhost'} and $vhost2lpar{$disks{$disk}->{'vhost'}}->{'lpar_name'} ) ? $vhost2lpar{$disks{$disk}->{'vhost'}}->{'lpar_name'} : "-",

(defined $disks{$disk}->{'vhost'} and $vhost2lpar{$disks{$disk}->{'vhost'}}->{'lpar_number'} ) ? $vhost2lpar{$disks{$disk}->{'vhost'}}->{'lpar_number'} : "-"

);

}

}