Context Navigation

mmremote

Last change on this file was 16, checked in by rock, 17 years ago

Property svn:executable set to ``*
File size: 79.5 KB

Line
1	#!/bin/ksh
2	# IBM_PROLOG_BEGIN_TAG
3	# This is an automatically generated prolog.
4	#
5	#
6	#
7	# Licensed Materials - Property of IBM
8	#
9	# (C) COPYRIGHT International Business Machines Corp. 1997,2006
10	# All Rights Reserved
11	#
12	# US Government Users Restricted Rights - Use, duplication or
13	# disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
14	#
15	# IBM_PROLOG_END_TAG
16	# @(#)29 1.290.1.9 src/avs/fs/mmfs/ts/admin/mmremote.sh, mmfs, avs_rgpfs24, rgpfs24s008a 11/25/06 00:29:43
17	#######################################################################
18
19	# Include global declarations and service routines.
20	. /usr/lpp/mmfs/bin/mmglobfuncs
21	. /usr/lpp/mmfs/bin/mmsdrfsdef
22	. /usr/lpp/mmfs/bin/mmfsfuncs
23
24	sourceFile="mmremote.sh"
25	[[ -n $DEBUG \|\| -n $DEBUGmmremote ]] && set -x
26	$mmTRACE_ENTER "$*"
27
28	# Local work files. Names should be of the form:
29	# fn=${tmpDir}fn.${mmcmd}.$$
30
31	LOCAL_FILES=" "
32
33
34	# Local variables
35	typeset -l kword_lc
36	typeset -l arg3_lc
37	rc=0
38
39
40	# Local functions
41
42	####################################################################
43	#
44	# Function: Take a snapshot of the currently-running trace.
45	#
46	# Input: $1 - action to perform
47	#
48	# Output: None
49	#
50	# Returns: 0
51	#
52	####################################################################
53	function traceSnapshot
54	{
55	typeset sourceFile="mmremote.sh"
56	[[ -n $DEBUG \|\| -n $DEBUGtraceSnapshot ]] && set -x
57	$mmTRACE_ENTER "$*"
58	typeset action=$1
59	typeset tracePid
60
61	if [[ -z $(print -- " off on offon log " \| $fgrep " $action ") ]]
62	then
63	# Invalid value for flag
64	printErrorMsg 153 $mmcmd tsnap
65	return 1
66	fi
67
68	if [[ $action != off ]]
69	then
70	$mmfsadm showtrace >/dev/null
71	if [[ $? -eq 0 ]]
72	then
73	$mmfsadm trace all 9
74	$mmfsadm trace tm 2 thread 1 mutex 1 vnode 1 ksvfs 1 klockl 0
75	$mmfsadm trace io 3 pgalloc 1 mb 1 lock 2 dfs 2 fsck 3
76	fi
77	fi
78
79	tracePid=$($ps -eo "pid args" \| $awk '/trace / && !/this process/ {print $1}')
80	if [[ ($action = off \|\| $action = offon) && -n $tracePid ]]
81	then
82	$trcstop
83	$mv /var/adm/ras/trcfile /var/adm/ras/trcfile.$(date +"%H.%M.%S")
84	fi
85
86	if [[ $action = offon \|\| $action = on ]]
87	then
88	$trace -a -l -L 12000000 -T 4000000 -j 306,307,308,309 \
89	-o /var/adm/ras/trcfile >/dev/null 2>&1 &
90	fi
91
92	date=$(date +"%y%m%d")
93	$mkdir -p /log/$date 2>/dev/null
94
95	for trcname in $($ls /var/adm/ras \| $grep trcfile.)
96	do
97	time=$(print -- $trcname \| $awk -F. '{print $2}')
98	$cp -p /var/adm/ras/trcfile.$time \
99	/log/$date/trcfile.$date.$time."$($hostname -s)"
100	$rm -f /var/adm/ras/trcfile.$time
101	done
102
103	return 0
104
105	} #------ end of function traceSnapshot -------------------
106
107
108	###############################################################################
109	#
110	# Function: Send the local mmsdrfs file to the node that is requesting it.
111	# Do this only if the client's generation number is smaller than
112	# the generation number of the mmsdrfs file on this node.
113	# If requested, get the lock.
114	#
115	# Input: $1 - generation number of the sdr file on the client
116	# $2 - name of client requesting the file
117	# $3 - name to use on the client for the retrieved file
118	# $4 - lockId or nolock
119	#
120	# Output: gpfsObject or 'fail'.
121	#
122	# Returns: Zero if successful, non-zero otherwise.
123	#
124	###############################################################################
125	function sendClusterSDRFiles # <clientGenNumber> <client> <fileName> <lockId>
126	{
127	typeset sourceFile="mmremote.sh"
128	[[ -n $DEBUG \|\| -n $DEBUGsendClusterSDRFiles ]] && set -x
129	$mmTRACE_ENTER "$*"
130	typeset clientGenNumber=$1
131	typeset client=$2
132	typeset fileName=$3
133	typeset lockId=$4
134
135	typeset rc=0
136	typeset lockObtained=""
137	typeset lockResult gpfsObjectInfo serverGenNumber junk
138	typeset pid getObjectPort
139
140	# Get the lock if requested
141	if [[ $lockId != nolock ]]
142	then
143	lockResult=$(getLock $lockId)
144
145	# Look at the result from the lock request.
146	# If it is more than one word, we assume it is an error message.
147	set -f ; set -- $lockResult ; set +f
148	gpfsObjectInfo=$1
149	junk=$2
150	if [[ -z $gpfsObjectInfo \|\| -n $junk ]]
151	then
152	# If unexpected output, give up
153	[[ -n $junk ]] && \
154	print -u2 "$lockResult"
155	return 1
156	fi
157	if [[ $lockResult = fail ]]
158	then
159	print -- "fail"
160	return 1
161	else
162	lockObtained=yes
163	fi
164	fi
165
166	# If we are here, either the caller did not need the lock or the lock
167	# was successfully obtained. Make sure the caller has the latest data.
168
169	# Get the server's generation number.
170	gpfsObjectInfo=$(getGpfsObject)
171	rc=$?
172	IFS=':'
173	set -f ; set -- $gpfsObjectInfo ; set +f
174	IFS="$IFS_sv"
175	serverGenNumber=$2
176	if [[ $rc -ne 0 \|\| -z $serverGenNumber ]]
177	then
178	# Unexpected value for the Gpfs object
179	[[ $rc -eq 0 ]] && \
180	printErrorMsg 286 sendClusterSDRFiles $gpfsObjectInfo
181	[[ $lockObtained = yes ]] && \
182	freeLock 0 > /dev/null
183	print -- "fail"
184	return 1
185	fi
186
187	# If the client's local generation number is smaller than
188	# the one we have here, copy our version to the client.
189	if [[ $clientGenNumber -lt $serverGenNumber ]]
190	then
191	$rcp $mmsdrfsFile ${client}:${fileName}
192	rc=$?
193	fi
194
195	# If everything is OK so far, return the Gpfs object.
196	if [[ $rc -eq 0 ]]
197	then
198	print -- "$gpfsObjectInfo"
199	else
200	[[ $lockObtained = yes ]] && \
201	freeLock 0 > /dev/null
202	print -- "fail"
203	fi
204	return $rc
205
206	} #------ end of function sendClusterSDRFiles ------------
207
208
209	############################################################################
210	#
211	# Function: Determine whether this node is new to GPFS and whether the
212	# GPFS code on this node can support clustering. If it can,
213	# create a skeleton version of the sdrfs file that reflects
214	# the passed key attributes and a generation number of 1.
215	#
216	# Input: cltype - cluster and environment type (e.g., "lc/lc2")
217	# primaryServer - primary server
218	# backupServer - secondary server or _NOSECONDARY_
219	# localNodeData - hostname, node number, etc. for the node
220	# rshPath - remote shell command or _DEFAULT_
221	# rcpPath - remote file copy command or _DEFAULT_
222	# clusterIdAndSt - cluster id and cluster subtype
223	#
224	# Output: A colon-separated list of the following fields:
225	# keyword - checkNewClusterNode
226	# status - success, not_new, etc.
227	# adapter type - e.g., eth0
228	# daemon version - e.g., 800
229	# product version - e.g., 2.3.0.0
230	# OS name - AIX or Linux
231	#
232	# Note: The adapter type and subsequent fields have meaningful
233	# information only if status is "success".
234	#
235	# Returns: zero if success, non-zero otherwise
236	#
237	############################################################################
238	function checkNewClusterNode # <cltype> <primaryServer> <backupServer>
239	# <localNodeData> <rshPath> <rcpPath>
240	# <clusterIdAndSt>
241	{
242	typeset sourceFile="mmremote.sh"
243	[[ -n $DEBUG \|\| -n $DEBUGcheckNewClusterNode ]] && set -x
244	$mmTRACE_ENTER "$*"
245	typeset cltype=$1
246	typeset primary=$2
247	typeset secondary=$3
248	typeset localNodeData=$4
249	typeset rshPath=$5
250	typeset rcpPath=$6
251	typeset clusterIdAndSt=$7
252
253	typeset clusterType environmentType result hostResult
254	typeset initialSystemFiles sdrfsLine nodeNumber ipa adminNodeName adminIpa
255	typeset clusterId clusterSubtype adapterType nodeStatus
256
257	typeset newGenNumber=1
258	typeset rc=0
259
260	initialSystemFiles="$mmsdrfsFile ${mmfsEnvLevel}$newGenNumber $mmfsNodeData"
261	[[ $secondary = "_NOSECONDARY_" ]] && secondary=""
262	[[ $rshPath = "_DEFAULT_" ]] && rshPath=""
263	[[ $rcpPath = "_DEFAULT_" ]] && rcpPath=""
264	export GPFS_rshPath="$rshPath"
265	export GPFS_rcpPath="$rcpPath"
266
267	# Check that no sdrfs file exists on this node;
268	# report "not new" if an sdrfs file already exists.
269	if [[ -f $mmsdrfsFile ]]
270	then
271	print -- "checkNewClusterNode:not_new:"
272	return 1
273	fi
274
275	# Parse the overloaded input parameters.
276	IFS='/'
277	set -f ; set -- $cltype ; set +f
278	IFS="$IFS_sv"
279	clusterType=$1
280	environmentType=$2
281	[[ -z $environmentType ]] && environmentType=$clusterType
282
283	IFS=':'
284	set -f ; set -- $clusterIdAndSt ; set +f
285	IFS="$IFS_sv"
286	clusterId=$1
287	clusterSubtype=$2
288	[[ -z $clusterSubtype ]] && clusterSubtype=$environmentType
289
290	# Check whether the prerequisite software for the specified
291	# cluster type is installed.
292	checkPrereqs $environmentType
293	if [[ $? -ne 0 ]]
294	then
295	print -- "checkNewClusterNode:not_supported:"
296	return 1
297	fi
298
299	# Create a skeleton sdrfs file on this node.
300	$mkdir -p $mmsdrfsDir
301	sdrfsLine="$GLOBAL_ID:$VERSION_LINE::$CURRENT_SDRFS_FORMAT:$CURRENT_SDRFS_VERSION"
302	sdrfsLine="$sdrfsLine:$newGenNumber::$clusterType:$primary:$secondary"
303	sdrfsLine="$sdrfsLine::$rshPath:$rcpPath:$clusterId:$clusterSubtype:"
304	print -- "$sdrfsLine" > $mmsdrfsFile
305
306	# Add threatening comment lines: DO NOT MESS WITH THIS FILE!
307	sdrfsLine="$GLOBAL_ID:$COMMENT_LINE::1:"
308	print -- "$sdrfsLine" >> $mmsdrfsFile
309	sdrfsLine="$GLOBAL_ID:$COMMENT_LINE::2:$warningText"
310	print -- "$sdrfsLine" >> $mmsdrfsFile
311	sdrfsLine="$GLOBAL_ID:$COMMENT_LINE::3:"
312	print -- "$sdrfsLine" >> $mmsdrfsFile
313
314	# Add the local node information.
315	print -- "$localNodeData" >> $mmsdrfsFile
316	rc=$?
317	if [[ $rc -ne 0 ]]
318	then
319	printErrorMsg 171 "checkNewClusterNode" "writing to file $mmsdrfsFile" $rc
320	print -- "checkNewClusterNode:unexpected_error:"
321	$rm -f $initialSystemFiles
322	return 1
323	fi
324
325	# Create a file with the MEMBER_NODE line for this node.
326	# It will be used later to quickly determine the node's
327	# node number, reliable hostname, and other information.
328	print -- "$localNodeData" > $mmfsNodeData
329	rc=$?
330	if [[ $rc -ne 0 ]]
331	then
332	printErrorMsg 171 "checkNewClusterNode" "writing to file $mmfsNodeData" $rc
333	print -- "checkNewClusterNode:unexpected_error:"
334	$rm -f $initialSystemFiles
335	return 1
336	fi
337
338	# Remember the current level of the system files.
339	$touch ${mmfsEnvLevel}$newGenNumber
340
341	# Flush the important files to disk.
342	$mmsync $mmsdrfsFile $mmfsNodeData ${mmfsEnvLevel}$newGenNumber
343
344	# Retrieve needed information from the local node data.
345	IFS=':'
346	set -f ; set -A v -- - $localNodeData ; set +f
347	IFS="$IFS_sv"
348	nodeNumber=${v[$NODE_NUMBER_Field]}
349	ipa=${v[$IPA_Field]}
350	adapterType=${v[$ADAPTER_TYPE_Field]}
351	adminNodeName=${v[$REL_HOSTNAME_Field]}
352	daemonNodeName=${v[$DAEMON_NODENAME_Field]}
353
354	if [[ -z $adapterType ]]
355	then
356	# Get the node's adapter information.
357	$ifconfig -a > $adfile
358	rc=$?
359	if [[ $rc -ne 0 ]]
360	then
361	printErrorMsg 171 "checkNewClusterNode" "ifconfig -a" $rc
362	print -- "checkNewClusterNode:unexpected_error:"
363	$rm -f $initialSystemFiles
364	return 1
365	fi
366
367	# Find the adapter type for the primary GPFS network.
368	# The assumptions are that the ifconfig output is organized in stanzas.
369	# Each stanza begins with the adapter type starting in column 1.
370	# All other lines are indented by at least one space or tab character.
371	if [[ $osName = Linux ]]
372	then
373	adapterType=$($awk ' \
374	$0 !~ /^[ ]/ { adapterType = $1 } \
375	/ addr:'$ipa' / { print adapterType ; exit } \
376	' $adfile)
377	rc=$?
378	elif [[ $osName = AIX ]]
379	then
380	adapterType=$($awk ' \
381	$0 !~ /^[ ]/ { adapterType = $1 } \
382	/[ ]inet '$ipa' / { print adapterType ; exit } \
383	' $adfile)
384	rc=$?
385	adapterType=${adapterType%:}
386	else
387	# Should never get here.
388	printErrorMsg 171 "checkNewClusterNode" "unsupported OS $osName" 1
389	print -- "checkNewClusterNode:unexpected_error:"
390	$rm -f $initialSystemFiles
391	return 1
392	fi
393	if [[ $rc -ne 0 ]]
394	then
395	printErrorMsg 171 "checkNewClusterNode" "awk" $rc
396	print -- "checkNewClusterNode:unexpected_error:"
397	$rm -f $initialSystemFiles
398	return 1
399	fi
400
401	# Verify that the adapter exists.
402	if [[ -z $adapterType ]]
403	then
404	# Print error type and return.
405	printErrorMsg 154 $mmcmd $ipa $adminNodeName
406	print -- "checkNewClusterNode:ipa_missing"
407	$rm -f $initialSystemFiles
408	return 1
409	fi
410
411	# If this is an IP alias, use the name of the main device.
412	adapterType=${adapterType%%:*}
413
414	# Add the new information to the local node data.
415	v[$ADAPTER_TYPE_Field]=$adapterType
416	localNodeData=$(print_newLine)
417	print -- "$localNodeData" > $mmfsNodeData
418	rc=$?
419	if [[ $rc -ne 0 ]]
420	then
421	printErrorMsg 171 "checkNewClusterNode" "writing to file $mmfsNodeData" $rc
422	print -- "checkNewClusterNode:unexpected_error:"
423	$rm -f $initialSystemFiles
424	return 1
425	fi
426	fi # end of if [[ -z $adapterType ]]
427
428
429	# Check that the admin interface name is valid
430	# if it is different than the one we just checked.
431	if [[ $adminNodeName != $daemonNodeName ]]
432	then
433	# Determine the IP address for the specified admin node name.
434	hostResult=$($host $adminNodeName)
435	set -f ; set -- $hostResult ; set +f
436	adminIpa=${3%%,*}
437
438	# Check that the admin node name has a valid IP address.
439	if [[ -z $adminIpa ]]
440	then
441	# An invalid node name was specified.
442	printErrorMsg 54 $mmcmd $adminNodeName
443	$rm -f $initialSystemFiles
444	return 1
445	fi
446
447	# Find the adapter type for the admin network.
448	# The assumptions are that the ifconfig output is organized in stanzas.
449	# Each stanza begins with the adapter type starting in column 1.
450	# All other lines are indented by at least one space or tab character.
451	if [[ $osName = Linux ]]
452	then
453	adapterType=$($awk ' \
454	$0 !~ /^[ ]/ { adapterType = $1 } \
455	/ addr:'$adminIpa' / { print adapterType ; exit } \
456	' $adfile)
457	rc=$?
458	elif [[ $osName = AIX ]]
459	then
460	adapterType=$($awk ' \
461	$0 !~ /^[ ]/ { adapterType = $1 } \
462	/[ ]inet '$adminIpa' / { print adapterType ; exit } \
463	' $adfile)
464	rc=$?
465	adapterType=${adapterType%:}
466	else
467	# Should never get here.
468	printErrorMsg 171 "checkNewClusterNode" "unsupported OS $osName" 1
469	print -- "checkNewClusterNode:unexpected_error:"
470	$rm -f $initialSystemFiles
471	return 1
472	fi
473
474	if [[ $rc -ne 0 ]]
475	then
476	printErrorMsg 171 "checkNewClusterNode" "awk" $rc
477	print -- "checkNewClusterNode:unexpected_error:"
478	$rm -f $initialSystemFiles
479	return 1
480	fi
481
482	# Verify that the adapter exists.
483	if [[ -z $adapterType ]]
484	then
485	# Print error type and return.
486	printErrorMsg 154 $mmcmd $adminIpa $adminNodeName
487	print -- "checkNewClusterNode:ipa_missing"
488	$rm -f $initialSystemFiles
489	return 1
490	fi
491
492	# If this is an IP alias, use the name of the main device.
493	adapterType=${adapterType%%:*}
494
495	fi # end of if [[ $adminNodeName != $daemonNodeName ]]
496
497	# Report success and return to caller.
498	result="checkNewClusterNode:success:$adapterType:$currentDaemonVersion"
499	result="$result:$productVersion:$osName:"
500	print -- "$result"
501	return 0
502
503	} #------ end of function checkNewClusterNode --------------
504
505
506	############################################################################
507	#
508	# Function: Verify that the specified adapter exists.
509	#
510	# Input: IP address of the adapter to check
511	#
512	# Output: The word "success" or a keyword representing the type
513	# of failure: "unexpected_error", "ipa_missing", etc.
514	#
515	# Returns: zero if success, non-zero otherwise
516	#
517	############################################################################
518	function checkAdapter # <ipa>
519	{
520	typeset sourceFile="mmremote.sh"
521	[[ -n $DEBUG \|\| -n $DEBUGcheckAdapter ]] && set -x
522	$mmTRACE_ENTER "$*"
523	typeset ipa=$1
524
525	typeset adapterType=""
526	typeset rc=0
527
528	# Get the node's adapter information.
529	$ifconfig -a > $adfile
530	rc=$?
531	if [[ $rc -ne 0 ]]
532	then
533	printErrorMsg 171 "checkAdapter" "ifconfig -a" $rc
534	print -- "unexpected_error"
535	return 1
536	fi
537
538	# Find the adapter type from the ifconfig output.
539	# The assumptions are that the output is organized in stanzas.
540	# Each stanza begins with the adapter type starting in column 1.
541	# All other lines are indented by at least one space or tab character.
542	if [[ $osName = Linux ]]
543	then
544	adapterType=$($awk ' \
545	$0 !~ /^[ ]/ { adapterType = $1 } \
546	/ addr:'$ipa' / { print adapterType ; exit } \
547	' $adfile)
548	rc=$?
549	elif [[ $osName = AIX ]]
550	then
551	adapterType=$($awk ' \
552	$0 !~ /^[ ]/ { adapterType = $1 } \
553	/[ ]inet '$ipa' / { print adapterType ; exit } \
554	' $adfile)
555	rc=$?
556	adapterType=${adapterType%:}
557	else
558	# Should never get here.
559	printErrorMsg 171 "checkAdapter" "unsupported OS $osName" 1
560	print -- "unexpected_error"
561	return 1
562	fi
563	if [[ $rc -ne 0 ]]
564	then
565	printErrorMsg 171 "checkAdapter" "awk" $rc
566	print -- "unexpected_error"
567	return 1
568	fi
569
570	# Verify that the adapter exists.
571	if [[ -z $adapterType ]]
572	then
573	# Print error type and return.
574	print -- "ipa_missing"
575	return 1
576	fi
577
578	# Report success and return to caller.
579	print -- "success"
580	return 0
581
582	} #------ end of function checkAdapter ---------------------
583
584
585	################################################################
586	#
587	# Function: Run an administration command.
588	#
589	# Input: Command name and arguments
590	#
591	# Output: Depends on the command
592	#
593	# Returns: 127 Command not supported
594	# Return code from the command
595	#
596	################################################################
597	function runCommand # <adminCommand> [<arguments>]
598	{
599	typeset sourceFile="mmremote.sh"
600	[[ -n $DEBUG \|\| -n $DEBUGrunCommand ]] && set -x
601	$mmTRACE_ENTER "$*"
602	typeset adminCmd=${1##*/} # get the basename part of <adminCommand>
603	typeset arguments="$2"
604
605	typeset rc=0
606
607
608	# Verify the command belongs to the set of allowed commands.
609	case $adminCmd in
610
611	"cat" ) adminCmd=$cat ;;
612	"head" ) adminCmd=$head ;;
613	"lspv" ) adminCmd=$lspv ;;
614	"lssrc" ) adminCmd=$lssrc ;;
615	"lsvsd" ) adminCmd=$lsvsd ;;
616	"mmfsadm" ) adminCmd=$mmfsadm ;;
617	"mmtrace" ) adminCmd=$mmtrace ;;
618	"mount" ) adminCmd=$mount ;;
619	"removevsd" ) adminCmd="$removevsd -f -v " ;;
620	"touch" ) adminCmd=$touch ;;
621	"tsaddrmap" ) adminCmd=$tsaddrmap ;;
622	"tsctl" ) adminCmd=$tsctl ;;
623	"tspreparedisk" ) adminCmd=$tspreparedisk ;;
624	"umount" ) adminCmd=$umount ;;
625	"unmount" ) adminCmd=$unmount ;;
626	* ) return 127 ;; # invalid command
627	esac
628
629	# Run the command and propagate back the return code.
630	$adminCmd $arguments
631	rc=$?
632
633	[[ $adminCmd = ts* \|\| $adminCmd = mm* ]] && \
634	rc=$(remapRC $?)
635
636	return $rc
637
638	} #------ end of function runCommand -------------------
639
640
641	##############################################################################
642	#
643	# Function: Determine the state of the GPFS daemon and other node info.
644	#
645	# Input: $1 - (optional) Extended output (-L option)
646	#
647	# Output:
648	# mmGetState:nsId:nodeNum:name:tsQuorum:up:total:state:quorumDesignation:
649	#
650	# Returns: Zero if successful, non-zero otherwise.
651	#
652	##############################################################################
653	function mmGetState # [-L]
654	{
655	typeset sourceFile="mmremote.sh"
656	[[ -n $DEBUG \|\| -n $DEBUGmmGetState ]] && set -x
657	$mmTRACE_ENTER "$*"
658	typeset extendedOutput=$1
659
660	typeset tsctlOutput=""
661	typeset rc tsQuorum nodesUp totalNodes daemonState quorumDesignation result
662	typeset gpfsInitOutput
663
664
665	if [[ -n $extendedOutput ]]
666	then
667	# Extended output is requested.
668	# Make sure that the local copies of the mmsdrfs, mmfs.cfg,
669	# and the rest of the system files are up to date.
670	gpfsInitOutput=$(gpfsInit nolock)
671	setGlobalVar $? $gpfsInitOutput
672
673	# Determine the total nodes value and whether or not this is a quorum node.
674	totalAndType=$($awk -F: ' \
675	BEGIN { \
676	{ total = 0 } \
677	{ type = "" } \
678	} \
679	/':$NODESET_HDR:'/ { \
680	if ( $'$NODESETID_Field' == "'$nsId'" ) { \
681	{ total = $'$NODE_COUNT_Field' } \
682	} \
683	} \
684	/':$MEMBER_NODE:'/ { \
685	if ( $'$REL_HOSTNAME_Field' == "'$ourNodeName'" ) { \
686	{ type = $'$CORE_QUORUM_Field' } \
687	{ exit } \
688	} \
689	} \
690	END { print total ":" type } \
691	' $mmsdrfsFile)
692	checkForErrors awk $?
693
694	IFS=':'
695	set -f ; set -- $totalAndType ; set +f
696	totalNodes=$1
697	quorumDesignation=$2
698	IFS="$IFS_sv"
699
700	else
701	# Regular output is requested. Return fake values
702	# for quorum designation and total nodes.
703	totalNodes=0
704	quorumDesignation=unknown
705	fi # end of if [[ -n $extendedOutput ]]
706
707
708	# Determine the quorum state of the daemon.
709	tsctlOutput=$(LC_ALL=C $tsctl quorumState 2>$errMsg)
710	rc=$(remapRC $?)
711
712	# Interpret the results from the tsctl command.
713	if [[ -z $tsctlOutput ]]
714	then
715	# The command failed. Filter out "Failed to connect" messages.
716	# Show any other error messages that might be there.
717	$grep -v -e "6027-665" -e "Failed to connect to file system daemon" $errMsg >$errMsg2
718	[[ -s $errMsg2 ]] && $cat $errMsg2 1>&2
719
720	# Provide default values to be returned to the caller.
721	tsQuorum=0
722	nodesUp=0
723
724	if [[ $rc -eq $MM_DaemonDown ]]
725	then
726	daemonState="down"
727	else
728	daemonState="unknown"
729	fi
730
731	else
732	# The tsctl command seemed to work. Parse the output.
733	# We intentionally override the totalNodes value found prior to
734	# the tsctl call because the daemon value may include remote nodes
735	# not reflected in the value we obtained from the sdrfs file.
736	IFS=':'
737	set -f ; set -- $tsctlOutput ; set +f
738	tsQuorum=$1
739	nodesUp=$2
740	totalNodes=$3
741	daemonState=$4
742	IFS="$IFS_sv"
743
744	# Remap the daemon status strings.
745	case $daemonState in
746	"Initial" ) daemonState="arbitrating" ;;
747	"Active" ) daemonState="active" ;;
748	* ) : ;; # Unknown string; leave it as is.
749	esac
750	fi # end of if [[ -z $tsctlOutput ]]
751
752	# Build and print the result string.
753	result="mmGetState:$nsId:$ourNodeNumber:$ourShortName:$tsQuorum"
754	result="${result}:$nodesUp:$totalNodes:$daemonState:$quorumDesignation:"
755	print -- "$result"
756
757	return 0
758
759	} #------ end of function mmGetState -------------------
760
761
762	###################################################################
763	#
764	# Function: Determine the state of the specified subsystem.
765	#
766	# Input: $1 - subsystem name
767	#
768	# Output: mmgetSubsysState:<nodeName>:<subsystemState>:
769	#
770	# Returns: Always zero.
771	#
772	###################################################################
773	function getSubsysState # <subsystem>
774	{
775	typeset sourceFile="mmremote.sh"
776	[[ -n $DEBUG \|\| -n $DEBUGgetSubsysState ]] && set -x
777	$mmTRACE_ENTER "$*"
778	typeset subsys=$1
779
780	typeset subsysState=""
781
782	# Determine whether the subsystem is active.
783	if [[ $subsys = rvsd ]]
784	then
785	subsysState=$(LC_ALL=C $lssrc -ls $subsys \| $grep 'active=1, state=idle' 2>/dev/null)
786	[[ -n $subsysState ]] && subsysState=active
787
788	elif [[ $subsys = mmfs ]]
789	then
790	$ps -e \| $grep -w mmfsd >/dev/null 2>&1
791	rc=$?
792	if [[ $rc -eq 0 ]]
793	then
794	print -- "active"
795	else
796	print -- "inactive"
797	fi
798
799	else
800	subsysState=$(LC_ALL=C $lssrc -s $subsys \| \
801	$awk '
802	BEGIN { state = "inactive" }
803	$1 == "'$subsys'" { if ( $NF == "active" ) { state = "active" } }
804	END { print state }
805	')
806	fi # end if [[ $subsys = rvsd ]]
807
808	[[ -z $subsysState ]] && subsysState=down
809
810	# Build and print the result string.
811	result="mmgetSubsysState:$ourNodeName:$subsysState:"
812	print -- "$result"
813
814	return 0
815
816	} #------ end of function getSubsysState -------------------
817
818
819	###########################################################################
820	#
821	# Function: Verifies that the RVSD subsystem is active on all nodes
822	# on which the GPFS daemon is running and then sets the
823	# wait4RVSD parameter to yes.
824	#
825	# Input: none
826	#
827	# Output: none
828	#
829	# Returns: 0 - RVSD operational on all nodes
830	# 1 - Error detected, or RVSD inactive on one or more nodes
831	#
832	###########################################################################
833	function setWait4RVSD #
834	{
835	typeset sourceFile="mmremote.sh"
836	[[ -n $DEBUG \|\| -n $DEBUGsetWait4RVSD ]] && set -x
837	$mmTRACE_ENTER "$*"
838
839	typeset subsysStateLine kword nodeName rvsdState failedNodes junk
840	typeset errorFound=""
841	typeset rc=0
842
843	##################################################################
844	# Use tsdsh to find the state of RVSD on all active GPFS nodes.
845	##################################################################
846	$tsdsh $mmremote getSubsysState rvsd >$tmpfile 2>&1
847	rc=$(remapRC $?)
848
849	if [[ ! -s $tmpfile ]]
850	then
851	# If there is no output at all, something is very wrong.
852	[[ $rc -eq 0 ]] && rc=1
853	checkForErrors "setWait4RVSD" $rc
854	else
855	# If we have output, ignore the rc from tsdsh.
856	rc=0
857	fi
858
859	# Parse the output from the RVSD active test.
860	$rm -f $errMsg
861	exec 3<&-
862	exec 3< $tmpfile
863	while read -u3 subsysStateLine
864	do
865	IFS=':'
866	set -f ; set -- $subsysStateLine ; set +f
867	IFS="$IFS_sv"
868	junk=$1
869	kword=$2
870	nodeName=$3
871	rvsdState=$4
872
873	if [[ $kword = ?( )mmgetSubsysState ]]
874	then
875	[[ $rvsdState != active ]] && \
876	failedNodes="$failedNodes\n\t$nodeName"
877	elif [[ -n $subsysStateLine ]]
878	then
879	# Unexpected output - must be an error.
880	# Collect the lines in a separate file for later.
881	print -- "$subsysStateLine" >> $errMsg
882	checkForErrors "writing to file $errMsg" $?
883	else
884	: # do nothing
885	fi # end of if [[ $kword = mmgetSubsysState ]]
886	done # end of while read -u3 subsysStateLine
887
888	if [[ -n $failedNodes ]]
889	then
890	# RVSD is not yet ready on at least one node.
891	printErrorMsg 474 $mmcmd RVSD "$failedNodes"
892	rc=1
893	fi
894
895	if [[ -s $errMsg ]]
896	then
897	# Show the unexpected errors.
898	$cat $errMsg 1>&2
899	rc=1
900	fi
901	$rm -f $errMsg
902
903	# If things look OK so far, change the value of the wait4RVSD parameter.
904	if [[ $rc -eq 0 ]]
905	then
906	$tsctl setCfgValue wait4RVSD yes
907	rc=$(remapRC $?)
908	if [[ $rc -ne 0 ]]
909	then
910	# The tsctl command failed.
911	printErrorMsg 104 "$mmcmd" "tsctl setCfgValue wait4RVSD yes"
912	fi
913	fi
914
915	return $rc
916
917	} #------ end of function setWait4RVSD ------------------
918
919
920	###########################################################################
921	#
922	# Function: Determines the range of GPFS release levels on the
923	# nodes on which the daemon is currently running.
924	#
925	# Input: None
926	#
927	# Output: A string with the following format:
928	# getCodeRange:rc:status:maxDaemonVers:minDaemonVers
929	#
930	# Returns: 0 - Success
931	# 1 - Error detected
932	#
933	###########################################################################
934	function getCodeRange # <nodefile> <sdrfsFile> <failedNodes>
935	{
936	typeset sourceFile="mmremote.sh"
937	[[ -n $DEBUG \|\| -n $getCodeRange ]] && set -x
938	$mmTRACE_ENTER "$*"
939
940	typeset mmVersion2output nodeName nodeNumber kword cmdVersion
941	typeset installedDaemonVersion installedProductVersion installedOsName
942	typeset maxDaemonVersion=0
943	typeset minDaemonVersion=100000
944	typeset rc=0
945
946	# Request the release level information for all of the nodes.
947	$tsdsh $mmremote mmVersion2 >$tmpfile 2>&1
948	rc=$(remapRC $?)
949
950	if [[ ! -s $tmpfile ]]
951	then
952	# If there is no output at all, something is very wrong.
953	[[ $rc -eq 0 ]] && rc=1
954	print -- "getCodeRange:$rc:unexpected_failure:0:0:"
955	printErrorMsg 171 $mmcmd "tsdsh mmremote mmVersion2" $rc
956	return $rc
957	else
958	# If we have output, ignore the rc from tsdsh.
959	rc=0
960	fi
961
962	# Parse the output from mmremote mmVersion2.
963	$rm -f $errMsg
964	IFS=":"
965	exec 3<&-
966	exec 3< $tmpfile
967	while read -u3 mmVersion2output
968	do
969	IFS=':'
970	set -f ; set -- $mmVersion2output ; set +f
971	nodeName=$1
972	kword=$2
973	cmdVersion=$3
974	nodeNumber=$4
975	installedDaemonVersion=$5
976	installedProductVersion=$6
977	installedOsName=$7
978	IFS="$IFS_sv"
979
980	if [[ $kword != *( )mmVersion2 ]]
981	then
982	# Unexpected output; it must be an error.
983	# Collect the lines in a separate file for later.
984	print -- "$mmVersion2output" >> $errMsg
985	checkForErrors "writing to file $errMsg" $?
986	continue
987	fi
988
989	# Keep track of highest and lowest daemon versions found.
990	[[ $installedDaemonVersion -gt $maxDaemonVersion ]] && \
991	maxDaemonVersion=$installedDaemonVersion
992	[[ $installedDaemonVersion -lt $minDaemonVersion ]] && \
993	minDaemonVersion=$installedDaemonVersion
994
995	IFS=":" # Change the separator back to ":" for the next iteration.
996	done # end of while read -u3 mmVersion2output
997	IFS="$IFS_sv"
998
999	# Print out the results string and exit.
1000	if [[ $maxDaemonVersion -eq 0 ]]
1001	then
1002	# We did not get back any release level information.
1003	# The output must have been only error messages.
1004	[[ $rc -eq 0 ]] && rc=1
1005	$cat $errMsg 1>&2
1006	print -- "getCodeRange:$rc:unexpected_failure:0:0:"
1007	else
1008	# Everything looks good.
1009	rc=0
1010	print -- "getCodeRange:$rc:complete:$maxDaemonVersion:$minDaemonVersion:"
1011	fi
1012
1013	$rm -f $errMsg
1014	return $rc
1015
1016	} #------ end of function getCodeRange ------------------
1017
1018
1019	#####################################################################
1020	#
1021	# Function: Ensure local system configuration files are up-to-date.
1022	#
1023	# Input: $1 -f rebuild all files
1024	#
1025	# Output: None
1026	#
1027	# Returns: Zero if successful, non-zero otherwise.
1028	#
1029	#####################################################################
1030	function refreshSysconfig # [-f]
1031	{
1032	typeset sourceFile="mmremote.sh"
1033	[[ -n $DEBUG \|\| -n $DEBUGrefreshSysconfig ]] && set -x
1034	$mmTRACE_ENTER "$*"
1035	typeset option=$1
1036
1037	typeset gpfsInitOutput
1038	typeset rc=0
1039
1040	# If the -f option was specified, force mmfsNodeData
1041	# and the rest of the GPFS files to be rebuilt.
1042	if [[ $option = "-f" ]]
1043	then
1044	$rm -f $mmfscfgFile $mmfsNodeData $nsdpvol ${mmfsEnvLevel}+([0-9]) \
1045	${mmfsNewKeyLevel}+([0-9]) ${mmfsCommittedKeyLevel}+([0-9])
1046	getLocalNodeData
1047	fi
1048
1049	# Verify there is an mmfs entry in /etc/vfs.
1050	checkVfsNumber
1051	rc=$?
1052	[[ $rc -ne 0 ]] && \
1053	return $rc
1054
1055	# Make sure that the local copies of the mmsdrfs, mmfs.cfg,
1056	# and the rest of the system files are up-to-date.
1057	gpfsInitOutput=$(gpfsInit nolock)
1058	rc=$?
1059	[[ $rc -ne 0 ]] && printErrorMsg 171 "$mmcmd" "gpfsInit" $rc
1060	setGlobalVar $rc $gpfsInitOutput
1061
1062	return $rc
1063
1064	} #------ end of function refreshSysconfig -------------------
1065
1066
1067	###################################################################
1068	#
1069	# Function: Tell the daemon to reread the authorized_keys list.
1070	#
1071	# Input: None.
1072	#
1073	# Output: None.
1074	#
1075	# Returns: Zero if successful, non-zero otherwise.
1076	#
1077	###################################################################
1078	function refreshAuth
1079	{
1080	typeset sourceFile="mmremote.sh"
1081	[[ -n $DEBUG \|\| -n $DEBUGrefreshAuth ]] && set -x
1082	$mmTRACE_ENTER "$*"
1083	typeset gpfsInitOutput=""
1084
1085	# Retrieve the latest mmsdrfs file and rebuild the environment.
1086	gpfsInitOutput=$(gpfsInit nolock)
1087	setGlobalVar $rc $gpfsInitOutput
1088
1089	# Tell the daemon to reread the authorized_keys list.
1090	$tsauth
1091
1092	return 0
1093
1094	} #------ end of function refreshAuth -------------------
1095
1096
1097	###################################################################
1098	#
1099	# Function: Determine the generation number of a sdrfs file.
1100	#
1101	# Input: $1 - (optional) sdrfs file. If not specified,
1102	# /var/mmfs/gen/mmsdrfs is assumed.
1103	#
1104	# Output: <genNumber>:<timeStamp>
1105	#
1106	# Returns: Zero if successful, non-zero otherwise.
1107	#
1108	###################################################################
1109	function getGenNumber
1110	{
1111	typeset sourceFile="mmremote.sh"
1112	[[ -n $DEBUG \|\| -n $DEBUGgetGenNumber ]] && set -x
1113	$mmTRACE_ENTER "$*"
1114	typeset sdrfs=$1
1115	typeset versionLine=""
1116
1117	# If file not specified, use /var/mmfs/gen/mmsdrfs.
1118	[[ -z $sdrfs ]] && sdrfs=$mmsdrfsFile
1119
1120	# Parse the version line of the mmsdrfs file.
1121	versionLine=$($head -1 $sdrfs)
1122	IFS=':'
1123	set -f ; set -A v -- - $versionLine ; set +f
1124	IFS="$IFS_sv"
1125
1126	# Perform a quick sanity check.
1127	[[ ${v[$LINE_TYPE_Field]} != $VERSION_LINE ]] && \
1128	corruptedSdrFileExit 137 "$versionLine"
1129
1130	# Make sure the time stamp field has a value.
1131	[[ -z ${v[$GENNUM_TSTAMP_Field]} ]] && \
1132	v[$GENNUM_TSTAMP_Field]=0
1133
1134	# Generate and display the result.
1135	print "${v[$SDRFS_GENNUM_Field]}:${v[$GENNUM_TSTAMP_Field]}:${v[$PRIMARY_SERVER_Field]}"
1136
1137	return 0
1138
1139	} #------ end of function getGenNumber -------------------
1140
1141
1142	###################################################################
1143	#
1144	# Function: Move and rename the specified file.
1145	# Verify its checksum.
1146	#
1147	# Input: $1 - source file name
1148	# $2 - target file name
1149	# $3 - expected checksum
1150	# $4 - source host name
1151	#
1152	# Output: None
1153	#
1154	# Returns: Zero if successful, non-zero otherwise.
1155	#
1156	###################################################################
1157	function mvSGDescFile # <source> <target> <checksum> <sourceNode>
1158	{
1159	typeset sourceFile="mmremote.sh"
1160	[[ -n $DEBUG \|\| -n $DEBUGmvSGDescFile ]] && set -x
1161	$mmTRACE_ENTER "$*"
1162	typeset source=$1
1163	typeset target=$2
1164	typeset checksum=$3
1165	typeset sourceNodeName=$4
1166
1167	typeset sumOutput newSum
1168	typeset rc=0
1169
1170	# Make sure the target directory exists.
1171	$mkdir -p ${target%/*}
1172
1173	# Retrieve the file.
1174	if [[ $sourceNodeName = $ourNodeName ]]
1175	then
1176	$cp $source $target
1177	rc=$?
1178	else
1179	$rcp ${sourceNodeName}:$source $target
1180	rc=$?
1181	fi
1182
1183	if [[ $rc -ne 0 ]]
1184	then
1185	print -- "mvSGDescFile:error:copyfile:"
1186	return 1
1187	fi
1188
1189	$mmsync $target
1190
1191	# Verify the checksum.
1192	sumOutput=$($sum $target)
1193	checkForErrors "sum $target" $?
1194	set -f ; set -- $sumOutput ; set +f
1195	newSum=$1
1196	if [[ $checksum -ne $newSum ]]
1197	then
1198	print -- "mvSGDescFile:error:checksum:"
1199	return 1
1200	fi
1201
1202	print -- "mvSGDescFile:success::"
1203	return 0
1204
1205	} #------ end of function mvSGDescFile -------------------
1206
1207
1208	###################################################################
1209	#
1210	# Function: Mount the specified file system(s).
1211	#
1212	# Input: $1 - file system device name or all, all_local, or all_remote
1213	# $2 - mount point or DEFAULT
1214	# $3 - default mount options
1215	# $4 - new mount options or DEFAULT
1216	# $5 - do not remount indicator (optional)
1217	#
1218	# Output: None
1219	#
1220	# Returns: 0 - mount command issued
1221	# non-zero - unexpected error
1222	#
1223	###################################################################
1224	function mountFileSystems # <device> <mountPoint> <defaultOptions> <newOptions>
1225	{
1226	typeset sourceFile="mmremote.sh"
1227	[[ -n $DEBUG \|\| -n $DEBUGmountFileSystems ]] && set -x
1228	$mmTRACE_ENTER "$*"
1229	typeset deviceName=$1
1230	typeset mountPoint=$2
1231	typeset defaultOptions=$3
1232	typeset newOptions=$4
1233	typeset doNotRemount=$5
1234
1235	typeset nodeIndex=0
1236	typeset ourNodeIndex=0
1237	typeset fsNumber=0
1238	typeset n=0
1239	typeset rc=0
1240
1241	typeset gpfsInitOutput fsType fsName tsstatusOutput mountedFileSystems
1242	typeset mountDeviceList mountDeviceList_A mountDeviceList_B vfsType
1243	typeset nodeOptions mountAllRequested
1244
1245
1246	# Ensure the GPFS system data is up to date.
1247	# Note: To avoid undesired side effects, tell gpfsInit to restrict mount
1248	# point checking only to the file system(s) that we care about.
1249	export MOUNT_POINT_CHECK="$deviceName"
1250	gpfsInitOutput=$(gpfsInit nolock)
1251	setGlobalVar $? $gpfsInitOutput
1252	unset MOUNT_POINT_CHECK
1253
1254	# See if there are additional mount options to specify.
1255	if [[ $newOptions = DEFAULT ]]
1256	then
1257	newOptions=""
1258	else
1259	newOptions="-o $newOptions"
1260	fi
1261
1262	if [[ $deviceName = all \|\| $deviceName = all_local \|\| $deviceName = all_remote ]]
1263	then
1264	mountPoint=""
1265	mountAllRequested=yes
1266	fi
1267
1268	# Process the mount point parameter. Its value will also determine
1269	# whether it will be necessary to explicitly specify on the mount command
1270	# the vfs type and options string or if it is OK to let the mount
1271	# command figure out those things on its own.
1272	[[ $mountPoint = DEFAULT ]] && mountPoint=""
1273	if [[ -n $mountPoint ]]
1274	then
1275	defaultOptions="-o $defaultOptions"
1276	if [[ $osName = AIX ]]
1277	then
1278	vfsType="-v mmfs"
1279	elif [[ $osName = Linux ]]
1280	then
1281	vfsType="-t gpfs"
1282	else
1283	# Should never get here.
1284	printErrorMsg 171 "mountFileSystems" "unsupported OS $osName" 1
1285	return 1
1286	fi # end of if [[ $osName = AIX ]]
1287	else
1288	defaultOptions=""
1289	fi # end of if [[ -n $mountPoint ]]
1290
1291	# Go through the local mmsdrfs file and create
1292	# a list of the file systems to be mounted.
1293	IFS=":"
1294	exec 3<&-
1295	exec 3< $mmsdrfsFile
1296	while read -u3 sdrfsLine
1297	do
1298	# Parse the line.
1299	set -f ; set -A v -- - $sdrfsLine ; set +f
1300	IFS="$IFS_sv"
1301
1302	# Change some of the fields depending on the type of line.
1303	case ${v[$LINE_TYPE_Field]} in
1304
1305	$MEMBER_NODE )
1306	# Determine the index of this node relative
1307	# to the rest of the nodes in the cluster.
1308	[[ ${v[$NODE_NUMBER_Field]} = $ourNodeNumber ]] && \
1309	ourNodeIndex=$nodeIndex
1310	(( nodeIndex += 1 ))
1311	;;
1312
1313	$SG_HEADR )
1314	# See if we want to mount this file system.
1315	if [[ ${v[$DEV_NAME_Field]} = $deviceName \|\| $deviceName = all \|\|
1316	$deviceName = all_local && ${v[$FS_TYPE_Field]} = $localfs \|\|
1317	$deviceName = all_remote && ${v[$FS_TYPE_Field]} = $remotefs ]]
1318	then
1319	mountDeviceList="$mountDeviceList /dev/${v[$DEV_NAME_Field]}"
1320	(( fsNumber += 1 ))
1321	fi
1322	;;
1323
1324	* ) # Not interested in any other lines.
1325	;;
1326
1327	esac # end of Change some of the fields
1328
1329	IFS=":" # Change the separator back to ":" for the next iteration.
1330
1331	done # end while read -u3 mmsdrfsFile
1332	IFS="$IFS_sv"
1333
1334	# Ensure the requested file systems were found.
1335	# This should always be the case at this point.
1336	if [[ $fsNumber -eq 0 ]]
1337	then
1338	if [[ $deviceName = all \|\| $deviceName = all_local ]]
1339	then
1340	# No file systems found in the cluster.
1341	printErrorMsg 200 $mmcmd
1342	elif [[ $deviceName = all_remote ]]
1343	then
1344	# No remote file systems found in the cluster.
1345	printErrorMsg 193 $mmcmd
1346	else
1347	# The requested file system was not found.
1348	printErrorMsg 288 $mmcmd $deviceName
1349	fi
1350
1351	# Give up; nothing more to do.
1352	return $MM_FsNotFound
1353	fi # end of if [[ $fsNumber -eq 0 ]]
1354
1355	# If more than one file system will be mounted, order the list
1356	# based on the index of the local node within the cluster.
1357	# This is done to avoid the simultaneous mounting of the same
1358	# file system from all of the nodes in the cluster.
1359	if [[ $fsNumber -gt 1 ]]
1360	then
1361	# Calculate our node's index in the file system list.
1362	(( ourNodeIndex = ourNodeIndex % fsNumber ))
1363
1364	# Break the list of file systems into two parts
1365	# based on the above calculated index.
1366	for fsName in $mountDeviceList
1367	do
1368	if [[ $n -ge $ourNodeIndex ]]
1369	then
1370	mountDeviceList_A="$mountDeviceList_A $fsName"
1371	else
1372	mountDeviceList_B="$mountDeviceList_B $fsName"
1373	fi
1374	(( n += 1 ))
1375	done # end of for fsName in $mountDeviceList
1376
1377	# Combine the two parts of the mount list.
1378	mountDeviceList="$mountDeviceList_A $mountDeviceList_B"
1379	fi # end of if [[ $fsNumber -gt 1 ]]
1380
1381	# Create a list of the currently mounted file systems on this node.
1382	if [[ $osName = AIX ]]
1383	then
1384	$mount >$tmpfile 2>/dev/null
1385	mountedFileSystems=$tmpfile
1386	elif [[ $osName = Linux ]]
1387	then
1388	mountedFileSystems=/proc/mounts
1389	else
1390	# Should never get here.
1391	printErrorMsg 171 "mountFileSystems" "unsupported OS $osName" 1
1392	return 1
1393	fi # end of if [[ $osName = AIX ]]
1394
1395	# Ensure the local GPFS daemon is accepting commands.
1396	tsstatusOutput=$(LC_ALL=C $tsstatus -1 2>&1)
1397	print -- "$tsstatusOutput" \| $grep -qe 'file system daemon is running' >/dev/null 2>&1
1398	if [[ $? -ne 0 ]]
1399	then
1400	# GPFS daemon is not ready for commands yet.
1401	printErrorMsg 110 $mmcmd
1402	return $MM_DaemonDown
1403	fi
1404
1405	# Mount the file systems.
1406	for fsName in $mountDeviceList
1407	do
1408	# See if this file system is already mounted.
1409	$grep -qw $fsName $mountedFileSystems > /dev/null 2>&1
1410	if [[ $? -eq 0 ]]
1411	then
1412	# The file system appears to be already mounted. Verify that
1413	# everythig is OK by doing an internal remount if the stat on
1414	# mount point returns with a non-zero errno.
1415	activeMountPoint=$(findMountpoint $fsName)
1416	$perl -e ' $! = 0; stat "'$activeMountPoint'"; exit $!;'
1417	rc=$?
1418	if [[ $rc -ne 0 && -z $doNotRemount ]]
1419	then
1420	$tsremount ${fsName#/dev/}
1421	rc=$?
1422	if [[ $rc -ne 0 ]]
1423	then
1424	# The remount attempt failed.
1425	printErrorMsg 399 $mmcmd $fsName $rc
1426	[[ -n $mountAllRequested ]] && rc=0
1427	fi
1428	fi # end of if [[ $rc -ne 0 && -z $doNotRemount ]]
1429
1430	# If a specific mount point has been requested, see if it matches
1431	# the currently active mount point for the file system.
1432	if [[ -n $mountPoint ]]
1433	then
1434	[[ $mountPoint != $activeMountPoint ]] && \
1435	printErrorMsg 280 $mmcmd $fsName $activeMountPoint
1436	fi
1437
1438	# There is nothing more to do for this file system.
1439	continue
1440	fi # end of if [[ $? -eq 0 ]]
1441
1442	# See if there are local override mount options for this file system.
1443	if [[ -s ${localMountOptions}.${fsName#/dev/} ]]
1444	then
1445	nodeOptions="-o $($tail -n -1 ${localMountOptions}.${fsName#/dev/} 2>/dev/null)"
1446	else
1447	nodeOptions=""
1448	fi
1449
1450	# Mount the file system. If the overall request is to mount a single
1451	# file system, show all messages from the mount command. If the request
1452	# is to mount all GPFS file systems, hide the "already mounted" messages.
1453	if [[ -n $mountAllRequested ]]
1454	then
1455	$mount $vfsType $defaultOptions $nodeOptions $newOptions $fsName $mountPoint 2>&1 \| \
1456	$grep -i -v "already mounted"
1457	rc=0 # ignore errors
1458	else
1459	$mount $vfsType $defaultOptions $nodeOptions $newOptions $fsName $mountPoint
1460	rc=$?
1461	fi
1462	done # end of for fsName in $mountDeviceList
1463
1464	return $rc
1465
1466	} #------ end of function mountFileSystems -------------------
1467
1468
1469	###########################################################
1470	#
1471	# Mainline processing
1472	#
1473	###########################################################
1474	kword=$arg1
1475	kword_lc=$arg1
1476	arg3_lc=$arg3
1477
1478
1479	if [[ -z $kword ]]
1480	then
1481	# Missing keyword
1482	printErrorMsg 133 mmremote NULL
1483	cleanupAndExit
1484	fi
1485
1486	# Set up silent trap exception handling.
1487	trap pretrap3 HUP INT QUIT KILL
1488
1489	# Parse the caller's version information. If missing,
1490	# assume the request comes from a 3.1 compatible node.
1491	[[ -z $mmrpc ]] && mmrpc="mmrpc:1:1:901:"
1492	IFS=':'
1493	set -f ; set -- $mmrpc ; set +f
1494	rpcVersion=$2
1495	rpcMinVersion=$3
1496	daemonVersion=$4
1497	IFS="$IFS_sv"
1498
1499	# Determine the execution environment and set needed global variables.
1500	if [[ $kword_lc = checknewclusternode ]]
1501	then
1502	# The request is for a function that runs prior to the node becoming
1503	# a member of the GPFS cluster. Use the function arguments to set
1504	# some global variables.
1505	if [[ -z $MMMODE ]]
1506	then
1507	IFS='/'
1508	set -f ; set -- $arg2 ; set +f
1509	export MMMODE=$1
1510	IFS="$IFS_sv"
1511	fi
1512	[[ -z $primaryServer ]] && \
1513	primaryServer=$arg3
1514	elif [[ $arg3_lc = checknewclusternode* \|\|
1515	$arg3_lc = removefromclustercr ]]
1516	then
1517	# If the node is not yet a member of the GPFS cluster,
1518	# the functions to determine the local data do not work.
1519	[[ -z $ourNodeName ]] && ourNodeName=$($hostname)
1520	[[ -z $MMMODE ]] && export MMMODE=$arg4
1521	else
1522	# In all other cases, file mmsdrfs should already exist
1523	# and we can use it as a starting point.
1524	[[ -z $MMMODE \|\| -z $environmentType \|\| -z $primaryServer ]] && \
1525	determineMode
1526	getLocalNodeData
1527	fi
1528
1529	# Restore the original positional parameters.
1530	set -f ; set -- $cmdline ; set +f
1531
1532	# Initialize the local version information string.
1533	rpcMinSupported=1
1534	rpcMaxSupported=1
1535	localVersionInfo="$MM_Version3:$ourNodeNumber:$currentDaemonVersion:$productVersion"
1536	localVersionInfo="${localVersionInfo}:$osName:$rpcMinSupported:$rpcMaxSupported"
1537
1538	# Ensure we know how to interpret the request.
1539	if [[ $rpcMinVersion -gt $rpcMaxSupported ]]
1540	then
1541	# The caller is running incompatible GPFS version.
1542	# Tell him what our capabilities are and let him decide what to do.
1543	print -u2 "mmremote:incompatibleGPFScode:$ourNodeName:$localVersionInfo:"
1544	cleanupAndExit $MM_IncompatibleCode
1545	fi
1546
1547	# Make sure we have the proper credentials.
1548	[[ $getCredCalled = no ]] && getCred
1549
1550	# Reset the remote commands if necessary.
1551	[[ -n $GPFS_rshPath ]] && rsh=$GPFS_rshPath
1552	[[ -n $GPFS_rcpPath ]] && rcp=$GPFS_rcpPath
1553
1554	# Depending on the keyword, perform the requested action.
1555	case $kword_lc in
1556
1557	#----------------------------------------
1558	mmversion ) # mmremote mmVersion [<fileset>]
1559	#----------------------------------------
1560	# Determine whether the daemon is running.
1561	tsstatusOutput=$(LC_ALL=C $tsstatus -1 2>&1)
1562	print -- "$tsstatusOutput" \| $grep -e 'file system daemon is running' >/dev/null
1563	if [[ $? -eq 0 ]]
1564	then
1565	daemonStatus=active
1566	else
1567	print -- "$tsstatusOutput" \| $grep -e 'Waiting for quorum' >/dev/null
1568	if [[ $? -eq 0 ]]
1569	then
1570	daemonStatus=waitingForQuorum
1571	else
1572	daemonStatus=down
1573	fi
1574	fi
1575
1576	# Get the level of the installed fileset.
1577	# If not specified by the caller, look for mmfs.gpfs.rte.
1578	if [[ -n $arg2 ]]
1579	then
1580	fileset=$arg2
1581	else
1582	fileset="mmfs.gpfs.rte"
1583	fi
1584
1585	# The output of the lslpp -c -Lq command has the following format:
1586	# #Package Name:Fileset:Level:State:PTF Id:Fix State:Type:Description:
1587	lslppOutput=$(LC_ALL=C $lslpp -c -Lq $fileset 2>/dev/null)
1588	IFS=':'
1589	set -f ; set -- $lslppOutput ; set +f
1590	package=$1
1591	fileset=$2
1592	level=$3
1593	IFS="$IFS_sv"
1594	[[ $package != mmfs* ]] && level=""
1595
1596	# Return the string 'mmVersion', the version of the commands (2), the level
1597	# of the currently-installed fileset, and the status of the daemon.
1598	print -- "mmVersion:$MM_Version3:$level:$daemonStatus"
1599	rc=0
1600	;;
1601
1602	#---------------------
1603	mmversion2 ) # mmremote mmVersion2
1604	#---------------------
1605	# Return the keyword 'mmVersion2', the version of the commands (2),
1606	# the level of the currently-installed fileset (must match prod.h),
1607	# the OS name, and the fileset or rpm release string identifier for
1608	# the current level of the code.
1609	print -- "mmVersion2:$localVersionInfo"
1610	rc=0
1611	;;
1612
1613	#--------------------------------------------------
1614	unlock ) # mmremote unlock [<nodeNumber>] [<lockServer>]
1615	#--------------------------------------------------
1616	# Find our node number.
1617	if [[ -z $arg2 ]]
1618	then
1619	nodeNumber=$ourNodeNumber
1620	else
1621	nodeNumber=$arg2
1622	fi
1623
1624	# Find the lock server.
1625	if [[ -z $arg3 ]]
1626	then
1627	lockServer=$primaryServer
1628	else
1629	lockServer=$arg3
1630	fi
1631
1632	# Release the lock.
1633	freeLock $nodeNumber $lockServer
1634	rc=0
1635	;;
1636
1637	#------------------------------------------------------
1638	copyremotefile ) # mmremote copyRemoteFile <remoteNode> <remoteFile>
1639	# <localFile> <checksum>
1640	#------------------------------------------------------
1641	if [[ $argc -lt 5 ]]
1642	then
1643	operands=" <remoteNode> <remoteFile> <localFile> <checksum>"
1644	printErrorMsg 260 mmremote $kword "$operands"
1645	cleanupAndExit
1646	fi
1647
1648	copyRemoteFileOutput=$(copyRemoteFile "$arg2" "$arg3" "$arg4" "$arg5")
1649	rc=$?
1650	print -- "$copyRemoteFileOutput"
1651	;;
1652
1653	#-------------------------------------------------
1654	committoprimaryserver ) # mmremote commitToPrimaryServer <newsdrfs> <sum>
1655	# <genNumber> <client> <primaryServer>
1656	# <commitOption> <backupServer>
1657	#-------------------------------------------------
1658	if [[ $argc -lt 7 ]]
1659	then
1660	operands=" <newsdrfs> <checksum> <genNumber> <client> <primaryServer>"
1661	operands=$operands" <commitOption> <backupServer>"
1662	printErrorMsg 260 mmremote $kword "$operands"
1663	cleanupAndExit
1664	fi
1665
1666	# Check required system files.
1667	commitToPrimaryServer "$arg2" "$arg3" "$arg4" "$arg5" "$arg6" "$arg7" "$arg8"
1668	rc=$?
1669	;;
1670
1671	#----------------------------------------
1672	# mmremote vfs
1673	vfs \| checkvfsnumber ) # mmremote checkVfsNumber
1674	#----------------------------------------
1675	# Verify there is an mmfs entry in /etc/vfs.
1676	checkVfsNumber
1677	rc=$?
1678	;;
1679
1680	#----------------------------------------
1681	fs ) # mmremote fs [optionalTasks]
1682	#----------------------------------------
1683	# Verify there is an mmfs entry in /etc/vfs.
1684	checkVfsNumber
1685	rc=$?
1686	[[ $rc -ne 0 ]] && cleanupAndExit $rc
1687
1688	# Make sure that the local copies of the mmsdrfs, mmfs.cfg,
1689	# and the rest of the system files are up-to-date.
1690	gpfsInitOutput=$(gpfsInit nolock)
1691	checkForErrors gpfsInit $?
1692
1693	# Perform additional tasks as per the propagate options parameter.
1694	[[ -n $arg2 ]] && handlePropagateOptions $arg2
1695
1696	rc=0
1697	;;
1698
1699	#----------------------------------------
1700	cfg ) # mmremote cfg [-f]
1701	#----------------------------------------
1702	# Ensure local config data is up-to-date.
1703	refreshSysconfig $arg2
1704	rc=$?
1705	;;
1706
1707
1708	#----------------------------------------------------
1709	upgradesystemfiles ) # mmremote upgradeSystemFiles <sdrfsFile> <checksum>
1710	# [<optionalTasks>]
1711	#----------------------------------------------------
1712	if [[ $argc -lt 3 ]]
1713	then
1714	operands="<sdrfsFile> <checksum> [<optionalTasks>]"
1715	printErrorMsg 260 mmremote $kword "$operands"
1716	cleanupAndExit
1717	fi
1718
1719	upgradeSystemFiles $arg2 $arg3 NULL 0
1720	rc=$?
1721
1722	# Perform additional tasks as per the propagate options parameter.
1723	[[ -n $arg4 ]] && handlePropagateOptions $arg4
1724	;;
1725
1726
1727	#----------------------------------------------------
1728	upgradesystemfiles2 ) # mmremote upgradeSystemFiles2 <sdrfsFile> <checksum>
1729	# <keyFile> <checksum2>
1730	#----------------------------------------------------
1731	if [[ $argc -lt 5 ]]
1732	then
1733	operands="<sdrfsFile> <checksum> <keyFile> <checksum2>"
1734	printErrorMsg 260 mmremote $kword "$operands"
1735	cleanupAndExit
1736	fi
1737
1738	upgradeSystemFiles $arg2 $arg3 $arg4 $arg5
1739	rc=$?
1740	;;
1741
1742
1743	#---------------------------------------------
1744	updategpfsobject ) # mmremote updateGpfsObject <chng1> [<chng2>]
1745	#---------------------------------------------
1746	if [[ $argc -lt 2 ]]
1747	then
1748	operands="<change1> [<change2>] - Specify at least one change"
1749	printErrorMsg 260 mmremote $kword "$operands"
1750	cleanupAndExit
1751	fi
1752
1753	updateGpfsObject "$arg2" "$arg3"
1754	rc=$?
1755	;;
1756
1757	#----------------------------------------
1758	getgpfsobjectfromfile ) # mmremote getGpfsObjectFromFile
1759	#----------------------------------------
1760
1761	# Retrieve the information.
1762	gpfsObjectInfo=$(getGpfsObjectFromFile)
1763	rc=$?
1764
1765	print -- "$gpfsObjectInfo"
1766	;;
1767
1768	#------------------------------------------------
1769	sendclustersdrfiles ) # mmremote sendClusterSDRFiles <clientGenNumber>
1770	# <client> <fileName> <lockId>
1771	#------------------------------------------------
1772	if [[ $argc -lt 5 ]]
1773	then
1774	operands="<generationNumber> <client> <fileName> <lockId>"
1775	printErrorMsg 260 mmremote $kword "$operands"
1776	cleanupAndExit
1777	fi
1778
1779	sendClusterSDRFiles "$arg2" "$arg3" "$arg4" "$arg5"
1780	rc=$?
1781	;;
1782
1783	#-------------------------------------------------------------
1784	createshadow ) # mmremote createShadow <oldGenNumber> <newSum> <commitOption>
1785	#-------------------------------------------------------------
1786	if [[ $argc -lt 4 ]]
1787	then
1788	operands="<oldGenNumber> <newSum> <commitOption>"
1789	printErrorMsg 260 mmremote $kword "$operands"
1790	cleanupAndExit
1791	fi
1792
1793	createShadow "$arg2" "$arg3" "$arg4"
1794	rc=$?
1795	;;
1796
1797	#--------------------------------------------------
1798	removeuncommitted ) # mmremote removeUncommitted <genNumber> <version>
1799	#--------------------------------------------------
1800	if [[ $argc -lt 2 ]]
1801	then
1802	operands="<genNumber> <version>"
1803	printErrorMsg 260 mmremote $kword "$operands"
1804	cleanupAndExit
1805	fi
1806
1807	$rm -f $uncommitted.$arg3 ${mmsdrfsPrev}.$arg2
1808	rc=$?
1809	;;
1810
1811	#----------------------------
1812	removefromcluster \| removefromclustercr ) # mmremote removeFromCluster
1813	#----------------------------
1814	# Remove (almost) all traces.
1815	removeFromCluster
1816	rc=0
1817	;;
1818
1819	#-------------------------------------------
1820	rmfs ) # mmremote rmfs <fqDeviceName> <mountPoint>
1821	#-------------------------------------------
1822	if [[ $argc -lt 2 ]]
1823	then
1824	operands="<fqDeviceName> <mountPoint>"
1825	printErrorMsg 260 mmremote $kword "$operands"
1826	cleanupAndExit
1827	fi
1828
1829	# Remove the file system stanza from /etc/filesystems.
1830	# Remove the device and mount point. Ignore errors.
1831	removeStanza $arg2 >/dev/null 2>&1
1832	removeMountPoint $arg2 $arg3 0 >/dev/null 2>&1
1833
1834	rc=0
1835	;;
1836
1837	#----------------------------------------
1838	pid ) # mmremote pid <pid>
1839	#----------------------------------------
1840	if [[ $argc -lt 2 ]]
1841	then
1842	operands="<pid>"
1843	printErrorMsg 260 mmremote $kword "$operands"
1844	cleanupAndExit
1845	fi
1846
1847	# See if the specified process still exists.
1848	$ps "$arg2" >/dev/null 2>/dev/null
1849	rc=$?
1850	if [[ $rc -eq 0 ]]
1851	then
1852	print -- "alive"
1853	else
1854	print -- "died"
1855	fi
1856
1857	rc=0
1858	;;
1859
1860	#----------------------------------------
1861	active ) # mmremote active
1862	#----------------------------------------
1863	$ps -e \| $grep mmfsd >/dev/null 2>&1
1864	rc=$?
1865	if [[ $rc -eq 0 ]]
1866	then
1867	print -- "active"
1868	else
1869	print -- "down"
1870	fi
1871
1872	rc=0
1873	;;
1874
1875	#----------------------------------------
1876	quorum ) # mmremote quorum <quorumValue>
1877	#----------------------------------------
1878	if [[ $argc -lt 2 ]]
1879	then
1880	operands="<quorumValue>"
1881	printErrorMsg 260 mmremote $kword "$operands"
1882	cleanupAndExit
1883	fi
1884
1885	# Set the node quorum to the specified value.
1886	$mmfsadm quorum $arg2
1887	rc=$?
1888	;;
1889
1890	#-----------------------------------------
1891	tschpool ) # mmremote tschpool <tschpool_arguments>
1892	#-----------------------------------------
1893	if [[ $argc -lt 3 ]]
1894	then
1895	operands="<tschpool_arguments>"
1896	printErrorMsg 260 mmremote $kword "$operands"
1897	cleanupAndExit
1898	fi
1899
1900	# Collect the input parameters and invoke the command.
1901	shift 1
1902	commandArguments=$*
1903
1904	$tschpool $commandArguments
1905	rc=$(remapRC $?)
1906	;;
1907
1908	#----------------------------------------
1909	tsctl ) # mmremote tsctl <tsctl_arguments>
1910	#----------------------------------------
1911	if [[ $argc -lt 3 ]]
1912	then
1913	operands="<tsctl_arguments>"
1914	printErrorMsg 260 mmremote $kword "$operands"
1915	cleanupAndExit
1916	fi
1917
1918	# Collect the input parameters and invoke the command.
1919	shift 1
1920	commandArguments=$*
1921
1922	$tsctl $commandArguments
1923	rc=$(remapRC $?)
1924	;;
1925
1926	#----------------------------------------
1927	tsnap ) # mmremote tsnap <action>
1928	#----------------------------------------
1929	if [[ $argc -lt 2 ]]
1930	then
1931	operands="<action>"
1932	printErrorMsg 260 mmremote $kword "$operands"
1933	cleanupAndExit
1934	fi
1935
1936	# Take a trace snapshot.
1937	traceSnapshot $arg2
1938	rc=$?
1939	;;
1940
1941	#------------------------------------------------------
1942	checknewclusternode ) # mmremote checkNewClusterNode <clusterType> <primary>
1943	# <secondary \| _NOSECONDARY_> <localNodeData>
1944	# <rshPath \| _DEFAULT_> <rcpPath \| _DEFAULT_>
1945	# <clusterId>
1946	#------------------------------------------------------
1947	if [[ $argc -lt 8 ]]
1948	then
1949	operands="<clusterType> <primaryServer> <secondaryServer \| _NOSECONDARY_> "
1950	operands=${operands}"<localNodeData> <rshPath \| _DEFAULT_> <rcpPath \| _DEFAULT_> "
1951	operands=${operands}"<clusterId> "
1952	printErrorMsg 260 mmremote $kword "$operands"
1953	cleanupAndExit
1954	fi
1955
1956	# Determine whether the node is new and supports clusters.
1957	checkNewClusterNode "$arg2" "$arg3" "$arg4" "$arg5" "$arg6" "$arg7" "$arg8"
1958	rc=$?
1959	;;
1960
1961	#-----------------------------
1962	checkadapter ) # mmremote checkAdapter <ipa>
1963	#-----------------------------
1964	if [[ $argc -lt 2 ]]
1965	then
1966	operands="<ipa>"
1967	printErrorMsg 260 mmremote $kword "$operands"
1968	cleanupAndExit
1969	fi
1970
1971	# Verify the adapter exists.
1972	checkAdapter $arg2
1973	rc=0
1974	;;
1975
1976	#-----------------------------------------------
1977	admincmd ) # mmremote adminCmd <adminCommand> [<arg ... >]
1978	#-----------------------------------------------
1979	if [[ $argc -lt 2 ]]
1980	then
1981	operands="<adminCommand> [<arg ... >]"
1982	printErrorMsg 260 mmremote $kword "$operands"
1983	cleanupAndExit
1984	fi
1985
1986	# Get the command name and collect its arguments.
1987	adminCommand=$2
1988	shift 2
1989	argList=$@
1990
1991	# Run the requested command.
1992	runCommand $adminCommand "$argList"
1993	rc=$?
1994	;;
1995
1996	#---------------------------------------
1997	exectsmcommand ) # mmremote execTSMcommand [<arg ... >]
1998	#---------------------------------------
1999	if [[ $argc -lt 10 ]]
2000	then
2001	operands="<execTSMcommand> [<arg ... >]"
2002	printErrorMsg 260 mmremote $kword "$operands"
2003	cleanupAndExit
2004	fi
2005
2006	# Shift the command's arguments to remove the execTSMcommand verb.
2007	shift 1
2008	argList=$@
2009
2010	# Run the requested command.
2011	$mmexectsmcmd $argList
2012	rc=$?
2013	;;
2014
2015	#----------------------------------------------------
2016	startsubsys ) # mmremote startSubsys [-e <expTime>] [-E <envData>]
2017	# [-f] [-t <tracefile>] [-T <traceOpt>]
2018	#----------------------------------------------------
2019	# Parse the optional parameters.
2020	shift 1
2021	while getopts :e:E:fT:t: OPT
2022	do
2023	case $OPT in
2024	e) expirationData="$OPTARG" ;;
2025	E) envString=${envString}" $OPTARG " ;;
2026	f) argString='-a "-f"' ;;
2027	t) envString=${envString}" mmScriptTrace=$OPTARG " ;;
2028	T) envString=${envString}" MMTRACE=$OPTARG " ;;
2029	*) printErrorMsg 13 "$mmcmd" $OPTARG ;;
2030	esac
2031	done
2032
2033	# Process the expirationData parameter.
2034	if [[ -n $expirationData && ! -s mmSdrLockExp ]]
2035	then
2036	# Create a file with the sdr expiration data.
2037	print -- "$expirationData" > $mmSdrLockExp
2038
2039	# Start the background process that will remove the file.
2040	$mmcommon expirationDataCleanup $expirationData doNotUnlock >/dev/null 2>&1 &
2041	fi
2042
2043	# Check whether GPFS is running.
2044	pid=$($ps -eo "pid args" \| \
2045	$awk '/\/runmmfs/ && !/this process/ {print $1}')
2046	if [[ -n $pid ]]
2047	then
2048	# GPFS has already been started.
2049	printInfoMsg 586 GPFS
2050	else
2051	# Start GPFS.
2052	if [[ -n ${envString} ]]
2053	then
2054	$daemonize -e "$envString" -c $runmmfs $argString
2055	else
2056	$daemonize -c $runmmfs $argString
2057	fi
2058	fi # end if [[ -n $pid ]]
2059	;;
2060
2061	#------------------------------------------
2062	startautomounter ) # mmremote startAutomounter <automountDir>
2063	#------------------------------------------
2064	if [[ $argc -lt 2 ]]
2065	then
2066	operands="<automountDir>"
2067	printErrorMsg 260 mmremote $kword "$operands"
2068	cleanupAndExit
2069	fi
2070
2071	# Run the OS automount command.
2072	startAutomounter $arg2
2073	rc=$?
2074	;;
2075
2076	#-----------------------------------------------
2077	getlocaldiskname ) # mmremote getLocalDiskName <pvid> <nsdSubtype>
2078	#-----------------------------------------------
2079	if [[ $argc -lt 3 ]]
2080	then
2081	operands="<pvid> <nsdSubtype>"
2082	printErrorMsg 260 mmremote $kword "$operands"
2083	cleanupAndExit
2084	fi
2085
2086	# Determine the physical disk with the specified pvid and nsdSubtype.
2087	getLocalDiskName $arg2 $arg3
2088
2089	rc=0
2090	;;
2091
2092	#--------------------------------------
2093	getlocaldisknamevg ) # mmremote getLocalDiskNameVG <vgname>
2094	#--------------------------------------
2095	if [[ $argc -lt 2 ]]
2096	then
2097	operands="<vgname>"
2098	printErrorMsg 260 mmremote $kword "$operands"
2099	cleanupAndExit
2100	fi
2101
2102	# Determine the physical disk with the specified volume group name.
2103	getLocalDiskNameVG $arg2
2104	rc=0
2105	;;
2106
2107	#----------------------------------------
2108	findpvid ) # mmremote findPvid <lvname>
2109	#----------------------------------------
2110	if [[ $argc -lt 2 ]]
2111	then
2112	operands="<lvname>"
2113	printErrorMsg 260 mmremote $kword "$operands"
2114	cleanupAndExit
2115	fi
2116
2117	# Determine the pvid of the disk with the specified lvname.
2118	findPvid $arg2
2119	rc=$?
2120	;;
2121
2122	#----------------------------------------
2123	findvgpvid ) # mmremote findVgPvid <vgname>
2124	#----------------------------------------
2125	if [[ $argc -lt 2 ]]
2126	then
2127	operands="<vgname>"
2128	printErrorMsg 260 mmremote $kword "$operands"
2129	cleanupAndExit
2130	fi
2131
2132	# Determine the pvid of the disk with the specified vgname.
2133	findVgPvid $arg2
2134	rc=$?
2135	;;
2136
2137	#----------------------------------------
2138	findhdiskpvid ) # mmremote findHdiskPvid <hdisk_name>
2139	#----------------------------------------
2140	if [[ $argc -lt 2 ]]
2141	then
2142	operands="<hdisk name>"
2143	printErrorMsg 260 mmremote $kword "$operands"
2144	cleanupAndExit
2145	fi
2146
2147	# Determine the pvid of the specified physical disk.
2148	findHdiskPvid $arg2
2149	rc=$?
2150	;;
2151
2152	#----------------------------------------
2153	mmgetstate ) # mmremote mmGetState
2154	#----------------------------------------
2155	# Determine the quorum state.
2156	mmGetState $arg2
2157	rc=$?
2158	;;
2159
2160	#----------------------------------------
2161	getsubsysstate ) # mmremote getSubsysState <subsystem>
2162	#----------------------------------------
2163	if [[ $argc -lt 2 ]]
2164	then
2165	operands="<subsystem>"
2166	printErrorMsg 260 mmremote $kword "$operands"
2167	cleanupAndExit
2168	fi
2169
2170	# Determine the state of the specified subsystem.
2171	getSubsysState $arg2
2172	rc=$?
2173	;;
2174
2175	#----------------------------------------
2176	killsdrserv ) # mmremote killSdrServ
2177	#----------------------------------------
2178	# Kill the currently-running mmsdrserv daemon.
2179	killSdrServ
2180	rc=$?
2181	;;
2182
2183	#----------------------------------------
2184	startsdrserv ) # mmremote startSdrServ <sdrservPort>
2185	#----------------------------------------
2186	if [[ $argc -lt 2 ]]
2187	then
2188	operands="<sdrservPort>"
2189	printErrorMsg 260 mmremote $kword "$operands"
2190	cleanupAndExit
2191	fi
2192
2193	# If this is a server node, start the mmsdrserv daemon.
2194	if [[ $ourNodeName = $primaryServer \|\| $ourNodeName = $backupServer ]]
2195	then
2196	startSdrServ $arg2
2197	rc=$?
2198	else
2199	rc=132 # ESDR_NOT_SERVER "Node is not a server"
2200	fi
2201	;;
2202
2203	#----------------------------------------
2204	setwait4rvsd ) # mmremote setWait4RVSD
2205	#----------------------------------------
2206	# Set the wait4RVSD parm across the currently-active GPFS nodes.
2207	setWait4RVSD
2208	rc=$?
2209	;;
2210
2211	#----------------------------------------
2212	refreshauth ) # mmremote refreshAuth
2213	#----------------------------------------
2214	# Refresh the auth key files.
2215	refreshAuth
2216	rc=$?
2217	;;
2218
2219	#----------------------------------------
2220	getcoderange ) # mmremote getCodeRange
2221	#----------------------------------------
2222	# Determines the range of GPFS release levels on the
2223	# nodes on which the daemon is currently running.
2224	getCodeRange
2225	rc=$?
2226	;;
2227
2228	#----------------------------------------
2229	postmount ) # mmremote postMount
2230	#----------------------------------------
2231	# Perform post-mount processing. Currently, this is a no-op.
2232	rc=0
2233	;;
2234
2235	#----------------------------------------
2236	getgennumber ) # mmremote getGenNumber [<filename>]
2237	#----------------------------------------
2238	# Retrieve the generation number of the specified sdrfs file.
2239	getGenNumber $arg2
2240	rc=$?
2241	;;
2242
2243	#----------------------------------------
2244	rmdeventry ) # mmremote rmDevEntry <deviceNameList>
2245	#----------------------------------------
2246	# Get the list of devices to delete.
2247	shift 1
2248	deviceNameList=$@
2249
2250	# Loop through the list and delete the /dev entries.
2251	for devName in $deviceNameList
2252	do
2253	removeMountPoint $devName _NO_MOUNT_POINT_DELETE_ 0
2254	done
2255	;;
2256
2257	#------------------------------------------------------
2258	determinedisksubtype ) # mmremote determineDiskSubtype <lvname> [<reevaluate>]
2259	#------------------------------------------------------
2260	if [[ $argc -lt 2 ]]
2261	then
2262	operands="<lvname> [<reevaluate>]"
2263	printErrorMsg 260 mmremote $kword "$operands"
2264	cleanupAndExit
2265	fi
2266
2267	# Determine the disk type.
2268	determineDiskSubtype $arg2 $arg3
2269	rc=$?
2270	;;
2271
2272	#-----------------------------------------
2273	determinensdsubtype ) # mmremote determineNsdSubtype <diskName>
2274	#-----------------------------------------
2275	if [[ $argc -lt 2 ]]
2276	then
2277	operands="<diskName>"
2278	printErrorMsg 260 mmremote $kword "$operands"
2279	cleanupAndExit
2280	fi
2281
2282	# Determine the disk type.
2283	determineNsdSubtype $arg2
2284	rc=$?
2285	;;
2286
2287	#------------------------------------
2288	getlocalnsddata ) # mmremote getLocalNsdData [<Xflag>]
2289	#------------------------------------
2290	# Send the colon-delimited local nsd data from tspreparedisk -s
2291	# back to the requestor via stdout.
2292	getLocalNsdData $arg2
2293	rc=0
2294	;;
2295
2296	#---------------------------------------
2297	creatensd ) # mmremote createNsd <diskName> <vflag>
2298	# <invokingCommand> <nsdSubtype>
2299	#---------------------------------------
2300	if [[ $argc -lt 5 ]]
2301	then
2302	operands="<diskName> <vflag> <invokingCommand> <nsdSubtype>"
2303	printErrorMsg 260 mmremote $kword "$operands"
2304	cleanupAndExit
2305	fi
2306
2307	# Make an NSD out of the disk.
2308	createNsd $arg2 $arg3 $arg4 $arg5
2309	rc=$?
2310	;;
2311
2312	#----------------------------------------------------
2313	mvsgdescfile ) # mmremote mvSGDescFile <sourceFile> <targetFile>
2314	# <checksum> <sourceNode>
2315	#----------------------------------------------------
2316	if [[ $argc -lt 5 ]]
2317	then
2318	operands="<sourceFile> <targetFile> <checksum> <sourceNode>"
2319	printErrorMsg 260 mmremote $kword "$operands"
2320	cleanupAndExit
2321	fi
2322
2323	# Move the specified file and verify its checksum.
2324	mvSGDescFile $arg2 $arg3 $arg4 $arg5
2325	rc=$?
2326	;;
2327
2328	#----------------------------------------------------
2329	lssgdescfile ) # mmremote lsSGDescFile
2330	#----------------------------------------------------
2331	# Return a list of all disk descriptor recovery files.
2332	[[ -d ${tmpDir}mmimportfs ]] && \
2333	$ls -1 ${tmpDir}mmimportfs/tspreparedisk.diskDesc.* 2>/dev/null
2334	rc=0
2335	;;
2336
2337	#----------------------------------------------------
2338	rmsgdescfile ) # mmremote rmSGDescFile <diskName>
2339	#----------------------------------------------------
2340	if [[ $argc -lt 2 ]]
2341	then
2342	operands="<diskName>"
2343	printErrorMsg 260 mmremote $kword "$operands"
2344	cleanupAndExit
2345	fi
2346
2347	# Remove all disk descriptor recovery files for the specified disk.
2348	$rm -f ${tmpDir}mmimportfs/tspreparedisk.diskDesc.${arg2}.*
2349	rc=0
2350	;;
2351
2352	#-------------------------------------------
2353	getgpfsdiskname ) # mmremote getGpfsDiskName <rawDiskName>
2354	#-------------------------------------------
2355	if [[ $argc -lt 2 ]]
2356	then
2357	operands="<rawDiskName>"
2358	printErrorMsg 260 mmremote $kword "$operands"
2359	cleanupAndExit
2360	fi
2361
2362	# Determine the GPFS disk name of the specified physical disk.
2363	gpfsDiskName=$(getGpfsDiskName $arg2)
2364	rc=$?
2365	print -- "$gpfsDiskName"
2366	;;
2367
2368	#-------------------------------------------
2369	unfencedisks ) # mmremote unfenceDisks <diskFile>
2370	#-------------------------------------------
2371	if [[ $argc -lt 2 ]]
2372	then
2373	operands="<diskNameFile> \| <diskNameList>"
2374	printErrorMsg 260 mmremote $kword "$operands"
2375	cleanupAndExit
2376	fi
2377
2378	# Unfence the specified disks and clear the PR registrations.
2379	unfenceDisksOutput=$(unfenceDisks $arg2)
2380	rc=$?
2381	print -- "$unfenceDisksOutput"
2382
2383	# If this is invoked by mmimportfs, cleanup the input file.
2384	# Otherwise, leave the file alone. The decision is based on
2385	# the input file's name.
2386	[[ $arg2 = ${tmpDir}disksToUnfence.mmimportfs.*tmp ]] && \
2387	$rm -f $arg2
2388	;;
2389
2390	#--------------------------------------------------
2391	mountfilesystems ) # mmremote mountFileSystems <device> <mountPoint>
2392	# <defaultOptions> <newOptions> [doNotRemount]
2393	#--------------------------------------------------
2394	if [[ $argc -lt 5 ]]
2395	then
2396	operands="<device> {<mountPoint>\|DEFAULT} <defaultOptions>"
2397	operands="${operands} {<newOptions>\|DEFAULT} [doNotRemount]"
2398	printErrorMsg 260 mmremote $kword "$operands"
2399	cleanupAndExit
2400	fi
2401
2402	# Mount the specified file systems.
2403	mountFileSystems $arg2 "$arg3" "$arg4" "$arg5" $arg6
2404	rc=$?
2405	;;
2406
2407	#---------------------------------------------
2408	unmountfilesystems ) # mmremote unmountFileSystems <device> [-f]
2409	#---------------------------------------------
2410	if [[ $argc -lt 2 ]]
2411	then
2412	operands="<device> [-f]"
2413	printErrorMsg 260 mmremote $kword "$operands"
2414	cleanupAndExit
2415	fi
2416
2417	# Invoke the preunmount user exit.
2418	[[ -x ${mmfscfgDir}preunmount ]] && \
2419	$mmcommon preunmount $arg2 umount
2420
2421	# Unmount the specified file systems.
2422	unmountFileSystems $arg2 "$arg3"
2423	rc=$?
2424	;;
2425
2426	#----------------------------------------------
2427	unmountmountpoint ) # mmremote unmountMountpoint <mountPoint> [-f]
2428	#----------------------------------------------
2429	if [[ $argc -lt 2 ]]
2430	then
2431	operands="<mountPoint> [-f]"
2432	printErrorMsg 260 mmremote $kword "$operands"
2433	cleanupAndExit
2434	fi
2435
2436	# Unmount the specified file systems.
2437	unmountMountpoint $arg2 "$arg3"
2438	rc=$?
2439	;;
2440
2441	#-------------------------------------------------------------
2442	lsmount ) # mmremote lsmount <fsToShow> <scope> <showNodes> [norefresh]
2443	#-------------------------------------------------------------
2444	if [[ $argc -lt 4 ]]
2445	then
2446	operands="<fsToShow> <scope> <showNodes> [norefresh]"
2447	printErrorMsg 260 mmremote $kword "$operands"
2448	cleanupAndExit
2449	fi
2450
2451	# Find out who has the file systems mounted.
2452	lsmount "$arg2" "$arg3" $arg4 $arg5
2453	rc=$?
2454	;;
2455
2456	#---------------------------------
2457	shutdowndaemon ) # mmremote shutdownDaemon
2458	#---------------------------------
2459	# Remove the rerunmmfsFile file.
2460	# If not done, runmmfs will restart mmfsd.
2461	$rm -f $rerunmmfsFile
2462
2463	# Shut down the GPFS daemon.
2464	$mmfsadm shutdown 2>&1 \| $grep -v -e "mmfs daemon not running"
2465	$sleep 3
2466
2467	# Kill the runmmfs and mmfsenv processes if they are still running.
2468	# This would be the case if we were in a backoff respawn
2469	# or the daemon was never started in the first place.
2470	pidNumbers=$($ps -eo "pid args" \| \
2471	$awk '( /\/runmmfs/ \|\| /\/mmfsenv/ ) && !/this process/ {print $1}')
2472	[[ -n $pidNumbers ]] && $kill -s KILL $pidNumbers
2473	$rm -f "${respawnlog}".*
2474
2475	# If this is a server node, start the mmsdrserv daemon.
2476	[[ $ourNodeName = $primaryServer \|\| $ourNodeName = $backupServer ]] && \
2477	startSdrServ CURRENT >> $mmsdrservLog 2>&1
2478
2479	# Unload the kernel extensions (in Linux only).
2480	[[ $osName = Linux ]] && $mmfsenv -u
2481
2482	# Always return OK.
2483	rc=0
2484	;;
2485
2486	#---------------------------------
2487	cleanupdaemon ) # mmremote cleanupDaemon
2488	#---------------------------------
2489	# If this file is present, GPFS will be respawned.
2490	$rm -f $rerunmmfsFile >/dev/null 2>&1
2491
2492	# Shut down the daemon.
2493	$mmfsadm cleanup 2>&1 \| $grep -v -e "mmfs daemon not running"
2494	$sleep 3
2495
2496	# If this is a server node, start the mmsdrserv daemon.
2497	[[ $ourNodeName = $primaryServer \|\| $ourNodeName = $backupServer ]] && \
2498	startSdrServ CURRENT >> $mmsdrservLog 2>&1
2499
2500	# Unload the kernel extensions.
2501	[[ $osName = Linux ]] && $mmfsenv -u
2502
2503	# Always return OK.
2504	rc=0
2505	;;
2506
2507
2508	#------------------------------------------------------------------
2509	onbehalf) # mmremote onbehalf <reqNode> <rcFilename> <mmmode> <fileToCopy>
2510	# <fsToCheck> <scope> <link> <remoteCommand> [<arg ... >]
2511	#------------------------------------------------------------------
2512	if [[ $argc -lt 9 ]]
2513	then
2514	operands="<requestingNode> <rcFilename> <mmmode> <fileToCopy>"
2515	operands="$operands <fsToCheck> <scope> <link> <remoteCommand> [<arg ... >] "
2516	printErrorMsg 260 mmremote $kword "$operands"
2517	cleanupAndExit
2518	fi
2519
2520	# Shift past all positional parameters and collect the command arguments.
2521	shift 9
2522	arguments="$@"
2523
2524	# Setup the environment.
2525	export MMMODE=$arg4
2526
2527	# If there is a file to copy, get it.
2528	fileCopied=no
2529	if [[ $arg5 != $NO_FILE_COPY ]]
2530	then
2531	rcpResult=$(LC_ALL=C $rcp ${arg2}:${arg5} $arg5 2>&1)
2532	rc=$?
2533	if [[ $rc -eq 0 ]]
2534	then
2535	fileCopied=yes
2536	else
2537	# If there was no need to copy the file, that's fine.
2538	print -- "$rcpResult" \| $grep -e "refer to the same file" >/dev/null
2539	if [[ $? -ne 0 ]]
2540	then
2541	# Show the error from the rcp command and issue a message
2542	# that the rcp command failed.
2543	print -u2 "$rcpResult"
2544	printErrorMsg 171 $mmcmd "$rcp ${arg2}:${arg5} $arg5" $rc
2545	else
2546	fileCopied=yes
2547	rc=0
2548	fi
2549	fi # end of if [[ $rc -eq 0 ]]
2550	fi # end of if [[ $arg5 != $NO_FILE_COPY ]]
2551
2552	# If the copy worked, execute the command and return the return code.
2553	# The return code is reported by creating a temporary file in a scratch
2554	# directory on the caller's machine. This temporary "return code" file
2555	# has the return code as the trailing part of its name. It is the
2556	# caller's responsibility to look for this file to get the return code.
2557	# This mechanism is used because rsh does not return return codes.
2558	if [[ $rc -eq 0 ]]
2559	then
2560	runLocalCommand $arg6 $arg7 $arg8 $arg9 $arguments
2561	rc=$?
2562	rshResult=$($rsh $arg2 $mmremote adminCmd touch ${tmpDir}${arg3}.${rc} 2>&1)
2563	ec=$?
2564	if [[ $ec -ne 0 ]]
2565	then
2566	# Show the error from the rsh command and issue a message
2567	# that the rsh command failed.
2568	print -u2 $rshResult
2569	printErrorMsg 171 $mmcmd \
2570	"$rsh ${arg2} mmremote adminCmd touch ${tmpDir}${arg3}.${rc}" $ec
2571	fi
2572
2573	# Remove the input file if it was not created on this node.
2574	[[ $fileCopied = yes && $arg2 != $ourNodeName ]] && $rm -f $arg5
2575	fi # end of if [[ $rc -eq 0 ]]
2576	;;
2577
2578	#-----------------------------------------------------------
2579	onbehalf2) # mmremote onbehalf2 <reqNode> <rcFilename> <mmmode> <link>
2580	# <remoteCommand> [<arg ... >]
2581	#-----------------------------------------------------------
2582	if [[ $argc -lt 6 ]]
2583	then
2584	operands="<requestingNode> <rcFilename> <mmmode> <link>"
2585	operands="$operands <remoteCommand> [<arg ... >] "
2586	printErrorMsg 260 mmremote $kword "$operands"
2587	cleanupAndExit
2588	fi
2589
2590	# Shift past all positional parameters and collect the command arguments.
2591	shift 6
2592	arguments="$@"
2593
2594	# Setup the environment.
2595	export MMMODE=$arg4
2596
2597	# Execute the command and return the return code.
2598	# The return code is reported by creating a temporary file in a scratch
2599	# directory on the caller's machine. This temporary "return code" file
2600	# has the return code as the trailing part of its name. It is the
2601	# caller's responsibility to look for this file to get the return code.
2602	# This mechanism is used because rsh does not return return codes.
2603	runLocalCommand2 $arg5 $arg6 $arguments
2604	rc=$?
2605	rshResult=$($rsh $arg2 $mmremote adminCmd touch ${tmpDir}${arg3}.${rc} 2>&1)
2606	ec=$?
2607	if [[ $ec -ne 0 ]]
2608	then
2609	# Show the error from the rsh command and issue a message
2610	# that the rsh command failed.
2611	print -u2 -- $rshResult
2612	printErrorMsg 171 $mmcmd \
2613	"$rsh ${arg2} mmremote adminCmd touch ${tmpDir}${arg3}.${rc}" $ec
2614	fi
2615	;;
2616
2617	#----------------------------------------
2618	* ) # Unknown action requested
2619	#----------------------------------------
2620	# Invalid keyword. The caller is running incompatible GPFS version.
2621	# Tell him what our capabilities are and let him decide what to do.
2622	printErrorMsg 133 mmremote $kword
2623	print -u2 "mmremote:incompatibleGPFScode:$ourNodeName:$localVersionInfo:"
2624	cleanupAndExit $MM_IncompatibleCode
2625	;;
2626
2627	esac # end first case $kword_lc in
2628
2629	cleanupAndExit $rc doNotUnlock
2630

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: gpfs_3.1_ker2.6.20/lpp/mmfs/bin/mmremote

Download in other formats: