URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [insight/] [dejagnu/] [config/] [vxworks.exp] - Blame information for rev 1765

Details | Compare with Previous | View Log


# Copyright (C) 92, 93, 94, 95, 1996, 1997 Free Software Foundation, Inc.
 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
# Please email any bugs, comments, and/or additions to this file to:
# DejaGnu@cygnus.com
 
# This file was originally written by Rob Savoye. (rob@cygnus.com)
# and modified by Bob Manson (manson@cygnus.com)
 
#
# Try to boot the machine into the requested OS.
#
proc ${board}_init { dest } {
    # This is not the right way to determine the required OS...
    global target_os;
    set shell_prompt [board_info $dest shell_prompt];
    set do_reboot 0;
 
    set desired_kernel [board_info $dest "kernel,$target_os"];
 
    if { $desired_kernel == "" } {
        vxworks_final_init $dest;
        # Nothing to see here, nothing to do. Move along.
        return;
    }
 
    remote_raw_open $dest raw;
    remote_send $dest "\n";
    remote_expect $dest 5 {
        -re "$shell_prompt" {
            set do_reboot 1;
        }
        -re "Press any key to stop auto-boot" {
            remote_send $dest "\n";
            exp_continue;
        }
        -re "VxWorks Boot" {
            set boot_mon 0;
            set boot_mon_prompt "VxWorks Boot";
        }
        -re "\[0-9\]\[\r\n\]+ *\[0-9\]\[\r\n\]" {
            remote_send $dest "\n";
            exp_continue;
        }
        timeout {
            set do_reboot 1;
        }
    }
 
    if { $do_reboot } {
        remote_close $dest;
        remote_reboot $dest;
        return;
    }
    remote_binary $dest;
    remote_send $dest "\n\n";
    remote_expect $dest 3 {
        timeout {}
        -re ".+" { exp_continue; }
    }
    remote_send $dest "p\n";
    remote_expect $dest 20 {
        -re "file name\[ \t\]+: (\[^ \r\n\]+)\[ \r\n\]+" {
            set curr_file $expect_out(1,string);
            exp_continue;
        }
        -re "$boot_mon_prompt" { }
    }
    if ![info exists curr_file] {
        remote_close $dest;
        remote_reboot $dest;
        return;
    }
    if { $curr_file != $desired_kernel } {
        verbose "$curr_file != '$desired_kernel'";
        # Oh boy.
        remote_send $dest "c\n";
        remote_expect $dest 20 {
            -re "file name\[ \t\]+:.*$" {
                remote_send $dest "$desired_kernel\n";
                exp_continue;
            }
            -re "\[a-z() \t\]+:.*$" {
                remote_send $dest "\n";
                exp_continue;
            }
            -re "$boot_mon_prompt" {}
        }
    }
    remote_send $dest "@\n";
    remote_expect $dest 30 {
        -re "(^|\[\r\n\])$shell_prompt" {}
        -re ".+" {
            exp_continue;
        }
    }
    vxworks_final_init $dest;
    remote_close $dest;
}
 
proc vxworks_final_init { dest } {
    if [board_info $dest exists preload_obj] {
        if { [target_compile [board_info $dest preload_obj] foo.out object [board_info $dest preload_obj_flags]] == "" } {
            vxworks_ld $dest foo.out
        }
        remote_file build delete foo.out;
    }
}
#
# Execute the command PROGRAM on VxWorks.
#
 
proc vxworks_exec { dest program pargs inp outp } {
    global decimal hex;
 
    set shell_id [vxworks_open $dest];
    if { $shell_id < 0 } {
        return [list -1 "open failure"];
    }
 
    if { $inp != "" } {
        set inp [remote_download $dest $inp];
        set suffix " < $inp";
    } else {
        set suffix ""
    }
 
    set shell_prompt [board_info $dest shell_prompt];
    remote_send $dest "${program} ${pargs}$suffix\n";
    # FIXME: The value 300 below should probably be a parameter passed in.
    remote_expect $dest 300 {
        -re "\\\[VxWorks Boot\\\]:" {
            remote_send $dest "@\n";
            sleep 20;
            exp_continue;
        }
        -re "(.*)value = (-*$decimal) = $hex\[^\r\n\]*\[\r\n\]+$shell_prompt" {
            set result [list $expect_out(2,string) $expect_out(1,string)];
        }
        -re "undefined symbol: .*$shell_prompt" {
            set result [list 1 "unknown command"];
        }
        -re "syntax error.*$shell_prompt" {
            set result [list -1 "syntax error in command"];
        }
        default {
            set result [list -1 "unable to execute command"];
        }
    }
    if { $suffix != "" } {
        remote_file $dest delete $inp;
    }
    return $result;
}
 
proc vxworks_download { dest localfile remotefile } {
    if [board_info $dest exists vxworks_homedir] {
        set rfile "[board_info $dest vxworks_homedir]/$remotefile";
        remote_download build $localfile $rfile;
        return $rfile;
    }
    return [remote_raw_download $dest $localfile $remotefile];
}
 
proc vxworks_file { dest op args } {
    set file [lindex $args 0];
    if [board_info $dest exists vxworks_homedir] {
        set dir "[board_info $dest vxworks_homedir]";
        switch $op {
            exists {
                set file "${dir}/[file tail $file]";
                return [file exists $file];
            }
            delete {
                foreach x $args {
                    set x "${dir}/[file tail $x]";
                    if { [file exists $x] && [file isfile $x] } {
                        exec rm -f $x;
                    }
                }
                return;
            }
        }
    }
    return [eval remote_raw_file \"$dest\" \"$op\" $args];
}
 
proc vxworks_send { dest string } {
    # Convert LFs to CRs, 'cause that is what VxWorks wants to see.
    regsub -all "\n" $string "\r" string;
    verbose "Sending '$string' to $dest" 2
    return [remote_raw_send $dest "$string"];
}
 
proc vxworks_open { dest args } {
    if [board_info $dest exists fileid] {
        return [board_info $dest fileid];
    }
 
    set shell_prompt [board_info $dest shell_prompt]
 
    set shell_id [remote_raw_open $dest];
 
    if { $shell_id == "" || $shell_id < 0 } {
        return -1;
    }
 
    if [board_info $dest exists logname] {
        set logname [board_info $dest logname];
        if [board_info $dest exists password] {
            remote_send $dest "iam \"$logname\",\"[board_info $dest passwd]\"\r"
        } else {
            remote_send $dest "iam \"$logname\"\r"
        }
 
        remote_expect $dest 30 {
            "iam*value = 0 = 0x0*$shell_prompt" {
                verbose "Set default user." 2
            }
            timeout {
                # ??? This is really an error.  It's not clear whether `perror'
                # or `warning' should be used here.  There are *lots* of other
                # cases like this.
                perror "Couldn't set default user."
                return -1;
            }
        }
    }
 
    set dir "";
    if [board_info $dest exists ftp_directory] {
        set dir [board_info $dest ftp_directory];
    }
    if [board_info $dest exists vxworks_homedir] {
        set dir [board_info $dest vxworks_homedir];
    }
    if { $dir != "" } {
        set status [remote_exec $dest "cd" "\"$dir\""];
        if [lindex $status 0] {
            perror "Error in cd to $dir--[lindex $status 1]";
            return 1;
        }
    }
    return $shell_id;
}
#
# Load a file into vxworks
#
# The result is:
#  0 - success
#  1 - failed (eg: link failed so testcase should fail)
# -1 - unresolved (eg: timeout), may be fixed by rebooting
#
proc vxworks_ld { dest prog } {
    global decimal hex
    global board_info
 
    if { $prog == "" } {
        return 1;
    }
 
    set shell_id [remote_open $dest];
 
    if { $shell_id < 0 } {
        return -1;
    }
 
    set prog [remote_download $dest $prog];
 
    set shell_prompt [board_info $dest shell_prompt];
 
    # We always want to exit the program via the code at the end.
    # If the load fails we want `expect_out' stored in the log and this
    # saves duplicating that code.
 
    for { set x 0 ; } { $x < 3 } {incr x; } {
        remote_send $dest "\n";
        remote_expect $dest 30 {
            -re ".*$shell_prompt $" { set x 20; }
            -re "\\\[VxWorks Boot\\\]:" {
                remote_send $dest "@\n";
                sleep 20;
                exp_continue;
            }
            timeout { return -1; }
        }
    }
 
    set tries 0
    set maxtries 3
    set result -7       ;# -7 is a local value meaning "not done"
 
    while { $result == -7 && $tries < $maxtries } {
        verbose "Loading $prog into vxworks."
        remote_send $dest "ld < $prog\n";
        incr tries
        remote_expect $dest 300 {
            -re "USER.*command not understood" {
                perror "Need to set the user and password."
                set result 1
            }
            -re "Stale NFS file handle.*$shell_prompt $" {
                # Need to retry.
            }
            -re "undefined symbol:.*$shell_prompt $" {
                # This is an error in the testcase, don't call perror.
                warning "Undefined symbol, $prog not loaded."
                set result 1
            }
            -re "memPartAlloc: block too.*$shell_prompt $" {
                perror "Not enough memory to load $prog."
                set result -1
            }
            -re "can't open input.*$shell_prompt $" {
                perror "Can't access $prog."
                set result 1
            }
            -re "value = (-*${decimal}) = ${hex}.*$shell_prompt $" {
                verbose "Loaded $prog into vxworks."
                set board_info([board_info $dest name],vx_module) $expect_out(1,string);
                set result 0
            }
            -re "(.*)$shell_prompt $" {
                warning "Load failed: $expect_out(1,string)"
            }
            timeout {
                warning "Timed out trying load $prog."
                set result -1
            }
        }
    }
 
    if { $result && [info exists expect_out(buffer)] } {
        send_log "$expect_out(buffer)"
    }
 
    remote_file $dest delete $prog;
    return $result
}
 
#
# Start a thread (process) executing
#
# The result is:
#  0 - success
#  1 - failed (eg: testcase aborted)
# -1 - unresolved, may be fixed by rebooting
#
proc vxworks_run { dest function pargs inp outp } {
    global hex decimal;
 
    set shell_prompt [board_info $dest shell_prompt];
    set output "";
 
    # There isn't a command to wait for a thread to finish, so we have to keep
    # polling. Instead, we expect the status wrapper to return an exit
    # status.
 
    set status [remote_exec $dest "sp" "$function $pargs" $inp $outp];
 
    set tid [lindex $status 0];
 
    # Bad task id, reboot and try again.
    if { $tid == -1 || $tid == 0 } {
        return -1;
    }
 
    set result 1;
    # FIXME: The value 300 below should be a parameter.
    remote_expect $dest 300 {
        -re "task ${hex} - aborted.*$shell_prompt $" {
            # FIXME: It's not clear we'll ever get here.
            verbose "$function aborted"
            set result 1
        }
        -re "\[\r\n\]syntax error\[\r\n\]" {
            verbose "weirdness after task started"
            set result -1;
        }
        -re "(.*)\\*\\*\\* EXIT code ($decimal)\[\r\n\]" {
            set output "$expect_out(1,string)";
            set exit_code "$expect_out(2,string)";
            if { ($exit_code + 0) != 0 } {
                set result 1;
            } else {
                set result 0;
            }
        }
        -re "Operation Fault.*fault type:" {
            set result 1;
        }
        -re "Bus Error" {
            # This is here to try to cope with apparently flaky h/w.
            # This is potentially an error in the testcase, but we don't
            # really know, do we?
            warning "Bus Error."
            set result 1;
            set output "Bus Error";
            remote_reboot $dest;
        }
        timeout {
            # Infinite loop? probably.
            remote_exec $dest "td" "$tid";
            set result 1;
        }
    }
 
    return [list $result $output];
}
 
#
# Unload the last executable that we loaded, so we can free up its memory.
#
proc vxworks_unld { dest } {
    global board_info;
 
    if [board_info $dest exists vx_module] {
        # Vxworks5.0 does not have the unld command.
        if { [board_info $dest os] != "vxworks5.0" } {
            remote_exec $dest "unld" "[board_info $dest vx_module]";
        }
        unset board_info([board_info $dest name],vx_module);
    }
}
 
#
# We loop around rebooting the box until either the load and run
# "work" or we give up.
#
proc vxworks_load {dest prog args} {
    set result "";
    set output "";
 
    if { [llength $args] > 0 } {
        set pargs "[lindex $args 0]";
    } else {
        set pargs ""
    }
 
    if { [llength $args] > 1 } {
        set inp "[lindex $args 1]";
    } else {
        set inp ""
    }
 
    if { [llength $args] > 2 } {
        set outp "[lindex $args 2]";
    } else {
        set outp ""
    }
 
    for { set x 0; } { $x < 3 } { incr x } {
        set status [vxworks_ld $dest $prog];
        if { $status >= 0 } {
            if { $status > 0 } {
                set result "fail";
            } else {
                set out [vxworks_run $dest __wrap_main $pargs $inp $outp];
                set status [lindex $out 0];
                set output [lindex $out 1];
                # Get rid of the carriage returns, because they confuse
                # callers that try to parse the result.
                regsub -all "\r" $output "" output
                if { $status != 0 } {
                    if { $status > 0 } {
                        set result "fail";
                    }
                } else {
                    set result "pass";
                }
            }
        }
        if { $result != "" } {
            vxworks_unld $dest;
            return [list $result $output];
        }
        remote_reboot $dest;
    }
    return [list "fail" ""];
}
 
set_board_info protocol "vxworks"
# -lm under vxworks isn't needed.
set_board_info mathlib ""
set_board_info shell_prompt "->"
set_board_info needs_status_wrapper 1
# FTP doesn't work in passive mode to this board.
set_board_info ftp_no_passive 1
# Wait 15 seconds after powercycling.
set_board_info reboot_delay 15
 
# We don't have sys/unistd.h.
set_board_info wrap_compile_flags "-DNO_UNISTD_H"
 
set_board_info gdb_prompt "\[(\]vxgdb\[)\]"
 
set_board_info is_vxworks 1;
set_board_info gdb,nosignals 1;

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [insight/] [dejagnu/] [config/] [vxworks.exp] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	578	markom	`# Copyright (C) 92, 93, 94, 95, 1996, 1997 Free Software Foundation, Inc.`
2
3			`# This program is free software; you can redistribute it and/or modify`
4			`# it under the terms of the GNU General Public License as published by`
5			`# the Free Software Foundation; either version 2 of the License, or`
6			`# (at your option) any later version.`
7			`#`
8			`# This program is distributed in the hope that it will be useful,`
9			`# but WITHOUT ANY WARRANTY; without even the implied warranty of`
10			`# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
11			`# GNU General Public License for more details.`
12			`#`
13			`# You should have received a copy of the GNU General Public License`
14			`# along with this program; if not, write to the Free Software`
15			`# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
16
17			`# Please email any bugs, comments, and/or additions to this file to:`
18			`# DejaGnu@cygnus.com`
19
20			`# This file was originally written by Rob Savoye. (rob@cygnus.com)`
21			`# and modified by Bob Manson (manson@cygnus.com)`
22
23			`#`
24			`# Try to boot the machine into the requested OS.`
25			`#`
26			`proc ${board}_init { dest } {`
27			`# This is not the right way to determine the required OS...`
28			`global target_os;`
29			`set shell_prompt [board_info $dest shell_prompt];`
30			`set do_reboot 0;`
31
32			`set desired_kernel [board_info $dest "kernel,$target_os"];`
33
34			`if { $desired_kernel == "" } {`
35			`vxworks_final_init $dest;`
36			`# Nothing to see here, nothing to do. Move along.`
37			`return;`
38			`}`
39
40			`remote_raw_open $dest raw;`
41			`remote_send $dest "\n";`
42			`remote_expect $dest 5 {`
43			`-re "$shell_prompt" {`
44			`set do_reboot 1;`
45			`}`
46			`-re "Press any key to stop auto-boot" {`
47			`remote_send $dest "\n";`
48			`exp_continue;`
49			`}`
50			`-re "VxWorks Boot" {`
51			`set boot_mon 0;`
52			`set boot_mon_prompt "VxWorks Boot";`
53			`}`
54			`-re "\[0-9\]\[\r\n\]+ *\[0-9\]\[\r\n\]" {`
55			`remote_send $dest "\n";`
56			`exp_continue;`
57			`}`
58			`timeout {`
59			`set do_reboot 1;`
60			`}`
61			`}`
62
63			`if { $do_reboot } {`
64			`remote_close $dest;`
65			`remote_reboot $dest;`
66			`return;`
67			`}`
68			`remote_binary $dest;`
69			`remote_send $dest "\n\n";`
70			`remote_expect $dest 3 {`
71			`timeout {}`
72			`-re ".+" { exp_continue; }`
73			`}`
74			`remote_send $dest "p\n";`
75			`remote_expect $dest 20 {`
76			`-re "file name\[ \t\]+: (\[^ \r\n\]+)\[ \r\n\]+" {`
77			`set curr_file $expect_out(1,string);`
78			`exp_continue;`
79			`}`
80			`-re "$boot_mon_prompt" { }`
81			`}`
82			`if ![info exists curr_file] {`
83			`remote_close $dest;`
84			`remote_reboot $dest;`
85			`return;`
86			`}`
87			`if { $curr_file != $desired_kernel } {`
88			`verbose "$curr_file != '$desired_kernel'";`
89			`# Oh boy.`
90			`remote_send $dest "c\n";`
91			`remote_expect $dest 20 {`
92			`-re "file name\[ \t\]+:.*$" {`
93			`remote_send $dest "$desired_kernel\n";`
94			`exp_continue;`
95			`}`
96			`-re "\[a-z() \t\]+:.*$" {`
97			`remote_send $dest "\n";`
98			`exp_continue;`
99			`}`
100			`-re "$boot_mon_prompt" {}`
101			`}`
102			`}`
103			`remote_send $dest "@\n";`
104			`remote_expect $dest 30 {`
105			`-re "(^\|\[\r\n\])$shell_prompt" {}`
106			`-re ".+" {`
107			`exp_continue;`
108			`}`
109			`}`
110			`vxworks_final_init $dest;`
111			`remote_close $dest;`
112			`}`
113
114			`proc vxworks_final_init { dest } {`
115			`if [board_info $dest exists preload_obj] {`
116			`if { [target_compile [board_info $dest preload_obj] foo.out object [board_info $dest preload_obj_flags]] == "" } {`
117			`vxworks_ld $dest foo.out`
118			`}`
119			`remote_file build delete foo.out;`
120			`}`
121			`}`
122			`#`
123			`# Execute the command PROGRAM on VxWorks.`
124			`#`
125
126			`proc vxworks_exec { dest program pargs inp outp } {`
127			`global decimal hex;`
128
129			`set shell_id [vxworks_open $dest];`
130			`if { $shell_id < 0 } {`
131			`return [list -1 "open failure"];`
132			`}`
133
134			`if { $inp != "" } {`
135			`set inp [remote_download $dest $inp];`
136			`set suffix " < $inp";`
137			`} else {`
138			`set suffix ""`
139			`}`
140
141			`set shell_prompt [board_info $dest shell_prompt];`
142			`remote_send $dest "${program} ${pargs}$suffix\n";`
143			`# FIXME: The value 300 below should probably be a parameter passed in.`
144			`remote_expect $dest 300 {`
145			`-re "\\\[VxWorks Boot\\\]:" {`
146			`remote_send $dest "@\n";`
147			`sleep 20;`
148			`exp_continue;`
149			`}`
150			`-re "(.)value = (-$decimal) = $hex\[^\r\n\]*\[\r\n\]+$shell_prompt" {`
151			`set result [list $expect_out(2,string) $expect_out(1,string)];`
152			`}`
153			`-re "undefined symbol: .*$shell_prompt" {`
154			`set result [list 1 "unknown command"];`
155			`}`
156			`-re "syntax error.*$shell_prompt" {`
157			`set result [list -1 "syntax error in command"];`
158			`}`
159			`default {`
160			`set result [list -1 "unable to execute command"];`
161			`}`
162			`}`
163			`if { $suffix != "" } {`
164			`remote_file $dest delete $inp;`
165			`}`
166			`return $result;`
167			`}`
168
169			`proc vxworks_download { dest localfile remotefile } {`
170			`if [board_info $dest exists vxworks_homedir] {`
171			`set rfile "[board_info $dest vxworks_homedir]/$remotefile";`
172			`remote_download build $localfile $rfile;`
173			`return $rfile;`
174			`}`
175			`return [remote_raw_download $dest $localfile $remotefile];`
176			`}`
177
178			`proc vxworks_file { dest op args } {`
179			`set file [lindex $args 0];`
180			`if [board_info $dest exists vxworks_homedir] {`
181			`set dir "[board_info $dest vxworks_homedir]";`
182			`switch $op {`
183			`exists {`
184			`set file "${dir}/[file tail $file]";`
185			`return [file exists $file];`
186			`}`
187			`delete {`
188			`foreach x $args {`
189			`set x "${dir}/[file tail $x]";`
190			`if { [file exists $x] && [file isfile $x] } {`
191			`exec rm -f $x;`
192			`}`
193			`}`
194			`return;`
195			`}`
196			`}`
197			`}`
198			`return [eval remote_raw_file \"$dest\" \"$op\" $args];`
199			`}`
200
201			`proc vxworks_send { dest string } {`
202			`# Convert LFs to CRs, 'cause that is what VxWorks wants to see.`
203			`regsub -all "\n" $string "\r" string;`
204			`verbose "Sending '$string' to $dest" 2`
205			`return [remote_raw_send $dest "$string"];`
206			`}`
207
208			`proc vxworks_open { dest args } {`
209			`if [board_info $dest exists fileid] {`
210			`return [board_info $dest fileid];`
211			`}`
212
213			`set shell_prompt [board_info $dest shell_prompt]`
214
215			`set shell_id [remote_raw_open $dest];`
216
217			`if { $shell_id == "" \|\| $shell_id < 0 } {`
218			`return -1;`
219			`}`
220
221			`if [board_info $dest exists logname] {`
222			`set logname [board_info $dest logname];`
223			`if [board_info $dest exists password] {`
224			`remote_send $dest "iam \"$logname\",\"[board_info $dest passwd]\"\r"`
225			`} else {`
226			`remote_send $dest "iam \"$logname\"\r"`
227			`}`
228
229			`remote_expect $dest 30 {`
230			`"iamvalue = 0 = 0x0$shell_prompt" {`
231			`verbose "Set default user." 2`
232			`}`
233			`timeout {`
234			# ??? This is really an error. It's not clear whether `perror'
235			# or `warning' should be used here. There are lots of other
236			`# cases like this.`
237			`perror "Couldn't set default user."`
238			`return -1;`
239			`}`
240			`}`
241			`}`
242
243			`set dir "";`
244			`if [board_info $dest exists ftp_directory] {`
245			`set dir [board_info $dest ftp_directory];`
246			`}`
247			`if [board_info $dest exists vxworks_homedir] {`
248			`set dir [board_info $dest vxworks_homedir];`
249			`}`
250			`if { $dir != "" } {`
251			`set status [remote_exec $dest "cd" "\"$dir\""];`
252			`if [lindex $status 0] {`
253			`perror "Error in cd to $dir--[lindex $status 1]";`
254			`return 1;`
255			`}`
256			`}`
257			`return $shell_id;`
258			`}`
259			`#`
260			`# Load a file into vxworks`
261			`#`
262			`# The result is:`
263			`# 0 - success`
264			`# 1 - failed (eg: link failed so testcase should fail)`
265			`# -1 - unresolved (eg: timeout), may be fixed by rebooting`
266			`#`
267			`proc vxworks_ld { dest prog } {`
268			`global decimal hex`
269			`global board_info`
270
271			`if { $prog == "" } {`
272			`return 1;`
273			`}`
274
275			`set shell_id [remote_open $dest];`
276
277			`if { $shell_id < 0 } {`
278			`return -1;`
279			`}`
280
281			`set prog [remote_download $dest $prog];`
282
283			`set shell_prompt [board_info $dest shell_prompt];`
284
285			`# We always want to exit the program via the code at the end.`
286			# If the load fails we want `expect_out' stored in the log and this
287			`# saves duplicating that code.`
288
289			`for { set x 0 ; } { $x < 3 } {incr x; } {`
290			`remote_send $dest "\n";`
291			`remote_expect $dest 30 {`
292			`-re ".*$shell_prompt $" { set x 20; }`
293			`-re "\\\[VxWorks Boot\\\]:" {`
294			`remote_send $dest "@\n";`
295			`sleep 20;`
296			`exp_continue;`
297			`}`
298			`timeout { return -1; }`
299			`}`
300			`}`
301
302			`set tries 0`
303			`set maxtries 3`
304			`set result -7 ;# -7 is a local value meaning "not done"`
305
306			`while { $result == -7 && $tries < $maxtries } {`
307			`verbose "Loading $prog into vxworks."`
308			`remote_send $dest "ld < $prog\n";`
309			`incr tries`
310			`remote_expect $dest 300 {`
311			`-re "USER.*command not understood" {`
312			`perror "Need to set the user and password."`
313			`set result 1`
314			`}`
315			`-re "Stale NFS file handle.*$shell_prompt $" {`
316			`# Need to retry.`
317			`}`
318			`-re "undefined symbol:.*$shell_prompt $" {`
319			`# This is an error in the testcase, don't call perror.`
320			`warning "Undefined symbol, $prog not loaded."`
321			`set result 1`
322			`}`
323			`-re "memPartAlloc: block too.*$shell_prompt $" {`
324			`perror "Not enough memory to load $prog."`
325			`set result -1`
326			`}`
327			`-re "can't open input.*$shell_prompt $" {`
328			`perror "Can't access $prog."`
329			`set result 1`
330			`}`
331			`-re "value = (-${decimal}) = ${hex}.$shell_prompt $" {`
332			`verbose "Loaded $prog into vxworks."`
333			`set board_info([board_info $dest name],vx_module) $expect_out(1,string);`
334			`set result 0`
335			`}`
336			`-re "(.*)$shell_prompt $" {`
337			`warning "Load failed: $expect_out(1,string)"`
338			`}`
339			`timeout {`
340			`warning "Timed out trying load $prog."`
341			`set result -1`
342			`}`
343			`}`
344			`}`
345
346			`if { $result && [info exists expect_out(buffer)] } {`
347			`send_log "$expect_out(buffer)"`
348			`}`
349
350			`remote_file $dest delete $prog;`
351			`return $result`
352			`}`
353
354			`#`
355			`# Start a thread (process) executing`
356			`#`
357			`# The result is:`
358			`# 0 - success`
359			`# 1 - failed (eg: testcase aborted)`
360			`# -1 - unresolved, may be fixed by rebooting`
361			`#`
362			`proc vxworks_run { dest function pargs inp outp } {`
363			`global hex decimal;`
364
365			`set shell_prompt [board_info $dest shell_prompt];`
366			`set output "";`
367
368			`# There isn't a command to wait for a thread to finish, so we have to keep`
369			`# polling. Instead, we expect the status wrapper to return an exit`
370			`# status.`
371
372			`set status [remote_exec $dest "sp" "$function $pargs" $inp $outp];`
373
374			`set tid [lindex $status 0];`
375
376			`# Bad task id, reboot and try again.`
377			`if { $tid == -1 \|\| $tid == 0 } {`
378			`return -1;`
379			`}`
380
381			`set result 1;`
382			`# FIXME: The value 300 below should be a parameter.`
383			`remote_expect $dest 300 {`
384			`-re "task ${hex} - aborted.*$shell_prompt $" {`
385			`# FIXME: It's not clear we'll ever get here.`
386			`verbose "$function aborted"`
387			`set result 1`
388			`}`
389			`-re "\[\r\n\]syntax error\[\r\n\]" {`
390			`verbose "weirdness after task started"`
391			`set result -1;`
392			`}`
393			`-re "(.)\\\\\\ EXIT code ($decimal)\[\r\n\]" {`
394			`set output "$expect_out(1,string)";`
395			`set exit_code "$expect_out(2,string)";`
396			`if { ($exit_code + 0) != 0 } {`
397			`set result 1;`
398			`} else {`
399			`set result 0;`
400			`}`
401			`}`
402			`-re "Operation Fault.*fault type:" {`
403			`set result 1;`
404			`}`
405			`-re "Bus Error" {`
406			`# This is here to try to cope with apparently flaky h/w.`
407			`# This is potentially an error in the testcase, but we don't`
408			`# really know, do we?`
409			`warning "Bus Error."`
410			`set result 1;`
411			`set output "Bus Error";`
412			`remote_reboot $dest;`
413			`}`
414			`timeout {`
415			`# Infinite loop? probably.`
416			`remote_exec $dest "td" "$tid";`
417			`set result 1;`
418			`}`
419			`}`
420
421			`return [list $result $output];`
422			`}`
423
424			`#`
425			`# Unload the last executable that we loaded, so we can free up its memory.`
426			`#`
427			`proc vxworks_unld { dest } {`
428			`global board_info;`
429
430			`if [board_info $dest exists vx_module] {`
431			`# Vxworks5.0 does not have the unld command.`
432			`if { [board_info $dest os] != "vxworks5.0" } {`
433			`remote_exec $dest "unld" "[board_info $dest vx_module]";`
434			`}`
435			`unset board_info([board_info $dest name],vx_module);`
436			`}`
437			`}`
438
439			`#`
440			`# We loop around rebooting the box until either the load and run`
441			`# "work" or we give up.`
442			`#`
443			`proc vxworks_load {dest prog args} {`
444			`set result "";`
445			`set output "";`
446
447			`if { [llength $args] > 0 } {`
448			`set pargs "[lindex $args 0]";`
449			`} else {`
450			`set pargs ""`
451			`}`
452
453			`if { [llength $args] > 1 } {`
454			`set inp "[lindex $args 1]";`
455			`} else {`
456			`set inp ""`
457			`}`
458
459			`if { [llength $args] > 2 } {`
460			`set outp "[lindex $args 2]";`
461			`} else {`
462			`set outp ""`
463			`}`
464
465			`for { set x 0; } { $x < 3 } { incr x } {`
466			`set status [vxworks_ld $dest $prog];`
467			`if { $status >= 0 } {`
468			`if { $status > 0 } {`
469			`set result "fail";`
470			`} else {`
471			`set out [vxworks_run $dest __wrap_main $pargs $inp $outp];`
472			`set status [lindex $out 0];`
473			`set output [lindex $out 1];`
474			`# Get rid of the carriage returns, because they confuse`
475			`# callers that try to parse the result.`
476			`regsub -all "\r" $output "" output`
477			`if { $status != 0 } {`
478			`if { $status > 0 } {`
479			`set result "fail";`
480			`}`
481			`} else {`
482			`set result "pass";`
483			`}`
484			`}`
485			`}`
486			`if { $result != "" } {`
487			`vxworks_unld $dest;`
488			`return [list $result $output];`
489			`}`
490			`remote_reboot $dest;`
491			`}`
492			`return [list "fail" ""];`
493			`}`
494
495			`set_board_info protocol "vxworks"`
496			`# -lm under vxworks isn't needed.`
497			`set_board_info mathlib ""`
498			`set_board_info shell_prompt "->"`
499			`set_board_info needs_status_wrapper 1`
500			`# FTP doesn't work in passive mode to this board.`
501			`set_board_info ftp_no_passive 1`
502			`# Wait 15 seconds after powercycling.`
503			`set_board_info reboot_delay 15`
504
505			`# We don't have sys/unistd.h.`
506			`set_board_info wrap_compile_flags "-DNO_UNISTD_H"`
507
508			`set_board_info gdb_prompt "\[(\]vxgdb\[)\]"`
509
510			`set_board_info is_vxworks 1;`
511			`set_board_info gdb,nosignals 1;`