extras/path_id/path_id

   1 #!/bin/sh
   2
   3 # provide the shortest possible unique hardware path to a device
   4 # for the Linux Persistent Device Naming scheme
   5 #
   6 # Copyright (C) 2005-2006 SUSE Linux Products GmbH
   7 # Author:
   8 #       Hannes Reinecke <hare@suse.de>
   9 #
  10 #       This program is free software; you can redistribute it and/or modify it
  11 #       under the terms of the GNU General Public License as published by the
  12 #       Free Software Foundation version 2 of the License.
  13
  14 SYSFS=/sys
  15 RESULT=1
  16 TYPE=
  17 OPWD="`pwd`"
  18 full_sysfs_path=
  19 full_sysfs_device_path=
  20
  21 if [ -z "$DEVPATH" -a -z "$1" ] ; then
  22         exit 1
  23 fi
  24
  25 if [ -z "$DEVPATH" ] ; then
  26         case "$1" in
  27                 $SYSFS/*)
  28                         DEVPATH="${1#$SYSFS}"
  29                         ;;
  30                 *)
  31                         DEVPATH=$1
  32                         ;;
  33         esac
  34 fi
  35
  36 if [ ! -e $SYSFS$DEVPATH/dev ] ; then
  37         exit 1
  38 fi
  39
  40 case "$DEVPATH" in
  41         /devices/*)
  42                 cd "$SYSFS$DEVPATH/subsystem";
  43                 TYPE="`pwd -P`"
  44                 cd "$OPWD"
  45                 TYPE="${TYPE##*/}"
  46                 ;;
  47         /class/*)
  48                 TYPE="${DEVPATH#/class/}"
  49                 TYPE="${TYPE%%/*}"
  50                 ;;
  51         /block/*)
  52                 TYPE=block
  53                 ;;
  54         *)
  55                 exit 1
  56                 ;;
  57 esac
  58
  59 get_port_offset () {
  60         local type offset port
  61         type=$1
  62         offset=$2
  63         for i in $type[0-9]* ; do
  64                 : i $i
  65                 port="${i#$type}"
  66                 if [ "$port" -lt "$offset" ] ; then offset=$port ; fi
  67         done
  68         echo $offset
  69 }
  70
  71 handle_pci () {
  72         local DEV=$1
  73         cd -P $1
  74         DEV=${PWD}
  75         pci_id=${DEV##*/}
  76         host_dev_path=$DEV
  77         while [ ! -z "$host_dev_path" ] ; do
  78                 case "$host_dev_path" in
  79                         */pci[0-9]*)
  80                                 host_dev_path=${host_dev_path%/*}
  81                                 ;;
  82                         *)
  83                                 break
  84                                 ;;
  85                 esac
  86         done
  87         d="pci-$pci_id-$d"
  88         D="$host_dev_path"
  89         RESULT=0
  90 }
  91
  92 handle_platform () {
  93         local DEV=$1
  94         cd -P $1
  95         DEV=${PWD}
  96         platform_id=${DEV##*/}
  97         host_dev_path=$DEV
  98         while [ ! -z "$host_dev_path" ] ; do
  99                 case "$host_dev_path" in
 100                         */platform*)
 101                                 host_dev_path=${host_dev_path%/*}
 102                                 ;;
 103                         *)
 104                                 break
 105                                 ;;
 106                 esac
 107         done
 108         if [ "$d" ]; then
 109                 d="platform-$platform_id-$d"
 110         else
 111                 d="platform-$platform_id"
 112         fi
 113         D="$host_dev_path"
 114         RESULT=0
 115 }
 116
 117 handle_serio () {
 118         local DEV=$1
 119         cd -P $1
 120         DEV=${PWD}
 121         serio_id=${DEV##*/serio}
 122         host_dev_path=$DEV
 123         while [ ! -z "$host_dev_path" ] ; do
 124                 case "$host_dev_path" in
 125                         */serio*)
 126                                 host_dev_path=${host_dev_path%/*}
 127                                 ;;
 128                         *)
 129                                 break
 130                                 ;;
 131                 esac
 132         done
 133         if [ "$d" ]; then
 134                 d="serio-$serio_id-$d"
 135         else
 136                 d="serio-$serio_id"
 137         fi
 138         D="$host_dev_path"
 139         RESULT=0
 140 }
 141
 142 handle_ide () {
 143         : handle_ide $*
 144         local DEV=$1
 145         local port idedev idecontroller
 146         # IDE
 147         : DEV $DEV
 148         port=${DEV##*/}
 149         idedev=${DEV%/*}
 150         idecontroller=${idedev%/*}
 151         # port info if the controller has more than one interface
 152         port="${port#ide}"
 153         : port $port d $d
 154         : idedev $idedev kernel_port $port
 155         case "${port#*.}" in
 156                 0)
 157                         channel=0
 158                         ;;
 159                 1)
 160                         channel=1
 161                         ;;
 162                 *)
 163                         echo "Error: $idedev is neither master or slave" >&2
 164                         ;;
 165         esac
 166         cd $idecontroller
 167         offset="`get_port_offset ide ${port%.*}`"
 168         cd "$OPWD"
 169         :  port offset $offset
 170         port=$((${port%.*} - $offset))
 171         if [ "$d" ] ; then
 172                 d="ide-${port}:$channel-$d"
 173         else
 174                 d="ide-${port}:$channel"
 175         fi
 176         D=$idecontroller
 177         RESULT=0
 178 }
 179
 180 handle_scsi () {
 181         : handle_scsi $*
 182         local DEV=$1
 183         local cil controller_port controller_dev
 184         # SCSI device
 185         cil="${DEV##*/}"
 186         cil="${cil#*:}"
 187         target_dev=${DEV%/*}
 188         target_id=${target_dev##*/target}
 189         cd "$target_dev"
 190         target_num=0
 191         for tid in ${target_id}* ; do
 192                 target_num=$(( $target_num + 1 ))
 193         done
 194         controller_port=${target_dev%/*}
 195         controller_dev="${controller_port%/*}"
 196         : controller_dev $controller_dev
 197         : controller_port $controller_port
 198         # a host controller may have more than one interface/port
 199         controller_port="${controller_port##*/host}"
 200         #
 201         cd "$controller_dev"
 202         controller_offset=$(get_port_offset host $controller_port)
 203         cd "$OPWD"
 204         controller_port=$(( $controller_port - $controller_offset))
 205         scsi_id="scsi-${controller_port}:${cil}"
 206         if [ "$d" ] ; then
 207                 d="${scsi_id}-$d"
 208         else
 209                 d="$scsi_id"
 210         fi
 211         D="$controller_dev"
 212         RESULT=0
 213 }
 214
 215 handle_firewire () {
 216         : handle_firewire $*
 217         local DEV=$1
 218         if [ -f "$D/ieee1394_id" ] ; then
 219                 read ieee1394_id < $D/ieee1394_id
 220         fi
 221         if [ -z "$ieee1394_id" ] ; then
 222                 : no IEEE1394 ID
 223                 RESULT=1
 224                 return
 225         fi
 226         fw_host_dev=${DEV%/fw-host*}
 227         # IEEE1394 devices are always endpoints
 228         d="ieee1394-0x$ieee1394_id"
 229         D="$fw_host_dev"
 230         RESULT=0
 231 }
 232
 233 handle_fc () {
 234         : handle_fc $*
 235         local DEV=$1
 236         local cil controller_port controller_dev
 237         # SCSI-FC device
 238         fc_tgt_hcil="${DEV##*/}"
 239         fc_tgt_lun="${fc_tgt_hcil##*:}"
 240         fc_tgt_path="${DEV%/*}"
 241         fc_tgt_num="${fc_tgt_path##*/}"
 242         fc_tgt_dev="${fc_tgt_path}/fc_transport:${fc_tgt_num}"
 243         if [ -e "$fc_tgt_dev/port_name" ]; then
 244                 read wwpn < $fc_tgt_dev/port_name
 245         fi
 246         if [ -z "$wwpn" ] ; then
 247                 : no WWPN
 248                 D=
 249                 RESULT=1
 250                 return
 251         fi
 252         # Linux currently knows about 32bit luns
 253         tmp_lun3=$(printf "%04x" $(($fc_tgt_lun & 0xFFFF)))
 254         tmp_lun2=$(printf "%04x" $(( ($fc_tgt_lun >> 16) & 0xFFFF)))
 255         tmp_lun1="0000"
 256         tmp_lun0="0000"
 257         if (($fc_tgt_lun == 0)) ; then
 258                 lun="0x0000000000000000"
 259         else
 260                 lun="0x${tmp_lun3}${tmp_lun2}${tmp_lun1}${tmp_lun0}"
 261         fi
 262         controller_dev="${fc_tgt_path%/host[0-9]*}"
 263         # FC devices are always endpoints
 264         d="fc-${wwpn}:${lun}"
 265         D="$controller_dev"
 266         RESULT=0
 267 }
 268
 269 handle_sas () {
 270         : handle_sas $*
 271         local DEV=$1
 272         local cil adapter controller_dev
 273         # SAS device
 274         sas_host_path="${DEV%%/port*}"
 275         sas_phy_path="${DEV#*/host*/}"
 276         sas_phy_path="${sas_phy_path%%/target*}"
 277         sas_phy_id="${sas_phy_path%%/*}"
 278         sas_phy_id="${sas_phy_id##*port-}"
 279         sas_port_id="${sas_phy_path%%/end_device*}"
 280         sas_port_id="${sas_port_id##*port-}"
 281         sas_end_id="${sas_phy_path##*end_device-}"
 282         sas_phy_dev="/sys/class/sas_phy/phy-${sas_phy_id}"
 283         if [ -e "$sas_phy_dev/sas_address" ]; then
 284                 read phy_address < $sas_phy_dev/sas_address
 285                 read phy_id < $sas_phy_dev/phy_identifier
 286         fi
 287         if [ -z "$phy_address" ] ; then
 288                 : no initiator address
 289                 D=
 290                 RESULT=1
 291                 return
 292         fi
 293         sas_port_dev="/sys/class/sas_port/port-${sas_port_id}"
 294         if [ -e "$sas_port_dev/num_phys" ] ; then
 295                 read phy_port < $sas_port_dev/num_phys
 296         fi
 297         if [ -z "$phy_port" ] ; then
 298                 : no initiator address
 299                 D=
 300                 RESULT=1
 301                 return
 302         fi
 303         sas_phy_address="$phy_address:$phy_port:$phy_id"
 304         sas_end_dev="/sys/class/sas_device/end_device-${sas_end_id}"
 305         if [ -e "$sas_end_dev/sas_address" ]; then
 306                 read end_address < $sas_end_dev/sas_address
 307                 read end_id < $sas_end_dev/phy_identifier
 308         fi
 309         if [ -z "$end_address" ] ; then
 310                 : no initiator address
 311                 D=
 312                 RESULT=1
 313                 return
 314         fi
 315         sas_end_address="$end_address:$end_id"
 316         controller_dev="${sas_host_path%/host[0-9]*}"
 317         # SAS devices are always endpoints
 318         d="sas-${sas_phy_address}-${sas_end_address}"
 319         D="$controller_dev"
 320         RESULT=0
 321 }
 322
 323 handle_iscsi() {
 324         local DEV=$1
 325         local iscsi_session_dir
 326         local iscsi_session iscsi_session_path
 327         local iscsi_connection iscsi_connection_path
 328         local iscsi_scsi_lun
 329         # iSCSI device
 330         iscsi_session_dir="${DEV%%/target*}"
 331         iscsi_session="${iscsi_session_dir##*/}"
 332         iscsi_session_path=/sys/class/iscsi_session/${iscsi_session}
 333         if [ ! -d "$iscsi_session_path" ] ; then
 334             : no iSCSI session path
 335             RESULT=1
 336             return
 337         fi
 338         # Currently we're not doing MC/S
 339         for conn in ${iscsi_session_dir}/connection* ; do
 340             iscsi_conn_num=${conn##*:}
 341             if [ "$iscsi_conn_num" = '0' ] ; then
 342                 iscsi_connection=$(basename $conn)
 343             fi
 344         done
 345         if [ -z "$iscsi_connection" ] ; then
 346             : no iSCSI connection found
 347             RESULT=1
 348             return
 349         fi
 350         iscsi_connection_path=/sys/class/iscsi_connection/${iscsi_connection}
 351         if [ ! -d "$iscsi_connection_path" ] ; then
 352             : no iSCSI connection path
 353             RESULT=1
 354             return
 355         fi
 356         if [ -e "${iscsi_session_path}/targetname" ]; then
 357             read iscsi_tgtname < ${iscsi_session_path}/targetname
 358         fi
 359         if [ -z "$iscsi_tgtname" ] ; then
 360             : No iSCSI Targetname
 361             RESULT=1
 362             return
 363         fi
 364         if [ -e "${iscsi_connection_path}/persistent_address" ] ; then
 365             read iscsi_address < ${iscsi_connection_path}/persistent_address
 366         fi
 367         if [ -z "$iscsi_address" ] ; then
 368             : No iSCSI Target address
 369             RESULT=1
 370             return
 371         fi
 372         if [ -e "${iscsi_connection_path}/persistent_port" ] ; then
 373             read iscsi_port < ${iscsi_connection_path}/persistent_port
 374         fi
 375         iscsi_scsi_lun="${DEV##*:}"
 376         d="ip-${iscsi_address}:${iscsi_port}-iscsi-${iscsi_tgtname}-lun-${iscsi_scsi_lun}"
 377         RESULT=0
 378 }
 379
 380 handle_usb () {
 381 : handle_usb $*
 382         local DEV=$1
 383         cd -P $1
 384         DEV=${PWD}
 385         port_id=${DEV##*/}
 386         port_num=${port_id#*-}
 387         host_dev_path=$DEV
 388         while [ ! -z "$host_dev_path" ] ; do
 389                 case "$host_dev_path" in
 390                         */usb*)
 391                                 usb_host_path=$host_dev_path
 392                                 host_dev_path="${host_dev_path%/*}"
 393                                 ;;
 394                         *)
 395                                 break
 396                                 ;;
 397                 esac
 398         done
 399         : host_dev_path $host_dev_path
 400         usb_host_num=${usb_host_path##*/usb}
 401
 402         cd "$host_dev_path"
 403         usb_host_offset=$(get_port_offset usb $usb_host_num)
 404         usb_host_port=$(($usb_host_num - $usb_host_offset))
 405         cd "$OPWD"
 406         if [ "$d" ] ; then
 407                 d="usb-$usb_host_port:$port_num-${d}"
 408         else
 409                 d="usb-$usb_host_port:$port_num"
 410         fi
 411         D="$host_dev_path"
 412         RESULT=0
 413 }
 414
 415 handle_device () {
 416         full_sysfs_path="$SYSFS$DEVPATH"
 417         case "$DEVPATH" in
 418                 /devices/*)
 419                         # new sysfs layout
 420                         if [ -L $full_sysfs_path/subsystem ]; then
 421                                 full_sysfs_path="${full_sysfs_path%/*}"
 422                                 cd "$full_sysfs_path/subsystem";
 423                                 subsys="`pwd -P`"
 424                                 cd "$OPWD"
 425                                 subsys="${subsys##*/}"
 426                                 if [ "$subsys" = "block" ]; then
 427                                         # parent is "block", it's a partition, move one up
 428                                 full_sysfs_path="${full_sysfs_path%/*}"
 429                                 fi
 430                                 cd $full_sysfs_path
 431                         fi
 432                         ;;
 433                 *)
 434                         # old sysfs layout
 435                         if [ ! -L $full_sysfs_path/device ] ; then
 436                                 if [ -f $full_sysfs_path/range ] ; then return ; fi
 437                                 full_sysfs_path="${full_sysfs_path%/*}"
 438                                 : full_sysfs_path "$full_sysfs_path"
 439                                 if [ ! -L $full_sysfs_path/device -o ! -f $full_sysfs_path/dev ] ; then
 440                                         return
 441                                 fi
 442                         fi
 443                         cd $full_sysfs_path/device
 444                         ;;
 445         esac
 446         full_sysfs_device_path="`pwd -P`"
 447         cd "$OPWD"
 448         D=$full_sysfs_device_path
 449         while [ ! -z "$D" ] ; do
 450                 case "$D" in
 451                         */ide[0-9]/[0-9].[0-9]*|*/ide[0-9][0-9]/[0-9][0-9].[0-9]*)
 452                                 handle_ide "$D"
 453                                 ;;
 454                         */css0/*)
 455                                 if [ -r $full_sysfs_device_path/wwpn ]; then
 456                                         read wwpn < $full_sysfs_device_path/wwpn
 457                                 fi
 458                                 if [ -r $full_sysfs_device_path/fcp_lun ]; then
 459                                         read lun < $full_sysfs_device_path/fcp_lun
 460                                 fi
 461                                 if [ -r $full_sysfs_device_path/hba_id ]; then
 462                                         read bus_id < $full_sysfs_device_path/hba_id
 463                                 fi
 464                                 if [ "$bus_id" -a "$wwpn" -a "$lun" ]; then
 465                                         # S/390 zfcp adapter
 466                                         d="ccw-$bus_id-zfcp-$wwpn:$lun"
 467                                         RESULT=0
 468                                 else
 469                                         # DASD devices
 470                                         bus="ccw"
 471                                         adapter=${D##*/}
 472                                         d="$bus-$adapter"
 473                                         RESULT=0
 474                                 fi
 475                                 D=
 476                                 ;;
 477                         */rport-[0-9]*:[0-9]*-[0-9]*/*)
 478                                 handle_fc "$D"
 479                                 ;;
 480                         */end_device-[0-9]*:[0-9]*:[0-9]*/*)
 481                                 handle_sas "$D"
 482                                 ;;
 483                         */fw-host[0-9]*/*)
 484                                 handle_firewire "$D"
 485                                 ;;
 486                         */session[0-9]*/*)
 487                                 handle_iscsi "$D"
 488                                 D=
 489                                 ;;
 490                         */host[0-9]*/[0-9]*:[0-9]*:[0-9]*:[0-9]*)
 491                                 handle_scsi "$D"
 492                                 ;;
 493                         */usb[0-9]*/[0-9]*/*)
 494                                 handle_usb "$D"
 495                                 ;;
 496                         */pci[0-9]*:[0-9]*)
 497                                 handle_pci "$D"
 498                                 ;;
 499                         */serio[0-9]*)
 500                                 handle_serio "$D"
 501                                 ;;
 502                         */platform/*)
 503                                 handle_platform "$D"
 504                                 ;;
 505                         */devices)
 506                                 D=
 507                                 ;;
 508                         *)
 509                                 : not handled
 510                                 RESULT=1
 511                                 return
 512                                 ;;
 513                 esac
 514         done
 515         if [ "$TYPE" = "scsi_tape" ] ; then
 516                 devname=${full_sysfs_path##*/}
 517                 rewind="${devname%%st*}"
 518                 mode="${devname##*st}"
 519                 case "$mode" in
 520                         *l)
 521                                 mode="l"
 522                                 ;;
 523                         *m)
 524                                 mode="m"
 525                                 ;;
 526                         *a)
 527                                 mode="a"
 528                                 ;;
 529                         *)
 530                                 mode=""
 531                            ;;
 532                 esac
 533                 if [ "$d" ]; then
 534                         d="$d-${rewind}st${mode}"
 535                 fi
 536         fi
 537 }
 538
 539 case "$TYPE" in
 540         block)
 541                 handle_device
 542                 echo "ID_PATH=$d"
 543                 ;;
 544         scsi_tape)
 545                 handle_device
 546                 echo "ID_PATH=$d"
 547                 ;;
 548         input)
 549                 handle_device
 550                 echo "ID_PATH=$d"
 551                 ;;
 552         *)
 553                 RESULT=1
 554                 ;;
 555 esac
 556
 557 exit $RESULT