path: root/extras/path_id/path_id

#!/bin/sh

# provide the shortest possible unique hardware path to a device
# for the Linux Persistent Device Naming scheme
#
# Copyright (C) 2005-2006 SUSE Linux Products GmbH
# Author:
#	Hannes Reinecke <hare@suse.de>
#
#	This program is free software; you can redistribute it and/or modify it
#	under the terms of the GNU General Public License as published by the
#	Free Software Foundation version 2 of the License.
#
# to be called from a udev rule to return the name for a symlink
#	DEVPATH=<devpath>; path_id
#	path_id <devpath>

# examples for all block devices on a system:
#	for i in `find /sys/class/block`; do DEVPATH="`echo $i | sed -e 's@^/sys\|/dev@@g'`"; path_id; done

SYSFS=/sys
RESULT=1
TYPE=
OPWD="`pwd`"
full_sysfs_path=
full_sysfs_device_path=

if [ -z "$DEVPATH" -a -z "$1" ] ; then
	exit 1
fi

if [ -z "$DEVPATH" ] ; then
	case "$1" in
		$SYSFS/*)
			DEVPATH="${1#$SYSFS}"
			;;
		*)
			DEVPATH=$1
			;;
	esac
fi

if [ ! -e $SYSFS$DEVPATH/dev ] ; then
	exit 1
fi

case "$DEVPATH" in
	/devices/*)
		cd "$SYSFS$DEVPATH/subsystem";
		TYPE="`pwd -P`"
		cd "$OPWD"
		TYPE="${TYPE##*/}"
		;;
	/class/*)
		TYPE="${DEVPATH#/class/}"
		TYPE="${TYPE%%/*}"
		;;
	/block/*)
		TYPE=block
		;;
	*)
		exit 1
		;;
esac

get_port_offset () {
	local type offset port
	type=$1
	offset=$2
	for i in $type[0-9]* ; do
		: i $i
		port="${i#$type}"
		if [ "$port" -lt "$offset" ] ; then offset=$port ; fi
	done
	echo $offset
}

handle_pci () {
	local DEV=$1
	cd -P $1
	DEV=${PWD}
	pci_id=${DEV##*/}
	host_dev_path=$DEV
	while [ ! -z "$host_dev_path" ] ; do
		case "$host_dev_path" in
			*/pci[0-9]*)
				host_dev_path=${host_dev_path%/*}
				;;
			*)
				break
				;;
		esac
	done
	d="pci-$pci_id-$d"
	D="$host_dev_path"
	RESULT=0
}

handle_platform () {
	local DEV=$1
	cd -P $1
	DEV=${PWD}
	platform_id=${DEV##*/}
	host_dev_path=$DEV
	while [ ! -z "$host_dev_path" ] ; do
		case "$host_dev_path" in
			*/platform*)
				host_dev_path=${host_dev_path%/*}
				;;
			*)
				break
				;;
		esac
	done
	if [ "$d" ]; then
		d="platform-$platform_id-$d"
	else
		d="platform-$platform_id"
	fi
	D="$host_dev_path"
	RESULT=0
}

handle_serio () {
	local DEV=$1
	cd -P $1
	DEV=${PWD}
	serio_id=${DEV##*/serio}
	host_dev_path=$DEV
	while [ ! -z "$host_dev_path" ] ; do
		case "$host_dev_path" in
			*/serio*)
				host_dev_path=${host_dev_path%/*}
				;;
			*)
				break
				;;
		esac
	done
	if [ "$d" ]; then
		d="serio-$serio_id-$d"
	else
		d="serio-$serio_id"
	fi
	D="$host_dev_path"
	RESULT=0
}

handle_ide () {
	: handle_ide $*
	local DEV=$1
	local port idedev idecontroller
	# IDE
	: DEV $DEV
	port=${DEV##*/}
	idedev=${DEV%/*}
	idecontroller=${idedev%/*}
	# port info if the controller has more than one interface
	port="${port#ide}"
	: port $port d $d
	: idedev $idedev kernel_port $port
	case "${port#*.}" in
		0)
			channel=0
			;;
		1)
			channel=1
			;;
		*)
			echo "Error: $idedev is neither master or slave" >&2
			;;
	esac
	cd $idecontroller
	offset="`get_port_offset ide ${port%.*}`"
	cd "$OPWD"
	:  port offset $offset
	port=$((${port%.*} - $offset))
	if [ "$d" ] ; then
		d="ide-${port}:$channel-$d"
	else
		d="ide-${port}:$channel"
	fi
	D=$idecontroller
	RESULT=0
}

handle_scsi () {
	: handle_scsi $*
	local DEV=$1
	local cil controller_port controller_dev
	# SCSI device
	cil="${DEV##*/}"
	cil="${cil#*:}"
	target_dev=${DEV%/*}
	target_id=${target_dev##*/target}
	cd "$target_dev"
	target_num=0
	for tid in ${target_id}* ; do
		target_num=$(( $target_num + 1 ))
	done
	controller_port=${target_dev%/*}
	controller_dev="${controller_port%/*}"
	: controller_dev $controller_dev
	: controller_port $controller_port
	# a host controller may have more than one interface/port
	controller_port="${controller_port##*/host}"
	#
	cd "$controller_dev"
	controller_offset=$(get_port_offset host $controller_port)
	cd "$OPWD"
	controller_port=$(( $controller_port - $controller_offset))
	scsi_id="scsi-${controller_port}:${cil}"
	if [ "$d" ] ; then
		d="${scsi_id}-$d"
	else
		d="$scsi_id"
	fi
	D="$controller_dev"
	RESULT=0
}

handle_firewire () {
	:handle_firewire $*
	local DEV=$1
	if [ -f "$D/ieee1394_id" ] ; then
		read ieee1394_id < $D/ieee1394_id
	fi
	if [ -z "$ieee1394_id" ] ; then
		: no IEEE1394 ID
		RESULT=1
		return
	fi
	fw_host_dev=${DEV%/fw-host*}
	# IEEE1394 devices are always endpoints
	d="ieee1394-0x$ieee1394_id"
	D="$fw_host_dev"
	RESULT=0
}

handle_fc () {
	: handle_fc $*
	local DEV=$1
	local cil controller_port controller_dev
	# SCSI-FC device
	fc_tgt_hcil="${DEV##*/}"
	fc_tgt_lun="${fc_tgt_hcil##*:}"
	fc_tgt_path="${DEV%/*}"
	fc_tgt_num="${fc_tgt_path##*/}"
	fc_tgt_dev="${fc_tgt_path}/fc_transport:${fc_tgt_num}"
	if [ -e "$fc_tgt_dev/port_name" ]; then
		read wwpn < $fc_tgt_dev/port_name
	fi
	if [ -z "$wwpn" ] ; then
		: no WWPN
		RESULT=1
		return
	fi
	# Linux currently knows about 32bit luns
	tmp_lun3=$(printf "%04x" $(($fc_tgt_lun & 0xFFFF)))
	tmp_lun2=$(printf "%04x" $(( ($fc_tgt_lun >> 16) & 0xFFFF)))
	tmp_lun1="0000"
	tmp_lun0="0000"
	if (($fc_tgt_lun == 0)) ; then
		lun="0x0000000000000000"
	else
		lun="0x${tmp_lun3}${tmp_lun2}${tmp_lun1}${tmp_lun0}"
	fi
	controller_dev="${fc_tgt_path%/host[0-9]*}"
	# FC devices are always endpoints
	d="fc-${wwpn}:${lun}"
	D="$controller_dev"
	RESULT=0
}

handle_sas () {
	: handle_sas $*
	local DEV=$1
	local cil adapter controller_dev
	# SAS device
	sas_host_path="${DEV%%/phy*}"
	sas_phy_path="${DEV#*/host*/}"
	sas_phy_path="${sas_phy_path%%/target*}"
	sas_phy_id="${sas_phy_path%%/*}"
	sas_rphy_id="${sas_phy_path##*/}"
	sas_phy_dev="/sys/class/sas_phy/${sas_phy_id}"
	if [ -e "$sas_phy_dev/sas_address" ]; then
		read phy_address < $sas_phy_dev/sas_address
		read phy_port < $sas_phy_dev/port_identifier
		read phy_id < $sas_phy_dev/phy_identifier
	fi
	if [ -z "$phy_address" ] ; then
		: no initiator address
		RESULT=1
		return
	fi
	sas_phy_address="$phy_address:$phy_port:$phy_id"
	sas_rphy_dev="/sys/class/sas_device/${sas_rphy_id}"
	if [ -e "$sas_rphy_dev/sas_address" ]; then
		read rphy_address < $sas_rphy_dev/sas_address
		read rphy_id < $sas_rphy_dev/phy_identifier
	fi
	if [ -z "$rphy_address" ] ; then
		: no initiator address
		RESULT=1
		return
	fi
	sas_rphy_address="$rphy_address:$rphy_id"
	controller_dev="${sas_host_path%/host[0-9]*}"
	# SAS devices are always endpoints
	d="sas-${sas_phy_address}-${sas_rphy_address}"
	D="$controller_dev"
	RESULT=0
}

handle_usb () {
: handle_usb $*
	local DEV=$1
	cd -P $1
	DEV=${PWD}
	port_id=${DEV##*/}
	port_num=${port_id#*-}
	host_dev_path=$DEV
	while [ ! -z "$host_dev_path" ] ; do
		case "$host_dev_path" in
			*/usb*)
				usb_host_path=$host_dev_path
				host_dev_path="${host_dev_path%/*}"
				;;
			*)
				break
				;;
		esac
	done
	: host_dev_path $host_dev_path
	usb_host_num=${usb_host_path##*/usb}

	cd "$host_dev_path"
	usb_host_offset=$(get_port_offset usb $usb_host_num)
	usb_host_port=$(($usb_host_num - $usb_host_offset))
	cd "$OPWD"
	if [ "$d" ] ; then
		d="usb-$usb_host_port:$port_num-${d}"
	else
		d="usb-$usb_host_port:$port_num"
	fi
	D="$host_dev_path"
	RESULT=0
}

handle_device () {
	full_sysfs_path="$SYSFS$DEVPATH"
	if [ -L $full_sysfs_path/subsystem ]; then
		# new sysfs block layout
		full_sysfs_path="${full_sysfs_path%/*}"
		cd "$full_sysfs_path/subsystem";
		subsys="`pwd -P`"
		cd "$OPWD"
		subsys="${subsys##*/}"
		if [ "$subsys" == "block" ]; then
			# parent is "block", it's a partition, move one up
			full_sysfs_path="${full_sysfs_path%/*}"
		fi
		cd $full_sysfs_path
	else
		# old sysfs block layout
		if [ ! -L $full_sysfs_path/device ] ; then
			if [ -f $full_sysfs_path/range ] ; then return ; fi
			full_sysfs_path="${full_sysfs_path%/*}"
			: full_sysfs_path "$full_sysfs_path"
			if [ ! -L $full_sysfs_path/device -o ! -f $full_sysfs_path/dev ] ; then
				return
			fi
		fi
		cd $full_sysfs_path/device
	fi
	full_sysfs_device_path="`pwd -P`"
	cd "$OPWD"
	D=$full_sysfs_device_path
	while [ ! -z "$D" ] ; do
		case "$D" in
			*/ide[0-9]/[0-9].[0-9]*|*/ide[0-9][0-9]/[0-9][0-9].[0-9]*)
				handle_ide "$D"
				;;
			*/css0/*)
				if [ -r $full_sysfs_device_path/wwpn ]; then
					read wwpn < $full_sysfs_device_path/wwpn
				fi
				if [ -r $full_sysfs_device_path/fcp_lun ]; then
					read lun < $full_sysfs_device_path/fcp_lun
				fi
				if [ -r $full_sysfs_device_path/hba_id ]; then
					read bus_id < $full_sysfs_device_path/hba_id
				fi
				if [ "$bus_id" -a "$wwpn" -a "$lun" ]; then
					# S/390 zfcp adapter
					d="ccw-$bus_id-zfcp-$wwpn:$lun"
					RESULT=0
				else
					# DASD devices
					bus="ccw"
					adapter=${D##*/}
					d="$bus-$adapter"
					RESULT=0
				fi
				D=
				;;
			*/rport-[0-9]*:[0-9]*-[0-9]*/*)
				handle_fc "$D"
				;;
			*/phy-[0-9]*:[0-9]*/*)
				handle_sas "$D"
				;;
			*/fw-host[0-9]*/*)
				handle_firewire "$D"
				;;
			*/host[0-9]*/[0-9]*:[0-9]*:[0-9]*:[0-9]*)
				handle_scsi "$D"
				;;
			*/usb[0-9]*/[0-9]*/*)
				handle_usb "$D"
				;;
			*/pci[0-9]*:[0-9]*)
				handle_pci "$D"
				;;
			*/serio[0-9]*)
				handle_serio "$D"
				;;
			*/platform/*)
				handle_platform "$D"
				;;
			*/devices)
				D=
				;;
			*)
				: not handled
				RESULT=1
				return
				;;
		esac
	done
	if [ "$TYPE" == "scsi_tape" ] ; then
		devname=${full_sysfs_path##*/}
		rewind="${devname%%st*}"
		mode="${devname##*st}"
		case "$mode" in
			*l)
				mode="l"
				;;
			*m)
				mode="m"
				;;
			*a)
				mode="a"
				;;
			*)
				mode=""
			   ;;
		esac
		if [ "$d" ]; then
			d="$d-${rewind}st${mode}"
		fi
	fi
}

case "$TYPE" in
	block)
		handle_device
		echo "ID_PATH=$d"
		;;
	scsi_tape)
		handle_device
		echo "ID_PATH=$d"
		;;
	input)
		handle_device
		echo "ID_PATH=$d"
		;;
	*)
		RESULT=1
		;;
esac

exit $RESULT