#!/bin/bash
#
# Usage:
#
# There are utils for diskdiscover and configraid.
#

log_file=$1

##############################
# declare all commands
##############################
awk="awk"
sed="sed"
cut="cut"
sleep="sleep"
sort="sort"
ps="ps"
head="head"
readlink="readlink"
basename="basename"
udevadm="udevadm"
touch="touch"
tail="tail"
dmesg="dmesg"
grep="grep"
lspci="lspci"

############################################
#
# source raidcmd
#
###########################################
str_dir_name=`dirname $0`
. $str_dir_name/raidcmd

################################################################
#
#  Input PCI_ID to get PCI location
#
#  input: pci_id
#
#  output: pci locations
#
################################################################
function get_pciloc_by_id {
    local __in_pciid=$1
    if echo "$__in_pciid" | $grep -sq "_"; then
        __in_pciid=`echo "$__in_pciid" | $sed -e 's/_/:/'`
    fi
    local sysdevdir=/sys/bus/pci/devices
    local pcilocs=`cd $sysdevdir 2>/dev/null && for dev in *
    do
        lines=$($udevadm info --query=property --path=$sysdevdir/$dev)
        if echo "$lines" | $grep -i -sq -E "^PCI_ID=$__in_pciid$|^PCI_SUBSYS_ID=$__in_pciid$"; then
            echo $dev
        fi
    done `
    [ -z "$pcilocs" ] && return 1
    echo "$pcilocs"
    return 0
}

######################################################
#
# get pci_slot scsi device
#
# input: slocs, for example, 0:0:0:0 0:0:1:0
#
# output: <sloc>=<device_name> ...
#         <sloc>=<device_name>
#
######################################################
function convert_sloc_to_sg {
    local __slocs="$*"
    for __sloc in $__slocs
    do
        if echo "$__sloc" | grep -sq "[0-9]\+:[0-9]\+:[0-9]\+:[0-9]\+"; then
            __sg=`$readlink /sys/class/scsi_device/$__sloc/device/generic`
            if [ "$__sg" ]; then
                __sg=`$basename $__sg`
            fi
        elif echo "$__sloc" | grep -sq -E '^sg[0-9]+|^sd[a-z]+'; then
            __sg="$__sloc"
            __sloc=`convert_sg_to_sloc $__sg | $awk -F= '{print $2}'`
        fi
        echo "$__sloc=$__sg"
    done
    return 0
}

#################################################################
#
#  Through PCI/SCSI device to find PCI/SCSI location
#
#  input: device names,
#         sg0 ...sgn
#
#  output: <dev>=<sloc>... <dev>=<sloc>
#
################################################################
function convert_sg_to_sloc {
    local __sgs="$*"
    local __sloc=""
    for __sg in $__sgs
    do
        if echo "$__sg" | grep -sq "^sg[0-9]\+"; then
            __sloc=`$readlink /sys/class/scsi_generic/$__sg/device`
            if [ "$__sloc" ]; then
                __sloc=`$basename $__sloc`
            fi
        elif echo "$__sg" | grep -sq "^sd[a-z]\+"; then
            __sloc=`$readlink /sys/block/$__sg/device`
            if [ "$__sloc" ]; then
                __sloc=`$basename $__sloc`
            fi
        elif echo "$__sg" | grep -sq "[0-9]\+:[0-9]\+:[0-9]\+:[0-9]\+"; then
            __sloc="$__sg"
            __sg=`convert_sloc_to_sg $__sloc | $awk -F= '{print $2}'`
        fi
        echo "$__sg=$__sloc"
    done
    return 0
}

############################################################################
#
# get devices which are qualified to be used to create raid
# it should equals to "query-raid-create" after all array had
# been deleted.
# Note: output format of this command is multilines
# <pciloc_of_ioa1>=<sloc_of_disk1>,<sloc_of_disk2>,...
# <pciloc_of_ioa2>=<sloc_of_disk1>,<sloc_of_disk2>,...
# ...
###########################################################################
function get_raid_create_devices_by_pciloc {
    local lines=""
    local pcilocs="$*"
    [ -z "$pcilocs" ] && return 1

    # reorder ipr ioa pcilocs by its Primary and Secondary state
    local ioas=`get_ipr_ioas_by_pciloc $pcilocs`
    pcilocs=`get_sg_pciloc $ioas | $awk -F= '{print $2}' `
    lines=`cmd_show_config`
    local slocs=""
    local line=""
    for pciloc in $pcilocs
    do
        # exclude:
        # 1) scsi adapter(ioa);
        # 2) scsi enclosure;
        # 3) disk array;
        slocs=`echo "$lines" \
        | grep '^.*[ ]\+'$pciloc'\/[0-9]\+:[0-9]\+:[0-9]\+:[0-9]\+.*$' \
        | grep -v -E "Adapter|Enclosure|Disk Array" \
        | cut_sloc_from_iprconfig_line \
        | $sort -V \
        | $sed -e 's/ /,/g' \
        | awk '{printf (NR>1)?","$0:$0}'`
        if [ -n "$slocs" ]; then
            line="$pciloc=$slocs"
            echo "$line"
        fi
    done
    return 0
}

########################################################################################
#
# return list of ioas on target pciloc with order of Primary --> Secondary --> Others
#
# input: pci locations
#
# output: sorted raid adapters location list
#
#########################################################################################
function get_ipr_ioas_by_pciloc {
    local pcilocs="$*"
    [ -z "$pcilocs" ] && return 1

    # find out all ioas and its current adapter state
    local ioas_all=`cmd_show_ioas | grep "^sg[0-9]\+.*Operational" | $awk '{print $1}'`
    # group them into "Primary" and "Secondary" groups
    local lines=`for ioa in $ioas_all
    do
        state=$(cmd_show_details $ioa | grep "Current Dual Adapter State" | $sed -e 's/^.* : \+\(.*\)$/\1/')
        echo "$state=$ioa"
    done`
    local ioa_primary=`echo "$lines" | $awk -F= '($1 == "Primary") {print $2}'`
    local ioa_secondary=`echo "$lines" | $awk -F= '($1 == "Secondary") {print $2}'`
    local ioa_others=`echo "$lines" | $awk -F= '($1 != "Primary") && ($1 != "Secondary") {print $2}'`
    ioas_all="$ioa_primary $ioa_secondary $ioa_others"

    # pick up ioa on target pciloc
    lines=`echo "$pcilocs" | $sed -e 's/[, ]/\n/g'`
    local ioas_in=""
    if [ "$lines" = "all" ]; then
        ioas_in="$ioas_all"
    else
        ioas_in=`for ioa in $ioas_all
        do
            ioa_pciloc=$(get_sg_pciloc $ioa | awk -F= '{print $2}')
            if echo "$lines" | grep -sq -i "^${ioa_pciloc}$"; then
                echo $ioa
            fi
        done `
    fi
    [ -z "$ioas_in" ] && return 1
    echo "$ioas_in"
    return 0
}

###############################################
#
# use udev to determine pciloc of sg device
#
# input: disk name list
#
# output: <dev>=<sloc>...<dev>=<sloc>
#
###############################################
function get_sg_pciloc {
    local sgs="$*"
    [ -z "$sgs" ] && return 1

    local sg=""
    local pciloc=""
    for item in $sgs
    do
        sg=`convert_sloc_to_sg $item | $awk -F= '{print $2}'`
        [ -z "$sg" ] && continue
        pciloc=`cmd_show_details $sg \
                | grep "^PCI Address" \
                | $sed -e 's/.*:[ ]\+\([0-9]\+:[0-9]\+:[0-9]\+\.[0-9]\+\).*$/\1/'`

        if [ -n "$pciloc" ]; then
            echo "$sg=$pciloc"
        fi
    done
    return 0
}

######################################################
#
# cut resouce_path
#
#####################################################
function cut_sloc_from_iprconfig_line {
    $sed -e 's/^.*[ ]\+\(.*\)\/\([0-9]\+:[0-9]\+:[0-9]\+:[0-9]\+\).*$/\2/g'
}

#####################################################################
#
# find descriptions and status for device
#
# input: pci locations
#
# output:  descriptions and status from "iprconfig -c show-config"
#
###################################################################
function find_desc_status_sg {
    local lines=""
    local pciscsilocs="$*"
    [ -z "$pciscsilocs" ] && return 1

    lines=`cmd_show_config`
    local slocs=""
    local line=""
    for pciscsiloc in $pciscsilocs
    do
        slocs=`echo "$lines" \
        | $grep "${pciscsilocs}" \
        | awk '{for(i=3;i<=NF;++i) printf $i "\t";printf "\n"}'`
        echo $slocs
    done
    return 0

}

#######################################################
#
#  get disk devices through pci_id
#
#  input: pci id
#
#######################################################
function get_devices_by_pciid {

    local pciid="$*"
    [ -z "$pciid" ] && return 1

    pcilocs=`get_pciloc_by_id $pciid`


    if [ -z "$pcilocs" ]; then
        echo "There is no PCI_SLOT_NAME for PCI_ID:$pciid."
        return 1
    fi
    slocs_grps=`get_raid_create_devices_by_pciloc $pcilocs`
    if [ -z "$slocs_grps" ]; then
        echo "Could not find any disk on target pciloc ${pcilocs}!"
        return 1
    fi
    arrage_output $pciid "$slocs_grps"

}

######################################################################
#
# get ipr raid arrays by PCI location
#
# input: pci locations
#
# output: raid arrays
#
#####################################################################
function get_ipr_arrays_by_pciloc {
    local pcilocs="$*"
    [ -z "$pcilocs" ] && return 1

    # reorder ipr ioa pcilocs by its Primary and Secondary state
    local ioas=`get_ipr_ioas_by_pciloc $pcilocs`
    pcilocs=`get_sg_pciloc $ioas | $awk -F= '{print $2}' `

    local lines=$(cmd_show_arrays)
    local slocs=`for pciloc in $pcilocs
    do
        echo "$lines"
    done `
    [ -n "$slocs" ] && echo "$slocs"
    return 0
}

#####################################################################
#
# get all af and jbod disks
#
# input: no
#
# output: all devices table
#
####################################################################
function get_all_devices_for_raid {

    local showlines=`cmd_show_config`

    pcilocs=`echo "$showlines" \
             | $grep -v -E "Adapter|Enclosure|Disk Array" \
             | $grep '^.*[ ]\+\(.*\)\/\([0-9]\+:[0-9]\+:[0-9]\+:[0-9]\+\).*$'|$sed 's/ /,/g'|cut -c 8-19`

    [ -z "$pcilocs" ] && return 1
    slocs_grps=`get_raid_create_devices_by_pciloc $pcilocs`
    if [ -z "$slocs_grps" ]; then
        echo "Could not find any disk on target pciloc ${pcilocs}!"
    fi
    arrage_output "null" "$slocs_grps"
}

#####################################################################
#
# output of disks and arrays
#
# input: pci_id sloc_grps
#
# output: all devices table
#
####################################################################
function arrage_output {
    pciid=$1
    shift
    slocs_grps=$*

    # find the required member disks
    echo "--------------------------------------------------------------------------"
    echo "PCI_ID     PCI_SLOT_NAME  Resource_Path  Device  Description   Status"
    echo "------     -------------  -------------  ------  -----------   ----------------"
    slocs=""
    for item in $slocs_grps
    do
         pciloc=`echo "$item" | $awk -F= '{print $1}'`
         slocs_grp=`echo "$item" | $awk -F= '{print $2;}'i \
                                 | $sed 's/,/ /g'`

         if [ x$pciid == "xnull" ]; then
             pciid=`get_PCI_ID $pciloc`
         fi
         for sloc in $slocs_grp
         do
              pciscsiloc="$pciloc/$sloc"
              desc=`find_desc_status_sg $pciscsiloc`
              disk=`convert_sloc_to_sg $sloc | $awk -F= '{print $2}'`
              echo "$pciid  $pciloc   $sloc        $disk     $desc "
         done
         echo "-------------------------------------------------------------------"
         echo "Get ipr RAID arrays by PCI_SLOT_NAME: $pciloc"
         echo "-------------------------------------------------------------------"
         get_ipr_arrays_by_pciloc $pciloc
    done

}


###############################################################
#
# get PCI_ID through lspci
#
# input: pci location
#
# output: pci id
#
###############################################################
function get_PCI_ID {
    pcislot=$1
    pciid=`$lspci | $grep ${pcislot} | $awk '{print $5}'`
    echo $pciid
}

###########################################
#
# Identify if sloc is exist or not
#
# input: dev sloc
#
# output: 0  exist
#         1  not
#
##########################################
function sloc_exist {
    local __sloc="$1"
    __sloc=`convert_sg_to_sloc $__sloc | $awk -F= '{print $2}'`
    rc=1
    [ -n "$__sloc" ] && [ -d /sys/class/scsi_device/$__sloc/device ] && rc=0
    return $rc
}

###########################################
#
# get all raid arrays
#
# output : array1#array2..
#
##########################################
function get_all_raid_arrays {
    local arrays=`cmd_show_arrays \
                  | $awk '{print $1}'\
                  | $sed -n '3,$p'`
    echo $arrays
}

#################################################
#
# Identify if sloc is raid or not
#
# input : dev sloc
#
# return : 1  ------not raid
#          0  ------is raid
#
##################################################
function is_ipr_array {
    local __sloc="$1"
    local __sg=`convert_sloc_to_sg $__sloc | $awk -F= '{print $2}'`
    [ -n "$__sg" ] && is_array $__sg
}

#################################################
#
# get all ioas
#
##################################################
function get_ipr_ioas {
    get_ipr_ioas_by_pciloc all
}

#################################################
#
# cut pci location from iprconfig line
#
##################################################
function cut_pciloc_from_iprconfig_line {
    $sed -e 's/^.*[ ]\+\(.*\)\/\([0-9]\+:[0-9]\+:[0-9]\+:[0-9]\+\).*$/\1/g'
}

##############################################
#
# get member disk for ipr array
#
# input : array name
#
# output : member sloc list
#          "member_sloc1 member_sloc2 ...."
#
#############################################
function get_ipr_array_members {
    local array="$1"
    local array_sloc=`convert_sg_to_sloc $array | $awk -F= '{print $2}'`
    # array does not exist, error with rc=1
    [ -z "$array_sloc" ] && return 1

    local lines=`cmd_show_config`
    # get scsi locations of disk array members
    local member_slocs=`echo "$lines" \
    | $awk '
    BEGIN { hit=0; members=""; }
    /^.*\/'$array_sloc'[ ]+.*Disk Array.*$/ { hit=1; next; }
    {
        if (hit==1) {
            if ($0 ~ /RAID .* Member/) {
                # ignore "Remote" array members
                if ($0 !~ / *Remote *$/) {
                    print $0
                }
            } else {
                hit=0
            }
        }
    }' \
    | cut_sloc_from_iprconfig_line `
    # array does not have any member which should not, error with rc=1
    [ -z "$member_slocs" ] && return 1

    echo "$member_slocs"
    log_details "array[$array] has member disks[$member_slocs]" >&2
    return 0
}

#####################################################################
#
# get array by disk
#
# input : array disk member name
#
# output : array sloc
#
###################################################################
function get_ipr_array_by_member {
    local sg="$1"
    local member_sloc=`convert_sg_to_sloc $sg | $awk -F= '{print $2}'`
    # member does not exists, error with rc=1
    [ -z "$member_sloc" ] && return 1

    local lines=`cmd_show_config`
    local array_sloc=`echo "$lines" \
    | $awk '
    BEGIN { hit=0; line="na"; }
    /Disk Array/ { hit=1; line=$0; next; }
    {
        if (hit==1) {
            if ($0 ~ /RAID .* Member/) {
                if ($0 ~ /\/'$member_sloc'[ ]+.*/) {
                    print line
                    exit 0
                }
            } else {
              hit=0; line="na"
            }
        }
    }' \
    | cut_sloc_from_iprconfig_line`
    # disk does not belongs to any array, error with rc=1
    [ -z "$array_sloc" ] && return 1

    echo "$array_sloc"
    log_details "array[$array_sloc] owns disk[$sg]" >&2
    return 0
}

#################################################
#
# get process
# input : pids
# output : child_pids pids
#
##################################################
function getpstree {
    local pids="$*"

    local pslines=`$ps -e -o pid,ppid`
    while true
    do
        local has_expand=0
        local lines=`echo "$pids" | $sed -e 's/ /\n/g'`
        for pid in $pids
        do
            local child_pids=`echo "$pslines" | $awk -v pid=$pid '$2 == pid{print $1}'`
            child_pids=`for pid2 in $child_pids
            do
                echo "$lines" | grep -sq "^$pid2$" || echo "$pid2"
            done `
            if [ -n "$child_pids" ]; then
                pids="$child_pids $pids"
                has_expand=1
            fi
        done
        if [ $has_expand -eq 0 ]; then
            break
        fi
    done
    echo "$pids"
}

#####################################################################
#
# delete used disks from slocs
#
# input : disk slocs
#
# output : unused disk slocs
#
###################################################################
function delete_disks_belong_array_from_slocs {
    local slocs=$*
    validslocs=""
    usedslocs=""
    for sloc in $slocs
    do
        line=$(get_ipr_array_by_member $sloc)
        if [ $? -eq 0 ]; then
            if [ "x$usedslocs" != x ]; then
                usedslocs=$usedslocs" "$sloc
            else
                usedslocs=$sloc
            fi
        fi
    done
    if [ -n "$usedslocs" ]; then
        validslocs=`echo $slocs|sed "s/$usedslocs//g"`
        if [ -n "$validslocs" ]; then
            echo $validslocs
        fi
    else
        echo $slocs
    fi
}

####################################################################################
#
# create raid array
#
# input : $1 minutes,
#            Times to wait for the raid creation finish, minutes
#
#         $2 seconds
#            Interval of minitoring raid creation, status check
#
#         left: member disks , iprconfig_args
#
# output :
#
################################################################################
function create_ipr_array {
    local global_rc=0
    local lines=""
    local monCnt=$1
    shift
    local monInt=$1
    shift
    local member_sgs=`echo "$1" | $sed -e 's/,/ /g'`
    shift

    local stage_1_timeout=1        # unit minutes
    local stage_1_last_tick_count=`$awk -v monInt=$monInt -v timeout=$stage_1_timeout 'END{print timeout*60/monInt}' </dev/null`

    [ -z "$member_sgs" ] && return 1
    local member_slocs=`convert_sg_to_sloc $member_sgs | $awk -F= '{print $2}' `
    local member_sgs=`convert_sloc_to_sg $member_sgs | $awk -F= '{print $2}' `
    [ -z "$member_sgs" ] && return 1

    local iprconfig_args="$*"
    # log for details
    {
        echo "Attempt to create ipr array with command: iprconfig -c raid-create \"$iprconfig_args\" \"$member_sgs\""
        for member_sg in $member_sgs
        do
            echo "-------------------------------------"
            cmd_show_details $member_sg | $sed -e 's/^/details['$member_sg']: >> /g'
        done
        echo "-------------------------------------"
        for member_sg in $member_sgs
        do
            cmd_show_status $member_sg | $sed -e 's/^/status['$member_sg']: >> /g'
        done
        echo "-------------------------------------"
    } | log_lines details >&2

    # prepare tmp log file for iprconfig worker process
    local ftmp="/tmp/log_create.log.$$"
    $touch $ftmp

    # launch the iprconfig worker process
    cmd_raid_create "$iprconfig_args" "$member_sgs" >$ftmp 2>&1 &
    local pid_create=$!
    # log for debug
    local line=`$ps -f -p $pid_create | $awk -v pid=$pid_create '$2==pid{print $0}' | $head -n1`
    log_details "ps1: $line"

    # monitor the worker process and show status
    # array_stage=0, monitor array member disk states only
    # array_stage=1, wait for array showes up after array member disks are in termination states
    # array_stage=2, monitor array state
    local array_stage=0
    local array_sloc=""
    # is that possible sg names of member disks were changed after issued raid-create on top of them?
    local slocs="$member_slocs"
    local i=$monCnt
    while [ $i -gt 0 -a $monCnt -gt 0 ];
    do
        # Get status of all sgs which might include array itself.
        local status_lines=""
        local rc=0
        local sloc=""
        [ $array_stage -ne 1 ] && \
        for sloc in $slocs
        do
            local status=""
            local sg=`convert_sloc_to_sg $sloc | $awk -F= '{print $2}'`
            if [ -n "$sg" ]; then
                status=`cmd_show_status $sg `
            else
                status="Missing-sg_name"
            fi
            [ -z "$status" ] && status="no_status"

            local msg="status[$sloc/$sg]=\"$status\""
            log_details "array create stage[$array_stage], $msg"

            # list of "termination" status for member disks and target array
            # Refer to "Disk array states" section in ipr doc.
            local status_exp
            if [ $array_stage -eq 0 -o $array_stage -eq 1 ]; then
                # 1) If a physical disk fail to be formated as IPR AF, its status will be "Format Required" and be "Failed" later.
                # Should we handle this?
                status_exp="Active|Failed|Offline|Missing|R/W Protected|Format Required"

                # I saw phy disk in following state which not in the doc.
                status_exp+="|Optimized|Non-Optimized"

                # my faked status for disk
                status_exp+="|Missing-sg_name"
            else
                # Note:
                # - Array state "Missing" is not a terminate state, exclude it by adding "#" as prefix
                status_exp="Optimized|Active|Non-Optimized|Degraded|#Missing|Offline|Failed|R/W Protected|Rebuilding"
            fi
            # if not "termination" status, we record it and wait for next cycle.
            if ! echo "$status" | grep -i -sq -E "$status_exp"; then
                # aggregate status messages.
                [ -n "$status_lines" ] && status_lines+=","
                status_lines+="$msg"
                rc=1
            fi
        done
        # if all terminated, we fall back to check staus of array itself
        if [ $rc -eq 0 ]; then
            if [ $array_stage -eq 2 ]; then
                log_info "Create array($array_sg=$array_sloc) successfully on top of disks: $member_slocs."
                break
            else # end if stage == 2
                if [ $array_stage -eq 0 ]; then
                    # since all disks were in termination states, let's move to stage 2
                    # to wait for array to be created and start rebuild.
                    #
                    # It's possible that such array could not be created for some critical
                    # error, such in-sufficient disks for required raid level.
                    #
                    # Though there was smart way to handle this, here I only use a simple way
                    # by waiting for a fixed time(1 minute) before return error.
                    log_details "array create stage[1], entered, after finished formatting member disks $slocs"
                    lines=`{ cmd_show_config; cmd_show_alt_config; } | $sed -e 's/^/[0-->1] >> /g'`
                    log_lines details "$lines"
                    ((array_stage=1))
                    ((stage_1_last_tick_count=i-stage_1_last_tick_count))
                fi
                # IPR might had problem if some disks failed to response.
                # These disks will disapear in the system with sloc and sg were all gone.
                # in these case, we drop these disks in the operation and abort the operation
                # if all member disks were gone.
                local slocs_new=""
                local __tmp_item=""
                for __tmp_item in $slocs
                do
                    if sloc_exist $__tmp_item; then
                        [ -n "$slocs_new" ] && slocs_new+=" "
                        slocs_new+="$__tmp_item"
                    else
                        log_error "$i: disk $__tmp_item disapear..."
                    fi
                done
                if [ -n "$slocs_new" ]; then
                    slocs="$slocs_new"
                else
                    global_rc=1
                    log_error "All array member disks, $member_slocs, were gone, abort!"
                    break
                fi
                # get array owner of each member sg
                local array_slocs=`for __tmp_item in $slocs
                do
                    local sg_owner_sloc=$(get_ipr_array_by_member $__tmp_item)
                    [ -n "$sg_owner_sloc" ] && echo "$sg_owner_sloc"
                done \
                | $sort -u -V `
                # we only allow one unique array owns all member disks.
                # or, we we need to break out?
                local array_cnt=`echo "$array_slocs" | $awk 'END {print NF; exit 0;}'`
                log_details "All \"$array_cnt\" array(es), \"$array_slocs\", contain target disks, \"$slocs\"." >&2
                if [ $array_cnt -gt 0 ]; then

                    array_sloc=`echo "$array_slocs" | $awk '{print $1}'`
                    local array_sg=`convert_sloc_to_sg $array_sloc | $awk -F= '{print $2}'`
                    if [ -n "$array_sg" ]; then
                        log_details "array create stage[2], entered, after array show up with sg name $array_sg and sloc $array_sloc" >&2
                        array_stage=2
                        slocs="$array_sloc"
                    else
                        log_warn "$i: >> Why new array $array_sloc($array_slocs) does not have a valid sg name?" >&2
                        log_warn "$i: >> Let wait for a while to see if it could show up or not until tick count equals to $stage_1_last_tick_count" >&2
                    fi
                elif [ $array_stage -eq 1 -a $i -lt $stage_1_last_tick_count ]; then
                    log_error "Fail to wait array($array_slocs) showes up after its member disks, $member_slocs, were finished formatting." >&2
                    # log for debug
                    lines=`{
                        echo "$i: Current IPR configuration";
                        {
                            cmd_show_config;
                            cmd_show_alt_config;
                        } | $sed -e 's/^/'$i': >> /g';
                    }`
                    log_lines details "$lines"

                    global_rc=2
                    break
                else
                    # see if we need to issue the raid-create again.
                    # for some reason, previous raid-create might be terminated unexpectedly with disks
                    # actually had been formated for raid and ready to be used. So, we try to issue
                    # the raid-create command again to see if that would help. This usually happened when
                    # some failures when formtting physical disks to ipr AF. In that situation, iprconfig
                    # might abort without have array created after it had actually formatted those disks.
                    local pid_create_still_alive=0
                    local pid_create_cur=`getpstree $pid_create`
                    local pid_cur
                    for pid_cur in $pid_create_cur
                    do
                        if $kill -0 $pid_cur 2>/dev/null; then
                            pid_create_still_alive=1
                            break
                        fi
                    done
                    if [ $pid_create_still_alive -eq 0 ]; then
                        log_info "$i: disks $slocs had finished formatting, but array was not shown up, and iprconfig process($pid_create) had terminated."

                        log_details "$i: Last several raid-create output:"
                        lines=`$tail -n10 $ftmp | $sed -e 's/^/'$i': >> /g'`
                        log_lines details "$lines"
                        # launch the iprconfig worker process again
                        member_sgs=`convert_sloc_to_sg $member_slocs | $awk -F= '{print $2}'`
                        if [ -n "$member_sgs" ]; then
                            $iprconfig -c raid-create $iprconfig_args $member_sgs >$ftmp 2>&1 &
                            pid_create=$!

                            log_info "$i: Restart \"iprconfig -c raid-create $iprconfig_args $member_sgs\" with new pid $pid_create." >&2

                            # log for debug
                            local line=`$ps -f -p $pid_create | $awk -v pid=$pid_create '$2==pid{print $0}' | $head -n1`
                            if [ -n "$line" ]; then
                                log_details "ps1.2: $line" >&2
                            else
                                log_error "ps1.2: new iprconfig($pid_create) was gone" >&2
                            fi
                        else
                            log_warn "$i: Fail to restart iprconfig since $member_slocs could not be mapped to sg." >&2
                            log_warn "$i: Let try again next loop until tick count equals to $stage_1_last_tick_count" >&2
                        fi
                    else
                        log_warn "$i: Wait for array($array_slocs) showes up after disk format were finished on $slocs until tick count equals to $stage_1_last_tick_count" >&2
                        log_details "$i: Last several raid-create output:" >&2
                        lines=`$tail -n2 $ftmp | $sed -e 's/^/'$i': >> /g'`
                        log_info debug "$lines" >&2
                    fi
                fi
            fi # end else if stage == 2
        fi # end if $rc eq 0

        # log status for monitor
        # log for debug
        if [ -n "$status_lines" ]; then
            log_status "Creating IPR array with last info at time \""`date "+%Y-%m-%d %H:%M:%S"`"\": $status_lines" >&2
            lines=`echo "$status_lines" | $sed -e 's/,/\n/g' | $sed -e "s/^/$i: >> /g"`
            log_lines details "$lines" >&2
        fi

        $sleep $monInt
        [ $monCnt -gt 0 ] && ((i-=1))
    done

    # log for debug
    line=`$ps -f -p $pid_create | $awk -v pid=$pid_create '$2==pid{print $0}' | $head -n1`
    [ -n "$line" ] && log_details "ps2: $line"
    if $kill -0 $pid_create 2>/dev/null; then
        # If succ out, array status should in "rebuilding" state while iprconfig is still running
        # until the rebuild had finished. But we do not need to wait for its termination since the
        # block device is actually ready to use though performance might be downgrade.
        # so, by default, we will just kill the "iprconfig" command(? not sure if that would affect
        # the rebuild or not) and let raid controller do its job at backend.
        # in order to wait for the whole rebuilding, set IPR_REBUILD_WAIT=true explicitly.
        if [ "x$IPR_REBUILD_WAIT" = "xtrue" -a $i -gt 0 ]; then
            log_info "Wait for ipr raid creation command to finish. pid=$pid_create" >&2
            wait $pid_create
        else
            log_warn "Terminate ipr raid creation process enforcely. pid=$pid_create" >&2
            $kill -TERM $pid_create 2>/dev/null
            $sleep 1
            $kill -0 $pid_create 2>/dev/null \
            && $kill -KILL $pid_create 2>/dev/null
        fi
    fi
    # log for debug
    line=`$ps -f -p $pid_create | $awk -v pid=$pid_create '$2==pid{print $0}' | $head -n1`
    [ -n "$line" ] && log_details "ps3: $line" >&2

    log_details "Last several raid-create output:" >&2
    lines=`$tail -n10 $ftmp | sed -e 's/^/[last]: >> /g'`
    log_lines details "$lines" >&2
    rm -f $ftmp
    # Log "failed" status to PCM/xCAT with reason and instruction for future investigation.
    if [ $global_rc -ne 0 ]; then
        # set node "status" to "failed" to indicate that the installation was failed.
        fstatus_app=/tmp/baz.py
        if [ -x "$fstatus_app" ]; then
            $fstatus_app "installstatus failed" >&2
        fi

        # set node state with brief reason why installation failed and future instructions.
        # end user can get this message by running "nodestate" command to target nodes.
        log_status "Fail to create IPR array with return code \"$global_rc\"! Refer to more details in syslog by checking \"rhPreDbg\" flag..." >&2
    fi
    return $global_rc
}

###########################################################################################
#
# main process to handle create raid array when using pci_id or pci_slot_name
#
##########################################################################################
function handle_create_raid_array {
    local striple_size=$1
    local raidlevel=$2
    local disknum=$3
    local pcilocs=$4
    local disknames=$5

    if [ "x$pcilocs" != "xnull" ]; then

        # Find out all member disks in target IOAs
        # pciloc=sloc,sloc,sloc...
        slocs_grps=`get_raid_create_devices_by_pciloc $pcilocs `
        if [ -z "$slocs_grps" ]; then
            log_error "Could not find any disk on target pciloc ${pcilocs}!" >&2
            return 1
        else
            log_info "Disks in target IPR raid adapter: \"$slocs_grps\"" >&2
        fi

        # find the required member disks
        slocs=""
        validslocs=""
        for item in $slocs_grps
        do
            pciloc=`echo "$item" | $awk -F= '{print $1}'`
            slocs_grp=`echo "$item" | $awk -F= '{print $2;}'`
            # order disks by its resource path
            slocs_grp=`sort_devices_by_resource_path $slocs_grp`

            slocs=`echo "$slocs_grp" | sed 's/,/ /g'`
            if [ -n "$slocs" ]; then
                break
            else
                log_warn "Could not find enough disk on target adapter $pciloc which only has following disks ${slocs_grp}!" >&2
            fi
        done
        if [ -z "$slocs" ]; then
            log_error "Could not find enough disk on target adapter ${pciloc}!" >&2
            return 1
        else
            log_info "Find member disks $slocs on target IOA $pciloc" >&2
            slocs=`echo "$slocs" | $sed -e 's/,/ /g'`
            # if it is the first create_raid, do nothing, else:
            # delete used disks belong to existed raid array
            validslocs=`delete_disks_belong_array_from_slocs $slocs`
            if [ -z "$validslocs" ]; then
                log_error "Could not find enough unused disk on target adapter $pciloc."
                return 1
            else
                slocs="$validslocs"
                log_info "Find unused member disks $slocs on target IOA $pciloc" >&2
            fi

        fi
        # handle disk_num
        # if disknum is all, do nothing
        # if disknum is a number, then it should be compared with actual_disknum
        actual_disknum=`echo "$slocs"| $awk '{print NF}'`
        slocs=`compare_disknum_actualnum $disknum $actual_disknum $slocs`

    else
        # find the slocs for disks in disknames
        disklist=`echo $disknames|sed 's/#/ /g'`
        slocs_grp=`convert_sg_to_sloc $disklist`
        slocs=`echo "$slocs_grp"|awk -F= '{print $2}'`
    fi
    # check if target disks were already in a reusable array.
    # if not, create one by calling block command "create_ipr_array".
    # after than, check again to confirm if the target array was ready.
    array_sloc=""
    ((__i=0))
    while [ $__i -lt 2 ];
    do
        # get disk --> array association
        # format 0:0:0:0=sg0
        declare array_slocs_lines=`for sloc in $slocs
            do
                line=$(get_ipr_array_by_member $sloc)
                echo "$sloc=$line"
            done`

        # extract arrays from associations
        # get sg0 sg1
        declare array_slocs=`echo "$array_slocs_lines" \
                             | $awk -F= '{print $2}' | $sort -u`

        # count the number of arrays on target disks
        # which might include "blank" array
        declare n_arrays_lines=`echo "$array_slocs" | $awk 'END {print NR}'`
        # count the number of arrays on target disks, again
        # w/o "blank" array
        declare n_arrays=`echo "$array_slocs" | grep -v "^ *$" | $awk 'END {print NR}'`
        # get the sg names for owner arrays.
        declare array_sgs=""
        if [ $n_arrays -gt 0 ]; then
             array_sgs=`convert_sloc_to_sg $array_slocs \
                        | $awk -F= '{print $2}' `
        fi
        # (cond_1): if ALL target disks are in ONE array, reuse it.
        if [ $n_arrays_lines -eq 1 -a $n_arrays -eq 1 ]; then
            if [ $__i -eq 0 ]; then
                log_info "Target disks, $slocs, were already in an array, $array_slocs." >&2
            else
                log_info "An array, $array_slocs, had been created to include target disks, $slocs" >&2
            fi
            lines=`{   cmd_show_details $array_sgs;
                       cmd_show_status $array_sgs;
                    } | $sed -e 's/^/>> /g'`
            log_lines details "$lines"
            array_sloc="$array_slocs"
            break
        fi
        # (cond_2): delete arrays which owe target disks first before any future operations.
        #           NOTE: we redo the loop after "delete" command was issued to ipr
        if [ $n_arrays -gt 0 ]; then
            log_info "Target disks, $slocs, were owned by multiple arrays, \"$array_slocs\"($array_sgs). Delete them first before creating a new array on top of them." >&2
            delete_ipr_array enforce=1 tryCnt=360 tryInt=60 -- $array_sgs
            continue
        fi
        # (cond_3): create an array to include all target disks
        #           we assume all these disks are ready to be included into an array.
        if [ $__i -eq 0 ]; then
            declare sgs=`convert_sloc_to_sg $slocs \
                         | $awk -F= '{print $2}' | $sed -e 's/ /,/g'`
            # Times to wait for the raid creation finish
            # The lager capacity of member disks, longer times to wait.
            # :unit minutes
            monTime=240
            # Interval of minitoring raid creation, status check
            # :unit seconds
            monInt=30
            monCnt=`$awk -v monInt=$monInt -v monTime=$monTime 'END{print 60*monTime/monInt}' </dev/null`
            log_status "Creating RAID $raidlevel array on top of disks \""`echo "$slocs" | $sed -e 's/ /,/g'`"\"/\"$sgs\"..." >&2
            # handle striple_size
            if [ "x$striple_size" == "xdefault" ]; then
                create_ipr_array $monCnt $monInt "$sgs" -r $raidlevel
            elif [ -z $striple_size ]; then
                create_ipr_array $monCnt $monInt "$sgs" -r $raidlevel
            else
                create_ipr_array $monCnt $monInt "$sgs" -r $raidlevel -s $striple_size
            fi
        fi
    ((__i+=1))
    done
    lines=`cmd_show_config`
    if [ $__i -lt 2 -a -n "$array_sloc" ]; then
        array_sd=`echo "$lines" \
                | grep '^sd[a-z]\+[ ]\+.*\/'$array_sloc'[ ]\+.*Disk Array' \
                | $awk '{print $1}'`
        if [ -n "$array_sd" ]; then
            log_info "array_dev=$array_sd"
            return 0
        else
            log_error "Fail to get scsi device name for new array $array_sloc" >&2
            echo "$lines" | $sed -e 's/^/>> /g' | log_lines error >&2
            return 1
        fi
    else
        log_error "Fail to create array on top of disks $slocs" >&2
        echo "$lines" | $sed -e 's/^/>> /g' | log_lines error >&2
        return 1
    fi

}

############################################################################
#
# handle disk_num
# if disknum is all, do nothing
# if disknum is a number, then it should be compared with actual_disknum
# return <disknum> of slocs
#
##############################################################################
function compare_disknum_actualnum {
    local disknum=$1
    local actualnum=$2
    shift;
    shift;
    local slocs=$*
    local actualslocs
    if [ "x$disknum" != "xall" ]; then
        if [ $actualnum -ge $disknum ]; then
            actualslocs=`echo "$slocs"| \
                         awk -v anum=$disknum '{ for ( i=1; i<=anum; i++ ){print $i}}'`
            echo $actualslocs

        else
            log_error "Could not find enough disk on target adapter ${pciloc}!" >&2
        fi
    else
        echo "$slocs"
    fi

}

############################################################################
#
# Delete raid array
#
# input format : enforce=1 tryCnt=2 tryInt=60 -- arrays_name list
#
##########################################################################
function delete_ipr_array {
    # default to NO if enforcely wait for rebuilding array
    local enforce=0
    # default to wait 2 minutes for array rebuilding to finish
    local tryCnt=2
    # monitor rebuilding status every 60 seconds
    local tryInt=60

    # parser input arguments
    while [ -n "$1" ];
    do
        local key=`echo "$1" | $cut -s -d= -f1`
        if [ "$key" = "tryCnt" ] || \
           [ "$key" = "tryInt" ] || \
           [ "$key" = "enforce" ]; then
            local val=`echo "$1" | $cut -s -d= -f2-`
            eval "$key=\"$val\""
        elif [ "$1" = "--" ]; then
            shift
            arrays="$*"
            break
        fi
        shift
    done
    # should not with empty array list, if yes, error with rc=1
    if [ -z "$arrays" ]; then
        log_error "No array to delete, assume success!" >&2
        return 0
    fi
    local array_slocs=`convert_sg_to_sloc $arrays | awk -F= '{print $2}'`
    # if none of arrays were valid, error with rc=1
    if [ -z "$array_slocs" ]; then
        log_error "Fail to map arrayes, $arrays, to scsi location before deletion!"
        return 1
    fi
    local ioas=`get_ipr_ioas`

    local i=1
    while [ $i -le $tryCnt ];
    do
        # verify if all target arrays are still exists
        local tmp_array_slocs=`for _tmp_sloc in $array_slocs
        do
            is_ipr_array $_tmp_sloc && echo "$_tmp_sloc"
        done `
        if [ "$tmp_array_slocs" != "$array_slocs" ]; then
            array_slocs="$tmp_array_slocs"
            log_details "Renew available target arrays which will be deleting, \"$array_slocs\"" >&2
        fi
        if [ -z "$array_slocs" ]; then
            log_details "Round $i: All target arrays were gone!" >&2
            break
        fi
        # find out sg devs for all deletable arrays
        local array_slocs_deletable=`for ioa in $ioas
        do
            # [root@dn01-dat ~]# iprconfig -c query-raid-delete sg5
            # Name   PCI/SCSI Location         Description               Status
            # ------ ------------------------- ------------------------- -----------------
            # sdk    0003:70:00.0/0:2:0:0       RAID 0 Disk Array         Optimized
            # sdl    0003:70:00.0/0:2:1:0       RAID 0 Disk Array         Optimized
            cmd_query_raid_delete $ioa \
            | grep "Disk Array" \
            | cut_sloc_from_iprconfig_line
        done`
        if [ -z "$array_slocs_deletable" -a $enforce -eq 0 ]; then
            log_details "Round $i: No deletable array, nothing to do and finish." >&2
            break
        fi
        # log for debug
        {
            echo "$array_slocs_deletable" | $sed -e 's/^/Round '$i': Deletable array >> /g'
            cmd_show_config | $sed -e 's/^/Round '$i': ipr info before delete >> /g'
        } | log_lines details >&2
        log_info "Round $i: delete_ipr_array, \"$array_slocs\"" >&2

        # if requested array is a deletable array, mark it to be deleted in this round.
        local array_slocs_verified=`for array_sloc in $array_slocs
        do
            if echo "$array_slocs_deletable" | grep -sq "^$array_sloc$"; then
                echo $array_sloc
            else
                log_warn "Round $i: Array $array_sloc is un-deletable at present." >&2
            fi
        done`
        if [ -n "$array_slocs_verified" ]; then
            log_details "Round $i: Verified array slocs for deletion are \"$array_slocs_verified\"." >&2
        else
            log_info "Round $i: All remaining target arrayes are un-deletable now." >&2
            if [ $enforce -eq 1 ]; then
                log_info "Round $i: Wait for these un-deletable arrayes deletable with tryCnt=$tryCnt, tryInt=$tryInt." >&2
                wait_for_ipr_device_status \
                    tryCnt=$tryCnt tryInt=$tryInt cmd="grep -sq -E 'Optimized'" \
                    -- \
                    `echo "$array_slocs" | $sed -e "s/ /,/g"`
                # if wait succ, let's try to delete again
                if [ $? -eq 0 ]; then
                    ((i+=1))
                    continue
                else
                    break
                fi
            fi
        fi

        # issue delete command
        local dcnt=0
        for array_sloc in $array_slocs_verified
        do
            local array=`convert_sloc_to_sg $array_sloc | awk -F= '{print $2}'`
            [ -z "$array" ] && continue

            log_details "Round $i: Delete $dcnt array $array=$array_sloc" >&2
            cmd__raid_delete $array
            ((dcnt+=1))
        done

        # break out the loop forcely if nothing deleted.
        [ $dcnt -eq 0 ] && break

        # wait for next round
        $sleep $tryInt
        ((i+=1))
    done
    test $i -lt $tryCnt -a -z "$array_slocs"
    return $?
}

#################################################
#
# sort devices by resource path,
#
# input: dev list, "sg0,..sgn"
#
##################################################
function sort_devices_by_resource_path {
    local sgs="$*"

    local del=","
    if [ $# -gt 1 ]; then
        del=" "
    else
        sgs=`echo "$sgs" | $sed -e "s/,/ /g"`
    fi

    # [root@dn01-dat ~]# iprconfig -c show-alt-config
    # Name   Resource Path/Address      Vendor   Product ID       Status
    # ------ -------------------------- -------- ---------------- -----------------
    # sg15   FE                         IBM      57D7001SISIOA    Operational
    # sg10   00-0C                      IBM      HUC101212CSS600  Active
    # sg11   00-0D                      IBM      HUC101212CSS600  Active
    local lines=`$iprconfig -c show-alt-config | grep "^sg"`
    local item
    local lines_out=`for item in $sgs
    do
        local sg=$(convert_sloc_to_sg $item | $awk -F= '{print $2;}')
        local rp=$(echo "$lines" | $awk -vsg=$sg '$1 == sg { print $2; }')
        echo "$item $sg $rp"
    done \
    | $sort -t' ' -k3`
    # log for debug
    {
        echo "sort devices \"$sgs\" by IPR resource path:"
        echo "$lines_out" | $sed -e 's/^/sort by rp output: >> /g'
    } | log_lines details >&2

    # deliver ordered result
    lines_out=`echo "$lines_out" | $awk '{print $1;}' `
    if [ "$del" = "," ]; then
        echo "$lines_out" | $sed -e "s/ /,/g"
    fi
    return 0
}

##########################################################################################################################
#
# wait to check ipr device status
# usage: wait_for_ipr_device_status tryCnt=<minitutes> tryInt=<interval_seconds> cmd="check_cmd_line" -- "sg0,sg1,...,sgn"
#
#########################################################################################################################
function wait_for_ipr_device_status {
    local tryCnt=1
    local tryInt=10
    local cmd="true"

    # parser input arguments
    while [ -n "$1" ];
    do
        local key=`echo "$1" | $cut -s -d= -f1`
        if [ "$key" = "tryCnt" ] || \
           [ "$key" = "tryInt" ] || \
           [ "$key" = "cmd" ]; then
            local val=`echo "$1" | $cut -s -d= -f2-`
            eval "$key=\"$val\""
        elif [ "$1" = "--" ]; then
            shift
            sgs="$*"
            break
        fi
        shift
    done
    sgs=`echo "$sgs" | $sed -e "s/,/ /g"`
    local cnt=0
    local lines
    while [ $cnt -lt $tryCnt -o $tryCnt -le 0 ];
    do
        # sleep for specific interval for next cycle
        [ $cnt -gt 0 ] && $sleep $tryInt

        lines=`check_ipr_device_status $sgs`
        local status_lines=""
        local neg=0
        local sg
        for sg in $sgs
        do
            local _sg_status=`echo "$lines" | grep "^$sg=" | $cut -d= -f2- -s`
            echo "$_sg_status" | eval $cmd >&2
            if [ $? -ne 0 ]; then
                neg=1
                status_lines="${status_lines}${status_lines:+,}status[$sg]=\"$_sg_status\""
            fi
        done

        # break out if NO negative matching
        # or, try next loop
        if [ $neg -eq 0 ]; then
            break
        else
            log_status "Wait for device status at time \""`date "+%Y-%m-%d %H:%M:%S"`"\": $status_lines, expect: \"$cmd\"."
        fi

        ((cnt+=1))
    done
    test $cnt -lt $tryCnt -o $tryCnt -le 0
    local rc=$?

    # log for debug
    if [ $rc -eq 0 ]; then
        log_info "Wait for status on devices: \"$sgs\" succeed! (expected: \"$cmd\")"
    else
        log_warn "Wait for status on devices: \"$sgs\" failed! (expected: \"$cmd\")"
        echo "$lines" | $sed -e 's/^/last device status: >> /g' | log_lines debug
    fi

    return $rc
}

##############################################################
#
# check status of ipr devices
# input : slocs list, for example, 0:0:0:0 0:0:1:0
# usage : check_ipr_device_status <sloc1> <sloc2> ... <slocn>
#
##############################################################
function check_ipr_device_status {
    local sgs="$*"
    local lines=`convert_sloc_to_sg $sgs`

    local item
    for item in $sgs
    do
        declare sg=`echo "$lines" | $awk -F= -vkey=$item '$1 == key {print $2;}'`
        declare _sg_status=`$iprconfig -c status $sg`
        if [ "$_sg_status" = "Rebuilding" ]; then
            declare _sg_status_alt=`cmd_alt_status $sg`
            [ -n "$_sg_status_alt" ] && _sg_status="$_sg_status, $_sg_status_alt"
        fi
        echo "$item=$_sg_status"
    done
    return 0
}


######################################################
#
# log lines
#
# input : details or status or error
#
######################################################
function log_lines {
    local pcnt=$#
    local __level=$1
    shift
    local cmd=log_${__level}

    local hit=0
    local OIFS=$IFS
    local NIFS=$'\n'
    IFS=$NIFS
    local __msg
    for __msg in $*
    do
        IFS=$OIFS
        $cmd "$__msg"
        hit=1
        IFS=$NIFS
    done
    IFS=$OIFS

    [ $hit -eq 0 -a $pcnt -le 1 ] && \
    while read __msg;
    do
        $cmd "$__msg"
    done
}

######################################################
#
# error information
#
######################################################
function log_error {
    local __msg="$*"
    $log_print_cmd $log_print_arg "[E]: $__msg" >&2
    return 0
}

######################################################
#
# warning information
#
# input : message
#
######################################################
function log_warn {
    local __msg="$*"
    $log_print_cmd $log_print_arg "[W]: $__msg" >&2
    return 0
}

######################################################
#
# log information
#
# input : message
#
######################################################
function log_info {
    local __msg="$*"
    $log_print_cmd $log_print_arg "[I]: $__msg" >&2
    return 0
}

######################################################
#
# more details information
#
######################################################
function log_details {
    local __msg="$*"
    $log_print_cmd $log_print_arg "[I]: $__msg" >&2
    return 0
}

####################################################
#
# print command status
#
###################################################
__my_log_status=
function log_status {
    local __msg="$*"
    $log_print_cmd $log_print_arg "[S]: $__msg" >&2

    # call my_log_status hook to triger more processing for status messages.
    if [ -n "$__my_log_status" ]; then
        $__my_log_status "$__msg"
    fi
    return 0
}

####################################################
#
# print output and logfile
#
###################################################
function log_print_default {
    echo $*
    echo $* >> $log_file
}

####################################################
#
# handle command
#
###################################################
function set_log_print {
    local cmd="$1"
    if [ -z "$cmd" ]; then
        return 1
    fi
    shift
    local args="$*"

    eval "log_print_cmd=\"$cmd\""
    eval "log_print_arg=\"$args\""
}

# let log work
[ -z "$log_print" ] && set_log_print "log_print_default"



