1 #!/bin/sh
2
3 #
4 # Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
5 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 #
7 # This code is free software; you can redistribute it and/or modify it
8 # under the terms of the GNU General Public License version 2 only, as
9 # published by the Free Software Foundation.
10 #
11 # This code is distributed in the hope that it will be useful, but WITHOUT
12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 # version 2 for more details (a copy is included in the LICENSE file that
15 # accompanied this code).
16 #
17 # You should have received a copy of the GNU General Public License version
18 # 2 along with this work; if not, write to the Free Software Foundation,
19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 #
21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 # or visit www.oracle.com if you need additional information or have any
23 # questions.
24 #
25
26 #
27 #
28 # jtreg runs this in a scratch dir.
29 # It (and runregress -no) sets these env vars:
30 # TESTSRC: The dir that contains this file
31 # TESTCLASSES: Where .class files are compiled to
32 # TESTJAVA: The jdk to run
33 #
34 # This is a 'library' script that is included by
35 # shell script test cases that want to run a .java file as the debuggee
36 # and use jdb as the debugger. This file contains
37 # several functions that support such a test.
38
39 # The caller script can also set these shell vars before
40 # including this file:
41 # pkg=<package name> To use a package, define it here and put
42 # package $pkg
43 # in your java file
44 # classname=<classnam> Omit this to use the default class name, 'shtest'.
45
46 # compileOptions=<string> compile options for at least the first compile,
47 # eg, compileOptions=-g
48 # compileOptions2=<string> Options for the 2nd, ..., compile. compileOptions1
49 # is used if this is not set. To use no compile
50 # options for the 2nd ... compiles, do
51 # compileOptions2=none
52 #
53 # mode=-Xcomp or mode=-Xint to run in these modes. These should not
54 # really be used since the tests are normally
55 # run in both modes.
56 # javacCmd=path-to-javac to use a non-standard javac for compiling
57 # compileOptions=<string> Options to pass to javac
58 #
59 # See RedefineException.sh as an example of a caller script.
60 #
61 # To do RedefineClasses operations, embed @1 tags in the .java
62 # file to tell this script how to modify it to produce the 2nd
63 # version of the .class file to be used in the redefine operation.
64 # Here are examples of each editting tag and what change
65 # it causes in the new file. Note that blanks are not preserved
66 # in these editing operations.
67 #
68 # @1 uncomment
69 # orig: // @1 uncomment gus = 89;
70 # new: gus = 89;
71 #
72 # @1 commentout
73 # orig: gus = 89 // @1 commentout
74 # new: // gus = 89 // @1 commentout
75 #
76 # @1 delete
77 # orig: gus = 89 // @1 delete
78 # new: entire line deleted
79 #
80 # @1 newline
81 # orig: gus = 89; // @1 newline gus++;
82 # new: gus = 89; //
83 # gus++;
84 #
85 # @1 replace
86 # orig: gus = 89; // @1 replace gus = 90;
87 # new: gus = 90;
88 #
89 # The only other tag supported is @1 breakpoint. The setbkpts function
90 # sets bkpts at all lines that contain this string.
91 #
92 # Currently, all these tags are start with @1. It is envisioned that this script
93 # could be ehanced to allow multiple cycles of redefines by allowing
94 # @2, @3, ... tags. IE, processing the @i tags in the ith version of
95 # the file will produce the i+1th version of the file.
96 #
97 # There are problem with jtreg leaving behind orphan java and jdb processes
98 # when this script is run. Sometimes, on some platforms, it just doesn't
99 # get them all killed properly.
100 # The solution is to put a magic word in the cmd lines of background java
101 # and jdb processes this script launches. We can then do the right kind
102 # of ps cmds to find all these processes and kill them. We do this by
103 # trapping the completion of this script.
104 #
105 # An associated problem is that our trap handler (cleanup) doesn't
106 # always get called when jtreg terminates a test. This can leave tests
107 # hanging but following tests should run ok because each test uses
108 # unique names for the port and temp files (based on the PID returned
109 # by $$).
110 #
111 # mks 6.2a on win 98 presents two problems:
112 # $! returns the PID as a negative number whereas ps returns
113 # it in the form 0xFFF.... This means our trick of
114 # of using $! to get the PIDs of the jdb and debuggee processes
115 # doesn't work. This will cause some error cases to fail
116 # with a jtreg timeout instead of failing more gracefully.
117 #
118 # There is no form of the ps command that will show the whole
119 # cmd line. Thus, the magic keyword trick doesn't work. We
120 # resort to just killing java.exe and jdb.exes
121 #
122 # pid usage:
123 # debuggeepid: used in jdb process to detect if debuggee has died.
124 # - waitForDebuggeeMsg: fail if debuggee is gone
125 #
126 # jdbpid: dofail: used to detect if in main process or jdb process
127 # waitforfinish: quit if the jdb process is gone
128
129 #killcmd=/bin/kill
130 killcmd=kill
131
132 # This can be increased if timing seems to be an issue.
133 sleep_seconds=1
134 timeout_factor=1
135 if [ -n "$TESTTIMEOUTFACTOR" ] ; then
136 # convert float value to int
137 timeout_factor=$(echo $TESTTIMEOUTFACTOR | awk '{printf "%d\n", int($1)}')
138 fi
139
140 echo "ShellScaffold.sh: Running with timeout_factor = $timeout_factor" >& 2
141 topPid=$$
142
143 # Be careful to echo to >& in these general functions.
144 # If they are called from the functions that are sending
145 # cmds to jdb, then stdout is redirected to jdb.
146 cleanup()
147 {
148 if [ -r "$failFile" ] ; then
149 ls -l "$failFile" >&2
150 echo "<cleanup:_begin_failFile_contents>" >&2
151 cat "$failFile" >&2
152 echo "<cleanup:_end_failFile_contents>" >&2
153 fi
154
155 # Kill all processes that have our special
156 # keyword in their cmd line.
157 killOrphans cleanup $jdbKeyword
158 killOrphans cleanup $debuggeeKeyword
159 }
160
161 # Kill all processes with $2 in their cmd lines
162 # Print a msg about this using $1 as the prefix
163 killOrphans()
164 {
165 str=$2
166
167 if [ -z "$isCygwin" ] ; then
168 toBeKilled=`$psCmd | $grep -v grep | $grep -i $str | awk '{print $1}' | tr '\n\r' ' '`
169 else
170 # The cygwin ps command doesn't show the options passed to a cmd.
171 # We will use jps to get the win PID of the command, and
172 # then use ps to find the cygwin pid to be killed.
173 # The form of a ps output line is
174 # ^ ddddd dddd dddd dddd.*
175 # where the 4th digits are the win pid and the first
176 # are the cygwin pid.
177 if [ -r "$jdk/bin/$jstack" ] ; then
178 winPid=`$jdk/bin/jps -v | $grep -i $str | sed -e 's@ .*@@'`
179 if [ ! -z "$winPid" ] ; then
180 # Here is a way to kill using a win cmd and the win PID.
181 #echo "$1: taskkill /F $winPid" >& 2
182 #taskkill /F /PID $winPid
183
184 toBeKilled=`$psCmd | $grep -v grep | \
185 $grep '^ +[0-9]+ +[0-9]+ +[0-9]+ +'"$winPid" |\
186 awk '{print $1}' | tr '\n\r' ' '`
187 fi
188 else
189 # Well, too bad - we can't find what to kill.
190 toBeKilled=
191 fi
192 fi
193
194 if [ ! -z "$toBeKilled" ] ; then
195 echo "$1: kill -9 $toBeKilled" >& 2
196 kill -9 $toBeKilled
197 fi
198 }
199
200 # Returns 0 if $1 is the pid of a running process
201 findPid()
202 {
203 if [ -z "$1" ] ; then
204 return 1
205 fi
206
207 case "$osname" in
208 SunOS | AIX)
209 $psCmd | $grep '^ *'"$1 " > $devnull 2>&1
210 res=$?
211 ;;
212 Windows* | CYGWIN*)
213 # Don't use ps on cygwin since it sometimes misses
214 # some processes (!).
215 tasklist /NH | $grep " $1 " > $devnull 2>&1
216 res=$?
217 ;;
218 *)
219 # Never use plain 'ps', which requires a "controlling terminal"
220 # and will fail with a "ps: no controlling terminal" error.
221 # Running under 'rsh' will cause this ps error.
222 $psCmd -e | $grep '^ *'"$1 " > $devnull 2>&1
223 res=$?
224 ;;
225 esac
226 return $res
227 }
228
229 setup()
230 {
231 failed=
232 # This is used to tag each java and jdb cmd we issue so
233 # we can kill them at the end of the run.
234
235 orphanKeyword=HANGINGJAVA-$$
236 debuggeeKeyword=${orphanKeyword}_DEB
237 jdbKeyword=${orphanKeyword}_JDB
238 baseArgs=-D${debuggeeKeyword}
239 if [ -z "$TESTCLASSES" ] ; then
240 echo "--Warning: TESTCLASSES is not defined; using TESTCLASSES=."
241 echo " You should run: "
242 echo " runregress $0 -no"
243 echo " or"
244 echo " (setenv TESTCLASSES .; $0 $*)"
245 TESTCLASSES=.
246 fi
247 if [ ! -z "$TESTJAVA" ] ; then
248 jdk="$TESTJAVA"
249 else
250 echo "--Error: TESTJAVA must be defined as the pathname of a jdk to test."
251 exit 1
252 fi
253
254 ulimitCmd=
255 osname=`uname -s`
256 isCygwin=
257 case "$osname" in
258 Windows* | CYGWIN*)
259 devnull=NUL
260 case "$osname" in
261 CYGWIN*)
262 isCygwin=1
263 devnull=/dev/null
264 ;;
265 esac
266
267 if [ -r $jdk/bin/dt_shmem.dll ] ; then
268 transport=dt_shmem
269 address=kkkk.$$
270 else
271 transport=dt_socket
272 address=
273 fi
274 baseArgs="$baseArgs -XX:-ShowMessageBoxOnError"
275 # jtreg puts \\s in TESTCLASSES and some uses, eg. echo
276 # treat them as control chars on mks (eg \t is tab)
277 # Oops; windows mks really seems to want this cat line
278 # to start in column 1
279 if [ -w "$Temp" ] ; then
280 tmpFile=$Temp/tmp.$$
281 elif [ -w "$TEMP" ] ; then
282 tmpFile=$TEMP/tmp.$$
283 else
284 tmpFile=tmp.$$
285 fi
286 cat <<EOF >$tmpFile
287 $TESTCLASSES
288 EOF
289 TESTCLASSES=`cat $tmpFile | sed -e 's@\\\\@/@g'`
290 rm -f $tmpFile
291 # on mks
292 grep=egrep
293 psCmd=ps
294 jstack=jstack.exe
295 ;;
296 SunOS | Linux | Darwin | AIX)
297 transport=dt_socket
298 address=
299 devnull=/dev/null
300 grep=egrep
301 jstack=jstack
302 # On linux, core files take a long time, and can leave
303 # zombie processes
304 if [ "$osname" = SunOS ] ; then
305 # Experiments show Solaris '/usr/ucb/ps -axwww' and
306 # '/usr/bin/pgrep -f -l' provide the same small amount of the
307 # argv string (PRARGSZ=80 in /usr/include/sys/procfs.h)
308 # 1) This seems to have been working OK in ShellScaffold.
309 # 2) OpenSolaris does not provide /usr/ucb/ps, so use pgrep
310 # instead
311 # The alternative would be to use /usr/bin/pargs [pid] to get
312 # all the args for a process, splice them back into one
313 # long string, then grep.
314 UU=`/usr/xpg4/bin/id -u -n`
315 psCmd="pgrep -f -l -U $UU"
316 else
317 ulimit -c 0
318 # See bug 6238593.
319 psCmd="ps axwww"
320 fi
321 ;;
322 *)
323 echo "--Error: Unknown result from 'uname -s': $osname"
324 exit 1
325 ;;
326 esac
327
328
329 tmpFileDir=$TESTCLASSES/aa$$
330 TESTCLASSES=$tmpFileDir
331
332 mkdir -p $tmpFileDir
333
334 # This must not contain 'jdb' or it shows up
335 # in grep of ps output for some platforms
336 jdbOutFile=$tmpFileDir/jxdbOutput.txt
337 rm -f $jdbOutFile
338 touch $jdbOutFile
339
340 debuggeeOutFile=$tmpFileDir/debuggeeOutput.txt
341 failFile=$tmpFileDir/testFailed
342 debuggeepidFile=$tmpFileDir/debuggeepid
343 rm -f $failFile $debuggeepidFile
344 if [ -f "$failFile" ]; then
345 echo "ERROR: unable to delete existing failFile:" >&2
346 ls -l "$failFile" >&2
347 fi
348
349 if [ -z "$pkg" ] ; then
350 pkgSlash=
351 pkgDot=
352 redefineSubdir=.
353 else
354 pkgSlash=$pkg/
355 pkgDot=$pkg.
356 redefineSubdir=$pkgSlash
357 fi
358 if [ -z "$classname" ] ; then
359 classname=shtest
360 fi
361
362 if [ -z "$java" ] ; then
363 java=java
364 fi
365
366 if [ -z "$jdb" ] ; then
367 jdb=$jdk/bin/jdb
368 fi
369
370 ####################################################3
371 ####################################################3
372 ####################################################3
373 ####################################################3
374 # sol: this gets all processes killed but
375 # no jstack
376 # linux same as above
377 # win mks: No dice; processes still running
378 trap "cleanup" 0 1 2 3 4 6 9 10 15
379
380 jdbOptions="$jdbOptions -J-D${jdbKeyword}"
381 }
382
383 docompile()
384 {
385 if [ "$compile" = 0 ] ; then
386 return
387 fi
388 saveDir=`pwd`
389 cd $tmpFileDir
390 rm -f *.java
391 createJavaFile $classname
392
393 # Compile two versions of the file, the original and with the
394 # indicated lines modified.
395 cp $classname.java.1 $classname.java
396 echo "--Compiling first version of `pwd`/$classname.java with options: $compileOptions"
397 # Result is in $pkgSlash$classname.class
398
399 if [ -z "$javacCmd" ] ; then
400 javacCmd=$jdk/bin/javac
401 fi
402
403 echo "compiling " `ls *.java`
404 $javacCmd $compileOptions -d . *.java
405 if [ $? != 0 ] ; then
406 dofail "First compile failed"
407 fi
408 if [ -r vers1 ] ; then
409 rm -rf vers1
410 fi
411 mkdir -p vers1
412 mv *.class vers1
413 if [ ! -z "$compileOptions2" ] ; then
414 if [ "$compileOptions2" = none ] ; then
415 compileOptions=
416 else
417 compileOptions=$compileOptions2
418 fi
419 fi
420
421 while [ 1 = 1 ] ; do
422 # Not really a loop; just a way to avoid goto
423 # by using breaks
424 sed -e '/@1 *delete/ d' \
425 -e 's! *// *@1 *uncomment! !' \
426 -e 's!\(.*@1 *commentout\)!//\1!' \
427 -e 's/@1 *newline/\
428 /' \
429 -e 's/.*@1 *replace//' \
430 $classname.java.1 >$classname.java
431
432 cmp -s $classname.java.1 $classname.java
433 if [ $? = 0 ] ; then
434 break
435 fi
436 echo
437 echo "--Compiling second version of `pwd`/$classname.java with $compileOptions"
438 $javacCmd $compileOptions -d . $classname.java
439 if [ $? != 0 ] ; then
440 dofail "Second compile failed"
441 fi
442 if [ -r vers2 ] ; then
443 rm -rf vers2
444 fi
445 mkdir -p vers2
446 mv *.class vers2
447 mv $classname.java $classname.java.2
448 cp $classname.java.1 $classname.java
449
450 ###### Do the same for @2, and @3 allowing 3 redefines to occur.
451 ###### If I had more time to write sed cmds, I would do
452 ###### this in a loop. But, I don't think we will ever need
453 ###### more than 3 redefines.
454 sed -e '/@2 *delete/ d' \
455 -e 's! *// *@2 *uncomment! !' \
456 -e 's!\(.*@2 *commentout\)!//\1!' \
457 -e 's/@2 *newline/\
458 /' \
459 -e 's/.*@2 *replace//' \
460 $classname.java.2 >$classname.java
461 cmp -s $classname.java.2 $classname.java
462 if [ $? = 0 ] ; then
463 break
464 fi
465 echo
466 echo "--Compiling third version of `pwd`/$classname.java with $compileOptions"
467 $javacCmd $compileOptions -d . $classname.java
468 if [ $? != 0 ] ; then
469 dofail "Third compile failed"
470 fi
471 if [ -r vers3 ] ; then
472 rm -rf vers3
473 fi
474 mkdir -p vers3
475 mv *.class vers3
476 mv $classname.java $classname.java.3
477 cp $classname.java.1 $classname.java
478
479 ########
480 sed -e '/@3 *delete/ d' \
481 -e 's! *// *@3 *uncomment! !' \
482 -e 's!\(.*@3 *commentout\)!//\1!' \
483 -e 's/@3 *newline/\
484 /' \
485 -e 's/.*@3 *replace//' \
486 $classname.java.3 >$classname.java
487 cmp -s $classname.java.3 $classname.java
488 if [ $? = 0 ] ; then
489 break
490 fi
491 echo
492 echo "--Compiling fourth version of `pwd`/$classname.java with $compileOptions"
493 $javacCmd $compileOptions -d . $classname.java
494 if [ $? != 0 ] ; then
495 dofail "fourth compile failed"
496 fi
497 if [ -r vers4 ] ; then
498 rm -rf vers4
499 fi
500 mkdir -p vers4
501 mv *.class vers4
502 mv $classname.java $classname.java.4
503 cp $classname.java.1 $classname.java
504 break
505 fgrep @4 $classname.java
506 if [ $? = 0 ] ; then
507 echo "--Error: @4 and above are not yet allowed"
508 exit 1
509 fi
510 done
511
512 cp vers1/* $redefineSubdir
513 cd $saveDir
514 }
515
516 # Send a cmd to jdb and wait for the jdb prompt to appear.
517 # We don't want to allow > as a prompt because if the debuggee
518 # runs for awhile after a command, jdb will show this prompt
519 # but is not really ready to accept another command for the
520 # debuggee - ie, a cont in this state will be ignored.
521 # If it ever becomes necessary to send a jdb command before
522 # a main[10] form of prompt appears, then this
523 # code will have to be modified.
524 #
525 # Specify $1 = allowExit to show that the command given
526 # allows JDB to exit
527 cmd()
528 {
529 allowExit=
530 case "$1" in
531 allowExit)
532 allowExit="allowExit"
533 shift
534 ;;
535 exitJdb)
536 # Quit JDB only with this cmd() invocation
537 echo "--Sending cmd: quit" >& 2
538 echo quit
539 echo "--Quit cmd was sent" >& 2
540 # See 6562090. Maybe there is a way that the exit
541 # can cause jdb to not get the quit.
542 sleep 5
543
544 # The exit code value here doesn't matter since this function
545 # is called as part of a pipeline and it is not the last command
546 # in the pipeline.
547 exit 1
548 ;;
549 esac
550 command=$*
551
552 if [ -z "$command" ] ; then
553 dofail "Command can't be a null string. Test failure"
554 fi
555 if [ "$command" = "quit" -o "$command" = "exit" ] ; then
556 # We don't want the test to manually quit jdb,
557 # we will do it in the end automatically
558 dofail "It's not allowed to send quit or exit commands from the test"
559 fi
560 if [ -r "$failFile" ] ; then
561 # failFile exists, it's better to finish execution
562 dofinish "quit"
563 fi
564
565 # $jdbOutFile always exists here and is non empty
566 # because after starting jdb, we waited
567 # for the prompt.
568 fileSize=`wc -c $jdbOutFile | awk '{ print $1 }'`
569 echo "--Sending cmd: " $command >&2
570
571 # jjh: We have a few intermittent failures here.
572 # It is as if every so often, jdb doesn't
573 # get the first cmd that is sent to it here.
574 # (actually, I have seen it get the first cmd ok,
575 # but then not get some subsequent cmd).
576 # It seems like jdb really doesn't get the cmd; jdb's response
577 # does not appear in the jxdboutput file. It contains:
578 # main[1]
579 # The application has been disconnected
580
581 # Is it possible
582 # that jdb got the cmd ok, but its response didn't make
583 # it to the jxdboutput file? If so, why did 'The application
584 # has been disconnected' make it?
585
586 # This causes the following loop to timeout and the test to fail.
587 # The above echo works because the cmd (stop at ...)
588 # is in the System.err shown in the .jtr file.
589 # Also, the cmd is shown in the 'jdb never responded ...'
590 # msg output below after the timeout.
591 # And, we know jdb is started because the main[1] output is in the .jtr
592 # file. And, we wouldn't have gotten here if mydojdbcmds hadn't
593 # seen the ].
594 echo $command
595
596 # Now we have to wait for the next jdb prompt. We wait for a pattern
597 # to appear in the last line of jdb output. Normally, the prompt is
598 #
599 # 1) ^main[89] @
600 #
601 # where ^ means start of line, and @ means end of file with no end of line
602 # and 89 is the current command counter. But we have complications e.g.,
603 # the following jdb output can appear:
604 #
605 # 2) a[89] = 10
606 #
607 # The above form is an array assignment and not a prompt.
608 #
609 # 3) ^main[89] main[89] ...
610 #
611 # This occurs if the next cmd is one that causes no jdb output, e.g.,
612 # 'trace methods'.
613 #
614 # 4) ^main[89] [main[89]] .... > @
615 #
616 # jdb prints a > as a prompt after something like a cont.
617 # Thus, even though the above is the last 'line' in the file, it
618 # isn't the next prompt we are waiting for after the cont completes.
619 # HOWEVER, sometimes we see this for a cont command:
620 #
621 # ^main[89] $
622 # <lines output for hitting a bkpt>
623 #
624 # 5) ^main[89] > @
625 #
626 # i.e., the > prompt comes out AFTER the prompt we we need to wait for.
627 #
628 # So, how do we know when the next prompt has appeared??
629 # 1. Search for
630 # main[89] $
631 # This will handle cases 1, 2, 3
632 # 2. This leaves cases 4 and 5.
633 #
634 # What if we wait for 4 more chars to appear and then search for
635 #
636 # main[89] [>]$
637 #
638 # on the last line?
639 #
640 # a. if we are currently at
641 #
642 # ^main[89] main[89] @
643 #
644 # and a 'trace methods comes in, we will wait until at least
645 #
646 # ^main[89] main[89] main@
647 #
648 # and then the search will find the new prompt when it completes.
649 #
650 # b. if we are currently at
651 #
652 # ^main[89] main[89] @
653 #
654 # and the first form of cont comes in, then we will see
655 #
656 # ^main[89] main[89] > $
657 # ^x@
658 #
659 # where x is the first char of the msg output when the bkpt is hit
660 # and we will start our search, which will find the prompt
661 # when it comes out after the bkpt output, with or without the
662 # trailing >
663 #
664
665 # wait for 4 new chars to appear in the jdb output
666 count=0
667 desiredFileSize=`expr $fileSize + 4`
668 msg1=`echo At start: cmd/size/waiting : $command / $fileSize / \`date\``
669 timeLimit=`expr 60 * $timeout_factor`
670 while [ 1 = 1 ] ; do
671 newFileSize=`wc -c $jdbOutFile | awk '{ print $1 } '`
672 #echo jj: desired = $desiredFileSize, new = $newFileSize >& 2
673
674 done=`expr $newFileSize \>= $desiredFileSize`
675 if [ $done = 1 ] ; then
676 break
677 fi
678 sleep ${sleep_seconds}
679 count=`expr $count + ${sleep_seconds}`
680 if [ $count -gt $timeLimit ] ; then
681 # record some debug info.
682 echo "--DEBUG: jdb $$ didn't respond to command in $count secs: $command" >& 2
683 echo "--DEBUG:" $msg1 >& 2
684 echo "--DEBUG: "done size/waiting : / $newFileSize / `date` >& 2
685 echo "-- $jdbOutFile follows-------------------------------" >& 2
686 cat $jdbOutFile >& 2
687 echo "------------------------------------------" >& 2
688 dojstack
689 dofail "jdb never responded to command: $command"
690 fi
691 done
692 # Note that this assumes just these chars in thread names.
693 waitForJdbMsg '[a-zA-Z0-9_-][a-zA-Z0-9_-]*\[[1-9][0-9]*\] [ >]*$' 1 $allowExit
694 }
695
696 setBkpts()
697 {
698 # Can set multiple bkpts, but only in one class.
699 # $1 is the bkpt name, eg, @1
700 allLines=`$grep -n "$1 *breakpoint" $tmpFileDir/$classname.java.1 | sed -e 's@^\([0-9]*\).*@\1@g'`
701 for ii in $allLines ; do
702 cmd "stop at $pkgDot$classname:$ii"
703 done
704 }
705
706 runToBkpt()
707 {
708 # Don't pass allowExit here as we don't want JDB to unexpectedly exit
709 cmd run
710 # Don't need to do this - the above waits for the next prompt which comes out
711 # AFTER the Breakpoint hit message.
712 # Wait for jdb to hit the bkpt
713 #waitForJdbMsg "Breakpoint hit" 5
714 }
715
716 contToBkpt()
717 {
718 # Don't pass allowExit here as we don't want JDB to unexpectedly exit
719 cmd cont
720 # Don't need to do this - the above waits for the next prompt which comes out
721 # AFTER the Breakpoint hit message.
722 # Wait for jdb to hit the bkpt
723 #waitForJdbMsg "Breakpoint hit" 5
724 }
725
726
727 # Wait until string $1 appears in the output file, within the last $2 lines
728 # If $3 is allowExit, then don't fail if jdb exits before
729 # the desired string appears.
730 waitForJdbMsg()
731 {
732 # This can be called from the jdb thread which doesn't
733 # have access to $debuggeepid, so we have to read it from the file.
734 nlines=$2
735 allowExit="$3"
736 myCount=0
737 timeLimit=`expr 40 * $timeout_factor` # wait a max of this many secs for a response from a jdb command
738
739 while [ 1 = 1 ] ; do
740 if [ -r $jdbOutFile ] ; then
741 # Something here causes jdb to complain about Unrecognized cmd on x86.
742 tail -$nlines $jdbOutFile | $grep -s "$1" > $devnull 2>&1
743 if [ $? = 0 ] ; then
744 # Found desired string
745 break
746 fi
747 fi
748 tail -2 $jdbOutFile | $grep -s "The application exited" > $devnull 2>&1
749 if [ $? = 0 ] ; then
750 # Found 'The application exited'
751 echo "--JDB finished: The application exited" >&2
752 if [ ! -z "$allowExit" ] ; then
753 # Exit is allowed
754 dofinish
755 fi
756 # Otherwise, it is an error if we don't find $1
757 if [ -r $jdbOutFile ] ; then
758 tail -$nlines $jdbOutFile | $grep -s "$1" > $devnull 2>&1
759 if [ $? = 0 ] ; then
760 break
761 fi
762 fi
763 dofail "JDB unexpectedly finished: Waited for jdb msg $1, but it never appeared"
764 fi
765
766 sleep ${sleep_seconds}
767 findPid $topPid
768 if [ $? != 0 ] ; then
769 echo "--Top process ($topPid) is dead. We better die too" >&2
770 dojstack
771 exit 1
772 fi
773
774 myCount=`expr $myCount + ${sleep_seconds}`
775 if [ $myCount -gt $timeLimit ] ; then
776 echo "--Fail: waitForJdbMsg timed out after $timeLimit seconds, looking for /$1/, in $nlines lines; exiting" >> $failFile
777 echo "vv jdbOutFile vvvvvvvvvvvvvvvvvvvvvvvvvvvv" >& 2
778 cat $jdbOutFile >& 2
779 echo "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" >& 2
780 dojstack
781 exit 1
782 fi
783 done
784
785 }
786
787 # Finishes JDB execution
788 # Specify command to finish if it's needed
789 dofinish()
790 {
791 if [ ! -z "$*" ] ; then
792 echo "--Finish execution with sending \"$*\" command to JDB" >&2
793 cmd "exitJdb" "$*"
794 else
795 echo "--Finish without sending \"quit\" command to JDB" >&2
796 fi
797 exit 0
798 }
799
800 # $1 is the string to print. If $2 exists,
801 # it is the name of a file to print, ie, the name
802 # of the file that contains the $1 string.
803 dofail()
804 {
805 if [ ! -z "$jdbpid" ] ; then
806 # we are in the main process instead of the jdb process
807 echo " " >> $failFile
808 echo "--Fail: main: $*" >> $failFile
809 else
810 # Kill the debuggee ; it could be hung so
811 # we want to get rid of it as soon as possible.
812 killOrphans "killing debuggee" $debuggeeKeyword
813 # Kill debugger, it could be hung
814 killOrphans "killing debugger" $jdbKeyword
815
816 echo " " >>$failFile
817 echo "--Fail: $*" >> $failFile
818 fi
819 if [ ! -z "$2" ] ; then
820 echo "---- contents of $2 follows -------" >> $failFile
821 cat "$2" >> $failFile
822 echo "---------------" >>$failFile
823 fi
824 exit 1
825 }
826
827
828 redefineClass()
829 {
830 if [ -z "$1" ] ; then
831 vers=2
832 else
833 vers=`echo $1 | sed -e 's/@//'`
834 vers=`expr $vers + 1`
835 fi
836
837 cmd "redefine $pkgDot$classname $tmpFileDir/vers$vers/$classname.class"
838
839 cp $tmpFileDir/$classname.java.$vers \
840 $tmpFileDir/$classname.java
841 }
842
843 mydojdbCmds()
844 {
845 # Wait for jdb to start before we start sending cmds
846 waitForJdbMsg ']' 1
847 # Send commands from the test
848 dojdbCmds
849 # Finish jdb with quit command
850 dofinish "quit"
851 }
852
853 startJdb()
854 {
855 if [ ! -r "$jdb" -a ! -r "$jdb.exe" ] ; then
856 dofail "$jdb does not exist"
857 fi
858 echo
859 echo "--Starting jdb, address=$address"
860 if [ -z "$address" ] ; then
861 # Let jdb choose the port and write it to stdout
862 mydojdbCmds | $jdb $jdbOptions -listenany | tee $jdbOutFile &
863
864 while [ 1 ] ; do
865 lastLine=`$grep 'Listening at address' $jdbOutFile`
866 if [ ! -z "$lastLine" ] ; then
867 break
868 fi
869 sleep 1
870 done
871 # jjh: we got the address ok, and seemed to start the debuggee
872 address=`echo $lastLine | sed -e 's@.*: *@@'`
873 else
874 mydojdbCmds | $jdb $jdbOptions -listen $address | tee $jdbOutFile &
875 fi
876 #echo address = $address
877
878
879 # this gets the pid of tee, at least it does on solaris
880 jdbpid=$!
881
882 # This fails on linux because there is an entry for each thread in jdb
883 # so we get a list of numbers in jdbpid
884 # jdbpid=`$psCmd | $grep -v grep | $grep ${orphanKeyword}_JDB | awk '{print $1}' | tr '\n\r' ' '`
885 }
886
887 startDebuggee()
888 {
889 args="$TESTVMOPTS $TESTJAVAOPTS"
890
891 if [ ! -z "$args" ] ; then
892 echo "--Starting debuggee with args from TESTVMOPTS and/or TESTJAVAOPTS: $args"
893 else
894 echo "--Starting debuggee"
895 fi
896
897 debuggeepid=
898 waitForJdbMsg Listening 4
899
900 beOption="-agentlib:jdwp=transport=$transport,address=$address,server=n,suspend=y"
901 # beOption="-Xdebug -Xrunjdwp:transport=$transport,address=$address,server=n,suspend=y"
902
903 thecmd="$jdk/bin/$java $mode -classpath $tmpFileDir $baseArgs $args \
904 -Djtreg.classDir=$TESTCLASSES \
905 -showversion \
906 $beOption \
907 $pkgDot$classname"
908 echo "Cmd: $thecmd"
909
910 sh -c "$thecmd | tee $debuggeeOutFile" &
911
912 # Note that the java cmd and the tee cmd will be children of
913 # the sh process. We can use that to find them to kill them.
914 debuggeepid=$!
915
916 # Save this in a place where the jdb process can find it.
917 # Note that it is possible for the java cmd to abort during startup
918 # due to a bad classpath or whatever.
919 echo $debuggeepid > $debuggeepidFile
920 }
921
922 dojstack()
923 {
924 if [ -r "$jdk/bin/$jstack" ] ; then
925 # If jstack exists, so will jps
926 # Show stack traces of jdb and debuggee as a possible debugging aid.
927 jdbCmd=`$jdk/bin/jps -v | $grep $jdbKeyword`
928 realJdbPid=`echo "$jdbCmd" | sed -e 's@ .*@@'`
929 if [ ! -z "$realJdbPid" ] ; then
930 echo "-- jdb process info ----------------------" >&2
931 echo " $jdbCmd" >&2
932 echo "-- jdb threads: jstack $realJdbPid" >&2
933 $jdk/bin/$jstack $realJdbPid >&2
934 echo "------------------------------------------" >&2
935 echo >&2
936 fi
937 debuggeeCmd=`$jdk/bin/jps -v | $grep $debuggeeKeyword`
938 realDebuggeePid=`echo "$debuggeeCmd" | sed -e 's@ .*@@'`
939 if [ ! -z "$realDebuggeePid" ] ; then
940 echo "-- debuggee process info ----------------------" >&2
941 echo " $debuggeeCmd" >&2
942 echo "-- debuggee threads: jstack $moption $realDebuggeePid" >&2
943 $jdk/bin/$jstack $realDebuggeePid >&2
944 echo "=============================================" >&2
945 echo >&2
946 fi
947 fi
948 }
949
950 waitForFinish()
951 {
952 # This is the main process
953 # Wait for the jdb process to finish, or some error to occur
954
955 while [ 1 = 1 ] ; do
956 findPid $jdbpid
957 if [ $? != 0 ] ; then
958 break
959 fi
960
961 # (Don't use jdbFailIfPresent here since it is not safe
962 # to call from different processes)
963 $grep -s 'Input stream closed' $jdbOutFile > $devnull 2>&1
964 if [ $? = 0 ] ; then
965 dofail "jdb input stream closed prematurely"
966 fi
967
968 # If a failure has occured, quit
969 if [ -r "$failFile" ] ; then
970 break
971 fi
972
973 sleep ${sleep_seconds}
974 done
975
976 # jdb exited because its input stream closed prematurely
977 # (Don't use jdbFailIfPresent here since it is not safe
978 # to call from different processes)
979 $grep -s 'Input stream closed' $jdbOutFile > $devnull 2>&1
980 if [ $? = 0 ] ; then
981 dofail "jdb input stream closed prematurely"
982 fi
983
984 # It is necessary here to avoid the situation when JDB exited but
985 # mydojdbCmds() didn't finish because it waits for JDB message
986 # in waitForJdbMsg(), at the same time main process will finish
987 # the execution with no errors.
988 # To avoid that, wait for spawned processes to finish
989 case "$osname" in
990 SunOS)
991 # `wait` function doesn't work in Solaris shell as in bash,
992 # so create replacement that finds mydojdbCmds() shell process
993 # and waits for its finish
994 cmdsPid=
995 # get list of processes except main process with $topPid
996 processes=`$psCmd | $grep -v "$grep" | $grep -v $topPid | awk '{print $1}'`
997 for pid in $processes; do
998 # for each process grep its full args string for test name $0
999 # $0 contains full test name with path
1000 pargs -l $pid 2>$devnull | $grep "$0" >$devnull 2>&1
1001 if [ $? = 0 ] ; then
1002 cmdsPid=$pid
1003 break
1004 fi
1005 done
1006 echo "--waitForFinish: Waiting for mydojdbCmds() to finish" >&2
1007 while [ 1 = 1 ] ; do
1008 findPid $cmdsPid
1009 if [ $? != 0 ] ; then
1010 break
1011 fi
1012 sleep ${sleep_seconds}
1013 done
1014 ;;
1015 *)
1016 echo "--waitForFinish: Waiting for all processes to finish" >&2
1017 wait
1018 ;;
1019 esac
1020
1021 if [ -r "$failFile" ] ; then
1022 ls -l "$failFile" >&2
1023 echo "<waitForFinish:_begin_failFile_contents>" >&2
1024 cat "$failFile" >&2
1025 echo "<waitForFinish:_end_failFile_contents>" >&2
1026 exit 1
1027 fi
1028 }
1029
1030 # $1 is the filename, $2 is the string to look for,
1031 # $3 is the number of lines to search (from the end)
1032 grepForString()
1033 {
1034 if [ -z "$3" ] ; then
1035 theCmd=cat
1036 else
1037 theCmd="tail -$3"
1038 fi
1039
1040 case "$2" in
1041 *\>*)
1042 # Target string contains a '>' so we better not ignore it
1043 $theCmd $1 | $grep -s "$2" > $devnull 2>&1
1044 stat="$?"
1045 ;;
1046 *)
1047 # Target string does not contain a '>'.
1048 # NOTE: if $1 does not end with a new line, piping it to sed
1049 # doesn't include the chars on the last line. Detect this
1050 # case, and add a new line.
1051 theFile="$1"
1052 if [ `tail -1 "$theFile" | wc -l | sed -e 's@ @@g'` = 0 ] ; then
1053 # The target file doesn't end with a new line so we have
1054 # add one to a copy of the target file so the sed command
1055 # below can filter that last line.
1056 cp "$theFile" "$theFile.tmp"
1057 theFile="$theFile.tmp"
1058 echo >> "$theFile"
1059 fi
1060
1061 # See bug 6220903. Sometimes the jdb prompt chars ('> ') can
1062 # get interleaved in the target file which can keep us from
1063 # matching the target string.
1064 $theCmd "$theFile" | sed -e 's@> @@g' -e 's@>@@g' \
1065 | $grep -s "$2" > $devnull 2>&1
1066 stat=$?
1067 if [ "$theFile" != "$1" ]; then
1068 # remove the copy of the target file
1069 rm -f "$theFile"
1070 fi
1071 unset theFile
1072 esac
1073
1074 return $stat
1075 }
1076
1077 # $1 is the filename, $2 is the regexp to match and return,
1078 # $3 is the number of lines to search (from the end)
1079 matchRegexp()
1080 {
1081 if [ -z "$3" ] ; then
1082 theCmd=cat
1083 else
1084 theCmd="tail -$3"
1085 fi
1086
1087 case "$2" in
1088 *\>*)
1089 # Target string contains a '>' so we better not ignore it
1090 res=`$theCmd $1 | sed -e "$2"`
1091 ;;
1092 *)
1093 # Target string does not contain a '>'.
1094 # NOTE: if $1 does not end with a new line, piping it to sed
1095 # doesn't include the chars on the last line. Detect this
1096 # case, and add a new line.
1097 theFile="$1"
1098 if [ `tail -1 "$theFile" | wc -l | sed -e 's@ @@g'` = 0 ] ; then
1099 # The target file doesn't end with a new line so we have
1100 # add one to a copy of the target file so the sed command
1101 # below can filter that last line.
1102 cp "$theFile" "$theFile.tmp"
1103 theFile="$theFile.tmp"
1104 echo >> "$theFile"
1105 fi
1106
1107 # See bug 6220903. Sometimes the jdb prompt chars ('> ') can
1108 # get interleaved in the target file which can keep us from
1109 # matching the target string.
1110 res=`$theCmd "$theFile" | sed -e 's@> @@g' -e 's@>@@g' \
1111 | sed -e "$2"`
1112 if [ "$theFile" != "$1" ]; then
1113 # remove the copy of the target file
1114 rm -f "$theFile"
1115 fi
1116 unset theFile
1117 esac
1118 return $res
1119 }
1120
1121 # $1 is the filename, $2 is the string to look for,
1122 # $3 is the number of lines to search (from the end)
1123 failIfPresent()
1124 {
1125 if [ -r "$1" ] ; then
1126 grepForString "$1" "$2" "$3"
1127 if [ $? = 0 ] ; then
1128 dofail "Error output found: \"$2\" in $1" $1
1129 fi
1130 fi
1131 }
1132
1133 # $1 is the filename, $2 is the string to look for
1134 # $3 is the number of lines to search (from the end)
1135 failIfNotPresent()
1136 {
1137 if [ ! -r "$1" ] ; then
1138 dofail "Required output \"$2\" not found in $1"
1139 fi
1140 grepForString "$1" "$2" "$3"
1141 if [ $? != 0 ] ; then
1142 dofail "Required output \"$2\" not found in $1" $1
1143 fi
1144
1145 }
1146
1147 # fail if $1 is not in the jdb output
1148 # $2 is the number of lines to search (from the end)
1149 jdbFailIfNotPresent()
1150 {
1151 failIfNotPresent $jdbOutFile "$1" $2
1152 }
1153
1154 # fail if $1 is not in the debuggee output
1155 # $2 is the number of lines to search (from the end)
1156 debuggeeFailIfNotPresent()
1157 {
1158 failIfNotPresent $debuggeeOutFile "$1" $2
1159 }
1160
1161 # fail if $1 is in the jdb output
1162 # $2 is the number of lines to search (from the end)
1163 jdbFailIfPresent()
1164 {
1165 failIfPresent $jdbOutFile "$1" $2
1166 }
1167
1168 # fail if $1 is in the debuggee output
1169 # $2 is the number of lines to search (from the end)
1170 debuggeeFailIfPresent()
1171 {
1172 failIfPresent $debuggeeOutFile "$1" $2
1173 }
1174
1175 # match and return the output from the regexp $1 in the debuggee output
1176 # $2 is the number of lines to search (from the end)
1177 debuggeeMatchRegexp()
1178 {
1179 matchRegexp $debuggeeOutFile "$1" $2
1180 }
1181
1182
1183 # This should really be named 'done' instead of pass.
1184 pass()
1185 {
1186 if [ ! -r "$failFile" ] ; then
1187 echo
1188 echo "--Done: test passed"
1189 exit 0
1190 else
1191 ls -l "$failFile" >&2
1192 echo "<pass:_begin_failFile_contents>" >&2
1193 cat "$failFile" >&2
1194 echo "<pass:_end_failFile_contents>" >&2
1195 fi
1196 }
1197
1198 runit()
1199 {
1200 setup
1201 docompile
1202 startJdb
1203 startDebuggee
1204 waitForFinish
1205
1206 # in hs_err file from 1.3.1
1207 debuggeeFailIfPresent "Virtual Machine Error"
1208
1209 # in hs_err file from 1.4.2, 1.5: An unexpected error
1210 debuggeeFailIfPresent "An unexpected error"
1211
1212 # in hs_err file from 1.4.2, 1.5: Internal error
1213 debuggeeFailIfPresent "Internal error"
1214
1215
1216 # Don't know how this arises
1217 debuggeeFailIfPresent "An unexpected exception"
1218
1219 # Don't know how this arises
1220 debuggeeFailIfPresent "Internal exception"
1221 }