conmux/drivers/hmc - mirrors/cros/chromiumos/third_party/autotest - Git at Google

 #!/usr/bin/expect --
 #
 # hmc -- handle consoles and rebooting of HMC based systems
 #
 # Allow connecting to the console of and rebooting of HMC connected
 # machines.  Machines are identified by the HMC IP address, connected
 # system name, and partition name.
 #
 # usage:
 #  hmc open-term|reboot -h <hmc IP> -m <system> -p <partition> \
 #	-U <user> -P <password> -V <hmc version>
 #
 # example:
 #  hmc open-term -m elm3b70 -p FullSystemPartition -U hscroot -P passwd \
 #	-V 2.6 -h 1.2.3.4
 #  hmc reboot -m elm3b70 -p FullSystemPartition -U hscroot -P passwd \
 #	-V 2.6 -h 1.2.3.4
 #
 # (C) Copyright IBM Corp. 2004, 2005, 2006
 # Author: Andy Whitcroft <andyw@uk.ibm.com>
 #
 # The Console Multiplexor is released under the GNU Public License V2
 #
 set P "hmc"

 # See interactions.
 log_user 0
 #exp_internal 1

 proc note {m} {
 	global P
 	puts "$P: $m"
 }
 proc warn {m} {
 	global P
 	puts "$P: WARNING: $m"
 }
 proc winge {m} {
 	global P
 	puts "$P: MACHINE ERROR: $m"
 }

 #
 # OPTIONS: options parser.
 #
 proc shift {_list} {
 	upvar $_list list

 	set res [lindex $list 0]
 	set list [lreplace $list 0 0]

 	return $res
 }
 proc arg {_list arg} {
 	upvar $_list list

 	if {[llength $list] < 1} {
 		winge "$arg: required argument missing"
 		exit 1
 	}

 	return [shift list]
 }

 set user		{hscroot}
 set host		{}
 set system		{}
 set lpar		{}
 set profile		{default}
 set mode		{norm}
 set passwd		{}
 set version		{}

 set cmd [lindex $argv 0]
 shift argv
 while {[llength $argv] > 0} {
 	switch -- [shift argv] {
 		-h	{ set host [arg argv h]}
 		hmc	{ set host [arg argv h]}
 		-m	{ set system [arg argv m]}
 		-l   	{ set lpar [arg argv l]}
 		-p   	{ set lpar [arg argv p]}
 		-f   	{ set profile [arg argv f]}
 		-b   	{ set mode [arg argv b]}
 		-U	{ set user [arg argv P]}
 		-P	{ set passwd [arg argv P]}
 		-V	{ set version [arg argv P]}
 	}
 }

 if {[llength $argv] > 0} {
 	puts stderr "Usage: $P <cmd> -h <hmc> -m <system> -p <lpar> -f <profile> -b <mode>"
 	exit 1
 }
 if {[string compare $host ""] == 0 ||
     [string compare $system ""] == 0 ||
     [string compare $lpar ""] == 0} \
 {
 	winge "hmc (-h), machine (-m) and lpar (-p) required"
 	exit 1
 }

 set prompt		{___EOF___HMC___EOF___}
 set hscpath		{/opt/hsc/bin}

 #log_file -a "$logfile"

 set elapsed_time 0
 set timeout 30

 # Ensure we have a terminal so we don't get prompted for one.
 if {![info exists env(TERM)]} {
 	set env(TERM) {vt100}
 }

 # If we have a password don't use any ssh-keys we may have been offered.
 if {[string compare $passwd ""] == 0} {
 	set command "ssh $env(SSH_OPTIONS) $user@$host"
 } else {
 	set command "ssh $user@$host"
 }

 # CONNECT: connect to the remote console.  Set the prompt up so we
 #          know when a command we execute has completed.
 note "Logging into HMC console with command \"$command\" ..."
 eval spawn $command
 send "PS1=$prompt\r"
 expect {
 	-re {[pP]assword:} {
 		if {[string compare $passwd ""] == 0} {
 			winge "$host: requesting password - not hacked"
 			exit 2
 		}
 		send "$passwd\r"
 		after 500
 		send "PS1=$prompt\r"
 		exp_continue
 	}
 	"Connection timed out" {
 		winge "$host: cannot connect to console"
 		exit 2
 	}
 	"Name or service not known" {
 		winge "$host: HMC name invalid"
 		exit 1
 	}
 	"Permission denied" {
 		winge "$host: authentication failure, permission denied"
 		exit 2
 	}
 	timeout {
 		winge "$host: HMC did not prompt us, timed out"
 		exit 2
 	}
 	eof {
 		winge "$host: HMC disconnected without prompting"
 		exit 2
 	}

 	"Terminal type?" {
 		send "vt100\r"
 		send "PS1=$prompt\r"
 		exp_continue
 	}

 	"PS1=$prompt" {
 		# Ignore us typing the change to the prompt.
 		exp_continue
 	}
 	"$prompt" {
 		# Prompt see, we are in and working, drop out.
 		## note "prompt seen"
 	}

 	-re "^\[^\n]*\n" {
 		# We need to absorb any login information, motd etc.
 		## puts "NOISE<$expect_out(buffer)>"
 		exp_continue
 	}
 }

 proc runit {cmd _out} {
 	upvar $_out out

 	global prompt

 	send "$cmd"

 	set text ""
 	set line 0

 	set timeout 120
 	expect {

 		-re "^\[^\n]*\n" {
 			##note "LINE: $expect_out(buffer)"
 			if { $line > 0 } {
 				append text $expect_out(buffer)
 			}
 			incr line
 			exp_continue
 		}

 		-re "$prompt" {
 			##note "prompt seen"
 		}

 		timeout {
 			set out "hmc: command timeout"
 			return 255
 		}
 	}
 	set out [string trimright $text]

 	send "echo \$?\r"
 	set text ""
 	set line 0
 	set timeout 30
 	expect {
 		-re "^\[^\n]*\n" {
 			##note "LINE: $expect_out(buffer)"
 			if { $line > 0 } {
 				append text $expect_out(buffer)
 			}
 			incr line
 			exp_continue
 		}

 		-re "$prompt" {
 			##note "prompt seen"
 		}

 		timeout {
 			set out "hmc: command status timeout"
 			return 255
 		}
 	}
 	##note "EXIT: $text"

 	return [string trimright $text]
 }

 proc extract_names {out} {
 	set res {}
 	foreach sys [split $out] {
 		if {[string compare $sys ""] != 0} {
 			lappend res $sys
 		}
 	}

 	return $res
 }

 # Find out the current version of the HMC software.
 if {[string compare $version ""] == 0} {
 	runit "rpm -q IBMhsc.coreserver --qf '%{VERSION}'; echo ''\r" version
 }
 if {[string compare $version ""] == 0} {
 	winge "unable to obtain HMC code version"
 	exit 1
 }
 note "HMC revision v$version"

 # Based on the version of the HMC software select payload.
 if {$version < 4.0} {
 	#
 	# VERSION 2.6/3.0 specific support.
 	#
 	proc system_list {} {
 		global hscpath

 		# Ask for a list of systems.
 		if {[runit "lssyscfg -r sys --all -F name\r" out] != 0} {
 			winge "unable to obtain list of systems"
 			exit 1
 		}

 		return [extract_names $out]
 	}
 	proc system_state {system} {
 		global hscpath

 		# Ask for the system status.
 		if {[runit "lssyscfg -r sys -n $system -F state\r" out] != 0} {
 			winge "$system: failed to get status"
 			exit 1
 		}

 		return $out
 	}
 	proc lpar_list {system} {
 		global hscpath

 		# Ask for a list of lpars for this system.
 		if {[runit "lssyscfg -r lpar -m $system --all -F name\r" out] != 0} {
 			winge "unable to obtain list of lpars"
 			exit 1
 		}

 		return [extract_names $out]
 	}
 	proc state {system lpar} {
 		global hscpath

 		# Ask for the lpar status.
 		if {[runit "lssyscfg -r lpar -m $system -n $lpar -F state\r" out] != 0} {
 			winge "$system/$lpar: failed to get lpar status"
 			exit 1
 		}

 		return $out
 	}
 	proc reboot_metal {system lpar profile mode} {
 		global hscpath

 		# If we have no connection wait for the machine to appear.
 		# XXX: timeout?
 		set was {}
 		set when [clock seconds]
 		if {[string compare [system_state $system] "Ready"] != 0} {
 			while {([clock seconds] - $when) < 60} {
 				sleep 15
 				set state [system_state $system]

 				note "waiting for stable connected state ($state)"
 				if {$state != $was || [string compare $state "No Connection"] == 0} {
 					set was $state
 					set when [clock seconds]
 				}
 			}
 		}

 		# See if the system is is in Error, if so attempt to
 		# power it on.
 		if {[string compare [system_state $system] "Error"] == 0} {
 			note "starting full system (from Error)"
 			if {[runit "chsysstate -r sys -m $system -n $system -b $mode -o on -c full\r" out] == 0} {
 				note "started"
 				return
 			}
 			note "start failed - attempting shutdown"
 		}

 		# See if the system is up, if so shut it down.
 		if {[string compare [system_state $system] "No Power"] != 0} {
 			note "shutting down full system"
 			if {[runit "chsysstate -r sys -m $system -n $system -o off -c full\r" out] != 0} {
 				winge "$system: power off failed\n$out"
 				exit 2
 			}
 		}

 		while {[string compare [system_state $system] "No Power"] != 0} {
 			note "waiting for shutdown"
 			sleep 15
 		}

 		note "starting full system"
 		if {[runit "chsysstate -r sys -m $system -n $system -b $mode -o on -c full\r" out] != 0} {
 			winge "$system: power on failed"
 			exit 2
 		}
 		note "started"
 	}
 	proc reboot {system lpar profile mode} {
 		global hscpath

 		# Handle the bare metal separatly.
 		if {[string compare $lpar "FullSystemPartition"] == 0} {
 			return [reboot_metal $system $lpar $profile $mode]
 		}

 		# Partitions in Error state are tricky, you _may_ either
 		# have to shut them down and then start them, or you may
 		# just have to start them.  So, if we are in Error start
 		# the partition, if it fails we can just drop through
 		# to the regular stop/start cycle.
 		if {[string compare [state $system $lpar] "Error"] == 0} {
 			note "starting lpar (from Error)"
 			if {[runit "chsysstate -r lpar -m $system -n $lpar -b $mode -o on\r" out] == 0} {
 				note "started"
 				return
 			}
 			note "start failed - attempting shutdown"
 		}

 		# See if the lpar is up, if so shut it down.
 		if {[string compare [state $system $lpar] "Ready"] != 0} {
 			note "shutting down lpar"
 			if {[runit "chsysstate -r lpar -m $system -n $lpar -o off\r" out] != 0} {
 				winge "$system/$lpar: power off failed\n$out"
 				exit 2
 			}
 		}

 		while {[string compare [state $system $lpar] "Ready"] != 0} {
 			note "waiting for shutdown"
 			sleep 15
 		}

 		note "starting lpar"
 		if {[runit "chsysstate -r lpar -m $system -n $lpar -b $mode -o on\r" out] != 0} {
 			winge "$system/$lpar: power on failed\n$out"
 			exit 2
 		}
 		note "started"
 	}

 }

 if {$version >= 4.0} {
 	#
 	# VERSION 4.x specific support.
 	#
 	proc system_list {} {
 		global hscpath

 		# Ask for a list of systems.
 		if {[runit "lssyscfg -r sys -F name\r" out] != 0} {
 			winge "unable to obtain list of systems"
 			exit 1
 		}

 		return [extract_names $out]
 	}
 	proc system_state {system} {
 		global hscpath

 		# Ask for the system status.
 		if {[runit "lssyscfg -r sys -m $system -F state\r" out] != 0} {
 			winge "$system: failed to get system status"
 			exit 1
 		}

 		return $out
 	}
 	proc lpar_list {system} {
 		global hscpath

 		# Ask for a list of lpars for this system.
 		if {[runit "lssyscfg -r lpar -m $system -F name\r" out] != 0} {
 			winge "unable to obtain list of lpars"
 			exit 1
 		}

 		return [extract_names $out]
 	}
 	proc state {system lpar} {
 		global hscpath

 		# Ask for the lpar status.
 		if {[runit "lssyscfg -r lpar -m $system --filter lpar_names=$lpar -F state\r" out] != 0} {
 			winge "$system/$lpar: failed to get lpar status"
 			exit 1
 		}

 		return $out
 	}

 	proc reboot {system lpar profile mode} {
 		global hscpath

 		# Partitions in Error state are tricky, you _may_ either
 		# have to shut them down and then start them, or you may
 		# just have to start them.  So, if we are in Error start
 		# the partition, if it fails we can just drop through
 		# to the regular stop/start cycle.
 		if {[string compare [state $system $lpar] "Error"] == 0} {
 			note "starting lpar (from Error)"
 			if {[runit "chsysstate -r lpar -m $system -n $lpar -f $profile -b $mode -o on\r" out] == 0} {
 				note "started"
 				return
 			}
 			note "start failed - attempting shutdown"
 		}

 		# See if the lpar is up, if so shut it down.
 		if {[string compare [state $system $lpar] "Not Activated"] != 0} {
 			note "shutting down lpar"
 			if {[runit "chsysstate -r lpar -m $system -n $lpar -o shutdown --immed\r" out] != 0} {
 				winge "$system/$lpar: power off failed\n$out"
 				exit 2
 			}
 		}

 		while {[string compare [state $system $lpar] "Not Activated"] != 0} {
 			note "waiting for shutdown"
 			sleep 15
 		}

 		note "starting lpar"
 		if {[runit "chsysstate -r lpar -m $system -n $lpar -f $profile -b $mode -o on\r" out] != 0} {
 			winge "$system/$lpar: power on failed\n$out"
 			exit 2
 		}
 		note "started"
 	}
 }

 #
 # VERSION: common
 #
 proc open-term {system lpar} {
 	global prompt
 	global hscpath
 	global spawn_id

 	note "opening console ..."
 	send "ulimit -t 3600; \[ -f cleandown ] && sudo /home/hscroot/cleandown $system $lpar; mkvterm -m $system -p $lpar\r"
 	expect {
 		"NVTS" { }
 		"Open in progress.." { }
 		"$prompt" {
 			winge "$system/$lpar: open console failed"
 			exit 2
 		}
 	}

 	note "console open"
 	interact {
 		-i $spawn_id
 		" Connection has closed" {
 			winge "$system/$lpar: console connection closed"
 			exit 2
 		}
 		{Error in communication path to the partition} {
 			winge "$system/$lpar: lost contact with lpar"
 			exit 2
 		}
 		"$prompt" {
 			winge "$system/$lpar: open console failed"
 			exit 2
 		}
 		eof {
 			winge "$system/$lpar: payload lost"
 			exit 2
 		}
 		\000 {
 		}

 	}
 	note "console closed"
 }

 proc close-term {system lpar} {
 	global hscpath

 	note "closing console ..."
 	if {[runit "rmvterm -m $system -p $lpar\r" out] != 0} {
 		winge "$system/$lpar: close console failed"
 		exit 2
 	}
 }

 # Look and see if this system exists.
 set systems [system_list]
 if {[lsearch -exact $systems $system] < 0} {
 	winge "$system: system not known; console knows: $systems"
 	exit 1
 }
 set lpars [lpar_list $system]
 if {[lsearch -exact $lpars $lpar] < 0} {
 	winge "$system/$lpar: lpar not known; console knows: $lpars"
 	exit 1
 }

 # Check for system in Operating/Ready.
 set state [system_state $system]
 if {[string compare $lpar "FullSystemPartition"] != 0 &&
     [string compare $state "Operating"] != 0 &&
     [string compare $state "Ready"] != 0} \
 {
 	winge "$system: unusable - $state"
 	exit 1
 }

 # Ask for the lpar status, to see if it exists.
 set lstate [state $system $lpar]
 note "$system/$lpar: found ($state/$lstate)"

 #
 # COMMANDS: command.
 #
 switch -- $cmd {
 	{open-term}	{
 		close-term $system $lpar
 		open-term $system $lpar
 	}
 	{close-term}	{
 		close-term $system $lpar
 	}
 	{reboot}	{
 		reboot $system $lpar $profile $mode
 	}
 	default		{
 		winge "$cmd: unknown command"
 	}
 }

 exit 0
	#!/usr/bin/expect --
	#
	# hmc -- handle consoles and rebooting of HMC based systems
	#
	# Allow connecting to the console of and rebooting of HMC connected
	# machines. Machines are identified by the HMC IP address, connected
	# system name, and partition name.
	#
	# usage:
	# hmc open-term\|reboot -h <hmc IP> -m <system> -p <partition> \
	# -U <user> -P <password> -V <hmc version>
	#
	# example:
	# hmc open-term -m elm3b70 -p FullSystemPartition -U hscroot -P passwd \
	# -V 2.6 -h 1.2.3.4
	# hmc reboot -m elm3b70 -p FullSystemPartition -U hscroot -P passwd \
	# -V 2.6 -h 1.2.3.4
	#
	# (C) Copyright IBM Corp. 2004, 2005, 2006
	# Author: Andy Whitcroft <andyw@uk.ibm.com>
	#
	# The Console Multiplexor is released under the GNU Public License V2
	#
	set P "hmc"

	# See interactions.
	log_user 0
	#exp_internal 1

	proc note {m} {
	global P
	puts "$P: $m"
	}
	proc warn {m} {
	global P
	puts "$P: WARNING: $m"
	}
	proc winge {m} {
	global P
	puts "$P: MACHINE ERROR: $m"
	}

	#
	# OPTIONS: options parser.
	#
	proc shift {_list} {
	upvar $_list list

	set res [lindex $list 0]
	set list [lreplace $list 0 0]

	return $res
	}
	proc arg {_list arg} {
	upvar $_list list

	if {[llength $list] < 1} {
	winge "$arg: required argument missing"
	exit 1
	}

	return [shift list]
	}

	set user {hscroot}
	set host {}
	set system {}
	set lpar {}
	set profile {default}
	set mode {norm}
	set passwd {}
	set version {}

	set cmd [lindex $argv 0]
	shift argv
	while {[llength $argv] > 0} {
	switch -- [shift argv] {
	-h { set host [arg argv h]}
	hmc { set host [arg argv h]}
	-m { set system [arg argv m]}
	-l { set lpar [arg argv l]}
	-p { set lpar [arg argv p]}
	-f { set profile [arg argv f]}
	-b { set mode [arg argv b]}
	-U { set user [arg argv P]}
	-P { set passwd [arg argv P]}
	-V { set version [arg argv P]}
	}
	}

	if {[llength $argv] > 0} {
	puts stderr "Usage: $P <cmd> -h <hmc> -m <system> -p <lpar> -f <profile> -b <mode>"
	exit 1
	}
	if {[string compare $host ""] == 0 \|\|
	[string compare $system ""] == 0 \|\|
	[string compare $lpar ""] == 0} \
	{
	winge "hmc (-h), machine (-m) and lpar (-p) required"
	exit 1
	}

	set prompt {___EOF___HMC___EOF___}
	set hscpath {/opt/hsc/bin}

	#log_file -a "$logfile"

	set elapsed_time 0
	set timeout 30

	# Ensure we have a terminal so we don't get prompted for one.
	if {![info exists env(TERM)]} {
	set env(TERM) {vt100}
	}

	# If we have a password don't use any ssh-keys we may have been offered.
	if {[string compare $passwd ""] == 0} {
	set command "ssh $env(SSH_OPTIONS) $user@$host"
	} else {
	set command "ssh $user@$host"
	}

	# CONNECT: connect to the remote console. Set the prompt up so we
	# know when a command we execute has completed.
	note "Logging into HMC console with command \"$command\" ..."
	eval spawn $command
	send "PS1=$prompt\r"
	expect {
	-re {[pP]assword:} {
	if {[string compare $passwd ""] == 0} {
	winge "$host: requesting password - not hacked"
	exit 2
	}
	send "$passwd\r"
	after 500
	send "PS1=$prompt\r"
	exp_continue
	}
	"Connection timed out" {
	winge "$host: cannot connect to console"
	exit 2
	}
	"Name or service not known" {
	winge "$host: HMC name invalid"
	exit 1
	}
	"Permission denied" {
	winge "$host: authentication failure, permission denied"
	exit 2
	}
	timeout {
	winge "$host: HMC did not prompt us, timed out"
	exit 2
	}
	eof {
	winge "$host: HMC disconnected without prompting"
	exit 2
	}

	"Terminal type?" {
	send "vt100\r"
	send "PS1=$prompt\r"
	exp_continue
	}

	"PS1=$prompt" {
	# Ignore us typing the change to the prompt.
	exp_continue
	}
	"$prompt" {
	# Prompt see, we are in and working, drop out.
	## note "prompt seen"
	}

	-re "^\[^\n]*\n" {
	# We need to absorb any login information, motd etc.
	## puts "NOISE<$expect_out(buffer)>"
	exp_continue
	}
	}

	proc runit {cmd _out} {
	upvar $_out out

	global prompt

	send "$cmd"

	set text ""
	set line 0

	set timeout 120
	expect {

	-re "^\[^\n]*\n" {
	##note "LINE: $expect_out(buffer)"
	if { $line > 0 } {
	append text $expect_out(buffer)
	}
	incr line
	exp_continue
	}

	-re "$prompt" {
	##note "prompt seen"
	}

	timeout {
	set out "hmc: command timeout"
	return 255
	}
	}
	set out [string trimright $text]

	send "echo \$?\r"
	set text ""
	set line 0
	set timeout 30
	expect {
	-re "^\[^\n]*\n" {
	##note "LINE: $expect_out(buffer)"
	if { $line > 0 } {
	append text $expect_out(buffer)
	}
	incr line
	exp_continue
	}

	-re "$prompt" {
	##note "prompt seen"
	}

	timeout {
	set out "hmc: command status timeout"
	return 255
	}
	}
	##note "EXIT: $text"

	return [string trimright $text]
	}

	proc extract_names {out} {
	set res {}
	foreach sys [split $out] {
	if {[string compare $sys ""] != 0} {
	lappend res $sys
	}
	}

	return $res
	}

	# Find out the current version of the HMC software.
	if {[string compare $version ""] == 0} {
	runit "rpm -q IBMhsc.coreserver --qf '%{VERSION}'; echo ''\r" version
	}
	if {[string compare $version ""] == 0} {
	winge "unable to obtain HMC code version"
	exit 1
	}
	note "HMC revision v$version"

	# Based on the version of the HMC software select payload.
	if {$version < 4.0} {
	#
	# VERSION 2.6/3.0 specific support.
	#
	proc system_list {} {
	global hscpath

	# Ask for a list of systems.
	if {[runit "lssyscfg -r sys --all -F name\r" out] != 0} {
	winge "unable to obtain list of systems"
	exit 1
	}

	return [extract_names $out]
	}
	proc system_state {system} {
	global hscpath

	# Ask for the system status.
	if {[runit "lssyscfg -r sys -n $system -F state\r" out] != 0} {
	winge "$system: failed to get status"
	exit 1
	}

	return $out
	}
	proc lpar_list {system} {
	global hscpath

	# Ask for a list of lpars for this system.
	if {[runit "lssyscfg -r lpar -m $system --all -F name\r" out] != 0} {
	winge "unable to obtain list of lpars"
	exit 1
	}

	return [extract_names $out]
	}
	proc state {system lpar} {
	global hscpath

	# Ask for the lpar status.
	if {[runit "lssyscfg -r lpar -m $system -n $lpar -F state\r" out] != 0} {
	winge "$system/$lpar: failed to get lpar status"
	exit 1
	}

	return $out
	}
	proc reboot_metal {system lpar profile mode} {
	global hscpath

	# If we have no connection wait for the machine to appear.
	# XXX: timeout?
	set was {}
	set when [clock seconds]
	if {[string compare [system_state $system] "Ready"] != 0} {
	while {([clock seconds] - $when) < 60} {
	sleep 15
	set state [system_state $system]

	note "waiting for stable connected state ($state)"
	if {$state != $was \|\| [string compare $state "No Connection"] == 0} {
	set was $state
	set when [clock seconds]
	}
	}
	}

	# See if the system is is in Error, if so attempt to
	# power it on.
	if {[string compare [system_state $system] "Error"] == 0} {
	note "starting full system (from Error)"
	if {[runit "chsysstate -r sys -m $system -n $system -b $mode -o on -c full\r" out] == 0} {
	note "started"
	return
	}
	note "start failed - attempting shutdown"
	}

	# See if the system is up, if so shut it down.
	if {[string compare [system_state $system] "No Power"] != 0} {
	note "shutting down full system"
	if {[runit "chsysstate -r sys -m $system -n $system -o off -c full\r" out] != 0} {
	winge "$system: power off failed\n$out"
	exit 2
	}
	}

	while {[string compare [system_state $system] "No Power"] != 0} {
	note "waiting for shutdown"
	sleep 15
	}

	note "starting full system"
	if {[runit "chsysstate -r sys -m $system -n $system -b $mode -o on -c full\r" out] != 0} {
	winge "$system: power on failed"
	exit 2
	}
	note "started"
	}
	proc reboot {system lpar profile mode} {
	global hscpath

	# Handle the bare metal separatly.
	if {[string compare $lpar "FullSystemPartition"] == 0} {
	return [reboot_metal $system $lpar $profile $mode]
	}

	# Partitions in Error state are tricky, you _may_ either
	# have to shut them down and then start them, or you may
	# just have to start them. So, if we are in Error start
	# the partition, if it fails we can just drop through
	# to the regular stop/start cycle.
	if {[string compare [state $system $lpar] "Error"] == 0} {
	note "starting lpar (from Error)"
	if {[runit "chsysstate -r lpar -m $system -n $lpar -b $mode -o on\r" out] == 0} {
	note "started"
	return
	}
	note "start failed - attempting shutdown"
	}

	# See if the lpar is up, if so shut it down.
	if {[string compare [state $system $lpar] "Ready"] != 0} {
	note "shutting down lpar"
	if {[runit "chsysstate -r lpar -m $system -n $lpar -o off\r" out] != 0} {
	winge "$system/$lpar: power off failed\n$out"
	exit 2
	}
	}

	while {[string compare [state $system $lpar] "Ready"] != 0} {
	note "waiting for shutdown"
	sleep 15
	}

	note "starting lpar"
	if {[runit "chsysstate -r lpar -m $system -n $lpar -b $mode -o on\r" out] != 0} {
	winge "$system/$lpar: power on failed\n$out"
	exit 2
	}
	note "started"
	}

	}

	if {$version >= 4.0} {
	#
	# VERSION 4.x specific support.
	#
	proc system_list {} {
	global hscpath

	# Ask for a list of systems.
	if {[runit "lssyscfg -r sys -F name\r" out] != 0} {
	winge "unable to obtain list of systems"
	exit 1
	}

	return [extract_names $out]
	}
	proc system_state {system} {
	global hscpath

	# Ask for the system status.
	if {[runit "lssyscfg -r sys -m $system -F state\r" out] != 0} {
	winge "$system: failed to get system status"
	exit 1
	}

	return $out
	}
	proc lpar_list {system} {
	global hscpath

	# Ask for a list of lpars for this system.
	if {[runit "lssyscfg -r lpar -m $system -F name\r" out] != 0} {
	winge "unable to obtain list of lpars"
	exit 1
	}

	return [extract_names $out]
	}
	proc state {system lpar} {
	global hscpath

	# Ask for the lpar status.
	if {[runit "lssyscfg -r lpar -m $system --filter lpar_names=$lpar -F state\r" out] != 0} {
	winge "$system/$lpar: failed to get lpar status"
	exit 1
	}

	return $out
	}

	proc reboot {system lpar profile mode} {
	global hscpath

	# Partitions in Error state are tricky, you _may_ either
	# have to shut them down and then start them, or you may
	# just have to start them. So, if we are in Error start
	# the partition, if it fails we can just drop through
	# to the regular stop/start cycle.
	if {[string compare [state $system $lpar] "Error"] == 0} {
	note "starting lpar (from Error)"
	if {[runit "chsysstate -r lpar -m $system -n $lpar -f $profile -b $mode -o on\r" out] == 0} {
	note "started"
	return
	}
	note "start failed - attempting shutdown"
	}

	# See if the lpar is up, if so shut it down.
	if {[string compare [state $system $lpar] "Not Activated"] != 0} {
	note "shutting down lpar"
	if {[runit "chsysstate -r lpar -m $system -n $lpar -o shutdown --immed\r" out] != 0} {
	winge "$system/$lpar: power off failed\n$out"
	exit 2
	}
	}

	while {[string compare [state $system $lpar] "Not Activated"] != 0} {
	note "waiting for shutdown"
	sleep 15
	}

	note "starting lpar"
	if {[runit "chsysstate -r lpar -m $system -n $lpar -f $profile -b $mode -o on\r" out] != 0} {
	winge "$system/$lpar: power on failed\n$out"
	exit 2
	}
	note "started"
	}
	}

	#
	# VERSION: common
	#
	proc open-term {system lpar} {
	global prompt
	global hscpath
	global spawn_id

	note "opening console ..."
	send "ulimit -t 3600; \[ -f cleandown ] && sudo /home/hscroot/cleandown $system $lpar; mkvterm -m $system -p $lpar\r"
	expect {
	"NVTS" { }
	"Open in progress.." { }
	"$prompt" {
	winge "$system/$lpar: open console failed"
	exit 2
	}
	}

	note "console open"
	interact {
	-i $spawn_id
	" Connection has closed" {
	winge "$system/$lpar: console connection closed"
	exit 2
	}
	{Error in communication path to the partition} {
	winge "$system/$lpar: lost contact with lpar"
	exit 2
	}
	"$prompt" {
	winge "$system/$lpar: open console failed"
	exit 2
	}
	eof {
	winge "$system/$lpar: payload lost"
	exit 2
	}
	\000 {
	}

	}
	note "console closed"
	}

	proc close-term {system lpar} {
	global hscpath

	note "closing console ..."
	if {[runit "rmvterm -m $system -p $lpar\r" out] != 0} {
	winge "$system/$lpar: close console failed"
	exit 2
	}
	}

	# Look and see if this system exists.
	set systems [system_list]
	if {[lsearch -exact $systems $system] < 0} {
	winge "$system: system not known; console knows: $systems"
	exit 1
	}
	set lpars [lpar_list $system]
	if {[lsearch -exact $lpars $lpar] < 0} {
	winge "$system/$lpar: lpar not known; console knows: $lpars"
	exit 1
	}

	# Check for system in Operating/Ready.
	set state [system_state $system]
	if {[string compare $lpar "FullSystemPartition"] != 0 &&
	[string compare $state "Operating"] != 0 &&
	[string compare $state "Ready"] != 0} \
	{
	winge "$system: unusable - $state"
	exit 1
	}

	# Ask for the lpar status, to see if it exists.
	set lstate [state $system $lpar]
	note "$system/$lpar: found ($state/$lstate)"

	#
	# COMMANDS: command.
	#
	switch -- $cmd {
	{open-term} {
	close-term $system $lpar
	open-term $system $lpar
	}
	{close-term} {
	close-term $system $lpar
	}
	{reboot} {
	reboot $system $lpar $profile $mode
	}
	default {
	winge "$cmd: unknown command"
	}
	}

	exit 0