New files. This manual was ritten by Eric Valette <valette@crf.canon.fr>

and Emmanuel Raguet <raguet@crf.canon.fr>.  It was submitted in LaTeX
and converted to Texinfo by Joel.  At this point, the figures are
largely ignored except to put in an example block to show they are
missing.

The Makefile should be just enough to produce output with no links between
chapters.
This commit is contained in:
Joel Sherrill
1999-04-02 17:04:27 +00:00
parent 85e24a3237
commit bea606aee5
16 changed files with 12427 additions and 0 deletions

113
doc/rgdb_specs/Makefile Normal file
View File

@@ -0,0 +1,113 @@
#
# COPYRIGHT (c) 1988-1998.
# On-Line Applications Research Corporation (OAR).
# All rights reserved.
#
# $Id$
#
PROJECT=rgdb_specs
DISTRIBUTION_LEVEL=public
include ../Make.config
all: html info ps
dirs:
$(make-dirs)
COMMON_FILES=../common/cpright.texi ../common/setup.texi
GENERATED_FILES= \
intro.texi revision.texi objectives.texi gdbinternals.texi \
interfacing.texi comm.texi daemon.texi conclusion.texi
FILES=$(PROJECT).texi $(GENERATED_FILES)
INFOFILES=$(wildcard $(PROJECT) $(PROJECT)-*)
info: dirs $(PROJECT)
#cp $(wildcard $(PROJECT) $(PROJECT)-*) $(INFO_INSTALL)
# cp $(PROJECT) $(INFO_INSTALL)
$(PROJECT): $(FILES)
$(MAKEINFO) $(PROJECT).texi
dvi: $(PROJECT).dvi
ps: dirs $(PROJECT).ps
$(PROJECT).ps: $(PROJECT).dvi
dvips -o $(PROJECT).ps $(PROJECT).dvi
cp $(PROJECT).ps $(PS_INSTALL)
# run texi2dvi twice to generate the xref's properly.
$(PROJECT).dvi: $(FILES)
$(TEXI2DVI) $(PROJECT).texi
texi2dvi $(PROJECT).texi
html: dirs $(FILES)
-mkdir -p $(WWW_INSTALL)/$(PROJECT)
$(TEXI2WWW) $(TEXI2WWW_ARGS) -dir $(WWW_INSTALL)/$(PROJECT) \
$(PROJECT).texi
clean:
rm -f *.o $(PROG) *.txt core
rm -f *.dvi *.ps *.log *.aux *.cp *.fn *.ky *.pg *.toc *.tp *.vr $(BASE)
rm -f $(PROJECT) $(PROJECT)-* $(GENERATED_FILES)
rm -f *.fixed _* network.t
#
# Process Automatically Generated Files
#
@include intro.texi
@include revision.texi
@include objectives.texi
@include gdbinternals.texi
@include interfacing.texi
@include comm.texi
@include daemon.texi
@include conclusion.texi
intro.texi: intro.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t
revision.texi: revision.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t
objectives.texi: objectives.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t
gdbinternals.texi: gdbinternals.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t
interfacing.texi: interfacing.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t
comm.texi: comm.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t
daemon.texi: daemon.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t
conclusion.texi: conclusion.t Makefile
$(BMENU) -p "Top" \
-u "Top" \
-n "" ${*}.t

87
doc/rgdb_specs/comm.t Normal file
View File

@@ -0,0 +1,87 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@C
@c $Id$
@c
@chapter Communication with GDB
The RTEMS remote debugger will be accessed by GDB on a host machine
through a communication link. We will use the TCP/IP stack included in RTEMS
: the FreeBSD stack. The communication link will be based based on the UDP protocol
and the BSD sockets which are parts of the FreeBSD stack. On top of these layers,
we will plug a module which allows a simple communication between different
machines (especially between different endianess machines) : the SUN Remote
Procedure Call (SUN RPC). This code is freely available on the net and comes
with a BSD like license. With this module, a process can invoke a procedure
on a remote system. The RTEMS remote debugger will be seen by GDB as a SUN RPC
server. Commands will be packed by the GDB SUN RPC client and sent to the server.
This server will unpack these commands, execute them and, if needed, return
results to the SUN RPC client.
Only a minimal subset of the SUN RPC library must be implemented.
For example, the portmapper related API which allows a dynamic allocation of
port numbers will not be implemented and some specific UDP port numbers will
be used to establish the communication between the host and the target. The
SUN RPC library implements the XDR module (eXternal Data Representation) which
is a standard way of encoding data in a portable fashion between different endian
systems. Below are figures describing the additional code and data size for
the minimal library implementation we currently have already implemented for
RTEMS :
@example
$ size -x librpc.a
text data bss dec hex filename
0x40e 0x0 0x0 1038 40e rpc_callmsg.o (ex librpc.a)
0x2f1 0x18 0x0 777 309 rpc_prot.o (ex librpc.a)
0x458 0x0 0x0 1112 458 svc.o (ex librpc.a)
0x4f 0x4 0x0 83 53 svc_auth.o (ex librpc.a)
0x75c 0x18 0x0 1908 774 svc_udp.o (ex librpc.a)
0x711 0x4 0x10 1829 725 xdr.o (ex librpc.a)
0x149 0x0 0x0 329 149 xdr_array.o (ex librpc.a)
0x165 0x20 0x0 389 185 xdr_mem.o (ex librpc.a)
@end example
We have a constraint with the use of the UDP protocol. Because this
protocol is connectionless, it is impossible, especially for the target, to
detect if the connection is always active. On the other hand, using the TCP/IP
protocols seems to be heavy especially if we plan to implement a dedicated micro
stack for debug in the future. It can be a real problem to let the debugged
process stopped during a long time even if there is no more debugger connected
to the system. To avoid such a problem, the target must periodically test the
connection with the host on another way than the one used to receive the commands.
We must therefore open two communication ways so we need two fixed UDP port
numbers.
@enumerate
@item One port will be used by the debugger to send its commands to the
debugged process and to receive the result of these commands. View from the
remote debugger, this port will be called primary port. For this one, we choose
arbitrarily the port number 2000.
@item The other socket will be used as secondary port by the target to sometimes
test the connection between the host and the target. These tests will occur
in specific situations, when a process will be stopped on a breakpoint, single
step instruction or other means. This secondary port will also be used by the
target to signal any change in the behavior of a debugged process (stopped,
killed, waiting for,...). For the secondary port, we choose the port number
2010.
@end enumerate
These two port numbers are used by the remote debugger to open the
two communication sockets. GDB will use its own mean to choose its port numbers
(probably the Unix portmapper). The figure layer shows the different
layers we need to implement.
@example
XXXXX reference it in the previous paragraph
XXXXX insert layers.eps
XXXXX Caption Communications Layers
@end example

View File

@@ -0,0 +1,27 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@c
@c $Id$
@c
@chapter Conclusion
In this document we have presented how we envisage to add remote debugging facilities
to RTEMS by implementing a remote debugger daemon for GDB. As any debug implemented
in software, it will have limitation but we are confident that most of them
can be removed by adding separate software components dedicated to debug activity.
We must keep in mind that even with this approach, no software will enable the
debug of code with interrupt entirely masked at processor level and that In
Circuit Emulator (ICE) or use of BDM extension on the target board are the ultimate
way to really debug any portion of an RTOS. BDM support in GDB is still weak
but people are working on it and we may get something better in a near future.
@example
XXXXX insert process.eps
XXXXX Caption remote debugger tasks and handlers
@end example

420
doc/rgdb_specs/daemon.t Normal file
View File

@@ -0,0 +1,420 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@c
@c $Id$
@c
@chapter RTEMS Debugger Server Daemon
We will describe in this section how this debugger server will be
implemented on RTEMS environment. Our initial target is based on Intel Pentium
and we will use an Ethernet link to communicate between the host and the target.
The RTEMS remote debugger will be composed by several tasks and exception
handlers :
@itemize @b
@item an initialization task which opens the sockets and runs the SUN RPC
server. This task will also connect the interrupt handlers and launch the communication
task
@item a communication task which receives the SUN RPC commands, executes
them and sends the result to the GDB client,
@item A debuggee event management task which waits for events. We need a different
task than the command management task in order to be able to still accept commands
while no event has yet occurred for the debuggee. An example could be a continue
command from GDB and then hitting to DEL key to see what is currently going
on on the target side because an expected breakpoint is not caught...
@item a debug exception handler which manages the hardware breakpoint and
single step exceptions (INT 1 on Intel x86),
@item a breakpoint exception handler which manages the software breakpoints
exceptions (INT 3 on Intel x86),
@item a default exception handler used to catch every possible errors make on the
target system,
@end itemize
@c XXX figure reference
@c XXX references to other sections
Figure @b{remote debugger tasks and handlers} represents these
different tasks and handlers. The synchronization between the different task
and exception handlers will be described below in the section
@b{Synchronization Among Tasks and Exception Handlers}.
Some open issues we have faced for a prototype implementation are described
in the section @b{Open Issues}. The temporary workaround we chose are described
in chapter @b{Workarounds for Open Issues in Prototype}.
@subsection The INITIALIZATION task
This is the task that must be executed at the boot phase of RTEMS.
It initializes the debug context. It must :
@itemize @b
@item open the UDP sockets,
@item run the SUN RPC server main loop,
@item create the COMMAND MANAGEMENT task,
@item connect the DEBUG EXCEPTION handler,
@item connect the SOFTWARE BREAKPOINT handler,
@item delete itself.
@end itemize
If an error occurs at any step of the execution, the connections established
before the error will be closed, before the initialization task deletes itself.
@subsection The COMMAND_MNGT task
This task is in charge of receiving the SUN RPC messages and executing
the associated commands. This task must have an important priority because it
must be executed each time a command message comes from the debugger. It must
be executed even if one or both exception handlers are executed. But the COMMAND
MANAGEMENT task must not block the TCP/IP module without which no message can
be received.
When not executing a command, this task is waiting for a SUN RPC message
on the primary port. This idle state blocks the task, so the other active tasks
can run. Once a message comes from Ethernet via the primary port, the COMMAND
MANAGEMENT task wakes up and receives the message which is a request from GDB.
This request is sent to the SUN RPC server code which extracts the command and
its arguments, executes it and, if needed, sends a result to GDB. After having
performed these actions, the task sleeps, waiting for another message.
A particular case is the reception of the ATTACH command : in this
case the COMMAND_MNGT task creates the EVENT_MNGT task described below before
going to wait on UDP socket again.
@subsection The EVENT_MNGT task
This task is in charge of managing events happening on the debuggee such as
breakpoint, exceptions. This task does a basic simple loop waiting for event
on a synchronization variable. It is waken up by exception handlers code. It
then signals GDB that an event occurred and then go sleeping again as further
requests will be processed by the COMMAND_MNGT task.
@subsection The DEBUG EXCEPTION handler
This handler is connected to the DEBUG exception (INT 1 on Intel ix86).
This exception is entered when :
@itemize @b
@item executing a single-step instruction,
@item hardware breakpoint condition is true,
@end itemize
These events will be treated by the debugger because they are the
primary event used when debugging a software for instruction stepping. In both
cases, the DEBUG EXCEPTION handler code is executed. Please note that the execution
context of the exception handler is the supervisor stack of the task that generated
the exception . This implies :
@itemize @b
@item We may sleep in this context,
@item We have as many possible execution context for the DEBUG EXCEPTION handler as
we need to,
@item When we enter the high level exception handler code, a normalized exception
context has been pushed on the system stack and a pointer to this context is
available as the first argument (cf c/src/exec/score/cpu/i386/cpu.c for more
details),
@end itemize
First the exception handler wakeup the EVENT_MNGT task. Then it will
cause the faulting thread to sleep on a synchronization object. As soon as GDB
receives the event notifying that the debuggee status has changed, it will start
sending requests to get the debuggee status (registers set, faulty task id,
...). These requests are handled by the COMMAND MANAGEMENT task. When this task
receive a PTRACE_CONT command it will resume the execution of the task that
caused the exception by doing a V on the synchronization object.
@subsection The BREAKPOINT EXCEPTION handler
This handler is connected to the BREAKPOINT exception (INT3 on Intel
Ix86). Each time the debugger wants to place a software breakpoint in the debuggee,
a debuggee opcode is temporarily replaced by an instruction causing BREAKPOINT
exception (the ``INT 3'' instruction on Intel ix86). When ``INT 3'' is executed,
the BREAKPOINT handler is executed. Otherwise, the exception processing is the
same than the one described in previous section.
@subsection Synchronization Among Tasks and Exception Handlers
The previous chapters have presented a simplified and static view of the various
tasks and exceptions handlers. This chapter is more focussed on synchronization
requirements about the various pieces of code executed when RGDBSD is operating.
@subsubsection Implicit Synchronization Using Task Priorities
This chapter is relevant on Uniprocessor System (UP) only. However, it will
also list the requirements for explicit synchronization on Multi-processor Systems
(MP). Below are the task priorities sorted by high priority. They are not supposed
to be equal :
@enumerate
@item Network Input Task. This is the highest priority task. This can be regarded
as a software interrupt task for FreeBSD code,
@item RGDBSD command task. As this task waits on UDP sockets, it shall not prevent
the previous task from running. As the main debug entry point, it should preempt
any other task in the system,
@item RGDBSD event task. This task should preempt any task but the two mentionned
before to signal a debug event to GDB. The command task shall be able to preempt
this task for emergency command such as DEL, or REBOOT,
@item Applications tasks (task we are able to debug),
@end enumerate
Using theses priorities eliminates the need for adding more synchronization
objects in the next section. My belief is that symmetric MP support will require
more important change in the RTEMS than RGDBSD itself like multiple scheduler
queues, task to processor binding for non symmetric IO, use a different implementation
for @emph{task_disable_preemption}, ...
@subsubsection Explicit Synchronization
This chapter will describe the synchronization variables that need to be implemented
in order to sequence debug events in a way that is compatible with what GDB
code expects. The root of the problem is that GDB code mainly expects that once
a debug event has occurred on the debuggee, the entire debuggee is frozen and
no other event will occur before the CONTINUE command is issued. This behavior
is hard to achieve in our case as once we hit a breakpoint, only the task that
hits the breakpoint will be asleep on a synchronization object. Other tasks
may hit other breakpoints while we are waiting commands from GDB generating
potential unexpected events. There is a solutions if RGDBSD itself use RTEMS
threads to fix this problem by creating a task that loops forever at a priority
superior to any debugged task but below RGDBSD task priorities. Unfortunately
this will not work for the case we use the nano-kernel implementation and we
think it is better to study synchronization problems now. We also expects that
multi-thread debug support hardening in GDB will remove some event serializations
requirements. Here is the list of synchronization variables we plan to use and
their usage. They are all regular semaphores. They are not binary semaphores
because the task that does V is not the task that has done the P.
@itemize @b
@item @emph{WakeUpEventTask} : used by exception handler code to wake up the EVENT_MNGT
task by doing a V operation on this object. When target code is running normally
the EVENT_MNGT task sleeps due to a P operation on this semaphore,
@item @emph{SerializeDebugEvent} : used to serialize events in a way compatible to
what GDB expects. Before doing a V operation on @emph{WakeUpEventTask,} the
exception handler does a P on this semaphore to be sure processing of another
exception is not in progress. Upon reception of a CONTINUE command, the COMMAND_MNGT
task will issue a V operation so that the exception code can wake up EVENT_MNGT
task using the mechanism described above,
@item @emph{RestartFromException} : (in fact one semaphore per task) used by exception
handling code to put a faulty task to sleep once it has generated an exception
by doing a P operation on this semaphore. In the case the exception was generated
due to a breakpoint, GDB command will modify back the BREAKPOINT opcode to the
original value before doing the CONTINUE command. This command will perform
a V on this semaphore. In the case it is a real non restartable exception (faulty
memory reference via invalid pointer for example), GDB will not allow to restart
the program avoiding any loop. So not special analysis of cause of exception
is foreseen as far as RGDBSD code is concerned,
@end itemize
@subsection Open Issues
Here are some problems we have faced while implementing our prototype :
@table @b
@item [Protected ReadMem/WriteMem (I1)]:
A GDB user can request to see the content
of a corrupted pointer. The request PEEK_DATA will be performed by the COMMAND_MNGT
task. It shall not enter the default exception handler set by RGDBSD or it will
cause a dead lock in the RGDBSD code. Replacing the default exception vector
before calling @b{readMem/writeMem} can be temporarily sufficient but :
@itemize @b
@item It will never work on MP system as it will rely on task priorities to insure
that other task will not cause exceptions while we have removed the default
exception handler,
@item This feature should not be usable in RGDBSD only but also by an embedded debugger
that may run without any task. It is also unavoidable in case of protected memory
and in this case no priority mechanism can be used,
@item In the case of using RGDBSD code on a dedicated nano kernel, this code will
be called from interrupt level and we need a way to be sure we can debug other
interrupts that may also cause exceptions,
@end itemize
@item [ATTACH Command Implementation (I2)]:
After the @emph{target rtems symbolic_ip_target_name}
command, the normal operation is to issue an @emph{attach lid} command where
@emph{lid} represents a valid execution context. For Unix this is a process
id, for other multi-tasking system this is the id of a thread. After the attach
command, GDB expects to be waken up in the same manner as it is for normal events.
Once waken up it expects to have a complete register context available and also
that the target task is in a stopped state and that it can restart it using
the regular CONTINUE command. In RTEMS there is a way to get force a thread
to become inactive via @emph{rtems_task_suspend} but no way to get the full
registers set for the thread. A partial context can be retrieved from the task
@emph{Registers} data structure. On the other hand, relying on @emph{rtems_task_suspend
will be a problem for the nano-kernel implementation.
@item [Stopping Target System (I3)]:
Allthough it might not be obvious, most of the
actions made by a GDB user assume the target is not running. If you modify a
variable via the @emph{set variable = value} command you expect that the value
is the one you have put when restarting. If a still running task modifies the
same value in the mean time, this may be false. On the other hand, stopping
all the tasks on the target system impose to have a very deep knowledge of the
system. Using an interrupt driven RGDBSD, may facilitate the implementation
on the nano-kernel.
@item [Getting Tasks Contexts (I4)]:
As previously mentionned there is no way to get
tasks execution contexts via the RTEMS API. This is needed when debugging for
example via this classical sequence :
@enumerate
@item @emph{(gdb) target rtems symbolic_ip_target_name}
@item @emph{(gdb) info threads <=} get a thread list on screen
@item @emph{(gdb)} @emph{attach thread_id} <= thread_id is one of the thread in
the list
@item @emph{(gdb) b a_function_of_interest }
@item @emph{(gdb) continue}
@item @emph{(gdb)} @emph{backtrace} <= print the call stack on the screen once we
have hit the breakpoint
@item @emph{(gdb) thread target another_thread_li <=} change implicit current thread
value for gdb commands
@item @emph{(gdb)} @emph{backtrace <=} should print the backtrace for the chosen thread
@end enumerate
In our execution model, we have a valid context only for the threads that hits
the breakpoint as it has been pushed by the exception handler code. The other
thread is still running and during the various RPC requesting memory access,
it even changes as the COMMAND_MNGT thread is going to sleep. So the backtrace
command will fail. We must find a way to make this work as it is very usefull
when debugging multi-threaded programs,
@item [Backtrace Stop convention (I5)]:
The backtrace command on RTEMS task does not
gracefully terminate as GDB does not find some backtrace termination condition
it expects.
@end table
@subsection Workarounds for Open Issues in Prototype
@table @b
@item [(I1)]:
Not implemented.We would rather like to work on the formalization of
per thread flags and global flags that are much more general than any kludge
we could implement,
@item [(I2)]:
We have tried two solutions in our prototype. The first one was to use
the @emph{idle} thread context contained in the @emph{Registers} task control
block field. The drawback of this solution was that we had to implement specific
code for the continue operation immediately following the attach command. We
then decided to create a dedicated task that will only exist during the attach
phase. This task will call the ``ENTER_RGDB'' exception. This call will execute
the Exception Handler that saves a valid context and that notifies a change
to GDB. After the first CONTINUE command from GDB, this task will continue its
execution and delete itself,
@item [(I3)]:
As explained above in the synchronization chapter, we choose to serialize
events in a way that makes GDB think the system is frozen,
@item [(I4)]:
As a temporary fix, we have called @emph{rtems_task_suspend} and used
the context switch contex for tasks that are unknown to RGDBSD,
@item [(I5)]:
Not Implemented yet. If I remember correctly, setting the frame pointer
to 0 at task initialization for CISC processor solves this problem (ebp = 0x0
on Intel or a6 = 0x0 on 680x0). This should be done in rtems_task_create function
in the path to really starts the task for the first time. The processor/system
specific stop condition can be found as macros in the GDB source tree.
@end table
@subsection Output of a Debug Session with the Prototype
@example
GNU gdb 4.17
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as --host=i686-pc-linux-gnu --target=i386-rtems".
Attaching remote machine across net...
Connected to net-test.
Now the "run" command will start a remote process.
Setting up the environment for debugging gdb.
(gdb) attach 1
Attaching program: /build-rtems/pc386/tests/debug.exe pid 1
0x230715 in enterRdbg ()
(gdb) info threads
There are 8 threads:
Id. Name Detached Suspended
134283273 Rini No No <= current target thread
0x230715 in enterRdbg ()
134283272 Evnt No No
_Thread_Dispatch () at /rtems/c/src/exec/score/src/thread.c:315
134283271 SPE2 No No
_Thread_Dispatch () at /rtems/c/src/exec/score/src/thread.c:315
134283270 SPE1 No No
_Thread_Handler () at /rtems/c/src/exec/score/src/thread.c:1107
134283269 RDBG No No
0x230715 in enterRdbg ()
134283268 SCrx No No
_Thread_Dispatch () at /rtems/c/src/exec/score/src/thread.c:315
134283267 SCtx No No
_Thread_Dispatch () at /rtems/c/src/exec/score/src/thread.c:315
134283266 ntwk No No
_Thread_Dispatch () at /rtems/c/src/exec/score/src/thread.c:315
(gdb) b init.c:89
Breakpoint 1 at 0x200180: file /rtems/c/src/tests/samples/debug/init.c, line 89.
(gdb) c
Continuing.
Thread 134283273 (Rini) has been deleted.
[Switching to Rtems thread 134283271 (Not suspended) ( <= current target thread )]
Breakpoint 1, example2 (argument=4) at /rtems/c/src/tests/samples/debug/init.c:89
89 tuto += tuti;
(gdb) s
90 if (print_enable2)
(gdb) c
Continuing.
Breakpoint 1, example2 (argument=4) at /rtems/c/src/tests/samples/debug/init.c:89
89 tuto += tuti;
(gdb) b init.c:66
Breakpoint 2 at 0x200128: file /rtems/c/src/tests/samples/debug/init.c, line 66.
(gdb) c
Continuing.
{Switching to Rtems thread 134283270 (Not suspended) ( <= current target thread )]
Breakpoint 2, example1 (argument=4) at /rtems/c/src/tests/samples/debug/init.c:66
66 toto += titi;
(gdb) c
Continuing.
[Switching to Rtems thread 134283271 (Not suspended) ( <= current target thread )]
Breakpoint 1, example2 (argument=4) at /rtems/c/src/tests/samples/debug/init.c:89
89 tuto += tuti;
(gdb) bt
#0 example2 (argument=4)
at /rtems/c/src/tests/samples/debug/init.c:89
#1 0xf0009bd0 in ?? ()
(gdb) thread target 134283270
thread 134283270 [SPE1], _Thread_Dispatch () at /rtems/c/src/exec/score/src/thread.c:315
315 executing = _Thread_Executing;
(gdb) c
Continuing.
Breakpoint 2, example1 (argument=4) at /rtems/c/src/tests/samples/debug/init.c:66
66 toto += titi;
(gdb) detach
Detaching program: /build-rtems/pc386/tests/debug.exe pid 1
Warning: the next command will be done localy! If you want to restart another remote
program, reuse the target command
(gdb)
@end example

8168
doc/rgdb_specs/garde.eps Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,214 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@c
@c $Id$
@c
@chapter A Rapid Tour of GDB Internals
To help the reader to understand what needs to be implemented, we
will present briefly how GDB works regardless if the target is local or remote.
A debugger is a tool which enables control of the execution of software on a
target system. In most of cases, the debugger connects to a target system, attaches
a process, inserts breakpoints and resumes execution. Then the normal execution
is completely events driven (process execution stopped due to a breakpoint,
process fault, single-step,...) coming from the debuggee. It can also directly
access some parts of the target processor context (registers, data memory, code
memory,...) and change their content. Native GDB debugger can just be seen as
special cases where the host and the target are on the same machine and GDB
can directly access the target system debug API.
In our case, the host and the target are not on the same machine and
an Ethernet link is used to communicate between the different machines. Because
GDB needs to be able to support various targets (including Unix core file, ...),
each action that needs to be performed on the debuggee is materialized by a
field of the following @emph{targets_op}s structure :
@example
struct target_ops
@{
char *to_shortname; /* Name this target type */
char *to_longname; /* Name for printing */
char *to_doc; /* Documentation. Does not include trailing
newline, and starts with a one-line descrip-
tion (probably similar to to_longname). */
void (*to_open) PARAMS ((char *, int));
void (*to_close) PARAMS ((int));
void (*to_attach) PARAMS ((char *, int));
void (*to_detach) PARAMS ((char *, int));
void (*to_resume) PARAMS ((int, int, enum target_signal));
int (*to_wait) PARAMS ((int, struct target_waitstatus *));
void (*to_fetch_registers) PARAMS ((int));
void (*to_store_registers) PARAMS ((int));
void (*to_prepare_to_store) PARAMS ((void));
/* Transfer LEN bytes of memory between GDB address MYADDR and
target address MEMADDR. If WRITE, transfer them to the target, else
transfer them from the target. TARGET is the target from which we
get this function.
Return value, N, is one of the following:
0 means that we can't handle this. If errno has been set, it is the
error which prevented us from doing it (FIXME: What about bfd_error?).
positive (call it N) means that we have transferred N bytes
starting at MEMADDR. We might be able to handle more bytes
beyond this length, but no promises.
negative (call its absolute value N) means that we cannot
transfer right at MEMADDR, but we could transfer at least
something at MEMADDR + N. */
int (*to_xfer_memory) PARAMS ((CORE_ADDR memaddr, char *myaddr,
int len, int write,
struct target_ops * target));
void (*to_files_info) PARAMS ((struct target_ops *));
int (*to_insert_breakpoint) PARAMS ((CORE_ADDR, char *));
int (*to_remove_breakpoint) PARAMS ((CORE_ADDR, char *));
void (*to_terminal_init) PARAMS ((void));
void (*to_terminal_inferior) PARAMS ((void));
void (*to_terminal_ours_for_output) PARAMS ((void));
void (*to_terminal_ours) PARAMS ((void));
void (*to_terminal_info) PARAMS ((char *, int));
void (*to_kill) PARAMS ((void));
void (*to_load) PARAMS ((char *, int));
int (*to_lookup_symbol) PARAMS ((char *, CORE_ADDR *));
void (*to_create_inferior) PARAMS ((char *, char *, char **));
void (*to_mourn_inferior) PARAMS ((void));
int (*to_can_run) PARAMS ((void));
void (*to_notice_signals) PARAMS ((int pid));
int (*to_thread_alive) PARAMS ((int pid));
void (*to_stop) PARAMS ((void));
enum strata to_stratum;
struct target_ops
*DONT_USE; /* formerly to_next */
int to_has_all_memory;
int to_has_memory;
int to_has_stack;
int to_has_registers;
int to_has_execution;
struct section_table
*to_sections;
struct section_table
*to_sections_end;
int to_magic;
/* Need sub-structure for target machine related rather than comm related? */
@};
@end example
This structure contains pointers to functions (in C++, this would
be called a virtual class). Each different target supported by GDB has its own
structure with the relevant implementation of the functions (some functions
may be not implemented). When a user connects GDB to a target via the ``target''
command, GDB points to the structure corresponding to this target. Then the
user can attache GDB to a specific task via the ``attach'' command. We have
therefore identified two steps to begin a remote debug session :
@enumerate
@item the choice of the target type (in our case RTEMS),
@item the choice of what to debug (entire system, specific task,...),
@end enumerate
Note that in the case of natives debugger, the choice of the target is implicitly
performed by commands like @b{run}, @b{attach}, @b{detach}. Several
figures will now be described showing the main steps of a debug session.
@C XXX figure reference
Figure @b{Debug session initialization} explains how the debugger connects to the target
:
@enumerate
@item The debugger opens a connection to the target. The word ``connection''
doesn't only mean Ethernet or serial link connection but all the ways by which
a process can communicate with another one (direct function call, messages mailbox,
...),
@item The targets checks if it can accept or reject this connection,
@item If the connection is accepted, the host ``attaches'' the process,
@item the target stops the process, notifies a child's stop to the host
and waits for command,
@item the host can ask information about the debugged process (name, registers,...)
or perform some action like setting breakpoints, ...
@end enumerate
@C XXX figure reference
Figure @b{Breakpoint and process execution} explains how the debugger manages the
breakpoints and controls the execution of a process :
@enumerate
@item The host asks the debuggee what is the opcode at the concerned address
in order for GDB to memorize this instruction,
@item the host sends a CONTINUE command : it asks the target to write the
``DEBUG'' opcode (for example, the INTEL ``DEBUG'' opcode is INT3 which
generate a breakpoint trap) instead of the debugged opcode.
@item then the host waits for events,
@item after the change of instruction, the target resumes the execution
of the debuggee,
@item when the ``DEBUG'' opcode is executed, the breakpoint exception
handler is executed and it notifies the host that the process is stopped. Then
it waits for commands (if no command is sent after a certain amount of time,
the connection will be closed by the target).
@item the host asks the target to re-write the right opcode instead of the
''DEBUG'' opcode and then can ask information
@end enumerate
@C XXX figure reference
Figure @b{Breakpoint and process execution} also shows the case of other ``CONTINUE''
commands (remember that the ``DEBUG'' opcode has been replaced by the right
instruction):
@enumerate
@item Host sends first a ``single step'' command to execute the debugged
instruction,
@item It then waits for ``single step`` exception event,
@item the target, once the single step executed, calls the debug exception
handler. It notifies the host that execution is suspended and wait for commands.
@item the host asks the target to re-write the ``DEBUG'' opcode (breakpoint
trap) instead of the debugged one.
@item then the host sends a ``CONTINUE'' command in order the target to
resume the process execution to the next breakpoint.
@end enumerate
@C XXX figure reference
Figure @b{Detach a process and close a connection} explains how the debugger disconnects from
a target :
@enumerate
@item the host sends a detach command to the target.
@item the target detaches the concerned process, notifies the detachment
and resumes the process execution.
@item once notified, the host sends a close connection command.
@item the target closes the connection.
@end enumerate
These 3 examples show that the mains actions that are performed by
the host debugger on the target are only simple actions which look like :
@itemize @b
@item read/write code,
@item read/write data,
@item read/write registers,
@item manage exceptions,
@item send/receive messages to/from the host.
@end itemize
@example
XXX Figure seg_init.eps
XXX Debug session initialization
@end example
@example
XXX Figure seq_break.eps
XXX Breakpoint and process execution
@end example
@example
XXX Figure seq_detach.eps
XXX Detach a process and close a connection
@end example

View File

@@ -0,0 +1,79 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@c
@c $Id$
@c
@chapter Interfacing GDB with RTEMS as a Target
@C XXX figure reference
So, basically, porting GDB to RTEMS environment requires implementing
the functions contained in the target_ops structure. The native debugger implementation
(where the host machine is also the target one) uses direct function calls.
For our needs (remote debugging), these functions must be implemented to support
the encapsulation in UDP/IP layers and communications between different types
of host machines : the best solution is use the SUN Remote Procedure Calls API
(SUN RPC). This SUN RPC module will be explained below (see paragraph @b{Communication with GDB}).
We can note that the functions described in the target_ops structure
are high-level functions. The main reason is that GDB was designed in order
to be able to use monitor firmware as a debug server. In the case of a Unix
OS target, these high-level functions are implemented themselves using a lower
level POSIX API. Because we want to simplify the code running on the target
and decrease its size of this code, we propose to use the POSIX layer API used
for the debug like @b{waitpid}, @b{ptrace}, ... Due to the GDB working
mode and due to our requirements, we can establish here a non-exhaustive list
of some commands required to implement the previously described functions :
@itemize @b
@item set up a connection with a target,
@item close a connection,
@item send a signal to the specified process,
@item get a list of process/thread/connection running,
@item control process under debug,
@item ...
@end itemize
Control means that, with this function, we can read, write the memory
of the debuggee, insert breakpoint to stop the process and resume the process
execution. This command can be implemented by emulating in the RTEMS environment
a Unix function called ``ptrace''. This function allows the control of a child
process. The ``ptrace'' function has some sub-functions which are described
below (some of these actions and standardized, the others are added due to our
needs) :
@itemize @b
@item PTRACE_PEEKTEXT, PTRACE_PEEKDATA : read word at address,
@item PTRACE_POKETEXT, PTRACE_POKEDATA :write word at address,
@item PTRACE_CONT : restart after signal,
@item PTRACE_KILL : send the child a SIGKILL to make it exit,
@item PTRACE_SINGLESTEP : set the trap flag for single stepping,
@item PTRACE_ATTACH : attach to the process specified,
@item PTRACE_DETACH : detach a process that was previously attached.
@end itemize
This list only contains the command that are described in the ptrace
Unix manpage. For some specific needs (debug of one task among several ones,
register read/write,...), it is possible to create some special ptrace commands
as described after :
@itemize @b
@item get current task registers,
@item set current task registers,
@item list of the threads,
@item identifier of the target thread,
@item restart to address,
@item set breakpoint at address,
@item clear breakpoint,
@item get breakpoints,
@item load dynamically a task,
@item ...
@end itemize
This list is not exhaustive and can be increased due to the needs.
All the described functions will not be implemented in a first version, only
the strictly needed. If some commands are added, the modifications must be implemented
both in RTEMS and in GDB.

39
doc/rgdb_specs/intro.t Normal file
View File

@@ -0,0 +1,39 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@c
@c $Id$
@c
@chapter Introduction
The TOOLS project aims to provide a complete development environment
for RTEMS OS. This environment must be as close as possible to the Chorus one
(gnu compiler, gnu linker, gnu debugger, ...), because it is currently the OS
which is the most used at CRF and we want to simplify the migration path from
the ChorusOs environment to the RTEMS environment. One important item of this
development environment is the remote debugger which allows the developer to
debug his software on a target machine from a host machine via a communication
link (Ethernet, serial link, ...).
The choice of GDB as debugger has been made with because in CRF, every
developer, which uses the ChorusOs development environment, debugs his software
using the remote debugging functionality of GDB. Providing a remote GDB debug
server running on RTEMS, will enable the developers to use transparently the
same debugger for a different RTOS. Another reason for the choice of GDB is
its constant evolution, and that it can be interfaced with graphic user interfaces
like DDD providing a very powerfull debugging environment.
The subject of this document is to explain how GDB works and the way
to implement a daemon on RTEMS that will be used as a debugger server for a
GDB client. We will call this daemon Rtems GDB Debug Server Daemon (RGDBSD).
We aim to provide this debugger running at least on 2 host systems : Linux 2.x
and Solaris 2.5.1 as they are the two platforms used for developing Chorus applications
today.

359
doc/rgdb_specs/layers.eps Normal file
View File

@@ -0,0 +1,359 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: layers.eps
%%Creator: fig2dev Version 3.2 Patchlevel 0-beta3
%%CreationDate: Mon Oct 5 16:01:44 1998
%%For: raguet@genesis (Emmanuel Raguet)
%%Orientation: Portrait
%%BoundingBox: 0 0 445 609
%%Pages: 0
%%BeginSetup
%%EndSetup
%%Magnification: 1.0000
%%EndComments
/$F2psDict 200 dict def
$F2psDict begin
$F2psDict /mtrx matrix put
/col-1 {0 setgray} bind def
/col0 {0.000 0.000 0.000 srgb} bind def
/col1 {0.000 0.000 1.000 srgb} bind def
/col2 {0.000 1.000 0.000 srgb} bind def
/col3 {0.000 1.000 1.000 srgb} bind def
/col4 {1.000 0.000 0.000 srgb} bind def
/col5 {1.000 0.000 1.000 srgb} bind def
/col6 {1.000 1.000 0.000 srgb} bind def
/col7 {1.000 1.000 1.000 srgb} bind def
/col8 {0.000 0.000 0.560 srgb} bind def
/col9 {0.000 0.000 0.690 srgb} bind def
/col10 {0.000 0.000 0.820 srgb} bind def
/col11 {0.530 0.810 1.000 srgb} bind def
/col12 {0.000 0.560 0.000 srgb} bind def
/col13 {0.000 0.690 0.000 srgb} bind def
/col14 {0.000 0.820 0.000 srgb} bind def
/col15 {0.000 0.560 0.560 srgb} bind def
/col16 {0.000 0.690 0.690 srgb} bind def
/col17 {0.000 0.820 0.820 srgb} bind def
/col18 {0.560 0.000 0.000 srgb} bind def
/col19 {0.690 0.000 0.000 srgb} bind def
/col20 {0.820 0.000 0.000 srgb} bind def
/col21 {0.560 0.000 0.560 srgb} bind def
/col22 {0.690 0.000 0.690 srgb} bind def
/col23 {0.820 0.000 0.820 srgb} bind def
/col24 {0.500 0.190 0.000 srgb} bind def
/col25 {0.630 0.250 0.000 srgb} bind def
/col26 {0.750 0.380 0.000 srgb} bind def
/col27 {1.000 0.500 0.500 srgb} bind def
/col28 {1.000 0.630 0.630 srgb} bind def
/col29 {1.000 0.750 0.750 srgb} bind def
/col30 {1.000 0.880 0.880 srgb} bind def
/col31 {1.000 0.840 0.000 srgb} bind def
end
save
-51.0 635.0 translate
1 -1 scale
/cp {closepath} bind def
/ef {eofill} bind def
/gr {grestore} bind def
/gs {gsave} bind def
/sa {save} bind def
/rs {restore} bind def
/l {lineto} bind def
/m {moveto} bind def
/rm {rmoveto} bind def
/n {newpath} bind def
/s {stroke} bind def
/sh {show} bind def
/slc {setlinecap} bind def
/slj {setlinejoin} bind def
/slw {setlinewidth} bind def
/srgb {setrgbcolor} bind def
/rot {rotate} bind def
/sc {scale} bind def
/sd {setdash} bind def
/ff {findfont} bind def
/sf {setfont} bind def
/scf {scalefont} bind def
/sw {stringwidth} bind def
/tr {translate} bind def
/tnt {dup dup currentrgbcolor
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
bind def
/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
4 -2 roll mul srgb} bind def
/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
/$F2psEnd {$F2psEnteredState restore end} def
%%EndProlog
$F2psBegin
10 setmiterlimit
n -1000 11576 m -1000 -1000 l 9251 -1000 l 9251 11576 l cp clip
0.06000 0.06000 sc
% Polyline
7.500 slw
[60] 0 sd
gs clippath
4530 2904 m 4500 3048 l 4470 2904 l 4470 3090 l 4530 3090 l cp
clip
n 5325 2100 m 5324 2101 l 5321 2104 l 5313 2111 l 5302 2121 l 5290 2133 l
5278 2143 l 5267 2153 l 5257 2161 l 5248 2168 l 5238 2175 l
5229 2181 l 5219 2187 l 5209 2193 l 5198 2199 l 5186 2205 l
5173 2211 l 5161 2216 l 5148 2222 l 5135 2227 l 5123 2231 l
5112 2234 l 5100 2238 l 5088 2240 l 5077 2242 l 5064 2244 l
5051 2246 l 5037 2247 l 5023 2248 l 5009 2249 l 4994 2249 l
4980 2250 l 4966 2250 l 4952 2250 l 4938 2250 l 4923 2250 l
4908 2250 l 4891 2250 l 4874 2250 l 4857 2250 l 4839 2250 l
4822 2250 l 4805 2250 l 4790 2250 l 4775 2250 l 4762 2250 l
4750 2250 l 4737 2250 l 4724 2250 l 4712 2250 l 4701 2251 l
4689 2252 l 4678 2253 l 4668 2255 l 4658 2257 l 4648 2259 l
4638 2263 l 4627 2266 l 4615 2271 l 4603 2277 l 4590 2283 l
4577 2291 l 4564 2299 l 4552 2308 l 4542 2318 l 4533 2327 l
4525 2338 l 4520 2345 l 4516 2353 l 4513 2363 l 4510 2373 l
4507 2385 l 4505 2398 l 4503 2412 l 4502 2428 l 4501 2445 l
4501 2464 l 4500 2483 l 4500 2504 l 4500 2526 l 4500 2550 l
4500 2566 l 4500 2583 l 4500 2602 l 4500 2622 l 4500 2644 l
4500 2668 l 4500 2695 l 4500 2724 l 4500 2756 l 4500 2790 l
4500 2826 l 4500 2864 l 4500 2903 l 4500 2940 l 4500 2975 l
4500 3006 l 4500 3032 l 4500 3075 l gs col0 s gr gr
[] 0 sd
% arrowhead
n 4530 2904 m 4500 3048 l 4470 2904 l 4500 2928 l 4530 2904 l cp gs 0.00 setgray ef gr col0 s
% Polyline
[60] 0 sd
gs clippath
6180 2904 m 6150 3048 l 6120 2904 l 6120 3090 l 6180 3090 l cp
clip
n 5325 2100 m 5326 2101 l 5329 2104 l 5337 2111 l 5348 2121 l 5360 2133 l
5372 2143 l 5383 2153 l 5393 2161 l 5402 2168 l 5413 2175 l
5421 2181 l 5431 2187 l 5441 2193 l 5452 2199 l 5464 2205 l
5477 2211 l 5489 2216 l 5502 2222 l 5515 2227 l 5527 2231 l
5538 2234 l 5550 2238 l 5562 2240 l 5573 2242 l 5586 2244 l
5599 2246 l 5613 2247 l 5627 2248 l 5641 2249 l 5656 2249 l
5670 2250 l 5684 2250 l 5698 2250 l 5713 2250 l 5727 2250 l
5742 2250 l 5759 2250 l 5776 2250 l 5793 2250 l 5811 2250 l
5828 2250 l 5845 2250 l 5860 2250 l 5875 2250 l 5888 2250 l
5900 2250 l 5913 2250 l 5926 2250 l 5938 2250 l 5949 2251 l
5961 2252 l 5972 2253 l 5982 2255 l 5992 2257 l 6002 2259 l
6013 2263 l 6023 2266 l 6035 2271 l 6047 2277 l 6060 2283 l
6073 2291 l 6086 2299 l 6098 2308 l 6108 2318 l 6117 2327 l
6125 2338 l 6130 2345 l 6134 2353 l 6137 2363 l 6140 2373 l
6143 2385 l 6145 2398 l 6147 2412 l 6148 2428 l 6149 2445 l
6149 2464 l 6150 2483 l 6150 2504 l 6150 2526 l 6150 2550 l
6150 2566 l 6150 2583 l 6150 2602 l 6150 2622 l 6150 2644 l
6150 2668 l 6150 2695 l 6150 2724 l 6150 2756 l 6150 2790 l
6150 2826 l 6150 2864 l 6150 2903 l 6150 2940 l 6150 2975 l
6150 3006 l 6150 3032 l 6150 3075 l gs col0 s gr gr
[] 0 sd
% arrowhead
n 6180 2904 m 6150 3048 l 6120 2904 l 6150 2928 l 6180 2904 l cp gs 0.00 setgray ef gr col0 s
% Polyline
n 2614 5738 m 2615 5737 l 2619 5734 l 2628 5727 l 2642 5715 l 2659 5700 l
2676 5685 l 2693 5670 l 2707 5656 l 2719 5644 l 2730 5632 l
2738 5620 l 2746 5609 l 2752 5599 l 2758 5588 l 2763 5576 l
2769 5563 l 2774 5550 l 2779 5535 l 2783 5520 l 2787 5504 l
2791 5487 l 2795 5470 l 2798 5453 l 2801 5436 l 2804 5418 l
2807 5400 l 2809 5385 l 2811 5370 l 2814 5353 l 2816 5336 l
2818 5318 l 2821 5299 l 2823 5279 l 2825 5259 l 2828 5238 l
2830 5217 l 2832 5196 l 2834 5174 l 2836 5153 l 2837 5133 l
2839 5112 l 2840 5092 l 2842 5073 l 2843 5054 l 2844 5036 l
2845 5019 l 2845 5001 l 2846 4982 l 2847 4963 l 2847 4944 l
2848 4924 l 2848 4903 l 2849 4882 l 2849 4860 l 2849 4838 l
2849 4816 l 2850 4794 l 2850 4773 l 2850 4751 l 2850 4729 l
2850 4708 l 2850 4686 l 2850 4665 l 2850 4644 l 2850 4622 l
2850 4599 l 2850 4576 l 2850 4552 l 2850 4527 l 2850 4501 l
2850 4475 l 2850 4449 l 2850 4422 l 2850 4395 l 2850 4369 l
2850 4343 l 2850 4318 l 2850 4293 l 2850 4270 l 2850 4248 l
2850 4227 l 2850 4207 l 2850 4188 l 2850 4170 l 2850 4149 l
2850 4129 l 2850 4109 l 2850 4090 l 2850 4072 l 2851 4054 l
2851 4036 l 2852 4019 l 2852 4003 l 2853 3987 l 2854 3972 l
2856 3957 l 2857 3943 l 2859 3930 l 2860 3917 l 2863 3904 l
2865 3888 l 2868 3872 l 2872 3855 l 2875 3838 l 2880 3820 l
2884 3801 l 2889 3783 l 2894 3765 l 2900 3748 l 2905 3731 l
2910 3716 l 2915 3702 l 2920 3690 l 2925 3678 l 2932 3664 l
2939 3651 l 2947 3638 l 2955 3627 l 2964 3618 l 2974 3609 l
2983 3601 l 2993 3594 l 3002 3589 l 3013 3583 l 3021 3579 l
3031 3574 l 3042 3569 l 3055 3563 l 3070 3557 l 3087 3550 l
3105 3543 l 3122 3536 l 3136 3531 l 3145 3527 l 3149 3525 l
3150 3525 l gs col0 s gr
% Polyline
n 2614 5735 m 2615 5736 l 2619 5739 l 2628 5746 l 2642 5758 l 2659 5772 l
2676 5788 l 2693 5803 l 2707 5816 l 2719 5829 l 2730 5840 l
2738 5852 l 2746 5863 l 2752 5874 l 2758 5884 l 2763 5896 l
2769 5909 l 2774 5922 l 2779 5937 l 2783 5952 l 2787 5968 l
2791 5985 l 2795 6002 l 2798 6019 l 2801 6036 l 2804 6054 l
2807 6072 l 2809 6087 l 2811 6102 l 2814 6119 l 2816 6136 l
2818 6154 l 2821 6173 l 2823 6193 l 2825 6213 l 2828 6234 l
2830 6255 l 2832 6276 l 2834 6298 l 2836 6319 l 2837 6339 l
2839 6360 l 2840 6380 l 2842 6399 l 2843 6418 l 2844 6436 l
2845 6453 l 2845 6471 l 2846 6490 l 2847 6509 l 2847 6528 l
2848 6548 l 2848 6569 l 2849 6590 l 2849 6612 l 2849 6634 l
2849 6656 l 2850 6678 l 2850 6699 l 2850 6721 l 2850 6743 l
2850 6764 l 2850 6786 l 2850 6807 l 2850 6829 l 2850 6850 l
2850 6873 l 2850 6896 l 2850 6920 l 2850 6945 l 2850 6971 l
2850 6997 l 2850 7023 l 2850 7050 l 2850 7077 l 2850 7103 l
2850 7129 l 2850 7154 l 2850 7179 l 2850 7202 l 2850 7224 l
2850 7245 l 2850 7265 l 2850 7284 l 2850 7302 l 2850 7323 l
2850 7343 l 2850 7363 l 2850 7382 l 2850 7400 l 2851 7418 l
2851 7436 l 2852 7453 l 2852 7469 l 2853 7485 l 2854 7500 l
2856 7515 l 2857 7529 l 2859 7542 l 2860 7555 l 2863 7569 l
2865 7584 l 2868 7600 l 2872 7617 l 2875 7635 l 2880 7653 l
2884 7671 l 2889 7689 l 2894 7707 l 2900 7725 l 2905 7741 l
2910 7756 l 2915 7770 l 2920 7783 l 2925 7795 l 2932 7809 l
2939 7822 l 2947 7834 l 2955 7845 l 2964 7855 l 2974 7864 l
2983 7871 l 2993 7878 l 3002 7884 l 3013 7889 l 3021 7893 l
3031 7898 l 3042 7903 l 3055 7909 l 3070 7915 l 3087 7922 l
3105 7929 l 3122 7936 l 3136 7941 l 3145 7945 l 3149 7947 l
3150 7947 l gs col0 s gr
% Polyline
n 3930 8325 m 3825 8325 3825 9345 105 arcto 4 {pop} repeat
3825 9450 6720 9450 105 arcto 4 {pop} repeat
6825 9450 6825 8430 105 arcto 4 {pop} repeat
6825 8325 3930 8325 105 arcto 4 {pop} repeat
cp gs col0 s gr
% Polyline
gs clippath
5295 8046 m 5325 7902 l 5355 8046 l 5355 7860 l 5295 7860 l cp
5355 8154 m 5325 8298 l 5295 8154 l 5295 8340 l 5355 8340 l cp
clip
n 5325 8325 m 5325 7875 l gs col0 s gr gr
% arrowhead
n 5355 8154 m 5325 8298 l 5295 8154 l 5325 8178 l 5355 8154 l cp gs 0.00 setgray ef gr col0 s
% arrowhead
n 5295 8046 m 5325 7902 l 5355 8046 l 5325 8022 l 5295 8046 l cp gs 0.00 setgray ef gr col0 s
% Polyline
n 3930 6750 m 3825 6750 3825 7770 105 arcto 4 {pop} repeat
3825 7875 6720 7875 105 arcto 4 {pop} repeat
6825 7875 6825 6855 105 arcto 4 {pop} repeat
6825 6750 3930 6750 105 arcto 4 {pop} repeat
cp gs col0 s gr
% Polyline
gs clippath
5295 6471 m 5325 6327 l 5355 6471 l 5355 6285 l 5295 6285 l cp
5355 6579 m 5325 6723 l 5295 6579 l 5295 6765 l 5355 6765 l cp
clip
n 5325 6750 m 5325 6300 l gs col0 s gr gr
% arrowhead
n 5355 6579 m 5325 6723 l 5295 6579 l 5325 6603 l 5355 6579 l cp gs 0.00 setgray ef gr col0 s
% arrowhead
n 5295 6471 m 5325 6327 l 5355 6471 l 5325 6447 l 5295 6471 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5295 4896 m 5325 4752 l 5355 4896 l 5355 4710 l 5295 4710 l cp
5355 5004 m 5325 5148 l 5295 5004 l 5295 5190 l 5355 5190 l cp
clip
n 5325 5175 m 5325 4725 l gs col0 s gr gr
% arrowhead
n 5355 5004 m 5325 5148 l 5295 5004 l 5325 5028 l 5355 5004 l cp gs 0.00 setgray ef gr col0 s
% arrowhead
n 5295 4896 m 5325 4752 l 5355 4896 l 5325 4872 l 5295 4896 l cp gs 0.00 setgray ef gr col0 s
% Polyline
n 3930 3600 m 3825 3600 3825 4620 105 arcto 4 {pop} repeat
3825 4725 6720 4725 105 arcto 4 {pop} repeat
6825 4725 6825 3705 105 arcto 4 {pop} repeat
6825 3600 3930 3600 105 arcto 4 {pop} repeat
cp gs col0 s gr
% Polyline
gs clippath
4470 3321 m 4500 3177 l 4530 3321 l 4530 3135 l 4470 3135 l cp
4530 3429 m 4500 3573 l 4470 3429 l 4470 3615 l 4530 3615 l cp
clip
n 4500 3600 m 4500 3150 l gs col0 s gr gr
% arrowhead
n 4530 3429 m 4500 3573 l 4470 3429 l 4500 3453 l 4530 3429 l cp gs 0.00 setgray ef gr col0 s
% arrowhead
n 4470 3321 m 4500 3177 l 4530 3321 l 4500 3297 l 4470 3321 l cp gs 0.00 setgray ef gr col0 s
% Polyline
n 3930 2025 m 3825 2025 3825 3045 105 arcto 4 {pop} repeat
3825 3150 6720 3150 105 arcto 4 {pop} repeat
6825 3150 6825 2130 105 arcto 4 {pop} repeat
6825 2025 3930 2025 105 arcto 4 {pop} repeat
cp gs col0 s gr
% Polyline
gs clippath
5295 1746 m 5325 1602 l 5355 1746 l 5355 1560 l 5295 1560 l cp
5355 1854 m 5325 1998 l 5295 1854 l 5295 2040 l 5355 2040 l cp
clip
n 5325 2025 m 5325 1575 l gs col0 s gr gr
% arrowhead
n 5355 1854 m 5325 1998 l 5295 1854 l 5325 1878 l 5355 1854 l cp gs 0.00 setgray ef gr col0 s
% arrowhead
n 5295 1746 m 5325 1602 l 5355 1746 l 5325 1722 l 5295 1746 l cp gs 0.00 setgray ef gr col0 s
% Polyline
n 3930 450 m 3825 450 3825 1470 105 arcto 4 {pop} repeat
3825 1575 6720 1575 105 arcto 4 {pop} repeat
6825 1575 6825 555 105 arcto 4 {pop} repeat
6825 450 3930 450 105 arcto 4 {pop} repeat
cp gs col0 s gr
% Polyline
gs clippath
6120 3321 m 6150 3177 l 6180 3321 l 6180 3135 l 6120 3135 l cp
6180 3429 m 6150 3573 l 6120 3429 l 6120 3615 l 6180 3615 l cp
clip
n 6150 3600 m 6150 3150 l gs col0 s gr gr
% arrowhead
n 6180 3429 m 6150 3573 l 6120 3429 l 6150 3453 l 6180 3429 l cp gs 0.00 setgray ef gr col0 s
% arrowhead
n 6120 3321 m 6150 3177 l 6180 3321 l 6150 3297 l 6120 3321 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5364 10069 m 5263 10176 l 5312 10038 l 5217 10197 l 5268 10228 l cp
5211 9581 m 5311 9473 l 5263 9612 l 5358 9453 l 5307 9422 l cp
clip
n 5325 9450 m 5100 9825 l 5475 9825 l 5250 10200 l gs col0 s gr gr
% arrowhead
n 5211 9581 m 5311 9473 l 5263 9612 l 5249 9576 l 5211 9581 l cp gs 0.00 setgray ef gr col0 s
% arrowhead
n 5364 10069 m 5263 10176 l 5312 10038 l 5326 10074 l 5364 10069 l cp gs 0.00 setgray ef gr col0 s
% Polyline
n 3930 5175 m 3825 5175 3825 6195 105 arcto 4 {pop} repeat
3825 6300 6720 6300 105 arcto 4 {pop} repeat
6825 6300 6825 5280 105 arcto 4 {pop} repeat
6825 5175 3930 5175 105 arcto 4 {pop} repeat
cp gs col0 s gr
/Times-Roman ff 300.00 scf sf
5325 7500 m
gs 1 -1 sc (IP Protocol) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
5325 9150 m
gs 1 -1 sc (drivers) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
5325 5775 m
gs 1 -1 sc (UDP Protocol) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
5250 4200 m
gs 1 -1 sc (BSD Sockets) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
5325 1050 m
gs 1 -1 sc (Remote Debugger) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
5325 8850 m
gs 1 -1 sc (Ethernet / serial link / ...) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
1650 6075 m
gs 1 -1 sc (TCP/IP stack) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
1575 5775 m
gs 1 -1 sc (FreeBSD) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
5325 10500 m
gs 1 -1 sc (Physical link) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 225.00 scf sf
7275 3450 m
gs 1 -1 sc (secondary port \(2010\)) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 225.00 scf sf
3525 3450 m
gs 1 -1 sc (primary port \(2000\)) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
5325 2700 m
gs 1 -1 sc (SUN RPC Server) dup sw pop 2 div neg 0 rm col0 sh gr
$F2psEnd
rs

307
doc/rgdb_specs/objectives.t Normal file
View File

@@ -0,0 +1,307 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@c
@c $Id$
@c
@chapter Objectives
@C XXX reference
This section is intended to clearly define the current objectives of our work.
First, we will try here to list some ambitious requirements for the debugger
in section @b{List of Requirements}. These requirements will deliberately be much more
ambitious than what we will provide directly ourselves in the hope that the
Internet development model will enable others to implement some features we
rejected for man-power reasons in the first step. We are committed to do the
core work and redistribute it but would appreciate any comment and enhancement.
Then, in section @b{Requirements Analysis} we will analyze each requirement to see
what technical problem must be solved if we want to fullfill it. After this
analysis, we will determine in section @b{Requirements Selection} the requirements we
chose to implement and the ones we will not. We will then clearly identify the
limits of our solution in section @b{Implied Restrictions}.
@subsection List of Requirements
We will identify here possible requirements for the type of debug that may be
provided :
@table @b
@item [(R1)]:
We want to use GDB as the front-end debugger,
@item [(R2)]:
We want to support at least Intel and PowerPC as target processor architecture,
@item [(R3)]:
We want to use the GDB thread debugging interface,
@item [(R4)]:
We want to be able to debug a remote target over a serial line,
@item [(R5)]:
We want to be able to debug a remote target over Ethernet,
@item [(R6)]:
The set of target code path we will be able to debug using RGDBSD must
be clearly identified. It will be called Debug Path Set (@emph{DPS}) in the
remaining of this document,
@item [(R7)]:
@emph{DPS} must include the RTEMS core executive itself,
@item [(R8)]:
@emph{DPS} must include the FreeBSD stack,
@item [(R9)]:
@emph{DPS} must include anything but the FreeBSD stack and the RTEMS
core executive,
@item [(R10)]:
We want to enable several persons to debug different parts of the code
running on the target,
@item [(R11)]:
As much as possible the system must be frozen during a debug session
so that debugging a particular portion of code does not prevent another part
from functioning,
@end table
@subsection Requirements Analysis
@table @b
@item [(R1)]:
Worth recalling it. It mainly imposes few restrictions on the binary
files type, target processor type as :
@itemize @b
@item the binary format must be understood by GDB (to find debugging information).
Elf, Coff and A.out are the main formats currently supported. Elf/Dwarf 2.0
binary support will be our main target as they are the preferred format for
Intel and PowerPC processors. No change in GDB will be required for other binaries
except may be a new configuration file changing the binary/debug file format,
@item the processor must be supported for disassemble/step instruction command,
@item the target system must be supported. As far as I know RTEMS is not currently
@emph{officially} supported anyway,
@end itemize
@item [(R2)]:
Our primary targets are Intel and PowerPC. We however do not think implementing
RGDBSD for other processors will be a heavy task. It will mainly require :
@enumerate
@item Implementing exception handling for the target processor,
@item Interfacing the generic part of RGDBSD with the low level exception handling
and make RGDBSD aware of exception used for debugging (usually illegal instruction
or dedicated trap, single step),
@item Making GDB aware of the frame layout pushed on exceptions,
@item Implement the code for data transfer for the exception frame,
@item Implement code to copy data cache back to main memory and invalidate instruction
cache. This is needed in order to be sure opcode modification used to set breakpoint
that use the data cache will be proagated to the instruction cache,
@end enumerate
As soon as we will have completed the first core work a document describing
how to port it to a new processor should be written. So far we will organize
the source tree with processor dependent directories so that port will be as
easy as possible. May be a bare processor support should be created,
@item [(R3)]:
GDB already has an interface for manipulating multi-threaded programs.
This interface is rather weak at the moment but it will certainly be improved
in the future with the generalization of POSIX thread API on Linux and other
operating systems. This implies that either GDB or RGDBSD is able to obtain
the list of threads currently executing. The choice of implementing this in
GDB or RGDBSD is a tradeof between target code size and simplicity,
@item [(R4)]:
Regular GDB code contains clients code for debugging over a serial line.
However only few functions are implemented. We would like to provide a better
support and to uniformize serial line debugging with debugging over Ethernet
via the use of SLIP,
@item [(R5)]:
Regular GDB code contains client code for debugging over Ethernet for
VxWorks via the SUN RPC library. So there will be at least one starting point
to implement remote debugging over Ethernet via SUN RPC. The Chorus remote debugging
code has been disclosed under GPL and also contains code for debugging suing
SUN RPC,
@item [(R6)]:
Due to a classical chicken and egg problems, the remote debugging daemon
cannot be used to debug code it uses to function. Thus depending on the API
used by RGDBSD, some parts of the target system will not be debuggable via GDB.
The most important point is documentation because my feeling is that implementing
RGDBSD on a totally different @emph{dedicated} nano kernel should be possible,
@item [(R7)]:
RTEMS core executive is a real-time OS which implements priority level
scheduling, synchronization objects, and interrupt handling. As mentioned in
previous item, we may not debug theses features if RGDBSD uses them. This requirement
is thus very strong because it impose that :
@enumerate
@item RGDBSD is totally interrupt driven (no thread API available),
@item But it does not use RTEMS interrupt management,
@item Nor does not use RTEMS exception management,
@item RGDBSD must provide its own UDP/IP stack as the current FreeBSD code rely on
tasks switching and RTEMS provided synchronization object for input path handling,
@end enumerate
So our feeling is that the @b{(R7)} more or less requires to write a @emph{dedicated}
nano kernel with a very small dedicated UDP/IP stack.
@item [(R8)]:
GDB remote debugging over Ethernet code communicates with the remote
target via the SUN RPC protocol. This requires a UDP/IP protocol and a minimal
socket like interface. In RTEMS environment, this feature is currently provided
by the FreeBSD stack. Again, if we use the FreeBSD stack itself for remote communication,
it will be impossible to debug this stack as a breakpoint in the stack code
will stop its execution and there would be no more way to communicate with the
target. A solution consists in implementing a minimal, dedicated UDP/IP stack
(with at least IP and UDP protocols, a minimal BSD sockets) and a simple SUN
RPC library, which will be both dedicated to the debug. We can use RTEMS API
to implement it if @b{(R7)} is not required. As the two stack will need
to share the same chip, a kind of shared filter must be implemented at the bottom
of the two stacks so that Ethernet frames can be dynamically directed either
to the dedicated UDP/IP debug stack or to the regular FreeBSD stack. The fact
that in the current design, the low level ethernet input routine mainly signal
a thread should facilitate the design of this filter. The output path is less
complicated as it is run by a task and thus can sleep on a synchronization object,
@item [(R9)]:
This requirement represents what we find reasonable as a first target.
However, we can still present to the final user this kind of debugging via different
model. RTEMS can be represented as a single threaded system or, because RTEMS
is a multitasking system, as an ensemble of separate tasks. In the first representation,
the debugger sees only 1 ``task'' without distinguishing the core executive
part from the applicative part. This is the simplest way to implement the debugger
but also implies that there is no way to protect the core executive. Some of
these tasks are system tasks (tasks form the core executive and from the FreeBSD
stack), the other ones are tasks implemented by the developer. The developer
wants to debug his tasks, and sometimes only one of his tasks. We can provide
a way to debug not the entire system but only the concerned task by testing
if the current running task is a debugged task (test on the task identifier).
GDB offers an API to ``detach'' thread so that if a detached thread hits a
breakpoint it is automatically restarted without user intervention,
@item [(R10)]:
Several developers can work on a large project, each on a specific
module. Sometimes only one target is available for everyone. This requirements
is not really meaningfull until RTEMS supports dynamic code loading,
@item [(R11)]:
This requirement heavily depends on the @b{(R7)} and @b{(R8)}
requirements.
@end table
@subsection Requirements Selection
@subsubsection Requirement We Will Take Into Account For the First Implementation
@table @b
@item [(R1)]:
Obviously.
@item [(R2)]:
As these are our targets. Of course other will be free to contribute.
We will however document the works that needs to be done in order to port the
debug code to other processors,
@item [(R3)]:
We think it is feasible with only few RTEMS modifications,
@item [(R5)]:
We think serial line debugging is nowadays too restrictive as most equipment
are now connected via Ethernet,
@item [(R6)]:
This is a documentation problem and should be fairly easy to describe
once we have the RGDBSD code,
@item [(R9)]:
We will try to provide the multi-thread target system presentation,
@end table
@subsubsection Requirements We Will Not Implement
@table @b
@item [(R4)]:
it will not be implemented for the moment. It is just a matter on implementing
SLIP in the FreeBSD stack and alternative solutions already exist in the meantime,
@item [(R7)]:
To simplify the first developments, we don't plan to implement a @emph{dedicated}
nano-kernel to allow the RTEMS kernel to be debugged. It means that, if any
breakpoint is set in the kernel, unpredictable behaviors can occur. So, developers
must keep in mind to avoid stopping the kernel. They must also keep in mind,
in order to not stop the kernel, that the user's tasks must have a lower priority
than the tasks used for debug. The solution is to use a specific very-high priority
level for the system tasks used directly or indirectly by RGDBSD. The SYSTEM_TASK
attribute that already exists should be fine.
@item [(R8)]:
To avoid increasing the code size and the used memory and because the
FreeBSD stack doesn't need to be debug any more, we choose not to implement
a minimal TCP/IP stack but rather to use the FreeBSD one as communication protocol,
@item [(R10)]:
We will see later when a file system will be available and we can implement
@b{exec} system call,
@item [(R11)]:
Without a separate TCP/IP stack it will be hard to freeze the system
as some interrupts must occur in order to enable the FreeBSD stack to function,
@end table
@subsection Implied Restrictions
High priority level must be used for these features :
@itemize @b
@item FreeBSD interrupt handling thread,
@item Debugger threads.
@end itemize
This will allows these tasks not to be stopped when a process is stopped
in debug mode
If we don't want to use a ``specific'' priority level, we must affect
priority to each of these tasks as follow :
@itemize @b
@item FreeBSD stack (high priority)
@item Debugger (less high priority)
@end itemize
The user must remember the higher priority level he can use for his
software in order not to block one of the previous threads and to not put breakpoints
in part of the code executed by RGDBSD.

672
doc/rgdb_specs/process.eps Normal file
View File

@@ -0,0 +1,672 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: process.eps
%%Creator: fig2dev Version 3.2 Patchlevel 1
%%CreationDate: Tue Nov 10 13:55:53 1998
%%For: valette@tri-yann (Eric Valette,,6891,)
%%Orientation: Portrait
%%BoundingBox: 0 0 1245 646
%%Pages: 0
%%BeginSetup
%%EndSetup
%%Magnification: 1.0000
%%EndComments
/$F2psDict 200 dict def
$F2psDict begin
$F2psDict /mtrx matrix put
/col-1 {0 setgray} bind def
/col0 {0.000 0.000 0.000 srgb} bind def
/col1 {0.000 0.000 1.000 srgb} bind def
/col2 {0.000 1.000 0.000 srgb} bind def
/col3 {0.000 1.000 1.000 srgb} bind def
/col4 {1.000 0.000 0.000 srgb} bind def
/col5 {1.000 0.000 1.000 srgb} bind def
/col6 {1.000 1.000 0.000 srgb} bind def
/col7 {1.000 1.000 1.000 srgb} bind def
/col8 {0.000 0.000 0.560 srgb} bind def
/col9 {0.000 0.000 0.690 srgb} bind def
/col10 {0.000 0.000 0.820 srgb} bind def
/col11 {0.530 0.810 1.000 srgb} bind def
/col12 {0.000 0.560 0.000 srgb} bind def
/col13 {0.000 0.690 0.000 srgb} bind def
/col14 {0.000 0.820 0.000 srgb} bind def
/col15 {0.000 0.560 0.560 srgb} bind def
/col16 {0.000 0.690 0.690 srgb} bind def
/col17 {0.000 0.820 0.820 srgb} bind def
/col18 {0.560 0.000 0.000 srgb} bind def
/col19 {0.690 0.000 0.000 srgb} bind def
/col20 {0.820 0.000 0.000 srgb} bind def
/col21 {0.560 0.000 0.560 srgb} bind def
/col22 {0.690 0.000 0.690 srgb} bind def
/col23 {0.820 0.000 0.820 srgb} bind def
/col24 {0.500 0.190 0.000 srgb} bind def
/col25 {0.630 0.250 0.000 srgb} bind def
/col26 {0.750 0.380 0.000 srgb} bind def
/col27 {1.000 0.500 0.500 srgb} bind def
/col28 {1.000 0.630 0.630 srgb} bind def
/col29 {1.000 0.750 0.750 srgb} bind def
/col30 {1.000 0.880 0.880 srgb} bind def
/col31 {1.000 0.840 0.000 srgb} bind def
end
save
-19.0 647.0 translate
1 -1 scale
/cp {closepath} bind def
/ef {eofill} bind def
/gr {grestore} bind def
/gs {gsave} bind def
/sa {save} bind def
/rs {restore} bind def
/l {lineto} bind def
/m {moveto} bind def
/rm {rmoveto} bind def
/n {newpath} bind def
/s {stroke} bind def
/sh {show} bind def
/slc {setlinecap} bind def
/slj {setlinejoin} bind def
/slw {setlinewidth} bind def
/srgb {setrgbcolor} bind def
/rot {rotate} bind def
/sc {scale} bind def
/sd {setdash} bind def
/ff {findfont} bind def
/sf {setfont} bind def
/scf {scalefont} bind def
/sw {stringwidth} bind def
/tr {translate} bind def
/tnt {dup dup currentrgbcolor
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
bind def
/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
4 -2 roll mul srgb} bind def
/reencdict 12 dict def /ReEncode { reencdict begin
/newcodesandnames exch def /newfontname exch def /basefontname exch def
/basefontdict basefontname findfont def /newfont basefontdict maxlength dict def
basefontdict { exch dup /FID ne { dup /Encoding eq
{ exch dup length array copy newfont 3 1 roll put }
{ exch newfont 3 1 roll put } ifelse } { pop pop } ifelse } forall
newfont /FontName newfontname put newcodesandnames aload pop
128 1 255 { newfont /Encoding get exch /.notdef put } for
newcodesandnames length 2 idiv { newfont /Encoding get 3 1 roll put } repeat
newfontname newfont definefont pop end } def
/isovec [
8#200 /grave 8#201 /acute 8#202 /circumflex 8#203 /tilde
8#204 /macron 8#205 /breve 8#206 /dotaccent 8#207 /dieresis
8#210 /ring 8#211 /cedilla 8#212 /hungarumlaut 8#213 /ogonek 8#214 /caron
8#220 /dotlessi 8#230 /oe 8#231 /OE
8#240 /space 8#241 /exclamdown 8#242 /cent 8#243 /sterling
8#244 /currency 8#245 /yen 8#246 /brokenbar 8#247 /section 8#250 /dieresis
8#251 /copyright 8#252 /ordfeminine 8#253 /guillemotleft 8#254 /logicalnot
8#255 /endash 8#256 /registered 8#257 /macron 8#260 /degree 8#261 /plusminus
8#262 /twosuperior 8#263 /threesuperior 8#264 /acute 8#265 /mu 8#266 /paragraph
8#267 /periodcentered 8#270 /cedilla 8#271 /onesuperior 8#272 /ordmasculine
8#273 /guillemotright 8#274 /onequarter 8#275 /onehalf
8#276 /threequarters 8#277 /questiondown 8#300 /Agrave 8#301 /Aacute
8#302 /Acircumflex 8#303 /Atilde 8#304 /Adieresis 8#305 /Aring
8#306 /AE 8#307 /Ccedilla 8#310 /Egrave 8#311 /Eacute
8#312 /Ecircumflex 8#313 /Edieresis 8#314 /Igrave 8#315 /Iacute
8#316 /Icircumflex 8#317 /Idieresis 8#320 /Eth 8#321 /Ntilde 8#322 /Ograve
8#323 /Oacute 8#324 /Ocircumflex 8#325 /Otilde 8#326 /Odieresis 8#327 /multiply
8#330 /Oslash 8#331 /Ugrave 8#332 /Uacute 8#333 /Ucircumflex
8#334 /Udieresis 8#335 /Yacute 8#336 /Thorn 8#337 /germandbls 8#340 /agrave
8#341 /aacute 8#342 /acircumflex 8#343 /atilde 8#344 /adieresis 8#345 /aring
8#346 /ae 8#347 /ccedilla 8#350 /egrave 8#351 /eacute
8#352 /ecircumflex 8#353 /edieresis 8#354 /igrave 8#355 /iacute
8#356 /icircumflex 8#357 /idieresis 8#360 /eth 8#361 /ntilde 8#362 /ograve
8#363 /oacute 8#364 /ocircumflex 8#365 /otilde 8#366 /odieresis 8#367 /divide
8#370 /oslash 8#371 /ugrave 8#372 /uacute 8#373 /ucircumflex
8#374 /udieresis 8#375 /yacute 8#376 /thorn 8#377 /ydieresis] def
/Times-Roman /Times-Roman-iso isovec ReEncode
/DrawEllipse {
/endangle exch def
/startangle exch def
/yrad exch def
/xrad exch def
/y exch def
/x exch def
/savematrix mtrx currentmatrix def
x y tr xrad yrad sc 0 0 1 startangle endangle arc
closepath
savematrix setmatrix
} def
/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
/$F2psEnd {$F2psEnteredState restore end} def
%%EndProlog
$F2psBegin
10 setmiterlimit
n -1000 11779 m -1000 -1000 l 22054 -1000 l 22054 11779 l cp clip
0.06000 0.06000 sc
/Times-Roman-iso ff 300.00 scf sf
2250 600 m
gs 1 -1 sc (INITIALIZATION) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 300.00 scf sf
2250 825 m
gs 1 -1 sc (TASK) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 300.00 scf sf
6150 825 m
gs 1 -1 sc (TASK) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 300.00 scf sf
6150 600 m
gs 1 -1 sc (COMMAND MANAGEMENT) dup sw pop 2 div neg 0 rm col0 sh gr
7.500 slw
% Ellipse
n 10050 3600 1275 525 0 360 DrawEllipse gs col0 s gr
/Times-Roman-iso ff 180.00 scf sf
10050 3450 m
gs 1 -1 sc (WAIT FOR) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
10050 3900 m
gs 1 -1 sc (SEMAPHORE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
10050 3675 m
gs 1 -1 sc (WAKE-UP) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 1950 m
gs 1 -1 sc (WAIT FOR) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 2175 m
gs 1 -1 sc (RPC MESSAGE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 2400 m
gs 1 -1 sc (FROM GDB) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 3750 m
gs 1 -1 sc (EXECUTE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 3975 m
gs 1 -1 sc (RECEIVED) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 4200 m
gs 1 -1 sc (COMMAND) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 9150 m
gs 1 -1 sc (SEND) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 9375 m
gs 1 -1 sc (RESULT) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 9600 m
gs 1 -1 sc (IF NEEDED) dup sw pop 2 div neg 0 rm col0 sh gr
% Ellipse
n 5925 9300 1275 525 0 360 DrawEllipse gs col0 s gr
% Polyline
n 5925 9825 m 5925 9826 l 5925 9830 l 5926 9839 l 5926 9855 l 5928 9876 l
5929 9899 l 5931 9923 l 5934 9946 l 5937 9967 l 5941 9987 l
5945 10004 l 5950 10020 l 5956 10035 l 5963 10050 l 5969 10063 l
5977 10076 l 5986 10089 l 5996 10103 l 6007 10117 l 6020 10132 l
6033 10146 l 6048 10161 l 6063 10175 l 6080 10189 l 6097 10203 l
6114 10216 l 6132 10228 l 6150 10240 l 6169 10252 l 6188 10263 l
6203 10271 l 6220 10279 l 6237 10288 l 6255 10296 l 6274 10305 l
6293 10313 l 6314 10321 l 6335 10329 l 6356 10337 l 6378 10345 l
6401 10352 l 6423 10359 l 6445 10366 l 6467 10372 l 6488 10378 l
6509 10383 l 6529 10388 l 6549 10392 l 6568 10396 l 6588 10400 l
6606 10403 l 6625 10406 l 6644 10409 l 6664 10411 l 6684 10413 l
6704 10415 l 6724 10416 l 6745 10417 l 6766 10418 l 6788 10418 l
6809 10418 l 6830 10417 l 6851 10416 l 6871 10415 l 6891 10413 l
6911 10411 l 6931 10409 l 6950 10406 l 6969 10403 l 6988 10400 l
7007 10396 l 7026 10392 l 7046 10388 l 7066 10383 l 7087 10378 l
7108 10372 l 7129 10366 l 7151 10359 l 7173 10352 l 7195 10345 l
7216 10337 l 7237 10329 l 7258 10321 l 7277 10313 l 7296 10305 l
7313 10296 l 7330 10288 l 7346 10279 l 7361 10271 l 7375 10263 l
7392 10252 l 7408 10240 l 7423 10228 l 7438 10216 l 7452 10203 l
7465 10189 l 7478 10175 l 7490 10161 l 7501 10146 l 7510 10132 l
7519 10117 l 7527 10103 l 7534 10089 l 7540 10076 l 7545 10063 l
7550 10050 l 7555 10035 l 7558 10020 l 7562 10004 l 7565 9987 l
7567 9967 l 7569 9946 l 7571 9923 l 7572 9899 l 7573 9876 l
7574 9855 l 7575 9839 l 7575 9830 l 7575 9826 l 7575 9825 l gs col0 s gr
/Times-Roman-iso ff 180.00 scf sf
2250 8025 m
gs 1 -1 sc (DELETE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
2250 8250 m
gs 1 -1 sc (INITIALIZATION) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
2250 8475 m
gs 1 -1 sc (TASK) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
2250 6525 m
gs 1 -1 sc (COMMAND MANAGEMENT) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
2250 6300 m
gs 1 -1 sc (CREATE SEPARATE TASK) dup sw pop 2 div neg 0 rm col0 sh gr
% Ellipse
n 2250 6375 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 2250 8175 1275 525 0 360 DrawEllipse gs col0 s gr
% Polyline
gs clippath
2280 5730 m 2250 5850 l 2220 5730 l 2220 5865 l 2280 5865 l cp
clip
n 2250 5100 m 2250 5850 l gs col0 s gr gr
% arrowhead
n 2280 5730 m 2250 5850 l 2220 5730 l col0 s
% Polyline
gs clippath
2280 7530 m 2250 7650 l 2220 7530 l 2220 7665 l 2280 7665 l cp
clip
n 2250 6900 m 2250 7650 l gs col0 s gr gr
% arrowhead
n 2280 7530 m 2250 7650 l 2220 7530 l col0 s
% Ellipse
n 2250 2775 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 2250 4575 1275 525 0 360 DrawEllipse gs col0 s gr
% Polyline
gs clippath
2280 3930 m 2250 4050 l 2220 3930 l 2220 4065 l 2280 4065 l cp
clip
n 2250 3300 m 2250 4050 l gs col0 s gr gr
% arrowhead
n 2280 3930 m 2250 4050 l 2220 3930 l col0 s
/Times-Roman-iso ff 180.00 scf sf
2250 2850 m
gs 1 -1 sc (INITIALIZATION) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
2250 4425 m
gs 1 -1 sc (CONNECT) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
2250 4875 m
gs 1 -1 sc (HANDLER) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
2250 4650 m
gs 1 -1 sc (EXCEPTION) dup sw pop 2 div neg 0 rm col0 sh gr
% Ellipse
n 10050 5400 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 5925 2100 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 5925 3900 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 5943 5681 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 5925 7500 1275 525 0 360 DrawEllipse gs col0 s gr
% Polyline
60.000 slw
n 600 75 m 375 75 375 10500 225 arcto 4 {pop} repeat
375 10725 12600 10725 225 arcto 4 {pop} repeat
12825 10725 12825 300 225 arcto 4 {pop} repeat
12825 75 600 75 225 arcto 4 {pop} repeat
cp gs col0 s gr
% Polyline
7.500 slw
n 11700 3075 m 11700 5925 l gs col0 s gr
% Polyline
gs clippath
10080 4755 m 10050 4875 l 10020 4755 l 10020 4890 l 10080 4890 l cp
clip
n 10050 4125 m 10050 4875 l gs col0 s gr gr
% arrowhead
n 10080 4755 m 10050 4875 l 10020 4755 l col0 s
% Polyline
gs clippath
5955 3255 m 5925 3375 l 5895 3255 l 5895 3390 l 5955 3390 l cp
clip
n 5925 2625 m 5925 3375 l gs col0 s gr gr
% arrowhead
n 5955 3255 m 5925 3375 l 5895 3255 l col0 s
% Polyline
gs clippath
5955 5055 m 5925 5175 l 5895 5055 l 5895 5190 l 5955 5190 l cp
clip
n 5925 4425 m 5925 5175 l gs col0 s gr gr
% arrowhead
n 5955 5055 m 5925 5175 l 5895 5055 l col0 s
% Polyline
n 7575 1500 m 7575 9900 l gs col0 s gr
% Polyline
gs clippath
5955 6855 m 5925 6975 l 5895 6855 l 5895 6990 l 5955 6990 l cp
clip
n 5925 6225 m 5925 6975 l gs col0 s gr gr
% arrowhead
n 5955 6855 m 5925 6975 l 5895 6855 l col0 s
% Polyline
gs clippath
5955 8655 m 5925 8775 l 5895 8655 l 5895 8790 l 5955 8790 l cp
clip
n 5925 8025 m 5925 8775 l gs col0 s gr gr
% arrowhead
n 5955 8655 m 5925 8775 l 5895 8655 l col0 s
% Polyline
45.000 slw
n 4050 375 m 4050 10350 l gs col0 s gr
% Polyline
n 8175 375 m 8175 10425 l gs col0 s gr
% Polyline
30.000 slw
[60] 0 sd
gs clippath
4526 2104 m 4650 2100 l 4543 2162 l 4702 2116 l 4685 2059 l cp
clip
n 3525 6375 m 3526 6375 l 3528 6374 l 3531 6372 l 3537 6370 l 3544 6366 l
3554 6361 l 3566 6354 l 3580 6345 l 3596 6334 l 3612 6322 l
3630 6307 l 3648 6291 l 3666 6272 l 3684 6252 l 3702 6230 l
3719 6207 l 3735 6181 l 3750 6153 l 3765 6124 l 3778 6092 l
3791 6057 l 3804 6020 l 3815 5980 l 3826 5937 l 3837 5890 l
3847 5839 l 3856 5785 l 3866 5726 l 3875 5663 l 3880 5624 l
3885 5584 l 3891 5543 l 3896 5500 l 3901 5456 l 3906 5410 l
3911 5363 l 3917 5314 l 3922 5264 l 3927 5213 l 3932 5160 l
3938 5105 l 3943 5049 l 3948 4992 l 3954 4934 l 3959 4875 l
3965 4814 l 3970 4753 l 3976 4690 l 3981 4627 l 3987 4563 l
3993 4499 l 3999 4434 l 4004 4369 l 4010 4303 l 4016 4237 l
4022 4172 l 4028 4106 l 4034 4041 l 4040 3976 l 4046 3912 l
4052 3848 l 4058 3785 l 4064 3722 l 4070 3661 l 4076 3600 l
4082 3541 l 4088 3483 l 4094 3426 l 4100 3370 l 4106 3315 l
4112 3262 l 4118 3211 l 4124 3161 l 4130 3112 l 4137 3065 l
4143 3019 l 4149 2975 l 4156 2932 l 4162 2891 l 4168 2851 l
4175 2813 l 4186 2753 l 4197 2698 l 4209 2646 l 4221 2597 l
4233 2553 l 4247 2511 l 4261 2472 l 4276 2436 l 4291 2403 l
4308 2371 l 4326 2342 l 4345 2315 l 4365 2289 l 4385 2265 l
4407 2243 l 4430 2223 l 4453 2204 l 4476 2187 l 4500 2171 l
4523 2157 l 4545 2145 l 4566 2134 l 4585 2125 l 4601 2118 l
4616 2112 l 4627 2107 l 4636 2104 l 4650 2100 l gs col4 s gr gr
[] 0 sd
% arrowhead
7.500 slw
n 4526 2104 m 4650 2100 l 4543 2162 l col4 s
% Polyline
30.000 slw
[60] 0 sd
gs clippath
8652 3585 m 8775 3600 l 8659 3644 l 8823 3624 l 8816 3565 l cp
clip
n 7200 5700 m 7202 5700 l 7206 5699 l 7214 5698 l 7225 5697 l 7242 5695 l
7262 5691 l 7287 5687 l 7315 5682 l 7346 5676 l 7379 5668 l
7413 5660 l 7447 5650 l 7481 5640 l 7514 5628 l 7545 5616 l
7575 5602 l 7603 5587 l 7629 5571 l 7654 5554 l 7676 5535 l
7697 5515 l 7717 5492 l 7736 5468 l 7753 5442 l 7769 5414 l
7785 5383 l 7800 5350 l 7811 5324 l 7821 5297 l 7832 5268 l
7842 5238 l 7852 5207 l 7862 5174 l 7871 5140 l 7881 5104 l
7891 5068 l 7901 5030 l 7910 4991 l 7920 4951 l 7930 4910 l
7939 4868 l 7949 4825 l 7959 4782 l 7968 4738 l 7978 4694 l
7987 4650 l 7997 4606 l 8007 4562 l 8016 4518 l 8026 4475 l
8036 4432 l 8045 4390 l 8055 4349 l 8065 4309 l 8074 4270 l
8084 4232 l 8094 4196 l 8104 4160 l 8113 4126 l 8123 4093 l
8133 4062 l 8143 4032 l 8154 4003 l 8164 3976 l 8175 3950 l
8190 3917 l 8206 3886 l 8222 3858 l 8239 3832 l 8258 3808 l
8278 3785 l 8299 3765 l 8321 3746 l 8346 3729 l 8372 3713 l
8400 3698 l 8430 3684 l 8461 3672 l 8494 3660 l 8528 3650 l
8562 3640 l 8596 3632 l 8629 3624 l 8660 3618 l 8688 3613 l
8713 3609 l 8733 3605 l 8750 3603 l 8775 3600 l gs col4 s gr gr
[] 0 sd
% arrowhead
7.500 slw
n 8652 3585 m 8775 3600 l 8659 3644 l col4 s
% Polyline
gs clippath
10084 2956 m 10050 3075 l 10024 2954 l 10020 3089 l 10079 3091 l cp
clip
n 10050 3075 m 10051 3045 l 10053 3024 l 10054 3001 l 10056 2977 l 10059 2954 l
10062 2933 l 10066 2913 l 10070 2896 l 10075 2880 l 10081 2865 l
10088 2850 l 10094 2837 l 10102 2824 l 10111 2811 l 10121 2797 l
10132 2783 l 10145 2768 l 10158 2754 l 10173 2739 l 10188 2725 l
10205 2711 l 10222 2697 l 10239 2684 l 10257 2672 l 10275 2660 l
10294 2648 l 10313 2638 l 10328 2629 l 10345 2621 l 10362 2612 l
10380 2604 l 10399 2595 l 10418 2587 l 10439 2579 l 10460 2571 l
10481 2563 l 10503 2555 l 10526 2548 l 10548 2541 l 10570 2534 l
10592 2528 l 10613 2522 l 10634 2517 l 10654 2512 l 10674 2508 l
10693 2504 l 10713 2500 l 10731 2497 l 10750 2494 l 10769 2491 l
10789 2489 l 10809 2487 l 10829 2485 l 10849 2484 l 10870 2483 l
10891 2482 l 10913 2482 l 10934 2482 l 10955 2483 l 10976 2484 l
10996 2485 l 11016 2487 l 11036 2489 l 11056 2491 l 11075 2494 l
11094 2497 l 11113 2500 l 11132 2504 l 11151 2508 l 11171 2512 l
11191 2517 l 11212 2522 l 11233 2528 l 11254 2534 l 11276 2541 l
11298 2548 l 11320 2555 l 11341 2563 l 11362 2571 l 11383 2579 l
11402 2587 l 11421 2595 l 11438 2604 l 11455 2612 l 11471 2621 l
11486 2629 l 11500 2638 l 11517 2648 l 11533 2660 l 11548 2672 l
11563 2684 l 11577 2697 l 11590 2711 l 11603 2725 l 11615 2739 l
11626 2754 l 11635 2768 l 11644 2783 l 11652 2797 l 11659 2811 l
11665 2824 l 11670 2837 l 11675 2850 l 11680 2865 l 11683 2880 l
11687 2896 l 11690 2913 l 11692 2933 l 11694 2954 l 11696 2977 l
11697 3001 l 11698 3024 l 11699 3045 l 11700 3061 l 11700 3070 l
11700 3074 l 11700 3075 l gs col0 s gr gr
% arrowhead
n 10084 2956 m 10050 3075 l 10024 2954 l col0 s
% Polyline
n 10050 5925 m 10050 5926 l 10050 5930 l 10051 5939 l 10051 5955 l 10053 5976 l
10054 5999 l 10056 6023 l 10059 6046 l 10062 6067 l 10066 6087 l
10070 6104 l 10075 6120 l 10081 6135 l 10088 6150 l 10094 6163 l
10102 6176 l 10111 6189 l 10121 6203 l 10132 6217 l 10145 6232 l
10158 6246 l 10173 6261 l 10188 6275 l 10205 6289 l 10222 6303 l
10239 6316 l 10257 6328 l 10275 6340 l 10294 6352 l 10313 6363 l
10328 6371 l 10345 6379 l 10362 6388 l 10380 6396 l 10399 6405 l
10418 6413 l 10439 6421 l 10460 6429 l 10481 6437 l 10503 6445 l
10526 6452 l 10548 6459 l 10570 6466 l 10592 6472 l 10613 6478 l
10634 6483 l 10654 6488 l 10674 6492 l 10693 6496 l 10713 6500 l
10731 6503 l 10750 6506 l 10769 6509 l 10789 6511 l 10809 6513 l
10829 6515 l 10849 6516 l 10870 6517 l 10891 6518 l 10913 6518 l
10934 6518 l 10955 6517 l 10976 6516 l 10996 6515 l 11016 6513 l
11036 6511 l 11056 6509 l 11075 6506 l 11094 6503 l 11113 6500 l
11132 6496 l 11151 6492 l 11171 6488 l 11191 6483 l 11212 6478 l
11233 6472 l 11254 6466 l 11276 6459 l 11298 6452 l 11320 6445 l
11341 6437 l 11362 6429 l 11383 6421 l 11402 6413 l 11421 6405 l
11438 6396 l 11455 6388 l 11471 6379 l 11486 6371 l 11500 6363 l
11517 6352 l 11533 6340 l 11548 6328 l 11563 6316 l 11577 6303 l
11590 6289 l 11603 6275 l 11615 6261 l 11626 6246 l 11635 6232 l
11644 6217 l 11652 6203 l 11659 6189 l 11665 6176 l 11670 6163 l
11675 6150 l 11680 6135 l 11683 6120 l 11687 6104 l 11690 6087 l
11692 6067 l 11694 6046 l 11696 6023 l 11697 5999 l 11698 5976 l
11699 5955 l 11700 5939 l 11700 5930 l 11700 5926 l 11700 5925 l gs col0 s gr
% Polyline
gs clippath
5959 1456 m 5925 1575 l 5899 1454 l 5895 1589 l 5954 1591 l cp
clip
n 5925 1575 m 5926 1545 l 5928 1524 l 5929 1501 l 5931 1477 l 5934 1454 l
5937 1433 l 5941 1413 l 5945 1396 l 5950 1380 l 5956 1365 l
5963 1350 l 5969 1337 l 5977 1324 l 5986 1311 l 5996 1297 l
6007 1283 l 6020 1268 l 6033 1254 l 6048 1239 l 6063 1225 l
6080 1211 l 6097 1197 l 6114 1184 l 6132 1172 l 6150 1160 l
6169 1148 l 6188 1138 l 6203 1129 l 6220 1121 l 6237 1112 l
6255 1104 l 6274 1095 l 6293 1087 l 6314 1079 l 6335 1071 l
6356 1063 l 6378 1055 l 6401 1048 l 6423 1041 l 6445 1034 l
6467 1028 l 6488 1022 l 6509 1017 l 6529 1012 l 6549 1008 l
6568 1004 l 6588 1000 l 6606 997 l 6625 994 l 6644 991 l
6664 989 l 6684 987 l 6704 985 l 6724 984 l 6745 983 l
6766 982 l 6788 982 l 6809 982 l 6830 983 l 6851 984 l
6871 985 l 6891 987 l 6911 989 l 6931 991 l 6950 994 l
6969 997 l 6988 1000 l 7007 1004 l 7026 1008 l 7046 1012 l
7066 1017 l 7087 1022 l 7108 1028 l 7129 1034 l 7151 1041 l
7173 1048 l 7195 1055 l 7216 1063 l 7237 1071 l 7258 1079 l
7277 1087 l 7296 1095 l 7313 1104 l 7330 1112 l 7346 1121 l
7361 1129 l 7375 1138 l 7392 1148 l 7408 1160 l 7423 1172 l
7438 1184 l 7452 1197 l 7465 1211 l 7478 1225 l 7490 1239 l
7501 1254 l 7510 1268 l 7519 1283 l 7527 1297 l 7534 1311 l
7540 1324 l 7545 1337 l 7550 1350 l 7555 1365 l 7558 1380 l
7562 1396 l 7565 1413 l 7567 1433 l 7569 1454 l 7571 1477 l
7572 1501 l 7573 1524 l 7574 1545 l 7575 1561 l 7575 1570 l
7575 1574 l 7575 1575 l gs col0 s gr gr
% arrowhead
n 5959 1456 m 5925 1575 l 5899 1454 l col0 s
/Times-Roman-iso ff 300.00 scf sf
10575 825 m
gs 1 -1 sc (TASK) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 300.00 scf sf
10575 600 m
gs 1 -1 sc (EVENT MANAGEMENT) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5025 6000 m
gs 1 -1 sc (MANAGEMENT TASK) col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5250 5775 m
gs 1 -1 sc (CREATE EVENT) col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
4950 5550 m
gs 1 -1 sc (IF ATTACH COMMAND) col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 7575 m
gs 1 -1 sc (RELEASE SERIALIZE AND) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 7350 m
gs 1 -1 sc (IF CONTINUE COMMAND) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
5925 7800 m
gs 1 -1 sc (CONTINUE SEMAPHORES) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
10050 5250 m
gs 1 -1 sc (NOTIFY THE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
10050 5475 m
gs 1 -1 sc (DEBUGGEE CHANGES) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
10050 5700 m
gs 1 -1 sc (TO GDB) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 300.00 scf sf
6975 8175 m
gs 1 -1 sc (\(1\)->) dup sw pop 2 div neg 0 rm col13 sh gr
/Times-Roman-iso ff 300.00 scf sf
11025 4275 m
gs 1 -1 sc (\(2\)<-) dup sw pop 2 div neg 0 rm col1 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 2775 m
gs 1 -1 sc (WAIT FOR) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 3000 m
gs 1 -1 sc (SERIALIZE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 3225 m
gs 1 -1 sc (SEMAPHORE) dup sw pop 2 div neg 0 rm col0 sh gr
% Ellipse
n 18525 2925 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 18525 6450 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 18525 8250 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 18533 9976 1275 525 0 360 DrawEllipse gs col0 s gr
% Ellipse
n 18511 4735 1275 525 0 360 DrawEllipse gs col0 s gr
% Polyline
gs clippath
18597 2300 m 18525 2400 l 18542 2277 l 18492 2403 l 18547 2425 l cp
clip
n 18525 2400 m 18675 2025 l 18375 2025 l 18525 1650 l gs col0 s gr gr
% arrowhead
n 18597 2300 m 18525 2400 l 18542 2277 l col0 s
% Polyline
gs clippath
18555 4080 m 18525 4200 l 18495 4080 l 18495 4215 l 18555 4215 l cp
clip
n 18525 3450 m 18525 4200 l gs col0 s gr gr
% arrowhead
n 18555 4080 m 18525 4200 l 18495 4080 l col0 s
% Polyline
gs clippath
18555 7605 m 18525 7725 l 18495 7605 l 18495 7740 l 18555 7740 l cp
clip
n 18525 6975 m 18525 7725 l gs col0 s gr gr
% arrowhead
n 18555 7605 m 18525 7725 l 18495 7605 l col0 s
% Polyline
gs clippath
18555 9330 m 18525 9450 l 18495 9330 l 18495 9465 l 18555 9465 l cp
clip
n 18525 8775 m 18525 9450 l gs col0 s gr gr
% arrowhead
n 18555 9330 m 18525 9450 l 18495 9330 l col0 s
% Polyline
gs clippath
18555 5805 m 18525 5925 l 18495 5805 l 18495 5940 l 18555 5940 l cp
clip
n 18525 5250 m 18525 5925 l gs col0 s gr gr
% arrowhead
n 18555 5805 m 18525 5925 l 18495 5805 l col0 s
/Times-Roman-iso ff 300.00 scf sf
18450 600 m
gs 1 -1 sc ( DEBUG AND BREAKPOINT) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 300.00 scf sf
18450 825 m
gs 1 -1 sc (EXCEPTION HANDLER) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 6900 m
gs 1 -1 sc (SEMAPHORE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 6450 m
gs 1 -1 sc (OR BREAKPOINT EXCEP,) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 6225 m
gs 1 -1 sc (IF SINGLE STEP) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 6675 m
gs 1 -1 sc (RELEASE WAKE-UP) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 8100 m
gs 1 -1 sc (WAIT FOR) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 8550 m
gs 1 -1 sc (SEMAPHORE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 8325 m
gs 1 -1 sc (CONTINUE) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
17700 1425 m
gs 1 -1 sc (RECEIVE EXCEPTION) col0 sh gr
/Times-Roman-iso ff 300.00 scf sf
17250 8850 m
gs 1 -1 sc (->\(1\)) dup sw pop 2 div neg 0 rm col13 sh gr
/Times-Roman-iso ff 300.00 scf sf
17175 6975 m
gs 1 -1 sc (<-\(2\)) dup sw pop 2 div neg 0 rm col1 sh gr
/Times-Roman-iso ff 300.00 scf sf
17250 3525 m
gs 1 -1 sc (->\(1\)) dup sw pop 2 div neg 0 rm col13 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 10275 m
gs 1 -1 sc (RETURN OF EXCEPTION) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 10050 m
gs 1 -1 sc (AND) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18525 9825 m
gs 1 -1 sc (RESTORE CONTEXT) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
18075 4950 m
gs 1 -1 sc (CONTEXT) col0 sh gr
/Times-Roman-iso ff 180.00 scf sf
17700 4725 m
gs 1 -1 sc (SAVE EXCEPTION ) col0 sh gr
% Polyline
60.000 slw
n 16275 75 m 16050 75 16050 10500 225 arcto 4 {pop} repeat
16050 10725 20775 10725 225 arcto 4 {pop} repeat
21000 10725 21000 300 225 arcto 4 {pop} repeat
21000 75 16275 75 225 arcto 4 {pop} repeat
cp gs col0 s gr
$F2psEnd
rs

36
doc/rgdb_specs/revision.t Normal file
View File

@@ -0,0 +1,36 @@
@c
@c RTEMS Remote Debugger Server Specifications
@c
@c Written by: Eric Valette <valette@crf.canon.fr>
@c Emmanuel Raguet <raguet@crf.canon.fr>
@c
@c
@c $Id$
@c
@chapter Document Revision History
@ubaraccent{Current release} :
@itemize @b
@item Current applicable release is 2.0.
@end itemize
@ubaraccent{Existing releases} :
@itemize @b
@item 0.1 : Released the 29/09/98. First draft of this document.
@item 0.2 : Released the 05/10/98. Second draft version.
@item 1.0 : Released the 08/10/98. Version Approved internally.
@item 1.1 : Released the 13/13/98. Version Distributed for comments.
@item 2.0 : Released the 01/11/98. Version including modifications related
to comments we have got from the RTEMS mailing list. It also contains a
more precise description of RGDBSD as we now have a first prototype,
@end itemize
@ubaraccent{Planned releases} :
@itemize @b
@item 2.1 Final specification release intended to include a second round
of comments,
@end itemize

File diff suppressed because it is too large Load Diff

204
doc/rgdb_specs/seg_init.eps Normal file
View File

@@ -0,0 +1,204 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: seg_init.eps
%%Creator: fig2dev Version 3.2 Patchlevel 1
%%CreationDate: Tue Oct 13 13:59:59 1998
%%For: valette@tri-yann (Eric Valette,,6891,)
%%Orientation: Portrait
%%BoundingBox: 0 0 482 527
%%Pages: 0
%%BeginSetup
%%EndSetup
%%Magnification: 1.0000
%%EndComments
/$F2psDict 200 dict def
$F2psDict begin
$F2psDict /mtrx matrix put
/col-1 {0 setgray} bind def
/col0 {0.000 0.000 0.000 srgb} bind def
/col1 {0.000 0.000 1.000 srgb} bind def
/col2 {0.000 1.000 0.000 srgb} bind def
/col3 {0.000 1.000 1.000 srgb} bind def
/col4 {1.000 0.000 0.000 srgb} bind def
/col5 {1.000 0.000 1.000 srgb} bind def
/col6 {1.000 1.000 0.000 srgb} bind def
/col7 {1.000 1.000 1.000 srgb} bind def
/col8 {0.000 0.000 0.560 srgb} bind def
/col9 {0.000 0.000 0.690 srgb} bind def
/col10 {0.000 0.000 0.820 srgb} bind def
/col11 {0.530 0.810 1.000 srgb} bind def
/col12 {0.000 0.560 0.000 srgb} bind def
/col13 {0.000 0.690 0.000 srgb} bind def
/col14 {0.000 0.820 0.000 srgb} bind def
/col15 {0.000 0.560 0.560 srgb} bind def
/col16 {0.000 0.690 0.690 srgb} bind def
/col17 {0.000 0.820 0.820 srgb} bind def
/col18 {0.560 0.000 0.000 srgb} bind def
/col19 {0.690 0.000 0.000 srgb} bind def
/col20 {0.820 0.000 0.000 srgb} bind def
/col21 {0.560 0.000 0.560 srgb} bind def
/col22 {0.690 0.000 0.690 srgb} bind def
/col23 {0.820 0.000 0.820 srgb} bind def
/col24 {0.500 0.190 0.000 srgb} bind def
/col25 {0.630 0.250 0.000 srgb} bind def
/col26 {0.750 0.380 0.000 srgb} bind def
/col27 {1.000 0.500 0.500 srgb} bind def
/col28 {1.000 0.630 0.630 srgb} bind def
/col29 {1.000 0.750 0.750 srgb} bind def
/col30 {1.000 0.880 0.880 srgb} bind def
/col31 {1.000 0.840 0.000 srgb} bind def
end
save
-56.0 596.0 translate
1 -1 scale
/cp {closepath} bind def
/ef {eofill} bind def
/gr {grestore} bind def
/gs {gsave} bind def
/sa {save} bind def
/rs {restore} bind def
/l {lineto} bind def
/m {moveto} bind def
/rm {rmoveto} bind def
/n {newpath} bind def
/s {stroke} bind def
/sh {show} bind def
/slc {setlinecap} bind def
/slj {setlinejoin} bind def
/slw {setlinewidth} bind def
/srgb {setrgbcolor} bind def
/rot {rotate} bind def
/sc {scale} bind def
/sd {setdash} bind def
/ff {findfont} bind def
/sf {setfont} bind def
/scf {scalefont} bind def
/sw {stringwidth} bind def
/tr {translate} bind def
/tnt {dup dup currentrgbcolor
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
bind def
/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
4 -2 roll mul srgb} bind def
/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
/$F2psEnd {$F2psEnteredState restore end} def
%%EndProlog
$F2psBegin
10 setmiterlimit
n -1000 10922 m -1000 -1000 l 9958 -1000 l 9958 10922 l cp clip
0.06000 0.06000 sc
/Times-Roman ff 300.00 scf sf
1200 1680 m
gs 1 -1 sc (INDEPENDENT) col0 sh gr
/Times-Roman ff 300.00 scf sf
1500 1350 m
gs 1 -1 sc (TARGET) col0 sh gr
/Times-Roman ff 300.00 scf sf
1650 2025 m
gs 1 -1 sc (PART) col0 sh gr
/Times-Roman ff 300.00 scf sf
7125 1350 m
gs 1 -1 sc (TARGET) col0 sh gr
/Times-Roman ff 300.00 scf sf
7275 1950 m
gs 1 -1 sc (PART) col0 sh gr
/Times-Roman ff 300.00 scf sf
6750 1650 m
gs 1 -1 sc (DEPENDENT) col0 sh gr
% Polyline
7.500 slw
gs clippath
5861 3927 m 6000 3975 l 5853 3987 l 6011 4007 l 6019 3947 l cp
clip
n 3600 3675 m 6000 3975 l gs col0 s gr gr
% arrowhead
n 5861 3927 m 6000 3975 l 5853 3987 l 5881 3960 l 5861 3927 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3745 4380 m 3598 4368 l 3737 4320 l 3579 4340 l 3587 4400 l cp
clip
n 5998 4068 m 3598 4368 l gs col0 s gr gr
% arrowhead
n 3745 4380 m 3598 4368 l 3737 4320 l 3717 4353 l 3745 4380 l cp gs 0.00 setgray ef gr col0 s
/Times-Roman ff 300.00 scf sf
2550 3750 m
gs 1 -1 sc (Open connection) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
7125 4050 m
gs 1 -1 sc (Accept connection) dup sw pop 2 div neg 0 rm col0 sh gr
% Polyline
15.000 slw
n 3600 2400 m 3600 9825 l gs col0 s gr
% Polyline
n 6000 2400 m 6000 9900 l gs col0 s gr
% Polyline
30.000 slw
n 975 5100 m 8925 5100 l gs col0 s gr
% Polyline
7.500 slw
gs clippath
5861 7002 m 6000 7050 l 5853 7062 l 6011 7082 l 6019 7022 l cp
clip
n 3600 6750 m 6000 7050 l gs col0 s gr gr
% arrowhead
n 5861 7002 m 6000 7050 l 5853 7062 l 5881 7035 l 5861 7002 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5865 8399 m 6004 8447 l 5857 8459 l 6015 8479 l 6023 8419 l cp
clip
n 3604 8147 m 6004 8447 l gs col0 s gr gr
% arrowhead
n 5865 8399 m 6004 8447 l 5857 8459 l 5885 8432 l 5865 8399 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3746 8815 m 3599 8803 l 3738 8755 l 3580 8775 l 3588 8835 l cp
clip
n 5999 8503 m 3599 8803 l gs col0 s gr gr
% arrowhead
n 3746 8815 m 3599 8803 l 3738 8755 l 3718 8788 l 3746 8815 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3748 7709 m 3601 7697 l 3740 7649 l 3582 7669 l 3590 7729 l cp
clip
n 6001 7397 m 3601 7697 l gs col0 s gr gr
% arrowhead
n 3748 7709 m 3601 7697 l 3740 7649 l 3720 7682 l 3748 7709 l cp gs 0.00 setgray ef gr col0 s
/Times-Bold ff 300.00 scf sf
4800 2850 m
gs 1 -1 sc (Connect on target) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Bold ff 300.00 scf sf
4800 5850 m
gs 1 -1 sc (Attach a process) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3525 6825 m
gs 1 -1 sc (Attach a process) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 7125 m
gs 1 -1 sc (Stop the process) col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 7500 m
gs 1 -1 sc (Notify a child change) col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 8550 m
gs 1 -1 sc (Give information) col0 sh gr
/Times-Roman ff 300.00 scf sf
3150 8850 m
gs 1 -1 sc (...) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3525 8250 m
gs 1 -1 sc (Ask information) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
4800 2025 m
gs 1 -1 sc (messages exchange) dup sw pop 2 div neg 0 rm col0 sh gr
$F2psEnd
rs

View File

@@ -0,0 +1,311 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: seq_break.eps
%%Creator: fig2dev Version 3.2 Patchlevel 1
%%CreationDate: Tue Oct 13 14:00:22 1998
%%For: valette@tri-yann (Eric Valette,,6891,)
%%Orientation: Portrait
%%BoundingBox: 0 0 522 1067
%%Pages: 0
%%BeginSetup
%%EndSetup
%%Magnification: 1.0000
%%EndComments
/$F2psDict 200 dict def
$F2psDict begin
$F2psDict /mtrx matrix put
/col-1 {0 setgray} bind def
/col0 {0.000 0.000 0.000 srgb} bind def
/col1 {0.000 0.000 1.000 srgb} bind def
/col2 {0.000 1.000 0.000 srgb} bind def
/col3 {0.000 1.000 1.000 srgb} bind def
/col4 {1.000 0.000 0.000 srgb} bind def
/col5 {1.000 0.000 1.000 srgb} bind def
/col6 {1.000 1.000 0.000 srgb} bind def
/col7 {1.000 1.000 1.000 srgb} bind def
/col8 {0.000 0.000 0.560 srgb} bind def
/col9 {0.000 0.000 0.690 srgb} bind def
/col10 {0.000 0.000 0.820 srgb} bind def
/col11 {0.530 0.810 1.000 srgb} bind def
/col12 {0.000 0.560 0.000 srgb} bind def
/col13 {0.000 0.690 0.000 srgb} bind def
/col14 {0.000 0.820 0.000 srgb} bind def
/col15 {0.000 0.560 0.560 srgb} bind def
/col16 {0.000 0.690 0.690 srgb} bind def
/col17 {0.000 0.820 0.820 srgb} bind def
/col18 {0.560 0.000 0.000 srgb} bind def
/col19 {0.690 0.000 0.000 srgb} bind def
/col20 {0.820 0.000 0.000 srgb} bind def
/col21 {0.560 0.000 0.560 srgb} bind def
/col22 {0.690 0.000 0.690 srgb} bind def
/col23 {0.820 0.000 0.820 srgb} bind def
/col24 {0.500 0.190 0.000 srgb} bind def
/col25 {0.630 0.250 0.000 srgb} bind def
/col26 {0.750 0.380 0.000 srgb} bind def
/col27 {1.000 0.500 0.500 srgb} bind def
/col28 {1.000 0.630 0.630 srgb} bind def
/col29 {1.000 0.750 0.750 srgb} bind def
/col30 {1.000 0.880 0.880 srgb} bind def
/col31 {1.000 0.840 0.000 srgb} bind def
end
save
-40.0 1136.0 translate
1 -1 scale
/cp {closepath} bind def
/ef {eofill} bind def
/gr {grestore} bind def
/gs {gsave} bind def
/sa {save} bind def
/rs {restore} bind def
/l {lineto} bind def
/m {moveto} bind def
/rm {rmoveto} bind def
/n {newpath} bind def
/s {stroke} bind def
/sh {show} bind def
/slc {setlinecap} bind def
/slj {setlinejoin} bind def
/slw {setlinewidth} bind def
/srgb {setrgbcolor} bind def
/rot {rotate} bind def
/sc {scale} bind def
/sd {setdash} bind def
/ff {findfont} bind def
/sf {setfont} bind def
/scf {scalefont} bind def
/sw {stringwidth} bind def
/tr {translate} bind def
/tnt {dup dup currentrgbcolor
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
bind def
/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
4 -2 roll mul srgb} bind def
/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
/$F2psEnd {$F2psEnteredState restore end} def
%%EndProlog
$F2psBegin
10 setmiterlimit
n -1000 19922 m -1000 -1000 l 10365 -1000 l 10365 19922 l cp clip
0.06000 0.06000 sc
/Times-Roman ff 300.00 scf sf
7050 1350 m
gs 1 -1 sc (TARGET) col0 sh gr
/Times-Roman ff 300.00 scf sf
6825 1650 m
gs 1 -1 sc (DEPENDENT) col0 sh gr
/Times-Roman ff 300.00 scf sf
7275 1950 m
gs 1 -1 sc (PART) col0 sh gr
/Times-Roman ff 300.00 scf sf
975 1725 m
gs 1 -1 sc (INDEPENDENT) col0 sh gr
/Times-Roman ff 300.00 scf sf
1500 2025 m
gs 1 -1 sc (PART) col0 sh gr
/Times-Roman ff 300.00 scf sf
1350 1425 m
gs 1 -1 sc (TARGET) col0 sh gr
% Polyline
15.000 slw
n 6000 2400 m 6000 18900 l gs col0 s gr
% Polyline
n 3600 2400 m 3600 18900 l gs col0 s gr
% Polyline
7.500 slw
gs clippath
5857 14614 m 5996 14662 l 5849 14674 l 6007 14694 l 6015 14634 l cp
clip
n 3596 14362 m 5996 14662 l gs col0 s gr gr
% arrowhead
n 5857 14614 m 5996 14662 l 5849 14674 l 5877 14647 l 5857 14614 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5855 16198 m 5994 16246 l 5847 16258 l 6005 16278 l 6013 16218 l cp
clip
n 3594 15946 m 5994 16246 l gs col0 s gr gr
% arrowhead
n 5855 16198 m 5994 16246 l 5847 16258 l 5875 16231 l 5855 16198 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5853 16742 m 5992 16790 l 5845 16802 l 6003 16822 l 6011 16762 l cp
clip
n 3592 16490 m 5992 16790 l gs col0 s gr gr
% arrowhead
n 5853 16742 m 5992 16790 l 5845 16802 l 5873 16775 l 5853 16742 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5857 10639 m 5996 10687 l 5849 10699 l 6007 10719 l 6015 10659 l cp
clip
n 3596 10387 m 5996 10687 l gs col0 s gr gr
% arrowhead
n 5857 10639 m 5996 10687 l 5849 10699 l 5877 10672 l 5857 10639 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5867 11156 m 6006 11204 l 5859 11216 l 6017 11236 l 6025 11176 l cp
clip
n 3606 10904 m 6006 11204 l gs col0 s gr gr
% arrowhead
n 5867 11156 m 6006 11204 l 5859 11216 l 5887 11189 l 5867 11156 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3746 11590 m 3599 11578 l 3738 11530 l 3580 11550 l 3588 11610 l cp
clip
n 5999 11278 m 3599 11578 l gs col0 s gr gr
% arrowhead
n 3746 11590 m 3599 11578 l 3738 11530 l 3718 11563 l 3746 11590 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5855 7873 m 5994 7921 l 5847 7933 l 6005 7953 l 6013 7893 l cp
clip
n 3594 7621 m 5994 7921 l gs col0 s gr gr
% arrowhead
n 5855 7873 m 5994 7921 l 5847 7933 l 5875 7906 l 5855 7873 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5853 8417 m 5992 8465 l 5845 8477 l 6003 8497 l 6011 8437 l cp
clip
n 3592 8165 m 5992 8465 l gs col0 s gr gr
% arrowhead
n 5853 8417 m 5992 8465 l 5845 8477 l 5873 8450 l 5853 8417 l cp gs 0.00 setgray ef gr col0 s
% Polyline
30.000 slw
n 750 5625 m 9150 5625 l gs col0 s gr
% Polyline
n 825 12525 m 9225 12525 l gs col0 s gr
% Polyline
7.500 slw
gs clippath
5860 4386 m 5999 4434 l 5852 4446 l 6010 4466 l 6018 4406 l cp
clip
n 3599 4134 m 5999 4434 l gs col0 s gr gr
% arrowhead
n 5860 4386 m 5999 4434 l 5852 4446 l 5880 4419 l 5860 4386 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3743 4813 m 3596 4801 l 3735 4753 l 3577 4773 l 3585 4833 l cp
clip
n 5996 4501 m 3596 4801 l gs col0 s gr gr
% arrowhead
n 3743 4813 m 3596 4801 l 3735 4753 l 3715 4786 l 3743 4813 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3741 9894 m 3594 9882 l 3733 9834 l 3575 9854 l 3583 9914 l cp
clip
n 5994 9582 m 3594 9882 l gs col0 s gr gr
% arrowhead
n 3741 9894 m 3594 9882 l 3733 9834 l 3713 9867 l 3741 9894 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3741 15519 m 3594 15507 l 3733 15459 l 3575 15479 l 3583 15539 l cp
clip
n 5994 15207 m 3594 15507 l gs col0 s gr gr
% arrowhead
n 3741 15519 m 3594 15507 l 3733 15459 l 3713 15492 l 3741 15519 l cp gs 0.00 setgray ef gr col0 s
/Times-Roman ff 300.00 scf sf
3525 14775 m
gs 1 -1 sc (Wait for event...) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
6075 15300 m
gs 1 -1 sc (Notify a child change) col0 sh gr
/Times-Roman ff 300.00 scf sf
8475 15600 m
gs 1 -1 sc (Wait for command ...) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
6075 15000 m
gs 1 -1 sc (Debug Exception handler) col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 16950 m
gs 1 -1 sc (Wait for event...) dup sw pop neg 0 rm col0 sh gr
/Times-Bold ff 300.00 scf sf
3150 6525 m
gs 1 -1 sc (Continue process : first time) col0 sh gr
/Times-Bold ff 300.00 scf sf
5700 2925 m
gs 1 -1 sc (Set Breakpoint) dup sw pop neg 0 rm col0 sh gr
/Times-Bold ff 300.00 scf sf
2925 13425 m
gs 1 -1 sc (Continue process : next times) col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 9675 m
gs 1 -1 sc (Notify a child change) col0 sh gr
/Times-Roman ff 300.00 scf sf
8550 9975 m
gs 1 -1 sc (Wait for command ...) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3525 11025 m
gs 1 -1 sc (Ask information) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 11325 m
gs 1 -1 sc (Give information) col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 11625 m
gs 1 -1 sc (...) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 8250 m
gs 1 -1 sc (Resume process) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 8625 m
gs 1 -1 sc (Wait for event...) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
2250 10650 m
gs 1 -1 sc (at address) col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 9375 m
gs 1 -1 sc (Breakpoint Except. handler) col0 sh gr
/Times-Roman ff 300.00 scf sf
4800 1650 m
gs 1 -1 sc (message exchange) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 4800 m
gs 1 -1 sc (...) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 4200 m
gs 1 -1 sc (Ask opcode at address) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 4575 m
gs 1 -1 sc (Send opcode ) col0 sh gr
/Times-Roman ff 300.00 scf sf
675 7650 m
gs 1 -1 sc (Write "DEBUG" opcode) col0 sh gr
/Times-Roman ff 300.00 scf sf
8025 9075 m
gs 1 -1 sc (DEBUG opcode) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
900 10425 m
gs 1 -1 sc (Write previous opcode) col0 sh gr
/Times-Roman ff 300.00 scf sf
2400 7875 m
gs 1 -1 sc (at address) col0 sh gr
/Times-Roman ff 300.00 scf sf
750 15900 m
gs 1 -1 sc (Write "DEBUG" opcode) col0 sh gr
/Times-Roman ff 300.00 scf sf
2400 16125 m
gs 1 -1 sc (at address) col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 14475 m
gs 1 -1 sc (Single Step command) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 16575 m
gs 1 -1 sc (Continue command) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 16950 m
gs 1 -1 sc (Resume process) col0 sh gr
$F2psEnd
rs

View File

@@ -0,0 +1,167 @@
%!PS-Adobe-2.0 EPSF-2.0
%%Title: seq_detach.eps
%%Creator: fig2dev Version 3.2 Patchlevel 1
%%CreationDate: Tue Oct 13 14:00:31 1998
%%For: valette@tri-yann (Eric Valette,,6891,)
%%Orientation: Portrait
%%BoundingBox: 0 0 427 293
%%Pages: 0
%%BeginSetup
%%EndSetup
%%Magnification: 1.0000
%%EndComments
/$F2psDict 200 dict def
$F2psDict begin
$F2psDict /mtrx matrix put
/col-1 {0 setgray} bind def
/col0 {0.000 0.000 0.000 srgb} bind def
/col1 {0.000 0.000 1.000 srgb} bind def
/col2 {0.000 1.000 0.000 srgb} bind def
/col3 {0.000 1.000 1.000 srgb} bind def
/col4 {1.000 0.000 0.000 srgb} bind def
/col5 {1.000 0.000 1.000 srgb} bind def
/col6 {1.000 1.000 0.000 srgb} bind def
/col7 {1.000 1.000 1.000 srgb} bind def
/col8 {0.000 0.000 0.560 srgb} bind def
/col9 {0.000 0.000 0.690 srgb} bind def
/col10 {0.000 0.000 0.820 srgb} bind def
/col11 {0.530 0.810 1.000 srgb} bind def
/col12 {0.000 0.560 0.000 srgb} bind def
/col13 {0.000 0.690 0.000 srgb} bind def
/col14 {0.000 0.820 0.000 srgb} bind def
/col15 {0.000 0.560 0.560 srgb} bind def
/col16 {0.000 0.690 0.690 srgb} bind def
/col17 {0.000 0.820 0.820 srgb} bind def
/col18 {0.560 0.000 0.000 srgb} bind def
/col19 {0.690 0.000 0.000 srgb} bind def
/col20 {0.820 0.000 0.000 srgb} bind def
/col21 {0.560 0.000 0.560 srgb} bind def
/col22 {0.690 0.000 0.690 srgb} bind def
/col23 {0.820 0.000 0.820 srgb} bind def
/col24 {0.500 0.190 0.000 srgb} bind def
/col25 {0.630 0.250 0.000 srgb} bind def
/col26 {0.750 0.380 0.000 srgb} bind def
/col27 {1.000 0.500 0.500 srgb} bind def
/col28 {1.000 0.630 0.630 srgb} bind def
/col29 {1.000 0.750 0.750 srgb} bind def
/col30 {1.000 0.880 0.880 srgb} bind def
/col31 {1.000 0.840 0.000 srgb} bind def
end
save
-72.0 362.0 translate
1 -1 scale
/cp {closepath} bind def
/ef {eofill} bind def
/gr {grestore} bind def
/gs {gsave} bind def
/sa {save} bind def
/rs {restore} bind def
/l {lineto} bind def
/m {moveto} bind def
/rm {rmoveto} bind def
/n {newpath} bind def
/s {stroke} bind def
/sh {show} bind def
/slc {setlinecap} bind def
/slj {setlinejoin} bind def
/slw {setlinewidth} bind def
/srgb {setrgbcolor} bind def
/rot {rotate} bind def
/sc {scale} bind def
/sd {setdash} bind def
/ff {findfont} bind def
/sf {setfont} bind def
/scf {scalefont} bind def
/sw {stringwidth} bind def
/tr {translate} bind def
/tnt {dup dup currentrgbcolor
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add
4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
bind def
/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
4 -2 roll mul srgb} bind def
/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
/$F2psEnd {$F2psEnteredState restore end} def
%%EndProlog
$F2psBegin
10 setmiterlimit
n -1000 7022 m -1000 -1000 l 9307 -1000 l 9307 7022 l cp clip
0.06000 0.06000 sc
/Times-Roman ff 300.00 scf sf
1200 1680 m
gs 1 -1 sc (INDEPENDENT) col0 sh gr
/Times-Roman ff 300.00 scf sf
1800 1950 m
gs 1 -1 sc (PART) col0 sh gr
/Times-Roman ff 300.00 scf sf
1575 1425 m
gs 1 -1 sc (TARGET) col0 sh gr
/Times-Roman ff 300.00 scf sf
6450 1680 m
gs 1 -1 sc (DEPENDENT) col0 sh gr
/Times-Roman ff 300.00 scf sf
6675 1350 m
gs 1 -1 sc (TARGET) col0 sh gr
/Times-Roman ff 300.00 scf sf
6900 1950 m
gs 1 -1 sc (PART) col0 sh gr
% Polyline
15.000 slw
n 3600 2400 m 3600 6000 l gs col0 s gr
% Polyline
n 6000 2400 m 6000 6000 l gs col0 s gr
% Polyline
7.500 slw
gs clippath
5861 3927 m 6000 3975 l 5853 3987 l 6011 4007 l 6019 3947 l cp
clip
n 3600 3675 m 6000 3975 l gs col0 s gr gr
% arrowhead
n 5861 3927 m 6000 3975 l 5853 3987 l 5881 3960 l 5861 3927 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
5861 5427 m 6000 5475 l 5853 5487 l 6011 5507 l 6019 5447 l cp
clip
n 3600 5175 m 6000 5475 l gs col0 s gr gr
% arrowhead
n 5861 5427 m 6000 5475 l 5853 5487 l 5881 5460 l 5861 5427 l cp gs 0.00 setgray ef gr col0 s
% Polyline
gs clippath
3747 4643 m 3600 4631 l 3739 4583 l 3581 4603 l 3589 4663 l cp
clip
n 6000 4331 m 3600 4631 l gs col0 s gr gr
% arrowhead
n 3747 4643 m 3600 4631 l 3739 4583 l 3719 4616 l 3747 4643 l cp gs 0.00 setgray ef gr col0 s
/Times-Bold ff 300.00 scf sf
4800 2700 m
gs 1 -1 sc (Detach a process) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
2550 3750 m
gs 1 -1 sc (Detach a process) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
7200 4050 m
gs 1 -1 sc (Detach the process) dup sw pop 2 div neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 4425 m
gs 1 -1 sc (Notify detach) col0 sh gr
/Times-Roman ff 300.00 scf sf
6150 4800 m
gs 1 -1 sc (Resume process) col0 sh gr
/Times-Roman ff 300.00 scf sf
3450 5250 m
gs 1 -1 sc (Close connection) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
8100 5625 m
gs 1 -1 sc (Close connection) dup sw pop neg 0 rm col0 sh gr
/Times-Roman ff 300.00 scf sf
4800 1650 m
gs 1 -1 sc (messages exchange) dup sw pop 2 div neg 0 rm col0 sh gr
$F2psEnd
rs